diff --git a/.github/workflows/certora-prover.yml b/.github/workflows/certora-prover.yml index 39a62830a5..5987dc1807 100644 --- a/.github/workflows/certora-prover.yml +++ b/.github/workflows/certora-prover.yml @@ -32,7 +32,7 @@ jobs: - name: Install Foundry uses: foundry-rs/foundry-toolchain@v1 with: - version: nightly + version: stable - name: Install forge dependencies run: forge install - name: Install python diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml index 82f78a7941..535d51034f 100644 --- a/.github/workflows/coverage.yml +++ b/.github/workflows/coverage.yml @@ -50,7 +50,7 @@ jobs: - name: Install Foundry uses: foundry-rs/foundry-toolchain@v1 with: - version: nightly + version: stable - name: Run coverage run: forge coverage --report lcov env: diff --git a/.github/workflows/deploy-local.yml b/.github/workflows/deploy-local.yml index 33b29c10a6..25f9dd9a6a 100644 --- a/.github/workflows/deploy-local.yml +++ b/.github/workflows/deploy-local.yml @@ -30,7 +30,7 @@ jobs: - name: Install Foundry uses: foundry-rs/foundry-toolchain@v1 with: - version: nightly + version: stable - name: Run forge install run: forge install - name: Start anvil and deploy diff --git a/.github/workflows/format.yml b/.github/workflows/format.yml index 1869ccf191..0edb734c11 100644 --- a/.github/workflows/format.yml +++ b/.github/workflows/format.yml @@ -18,7 +18,7 @@ jobs: - name: Install Foundry uses: foundry-rs/foundry-toolchain@v1 with: - version: nightly + version: stable - name: Run forge fmt run: | forge fmt --check src/contracts diff --git a/.github/workflows/storage-report.yml b/.github/workflows/storage-report.yml index d4665b0155..f95b2099e9 100644 --- a/.github/workflows/storage-report.yml +++ b/.github/workflows/storage-report.yml @@ -16,7 +16,7 @@ jobs: - name: Install Foundry uses: foundry-rs/foundry-toolchain@v1 with: - version: nightly + version: stable - name: "Generate and prepare the storage reports for current branch" run: | diff --git a/.github/workflows/testinparallel.yml b/.github/workflows/testinparallel.yml index 82006ade75..fd4c63be13 100644 --- a/.github/workflows/testinparallel.yml +++ b/.github/workflows/testinparallel.yml @@ -34,7 +34,7 @@ jobs: - name: Install Foundry uses: foundry-rs/foundry-toolchain@v1 with: - version: nightly + version: stable - name: Run Forge build run: | diff --git a/Makefile b/Makefile index 4b68d11c90..997ee84719 100644 --- a/Makefile +++ b/Makefile @@ -45,4 +45,4 @@ gha-docker: docker run -v $(PWD):/build -w /build --rm -i ${CONTAINER_NAME}:latest bash -c "make gha" storage-report: - bash "bin/storage-report.sh" "docs/storage-report/" + bash "bin/storage-report.sh" "docs/storage-report/" \ No newline at end of file diff --git a/docs/README.md b/docs/README.md index fb781bd138..f88ed06775 100644 --- a/docs/README.md +++ b/docs/README.md @@ -16,6 +16,7 @@ This document provides an overview of system components, contracts, and user rol * [`RewardsCoordinator`](#rewardscoordinator) * [`AVSDirectory`](#avsdirectory) * [`AllocationManager`](#allocationmanager) + * [`PermissionController`](#permissioncontroller) * [Roles and Actors](#roles-and-actors) * [Common User Flows](#common-user-flows) * [Depositing Into EigenLayer](#depositing-into-eigenlayer) @@ -64,10 +65,13 @@ See full documentation in [`/core/StrategyManager.md`](./core/StrategyManager.md | -------- | -------- | -------- | | [`DelegationManager.sol`](../src/contracts/core/DelegationManager.sol) | Singleton | Transparent proxy | -The `DelegationManager` sits between the `EigenPodManager` and `StrategyManager` to manage delegation and undelegation of Stakers to Operators. Its primary features are to allow Operators to register as Operators (`registerAsOperator`), to keep track of delegated shares to Operators across different strategies, and to manage withdrawals on behalf of the `EigenPodManager` and `StrategyManager`. -The `DelegationManager` is tightly coupled with the `AllocationManager` as withdrawable shares for a Staker is dependent on reading state from the `AllocationManager`. That is, a staker's withdrawable shares is decreased in the event their delegated Operator was slashed by an AVS (more specifically an operatorSet but more on this later). +The `DelegationManager` sits between the `EigenPodManager` and `StrategyManager` to manage delegation and undelegation of stakers to operators. Its primary features are to allow users to become operators, to keep track of delegated shares to operators across different strategies, and to manage withdrawals on behalf of stakers via the `EigenPodManager` and `StrategyManager`. -See full documentation in [`/core/DelegationManager.md`](./core/DelegationManager.md). +The `DelegationManager` is tightly coupled with the `AllocationManager`. The `DelegationManager` ingests information about slashing as part of managing share accounting for stakers whose operators have been slashed. It also receives directives to slash/burn operator shares when an AVS slashes an operator. + +See: +* full documentation in [`/core/DelegationManager.md`](./core/DelegationManager.md) +* share accounting documentation in [`/core/accounting/SharesAccounting.md`](./core/accounting/SharesAccounting.md) #### RewardsCoordinator @@ -76,9 +80,9 @@ See full documentation in [`/core/DelegationManager.md`](./core/DelegationManage | [`RewardsCoordinator.sol`](../src/contracts/core/RewardsCoordinator.sol) | Singleton | Transparent proxy | The `RewardsCoordinator` is the main entry point of submission and claiming of ERC20 rewards in EigenLayer. It carries out three basic functions: -* AVSs (via the AVS's contracts) submit "rewards submissions" to their registered Operators and Stakers over a specific time period -* *Off-chain*, the rewards updater will use each RewardsSubmission time period to apply reward amounts to historical Staker/Operator stake weights. This is consolidated into a merkle root that is posted *on-chain* to the `RewardsCoordinator`, allowing Stakers/Operators to claim their allocated rewards. -* Stakers/Operators can claim rewards posted by the rewards updater. +* AVSs (via the AVS's contracts) submit "rewards submissions" to their registered operators and stakers over a specific time period +* *Off-chain*, the rewards updater will use each RewardsSubmission time period to apply reward amounts to historical staker/operator stake weights. This is consolidated into a merkle root that is posted *on-chain* to the `RewardsCoordinator`, allowing stakers/operators to claim their allocated rewards. +* Stakers/operators can claim rewards posted by the rewards updater. See full documentation in [`/core/RewardsCoordinator.md`](./core/RewardsCoordinator.md). @@ -88,9 +92,9 @@ See full documentation in [`/core/RewardsCoordinator.md`](./core/RewardsCoordina | -------- | -------- | -------- | | [`AVSDirectory.sol`](../src/contracts/core/AVSDirectory.sol) | Singleton | Transparent proxy | -##### Note: This contract is left unchanged for backwards compatability. Operator<>AVS Registrations are to be replaced entirely with the `AllocationManager` and this contract will be deprecated(no longer indexed) in a future release. +##### Note: This contract is left unchanged for backwards compatability. Operator<>AVS Registrations are to be replaced entirely with the `AllocationManager` and this contract will be deprecated in a future release. -The `AVSDirectory` handles interactions between AVSs and the EigenLayer core contracts. Once registered as an Operator in EigenLayer core (via the `DelegationManager`), Operators can register with one or more AVSs (via the AVS's contracts) to begin providing services to them offchain. As a part of registering with an AVS, the AVS will record this registration in the core contracts by calling into the `AVSDirectory`. +Previously, the `AVSDirectory` handled interactions between AVSs and the EigenLayer core contracts. Once registered as an operator in EigenLayer core (via the `DelegationManager`), operators could register with one or more AVSs (via the AVS's contracts) to begin providing services to them offchain. As a part of registering with an AVS, the AVS would record this registration in the core contracts by calling into the `AVSDirectory`. As of the slashing release, this process is now managed by the [`AllocationManager`](#allocationmanager). See full documentation in [`/core/AVSDirectory.md`](./core/AVSDirectory.md). @@ -102,19 +106,28 @@ For more information on AVS contracts, see the [middleware repo][middleware-repo | -------- | -------- | -------- | | [`AllocationManager.sol`](../src/contracts/core/AllocationManager.sol) | Singleton | Transparent proxy | -The `AllocationManager` is meant to replace the AVSDirectory with the introduction of OperatorSets as well as introduce the core functionality of Slashing. It handles several use cases: -* AVSs can create OperatorSets and can define the EigenLayer Strategies within them -* Operators can register/deregister with AVS operatorSets -* Operators can make slashable security commitments to an operatorSet by allocating a proportion of their total delegated stake for a Strategy to be slashable. Ex. As an operator, I can allocate 50% of my stETH to be slashable by a specific OperatorSet -* AVSs can slash an operator (without being objectively attributable) who has slashable allocations to the AVS's corresponding OperatorSet. +The `AllocationManager` is replaces the AVSDirectory with the introduction of _operator sets_ and slashing. It handles several use cases: +* AVSs can create operator sets and can define the EigenLayer Strategies within them +* Operators can register to or deregister from an AVS's operator sets +* Operators can make slashable security commitments to an operator set by allocating a proportion of their total delegated stake for a Strategy to be slashable. Ex. As an operator, I can allocate 50% of my delegated stETH to be slashable by a specific operator set +* AVSs can slash an operator who has allocated to and is registered for one of the AVS's operator sets See full documentation in [`/core/AllocationManager.md`](./core/AllocationManager.md). ---- +#### PermissionController + +| File | Type | Proxy | +| -------- | -------- | -------- | +| [`PermissionController.sol`](../src/contracts/permissions/PermissionController.sol) | Singleton | Transparent proxy | + +The `PermissionController` allows AVSs and operators to delegate the ability to call certain core contract functions to other addresses. This delegation ability is not available to stakers, and is not available in ALL core contract functions. -#### Shares Accounting +The following core contracts use the `PermissionController` in certain methods: +* `DelegationManager` +* `AllocationManager` +* `RewardsCoordinator` -TODO +See full documentation in [`/permissions/PermissionController.md`](./permissions/PermissionController.md). --- @@ -124,39 +137,33 @@ To see an example of the user flows described in this section, check out our int ##### Staker -A Staker is any party who has assets deposited (or "restaked") into EigenLayer. Currently, these assets can be: +A staker is any party who has assets deposited (or "restaked") into EigenLayer. Currently, these assets can be: * Native beacon chain ETH (via the EigenPodManager) -* Liquid staking tokens (via the StrategyManager): cbETH, rETH, stETH, ankrETH, OETH, osETH, swETH, wBETH +* Arbitrary ERC20s (via the StrategyManager) -Stakers can restake any combination of these: a Staker may hold ALL of these assets, or only one of them. +Stakers can restake any combination of these: a staker may hold ALL of these assets, or only one of them. *Flows:* -* Stakers **deposit** assets into EigenLayer via either the StrategyManager (for LSTs) or EigenPodManager (for beacon chain ETH) +* Stakers **deposit** assets into EigenLayer via either the StrategyManager (for ERC20s) or the EigenPodManager (for beacon chain ETH) * Stakers **withdraw** assets via the DelegationManager, *no matter what assets they're withdrawing* -* Stakers **delegate** to an Operator via the DelegationManager - -*Unimplemented as of v0.4.0:* -* Stakers are at risk of being slashed if the Operator misbehaves +* Stakers **delegate** to an operator via the DelegationManager ##### Operator -An Operator is a user who helps run the software built on top of EigenLayer (AVSs). Operators register in EigenLayer and allow Stakers to delegate to them, then opt in to provide various services built on top of EigenLayer. Operators may themselves be Stakers; these are not mutually exclusive. +An operator is a user who helps run the software built on top of EigenLayer (AVSs). operators register in EigenLayer and allow stakers to delegate to them, then opt in to provide various services built on top of EigenLayer. operators may themselves be stakers; these are not mutually exclusive. *Flows:* -* User can **register** as an Operator via the DelegationManager -* Operators can **deposit** and **withdraw** assets just like Stakers can +* Users can **register** as an operator via the DelegationManager +* Operators can **deposit** and **withdraw** assets just like stakers can * Operators can opt in to providing services for an AVS using that AVS's middleware contracts. See the [EigenLayer middleware][middleware-repo] repo for more details. -*Unimplemented as of v0.4.0:* -* Operators may be slashed by the services they register with (if they misbehave) - --- #### Common User Flows ##### Depositing Into EigenLayer -Depositing into EigenLayer varies depending on whether the Staker is depositing Native ETH or LSTs: +Depositing into EigenLayer varies depending on whether the staker is depositing Native ETH or LSTs: ![.](./images/Staker%20Flow%20Diagrams/Depositing.png) @@ -166,13 +173,13 @@ Depositing into EigenLayer varies depending on whether the Staker is depositing ##### Undelegating or Queueing a Withdrawal -Undelegating from an Operator automatically queues a withdrawal that needs to go through the `DelegationManager's` withdrawal delay. Stakers that want to withdraw can choose to `undelegate`, or can simply call `queueWithdrawals` directly. +Undelegating from an operator automatically queues a withdrawal that needs to go through the `DelegationManager's` withdrawal delay. Stakers that want to withdraw can choose to `undelegate`, or can simply call `queueWithdrawals` directly. ![.](./images/Staker%20Flow%20Diagrams/Queue%20Withdrawal.png) ##### Completing a Withdrawal as Shares -This flow is mostly useful if a Staker wants to change which Operator they are delegated to. The Staker first needs to undelegate (see above). At this point, they can delegate to a different Operator. However, the new Operator will only be awarded shares once the Staker completes their queued withdrawal "as shares": +This flow is mostly useful if a staker wants to change which operator they are delegated to. The staker first needs to undelegate (see above). At this point, they can delegate to a different operator. However, the new operator will only be awarded shares once the staker completes their queued withdrawal "as shares": ![.](./images/Staker%20Flow%20Diagrams/Complete%20Withdrawal%20as%20Shares.png) @@ -186,12 +193,12 @@ However, note that *before* a withdrawal can be completed, native ETH stakers wi ##### `EigenPods`: Processing Validator Exits -If a Staker wants to fully withdraw from the beacon chain, they need to perform these additional steps before their withdrawal is completable: +If a staker wants to fully withdraw from the beacon chain, they need to perform these additional steps before their withdrawal is completable: ![.](./images/Staker%20Flow%20Diagrams/Validator%20Exits.png) ##### `EigenPods`: Processing Validator Yield -As the Staker's `EigenPod` accumulates consensus layer or execution layer yield, the `EigenPod's` balance will increase. The Staker can Checkpoint their validator to claim this yield as shares, which can either remain staked in EigenLayer or be withdrawn via the `DelegationManager` withdrawal queue: +As the staker's `EigenPod` accumulates consensus layer or execution layer yield, the `EigenPod's` balance will increase. The staker can Checkpoint their validator to claim this yield as shares, which can either remain staked in EigenLayer or be withdrawn via the `DelegationManager` withdrawal queue: ![.](./images/Staker%20Flow%20Diagrams/Validator%20Yield.png) \ No newline at end of file diff --git a/docs/core/AllocationManager.md b/docs/core/AllocationManager.md index 4e722b5228..ca4dacf75b 100644 --- a/docs/core/AllocationManager.md +++ b/docs/core/AllocationManager.md @@ -22,7 +22,9 @@ Libraries and Mixins: ## Overview -The `AllocationManager` manages registration and deregistration of operators to operator sets, handles allocation and slashing of operators' slashable stake, and is the entry point an AVS uses to slash an operator. The `AllocationManager's` responsibilities are broken down into the following concepts: +The `AllocationManager` manages AVS metadata registration, registration and deregistration of operators to operator sets, handles allocation and slashing of operators' slashable stake, and is the entry point an AVS uses to slash an operator. The `AllocationManager's` responsibilities are broken down into the following concepts: + +* [AVS Metadata](#avs-metadata) * [Operator Sets](#operator-sets) * [Allocations and Slashing](#allocations-and-slashing) * [Config](#config) @@ -38,6 +40,104 @@ The `AllocationManager` manages registration and deregistration of operators to --- +## AVS Metadata + +AVSs must register their metadata to declare themselves who they are as the first step, before they can create operator sets or register operators into operator sets. `AllocationManager` keeps track of AVSs that have registered metadata. + +**Methods:** +* [`updateAVSMetadataURI`](#updateavsmetadatauri) + + +#### `updateAVSMetadataURI` + +```solidity +/** + * @notice Called by an AVS to emit an `AVSMetadataURIUpdated` event indicating the information has updated. + * + * @param metadataURI The URI for metadata associated with an AVS. + * + * @dev Note that the `metadataURI` is *never stored* and is only emitted in the `AVSMetadataURIUpdated` event. + */ +function updateAVSMetadataURI( + address avs, + string calldata metadataURI +) + external + checkCanCall(avs) +``` + +_Note: this method can be called directly by an AVS, or by a caller authorized by the AVS. See [`PermissionController.md`](../permissions/PermissionController.md) for details._ + +Below is the format AVSs should use when updating their metadata URI initially. This is not validated onchain. + +```json +{ + "name": "AVS", + "website": "https.avs.xyz/", + "description": "Some description about", + "logo": "http://github.com/logo.png", + "twitter": "https://twitter.com/avs", +} +``` + + +Later on, once AVSs have created operator sets, content in their metadata URI can be updated subsequently. + +```json +{ + "name": "AVS", + "website": "https.avs.xyz/", + "description": "Some description about", + "logo": "http://github.com/logo.png", + "twitter": "https://twitter.com/avs", + "operatorSets": [ + { + "name": "ETH Set", + "id": "1", // Note: we use this param to match the opSet id in the Allocation Manager + "description": "The ETH operatorSet for AVS", + "software": [ + { + "name": "NetworkMonitor", + "description": "", + "url": "https://link-to-binary-or-github.com" + }, + { + "name": "ValidatorClient", + "description": "", + "url": "https://link-to-binary-or-github.com" + } + ], + "slashingConditions": ["Condition A", "Condition B"] + }, + { + "name": "EIGEN Set", + "id": "2", // Note: we use this param to match the opSet id in the Allocation Manager + "description": "The EIGEN operatorSet for AVS", + "software": [ + { + "name": "NetworkMonitor", + "description": "", + "url": "https://link-to-binary-or-github.com" + }, + { + "name": "ValidatorClient", + "description": "", + "url": "https://link-to-binary-or-github.com" + } + ], + "slashingConditions": ["Condition A", "Condition B"] + } + ] +} +``` + +*Effects*: +* Emits an `AVSMetadataURIUpdated` event for use in offchain services + +*Requirements*: +* Caller MUST be authorized, either as the AVS itself or an admin/appointee (see [`PermissionController.md`](../permissions/PermissionController.md)) + + ## Operator Sets Operator sets, as described in [ELIP-002](https://github.com/eigenfoundation/ELIPs/blob/main/ELIPs/ELIP-002.md#operator-sets), are useful for AVSs to configure operator groupings which can be assigned different tasks, rewarded based on their strategy allocations, and slashed according to different rules. Operator sets are defined in [`libraries/OperatorSetLib.sol`](../../src/contracts/libraries/OperatorSetLib.sol): @@ -145,6 +245,7 @@ Optionally, the `avs` can provide a list of `strategies`, specifying which strat *Requirements*: * Caller MUST be authorized, either as the AVS itself or an admin/appointee (see [`PermissionController.md`](../permissions/PermissionController.md)) +* AVS MUST have registered metadata * For each `CreateSetParams` element: * Each `params.operatorSetId` MUST NOT already exist in `_operatorSets[avs]` @@ -585,7 +686,26 @@ struct SlashingParams { } /** - * @notice Called by an AVS to slash an operator in a given operator set + * @notice Called by an AVS to slash an operator in a given operator set. The operator must be registered + * and have slashable stake allocated to the operator set. + * + * @param avs The AVS address initiating the slash. + * @param params The slashing parameters, containing: + * - operator: The operator to slash. + * - operatorSetId: The ID of the operator set the operator is being slashed from. + * - strategies: Array of strategies to slash allocations from (must be in ascending order). + * - wadsToSlash: Array of proportions to slash from each strategy (must be between 0 and 1e18). + * - description: Description of why the operator was slashed. + * + * @dev For each strategy: + * 1. Reduces the operator's current allocation magnitude by wadToSlash proportion. + * 2. Reduces the strategy's max and encumbered magnitudes proportionally. + * 3. If there is a pending deallocation, reduces it proportionally. + * 4. Updates the operator's shares in the DelegationManager. + * + * @dev Small slashing amounts may not result in actual token burns due to + * rounding, which will result in small amounts of tokens locked in the contract + * rather than fully burning through the burn mechanism. */ function slashOperator( address avs, @@ -646,7 +766,6 @@ Once slashing is processed for a strategy, [slashed stake is burned via the `Del **Methods:** * [`setAllocationDelay`](#setallocationdelay) * [`setAVSRegistrar`](#setavsregistrar) -* [`updateAVSMetadataURI`](#updateavsmetadatauri) #### `setAllocationDelay` @@ -737,79 +856,3 @@ Note that when an operator registers, registration will FAIL if the call to `IAV *Requirements*: * Caller MUST be authorized, either as the AVS itself or an admin/appointee (see [`PermissionController.md`](../permissions/PermissionController.md)) - -#### `updateAVSMetadataURI` - -```solidity -/** - * @notice Called by an AVS to emit an `AVSMetadataURIUpdated` event indicating the information has updated. - * - * @param metadataURI The URI for metadata associated with an AVS. - * - * @dev Note that the `metadataURI` is *never stored* and is only emitted in the `AVSMetadataURIUpdated` event. - */ -function updateAVSMetadataURI( - address avs, - string calldata metadataURI -) - external - checkCanCall(avs) -``` - -_Note: this method can be called directly by an AVS, or by a caller authorized by the AVS. See [`PermissionController.md`](../permissions/PermissionController.md) for details._ - -Below is the format AVSs should use when updating their metadata URI. This is not validated onchain. - -```json -{ - "name": "AVS", - "website": "https.avs.xyz/", - "description": "Some description about", - "logo": "http://github.com/logo.png", - "twitter": "https://twitter.com/avs", - "operatorSets": [ - { - "name": "ETH Set", - "id": "1", // Note: we use this param to match the opSet id in the Allocation Manager - "description": "The ETH operatorSet for AVS", - "software": [ - { - "name": "NetworkMonitor", - "description": "", - "url": "https://link-to-binary-or-github.com" - }, - { - "name": "ValidatorClient", - "description": "", - "url": "https://link-to-binary-or-github.com" - } - ], - "slashingConditions": ["Condition A", "Condition B"] - }, - { - "name": "EIGEN Set", - "id": "2", // Note: we use this param to match the opSet id in the Allocation Manager - "description": "The EIGEN operatorSet for AVS", - "software": [ - { - "name": "NetworkMonitor", - "description": "", - "url": "https://link-to-binary-or-github.com" - }, - { - "name": "ValidatorClient", - "description": "", - "url": "https://link-to-binary-or-github.com" - } - ], - "slashingConditions": ["Condition A", "Condition B"] - } - ] -} -``` - -*Effects*: -* Emits an `AVSMetadataURIUpdated` event for use in offchain services - -*Requirements*: -* Caller MUST be authorized, either as the AVS itself or an admin/appointee (see [`PermissionController.md`](../permissions/PermissionController.md)) \ No newline at end of file diff --git a/docs/core/DelegationManager.md b/docs/core/DelegationManager.md index fd78549a03..11da3e186f 100644 --- a/docs/core/DelegationManager.md +++ b/docs/core/DelegationManager.md @@ -168,9 +168,9 @@ Allows an operator to emit an `OperatorMetadataURIUpdated` event. No other state ## Delegation and Withdrawals **Concepts**: -* [Enforcing a Withdrawal Delay]() TODO -* [Legacy vs New Withdrawals]() TODO -* [Getting the Slashing Factor]() TODO +* [Shares Accounting](./accounting/SharesAccounting.md) +* [Legacy and Post-Slashing Withdrawals](#legacy-and-post-slashing-withdrawals) +* [Slashing Factors and Scaling Shares](#slashing-factors-and-scaling-shares) **Methods**: * [`DelegationManager.delegateTo`](#delegateto) @@ -180,12 +180,6 @@ Allows an operator to emit an `OperatorMetadataURIUpdated` event. No other state * [`DelegationManager.completeQueuedWithdrawal`](#completequeuedwithdrawal) * [`DelegationManager.completeQueuedWithdrawals`](#completequeuedwithdrawals) - - -#### Role of the Withdrawal Delay - -TODO - #### Legacy and Post-Slashing Withdrawals The `DelegationManager` tracks withdrawal-related state in the following mappings: @@ -241,11 +235,19 @@ mapping(address operator => mapping(IStrategy strategy => Snapshots.DefaultZeroH _cumulativeScaledSharesHistory; ``` -Of these mappings, only `pendingWithdrawals` and `cumulativeWithdrawalsQueued` +Prior to the slashing release, withdrawals were only stored as hashes in the `pendingWithdrawals` mapping. + +With the slashing release, withdrawals are now stored entirely in state, and two new mappings have been added to support this: +* `_stakedQueuedWithdrawalRoots`: a list of all the currently-queued withdrawal hashes belonging to a staker +* `queuedWithdrawals`: maps queued withdrawal hash to `Withdrawal` struct + +Legacy withdrawals remain completable using the same methods as new withdrawals. The primary difference between the two is that it is not possible to query the corresponding `Withdrawal` struct for a legacy withdrawal hash. When determining what `Withdrawal` struct to supply to the contract to complete a legacy withdrawal, the caller will need to derive the original `Withdrawal` struct generated when the withdrawal was queued. #### Slashing Factors and Scaling Shares -Throughout the `DelegationManager`, a staker's _deposit shares_ can be converted into their current _withdrawable shares_ by applying two factors: the _slashing factor_ and the _deposit scaling factor_. These two values are scaling factors that act as numerators or denominators when scaling shares. By default, these values start at `1 WAD` (`1e18`). A fundamental constraint of the system is that both _slashing factors_ and _deposit scaling factors_ are monotonically decreasing. +_See the [Shares Accounting](./accounting/SharesAccounting.md) doc for a more thorough explanation with examples._ + +Throughout the `DelegationManager`, a staker's _deposit shares_ can be converted into their current _withdrawable shares_ by applying two factors: the _slashing factor_ and the _deposit scaling factor_. These two values are scaling factors that act as numerators when scaling shares. By default, these values start at `1 WAD` (`1e18`). `1 WAD` also acts as the denominator when scaling. ```solidity /// @dev All scaling factors have `1e18` as an initial/default value. This value is represented @@ -305,10 +307,6 @@ function _getSlashingFactor( } ``` -#### Applying Slashing to Withdrawals - -TODO - #### `delegateTo` ```solidity @@ -390,8 +388,8 @@ Just as with a normal queued withdrawal, these withdrawals can be completed by t * _Deposit shares_ are removed from the staker's deposit share balances * See [`EigenPodManager.removeDepositShares`](./EigenPodManager.md#removedepositshares) * See [`StrategyManager.removeDepositShares`](./StrategyManager.md#removedepositshares) - * _Deposit shares_ are converted to _withdrawable shares_ (See [Slashing Factors and Scaling Deposits](#slashing-factors-and-scaling-shares)). These are decremented from the operator's delegated shares. - * _Deposit shares_ are converted to _scaled shares_ (See [Applying Slashing to Withdrawals](#applying-slashing-to-withdrawals)), which are stored in the `Withdrawal` struct + * _Deposit shares_ are converted to _withdrawable shares_ (See [Slashing Factors and Scaling Shares](#slashing-factors-and-scaling-shares)). These are decremented from the operator's delegated shares. + * _Deposit shares_ are converted to _scaled shares_ (See [Shares Accounting - Queue Withdrawals](./accounting/SharesAccounting.md#queue-withdrawal)), which are stored in the `Withdrawal` struct * _Scaled shares_ are pushed to `_cumulativeScaledSharesHistory`, which is used for burning slashed shares * The `Withdrawal` is saved to storage * The hash of the `Withdrawal` is marked as "pending" @@ -476,7 +474,7 @@ function queueWithdrawals( returns (bytes32[] memory) ``` -Allows the caller to queue their deposit shares for withdrawal across any strategy. Withdrawals can be completed after `MIN_WITHDRAWAL_DELAY_BLOCKS`, by calling [`completeQueuedWithdrawal`](#completequeuedwithdrawal). This method accepts _deposit shares_ as input - however, the amounts received upon completion may be lower if the staker has experienced slashing (See [Shares Accounting - Terminology](./accounting/SharesAccounting.md#terminology) and [Slashing Factors and Scaling Shares](#slashing-factors-and-scaling-shares)). +Allows the caller to queue their deposit shares for withdrawal across any strategy. Withdrawals can be completed after `MIN_WITHDRAWAL_DELAY_BLOCKS`, by calling [`completeQueuedWithdrawal`](#completequeuedwithdrawal). This method accepts _deposit shares_ as input - however, the amounts received upon completion may be lower if the staker has experienced slashing (See [Shares Accounting](./accounting/SharesAccounting.md) and [Slashing Factors and Scaling Shares](#slashing-factors-and-scaling-shares)). For each `QueuedWithdrawalParams` passed as input, a `Withdrawal` is created in storage (See [Legacy and Post-Slashing Withdrawals](#legacy-and-post-slashing-withdrawals) for details on structure and querying). Queueing a withdrawal involves multiple transformations to a staker's _deposit shares_, serving a few different purposes: * The raw _deposit shares_ are removed from the staker's deposit share balance in the corresponding share manager (`EigenPodManager` or `StrategyManager`). @@ -493,7 +491,7 @@ Note that the `QueuedWithdrawalParams.__deprecated_withdrawer` field is ignored. * See [`EigenPodManager.removeDepositShares`](./EigenPodManager.md#removedepositshares) * See [`StrategyManager.removeDepositShares`](./StrategyManager.md#removedepositshares) * _Deposit shares_ are converted to _withdrawable shares_ (See [Slashing Factors and Scaling Deposits](#slashing-factors-and-scaling-shares)). These are decremented from their operator's delegated shares (if applicable) - * _Deposit shares_ are converted to _scaled shares_ (See [Applying Slashing to Withdrawals](#applying-slashing-to-withdrawals)), which are stored in the `Withdrawal` struct + * _Deposit shares_ are converted to _scaled shares_ (See [Shares Accounting - Queue Withdrawals](./accounting/SharesAccounting.md#queue-withdrawal)), which are stored in the `Withdrawal` struct * If the caller is delegated to an operator, _scaled shares_ are pushed to that operator's `_cumulativeScaledSharesHistory`, which may be burned if slashing occurs. * The `Withdrawal` is saved to storage * The hash of the `Withdrawal` is marked as "pending" @@ -513,6 +511,43 @@ Note that the `QueuedWithdrawalParams.__deprecated_withdrawer` field is ignored. #### `completeQueuedWithdrawal` ```solidity +/** + * @dev A struct representing an existing queued withdrawal. After the withdrawal delay has elapsed, this withdrawal can be completed via `completeQueuedWithdrawal`. + * A `Withdrawal` is created by the `DelegationManager` when `queueWithdrawals` is called. The `withdrawalRoots` hashes returned by `queueWithdrawals` can be used + * to fetch the corresponding `Withdrawal` from storage (via `getQueuedWithdrawal`). + * + * @param staker The address that queued the withdrawal + * @param delegatedTo The address that the staker was delegated to at the time the withdrawal was queued. Used to determine if additional slashing occurred before + * this withdrawal became completeable. + * @param withdrawer The address that will call the contract to complete the withdrawal. Note that this will always equal `staker`; alternate withdrawers are not + * supported at this time. + * @param nonce The staker's `cumulativeWithdrawalsQueued` at time of queuing. Used to ensure withdrawals have unique hashes. + * @param startBlock The block number when the withdrawal was queued. + * @param strategies The strategies requested for withdrawal when the withdrawal was queued + * @param scaledShares The staker's deposit shares requested for withdrawal, scaled by the staker's `depositScalingFactor`. Upon completion, these will be + * scaled by the appropriate slashing factor as of the withdrawal's completable block. The result is what is actually withdrawable. + */ +struct Withdrawal { + address staker; + address delegatedTo; + address withdrawer; + uint256 nonce; + uint32 startBlock; + IStrategy[] strategies; + uint256[] scaledShares; +} + +/** + * @notice Used to complete a queued withdrawal + * @param withdrawal The withdrawal to complete + * @param tokens Array in which the i-th entry specifies the `token` input to the 'withdraw' function of the i-th Strategy in the `withdrawal.strategies` array. + * @param tokens For each `withdrawal.strategies`, the underlying token of the strategy + * NOTE: if `receiveAsTokens` is false, the `tokens` array is unused and can be filled with default values. However, `tokens.length` MUST still be equal to `withdrawal.strategies.length`. + * NOTE: For the `beaconChainETHStrategy`, the corresponding `tokens` value is ignored (can be 0). + * @param receiveAsTokens If true, withdrawn shares will be converted to tokens and sent to the caller. If false, the caller receives shares that can be delegated to an operator. + * NOTE: if the caller receives shares and is currently delegated to an operator, the received shares are + * automatically delegated to the caller's current operator. + */ function completeQueuedWithdrawal( Withdrawal calldata withdrawal, IERC20[] calldata tokens, @@ -523,23 +558,19 @@ function completeQueuedWithdrawal( nonReentrant ``` -After waiting `minWithdrawalDelayBlocks()` number of blocks, this allows the `withdrawer` of a `Withdrawal` to finalize a withdrawal and receive either (i) the underlying tokens of the strategies being withdrawn from, or (ii) the withdrawable shares being withdrawn. This choice is dependent on the passed-in parameter `receiveAsTokens`. +`MIN_WITHDRAWAL_DELAY_BLOCKS` after queueing, a staker can complete a `Withdrawal` by calling this method. The staker can elect to receive _either_ tokens OR shares depending on the value of the `receiveAsTokens` parameter. + +Before processing a withdrawal, this method will calculate the slashing factor at the withdrawal's completion block (`withdrawal.startBlock + MIN_WITHDRAWAL_DELAY_BLOCKS`), according to the operator that was delegated to when the withdrawal was queued (`withdrawal.delegatedTo`). This slashing factor is used to determine if any additional slashing occurred while the withdrawal was in the queue. If so, this slashing is applied now. + +For each `Withdrawal`, `withdrawal.scaledShares` are converted into _withdrawable shares_, accounting for any slashing that occurred during the withdrawal period (See [Shares Accounting - Complete Withdrawal](./accounting/SharesAccounting.md#complete-withdrawal)). + +If the staker chooses to receive the withdrawal _as tokens_, the withdrawable shares are converted to tokens via the corresponding share manager (`EigenPodManager`/`StrategyManager`), and sent to the caller. -For each strategy/scaled share pair in the `Withdrawal`: -* The scaled shares in the`Withdrawal` are converted into actual withdrawable shares, accounting for any slashing that has occurred during the withdrawal period. -* If the `withdrawer` chooses to receive tokens: - * The calculated withdrawable shares are converted to their underlying tokens via either the `EigenPodManager` or `StrategyManager` and sent to the `withdrawer`. -* If the `withdrawer` chooses to receive shares (and the strategy belongs to the `StrategyManager`): - * The calculated withdrawable shares are awarded back(redeposited) to the `withdrawer` via the `StrategyManager` as deposit shares. - * If the `withdrawer` is delegated to an operator, that operator's delegated shares are increased by the added deposit shares (according to the strategy being added to). +If the staker chooses to receive the withdrawal _as shares_, the withdrawable shares are credited to the staker via the corresponding share manager (`EigenPodManager`/`StrategyManager`). Additionally, if the caller is delegated to an operator, the new slashing factor for the given `(staker, operator, strategy)` determines how many shares are awarded to the operator (and how the staker's deposit scaling factor is updated) (See [Slashing Factors and Scaling Shares](#slashing-factors-and-scaling-shares)). -`Withdrawals` concerning `EigenPodManager` shares have some additional nuance depending on whether a withdrawal is specified to be received as tokens vs shares (read more about "why" in [`EigenPodManager.md`](./EigenPodManager.md)): -* `EigenPodManager` withdrawals received as shares: - * OwnedShares ALWAYS go back to the originator of the withdrawal (rather than the `withdrawer` address). - * OwnedShares are also delegated to the originator's operator, rather than the `withdrawer's` operator. - * OwnedShares received by the originator may be lower than the shares originally withdrawn if the originator has debt. -* `EigenPodManager` withdrawals received as tokens: - * Before the withdrawal can be completed, the originator needs to prove that a withdrawal occurred on the beacon chain (see [`EigenPod.verifyAndProcessWithdrawals`](./EigenPodManager.md#eigenpodverifyandprocesswithdrawals)). +**Note:** if the staker (i) receives the withdrawal as shares, (ii) has `MAX_STAKER_STRATEGY_LIST_LENGTH` unique deposit strategies in the `StrategyManager`, and (iii) is withdrawing to a `StrategyManager` strategy in which they do not currently have shares, this will revert. The staker cannot withdraw such that their `stakerStrategyList` length exceeds the maximum; this withdrawal will have to be completed as tokens instead. + +**Note:** if the staker receives a `beaconChainETHStrategy` withdrawal as tokens, the staker's `EigenPod` MUST have sufficient `withdrawableExecutionLayerGwei` to honor the withdrawal. *Effects*: * The hash of the `Withdrawal` is removed from the pending withdrawals @@ -547,32 +578,36 @@ For each strategy/scaled share pair in the `Withdrawal`: * The `Withdrawal` struct is removed from the queued withdrawals * If `receiveAsTokens`: * See [`StrategyManager.withdrawSharesAsTokens`](./StrategyManager.md#withdrawsharesastokens) - * See [`EigenPodManager.withdrawSharesAsTokens`](./EigenPodManager.md#eigenpodmanagerwithdrawsharesastokens) + * See [`EigenPodManager.withdrawSharesAsTokens`](./EigenPodManager.md#withdrawsharesastokens) * If `!receiveAsTokens`: - * For `StrategyManager` strategies: - * OwnedShares are awarded to the `withdrawer` and delegated to the `withdrawer's` operator - * See [`StrategyManager.addShares`](./StrategyManager.md#addshares) - * For the native beacon chain ETH strategy (`EigenPodManager`): - * OwnedShares are awarded to `withdrawal.staker`, and delegated to the staker's operator - * See [`EigenPodManager.addShares`](./EigenPodManager.md#eigenpodmanageraddshares) + * Withdrawable shares are awarded to the caller and delegated to the caller's current operator if applicable + * See [`StrategyManager.addShares`](./StrategyManager.md#addshares) + * See [`EigenPodManager.addShares`](./EigenPodManager.md#addshares) *Requirements*: * Pause status MUST NOT be set: `PAUSED_EXIT_WITHDRAWAL_QUEUE` * `tokens.length` must equal `withdrawal.strategies.length` -* Caller MUST be the `withdrawer` specified in the `Withdrawal` -* At least `minWithdrawalDelayBlocks` MUST have passed before `completeQueuedWithdrawal` is called +* Caller MUST be the `staker/withdrawer` specified in the `Withdrawal` +* At least `MIN_WITHDRAWAL_DELAY_BLOCKS` MUST have passed before `completeQueuedWithdrawal` is called * The hash of the passed-in `Withdrawal` MUST correspond to a pending withdrawal * If `receiveAsTokens`: * The caller MUST pass in the underlying `IERC20[] tokens` being withdrawn in the appropriate order according to the strategies in the `Withdrawal`. * See [`StrategyManager.withdrawSharesAsTokens`](./StrategyManager.md#withdrawsharesastokens) - * See [`EigenPodManager.withdrawSharesAsTokens`](./EigenPodManager.md#eigenpodmanagerwithdrawsharesastokens) + * See [`EigenPodManager.withdrawSharesAsTokens`](./EigenPodManager.md#withdrawsharesastokens) * If `!receiveAsTokens`: * See [`StrategyManager.addShares`](./StrategyManager.md#addshares) - * See [`EigenPodManager.addShares`](./EigenPodManager.md#eigenpodmanageraddshares) + * See [`EigenPodManager.addShares`](./EigenPodManager.md#addshares) #### `completeQueuedWithdrawals` ```solidity +/** + * @notice Used to complete multiple queued withdrawals + * @param withdrawals Array of Withdrawals to complete. See `completeQueuedWithdrawal` for the usage of a single Withdrawal. + * @param tokens Array of tokens for each Withdrawal. See `completeQueuedWithdrawal` for the usage of a single array. + * @param receiveAsTokens Whether or not to complete each withdrawal as tokens. See `completeQueuedWithdrawal` for the usage of a single boolean. + * @dev See `completeQueuedWithdrawal` for relevant dev tags + */ function completeQueuedWithdrawals( Withdrawal[] calldata withdrawals, IERC20[][] calldata tokens, @@ -589,34 +624,90 @@ This method is the plural version of [`completeQueuedWithdrawal`](#completequeue ## Slashing and Accounting -These methods are called by the `StrategyManager` and `EigenPodManager` to update delegated share accounting when a staker's balance changes (e.g. due to a deposit): +These methods are all called by other system contracts: the `AllocationManager` calls `slashOperatorShares` during slashing, and the `EigenPodManager/StrategyManager` call `increaseDelegatedShares/decreaseDelegatedShares` when stakers' deposit shares (or when beacon chain balance decreases occur). +**Methods**: +* [`DelegationManager.slashOperatorShares`](#slashoperatorshares) * [`DelegationManager.increaseDelegatedShares`](#increasedelegatedshares) * [`DelegationManager.decreaseDelegatedShares`](#decreasedelegatedshares) +#### `slashOperatorShares` + +```solidity +/** + * @notice Decreases the operators shares in storage after a slash and increases the burnable shares by calling + * into either the StrategyManager or EigenPodManager (if the strategy is beaconChainETH). + * @param operator The operator to decrease shares for + * @param strategy The strategy to decrease shares for + * @param prevMaxMagnitude the previous maxMagnitude of the operator + * @param newMaxMagnitude the new maxMagnitude of the operator + * @dev Callable only by the AllocationManager + * @dev Note: Assumes `prevMaxMagnitude <= newMaxMagnitude`. This invariant is maintained in + * the AllocationManager. + */ +function slashOperatorShares( + address operator, + IStrategy strategy, + uint64 prevMaxMagnitude, + uint64 newMaxMagnitude +) + external + onlyAllocationManager +``` + +_See [Shares Accounting - Slashing](https://github.com/Layr-Labs/eigenlayer-contracts/blob/slashing-magnitudes/docs/core/accounting/SharesAccounting.md#slashing) for a description of the accounting in this method._ + +This method is called by the `AllocationManager` when processing an AVS's slash of an operator. Slashing occurs instantly, with this method directly reducing the operator's delegated shares proportional to the slash. + +Additionally, any _slashable shares_ in the withdrawal queue are marked for burning according to the same slashing proportion (shares in the withdrawal queue remain slashable for `MIN_WITHDRAWAL_DELAY_BLOCKS`). For the slashed strategy, the corresponding share manager (`EigenPodManager/StrateyManager`) is called, increasing the burnable shares for that strategy. + +**Note**: native ETH does not currently posess a burning mechanism, as this requires Pectra to be able to force exit validators. Currently, slashing for the `beaconChainETHStrategy` is realized by modifying the amount stakers are able to withdraw. + +*Effects*: +* The `operator's` `operatorShares` are reduced for the given `strategy`, according to the proportion given by `prevMaxMagnitude` and `newMaxMagnitude` +* Any slashable shares in the withdrawal queue are marked for burning according to the same proportion +* See [`StrategyManager.increaseBurnableShares`](./StrategyManager.md#increaseBurnableShares) +* See [`EigenPodManager.increaseBurnableShares`](./EigenPodManager.md#increaseBurnableShares) + + +*Requirements*: +* The amount slashed from the operator must not result in underflow of their `operatorShares` for the given `strategy` + #### `increaseDelegatedShares` ```solidity +/** + * @notice Called by a share manager when a staker's deposit share balance in a strategy increases. + * This method delegates any new shares to an operator (if applicable), and updates the staker's + * deposit scaling factor regardless. + * @param staker The address whose deposit shares have increased + * @param strategy The strategy in which shares have been deposited + * @param prevDepositShares The number of deposit shares the staker had in the strategy prior to the increase + * @param addedShares The number of deposit shares added by the staker + * + * @dev Note that if either the staker's current operator has been slashed 100% for `strategy`, OR the + * staker has been slashed 100% on the beacon chain such that the calculated slashing factor is 0, this + * method WILL REVERT. + */ function increaseDelegatedShares( - address staker, - IStrategy strategy, - uint256 shares -) + address staker, + IStrategy strategy, + uint256 prevDepositShares, + uint256 addedShares +) external onlyStrategyManagerOrEigenPodManager ``` -Called by either the `StrategyManager` or `EigenPodManager` when a staker's shares for one or more strategies increase. This method is called to ensure that if the staker is delegated to an operator, that operator's share count reflects the increase. +Called by either the `StrategyManager` or `EigenPodManager` when a staker's deposit shares for one or more strategies increase. -*Entry Points*: -* `StrategyManager.depositIntoStrategy` -* `StrategyManager.depositIntoStrategyWithSignature` -* `EigenPod.verifyWithdrawalCredentials` -* `EigenPod.verifyBalanceUpdates` -* `EigenPod.verifyAndProcessWithdrawals` +If the staker is delegated to an operator, the new deposit shares are directly added to that operator's `operatorShares`. Regardless of delegation status, the staker's deposit scaling factor is updated. -*Effects*: If the staker in question is delegated to an operator, the operator's shares for the `strategy` are increased. -* This method is a no-op if the staker is not delegated to an operator. +**Note** that if either the staker's current operator has been slashed 100% for `strategy`, OR the staker has been slashed 100% on the beacon chain such that the calculated slashing factor is 0, this method WILL REVERT. See [Shares Accounting - Fully Slashed](./accounting/SharesAccountingEdgeCases.md#fully-slashed-for-a-strategy) for details. + +*Effects*: +* If the staker is delegated to an operator, `addedShares` are added to the operator's shares +* The staker's deposit scaling factor is updated *Requirements*: * Caller MUST be either the `StrategyManager` or `EigenPodManager` @@ -624,23 +715,28 @@ Called by either the `StrategyManager` or `EigenPodManager` when a staker's shar #### `decreaseDelegatedShares` ```solidity +/** + * @notice If the staker is delegated, decreases its operator's shares in response to + * a decrease in balance in the beaconChainETHStrategy + * @param staker the staker whose operator's balance will be decreased + * @param curDepositShares the current deposit shares held by the staker + * @param beaconChainSlashingFactorDecrease the amount that the staker's beaconChainSlashingFactor has decreased by + * @dev Note: `beaconChainSlashingFactorDecrease` are assumed to ALWAYS be < 1 WAD. + * These invariants are maintained in the EigenPodManager. + */ function decreaseDelegatedShares( - address staker, - IStrategy strategy, - uint256 shares -) + address staker, + uint256 curDepositShares, + uint64 beaconChainSlashingFactorDecrease +) external - onlyStrategyManagerOrEigenPodManager + onlyEigenPodManager ``` -Called by the `EigenPodManager` when a staker's shares decrease. This method is called to ensure that if the staker is delegated to an operator, that operator's share count reflects the decrease. - -*Entry Points*: This method may be called as a result of the following top-level function calls: -* `EigenPod.verifyBalanceUpdates` -* `EigenPod.verifyAndProcessWithdrawals` +Called by the `EigenPodManager` when a staker's shares decrease due to a checkpointed balance decrease on the beacon chain. If the staker is delegated to an operator, the operator's shares are decreased in return. Otherwise, this method does nothing. -*Effects*: If the staker in question is delegated to an operator, the operator's delegated balance for the `strategy` is decreased by `shares` +*Effects*: If the staker in question is delegated to an operator, the operator's shares for the `beaconChainETHStrategy` are decreased by the amount the staker's withdrawable shares have decreased by * This method is a no-op if the staker is not delegated to an operator. *Requirements*: -* Caller MUST be either the `StrategyManager` or `EigenPodManager` (although the `StrategyManager` doesn't use this method) \ No newline at end of file +* Caller MUST be the `EigenPodManager` \ No newline at end of file diff --git a/docs/core/EigenPodManager.md b/docs/core/EigenPodManager.md index fde955d9f8..322ef3cdb7 100644 --- a/docs/core/EigenPodManager.md +++ b/docs/core/EigenPodManager.md @@ -1,50 +1,75 @@ ## EigenPodManager -| File | Type | Proxy | -| -------- | -------- | -------- | -| [`EigenPodManager.sol`](../../src/contracts/pods/EigenPodManager.sol) | Singleton | Transparent proxy | -| [`EigenPod.sol`](../../src/contracts/pods/EigenPod.sol) | Instanced, deployed per-user | Beacon proxy | +| File | Notes | +| -------- | -------- | +| [`EigenPodManager.sol`](../../src/contracts/pods/EigenPodManager.sol) | | +| [`EigenPodManagerStorage.sol`](../../src/contracts/pods/EigenPodManagerStorage.sol) | state variables | +| [`IEigenPodManager.sol`](../../src/contracts/interfaces/IEigenPodManager.sol) | interface | -The `EigenPodManager` manages the relationship between a Staker's `EigenPod`, the delegatable shares each Staker holds in the beacon chain ETH strategy, and the withdrawal of those shares via the `DelegationManager`. These functions together support Stakers' ability to restake beacon chain ETH and delegate restaked ETH to Operators in order to earn additional yield. +Libraries and Mixins: +| File | Notes | +| -------- | -------- | +| [`EigenPodPausingConstants.sol`](../../src/contracts/pods/EigenPodPausingConstants.sol) | pause values for `EigenPod/EigenPodManager` methods | -The `EigenPodManager` is the entry point for this process, allowing Stakers to deploy an `EigenPod` and begin restaking. After a Staker deploys their `EigenPod`, the `EigenPodManager` receives various updates from the pod that add or remove shares from the Staker. +## Prior Reading -#### High-level Concepts +* [Shares Accounting](./accounting/SharesAccounting.md), especially [_Handling Beacon Chain Balance Decreases in EigenPods_](./accounting/SharesAccounting.md#handling-beacon-chain-balance-decreases-in-eigenpods) -This document organizes methods according to the following themes (click each to be taken to the relevant section): +## Overview + +The `EigenPodManager` manages the "beacon chain ETH strategy", a virtual strategy that stakers can hold delegatable shares in, similar to the strategies managed by the `StrategyManager`. Whereas the `StrategyManager's` strategy shares are backed by deposited ERC20 tokens, beacon chain ETH strategy shares are backed either by beacon chain validators or native ETH attributed to `EigenPods`. + +The `EigenPodManager` allows any staker to deploy an `EigenPod`. `EigenPods` contains beacon chain state proof logic that enable a staker to point either/both a validator's _withdrawal credentials_ and/or _fee recipient_ addresses to their pod. After submitting beacon chain state proofs to their pod, the staker is awarded deposit shares in the beacon chain ETH strategy, which are then delegated to their operator in the `DelegationManager` (if applicable). For more details, see [`EigenPod.md`](./EigenPod.md). + +As an `EigenPod` receives balance updates, they are forwarded to the `EigenPodManager`. Balance increases resulting from validator activity on the beacon chain or ETH received in the `EigenPod` will result in an increase in the staker's _deposit shares_ for the beacon chain ETH strategy. + +Balance decreases resulting from validator inactivity or beacon chain slashing do NOT decrease the staker's deposit shares. Instead, they result in a _decrease_ to the staker's _beacon chain slashing factor_. Among other factors, the `DelegationManager` uses the beacon chain slashing factor when determining: +* How many of a staker's _deposit shares_ can actually be withdrawn +* How many of a staker's _deposit shares_ can be delegated to an operator + +Note that the number of _withdrawable shares_ a staker's _deposit shares_ represent can be queried using `DelegationManager.getWithdrawableShares(staker, strategies)`. + +The `EigenPodManager's` responsibilities can be broken down into the following concepts: * [Depositing Into EigenLayer](#depositing-into-eigenlayer) * [Withdrawal Processing](#withdrawal-processing) * [Other Methods](#other-methods) -#### Important State Variables +## Parameterization -* `mapping(address => IEigenPod) public ownerToPod`: Tracks the deployed `EigenPod` for each Staker -* `mapping(address => int256) public podOwnerShares`: Keeps track of the actively restaked beacon chain ETH for each Staker. - * In some cases, a beacon chain balance update may cause a Staker's balance to drop below zero. This is because when queueing for a withdrawal in the `DelegationManager`, the Staker's current shares are fully removed. If the Staker's beacon chain balance drops after this occurs, their `podOwnerShares` may go negative. This is a temporary change to account for the drop in balance, and is ultimately corrected when the withdrawal is finally processed. - * Since balances on the consensus layer are stored only in Gwei amounts, the EigenPodManager enforces the invariant that `podOwnerShares` is always a whole Gwei amount for every staker, i.e. `podOwnerShares[staker] % 1e9 == 0` always. +* `beaconChainETHStrategy = 0xbeaC0eeEeeeeEEeEeEEEEeeEEeEeeeEeeEEBEaC0` + * A virtual strategy used to represent beacon chain ETH internally. The `DelegationManager` uses this address to denote the beacon chain ETH strategy managed by the `EigenPodManager`. However, it does not correspond to an actual contract! +* `ethPOS = 0x00000000219ab540356cBB839Cbe05303d7705Fa` + * The address of the beacon chain deposit contract +* `beaconProxyBytecode` (defined in `EigenPodManagerStorage.sol`) + * `EigenPods` are deployed using a beacon proxy. This bytecode is a constant, containing the _creation bytecode_ calculated by compiling [OpenZeppelin's `BeaconProxy` contract at version 4.7.1](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.7.1/contracts/proxy/beacon/BeaconProxy.sol). Compilation used solc version `0.8.12`, optimization enabled, 200 runs. Example verified contract [here](https://etherscan.io/address/0xA6f93249580EC3F08016cD3d4154AADD70aC3C96#code). ---- +--- -### Depositing Into EigenLayer +## Depositing Into EigenLayer -Before a Staker begins restaking beacon chain ETH, they need to deploy an `EigenPod`, stake, and start a beacon chain validator: +Before a staker begins restaking beacon chain ETH, they need to deploy an `EigenPod`, stake, and start a beacon chain validator: * [`createPod`](#createpod) * [`stake`](#stake) #### `createPod` ```solidity -function createPod() - external - onlyWhenNotPaused(PAUSED_NEW_EIGENPODS) +/** + * @notice Creates an EigenPod for the sender. + * @dev Function will revert if the `msg.sender` already has an EigenPod. + * @dev Returns EigenPod address + */ +function createPod() + external + onlyWhenNotPaused(PAUSED_NEW_EIGENPODS) returns (address) ``` -Allows a Staker to deploy an `EigenPod` instance, if they have not done so already. +Allows a staker to deploy an `EigenPod` instance, if they have not done so already. -Each Staker can only deploy a single `EigenPod` instance, but a single `EigenPod` can serve as the fee recipient / withdrawal credentials for any number of beacon chain validators. Each `EigenPod` is created using Create2 and the beacon proxy pattern, using the Staker's address as the Create2 salt. +Each staker can only deploy a single `EigenPod` instance, but a single `EigenPod` can serve as the fee recipient / withdrawal credentials for any number of beacon chain validators. Each `EigenPod` is created using Create2 and the beacon proxy pattern, using the staker's address as the Create2 salt. -As part of the `EigenPod` deployment process, the Staker is made the Pod Owner, a permissioned role within the `EigenPod`. +As part of the `EigenPod` deployment process, the staker is made the Pod Owner, a permissioned role within the `EigenPod`. *Effects*: * Create2 deploys `EigenPodManager.beaconProxyBytecode`, appending the `eigenPodBeacon` address as a constructor argument. `bytes32(msg.sender)` is used as the salt. @@ -60,20 +85,27 @@ As part of the `EigenPod` deployment process, the Staker is made the Pod Owner, #### `stake` ```solidity +/** + * @notice Stakes for a new beacon chain validator on the sender's EigenPod. + * Also creates an EigenPod for the sender if they don't have one already. + * @param pubkey The 48 bytes public key of the beacon chain validator. + * @param signature The validator's signature of the deposit data. + * @param depositDataRoot The root/hash of the deposit data for the validator's deposit. + */ function stake( - bytes calldata pubkey, - bytes calldata signature, + bytes calldata pubkey, + bytes calldata signature, bytes32 depositDataRoot -) - external +) + external payable onlyWhenNotPaused(PAUSED_NEW_EIGENPODS) ``` -Allows a Staker to deposit 32 ETH into the beacon chain deposit contract, providing the credentials for the Staker's beacon chain validator. The `EigenPod.stake` method is called, which automatically calculates the correct withdrawal credentials for the pod and passes these to the deposit contract along with the 32 ETH. +Allows a staker to deposit 32 ETH into the beacon chain deposit contract, providing the credentials for the staker's beacon chain validator. The `EigenPod.stake` method is called, which automatically calculates the correct withdrawal credentials for the pod and passes these to the deposit contract along with the 32 ETH. *Effects*: -* Deploys and initializes an `EigenPod` on behalf of Staker, if this has not been done already +* Deploys and initializes an `EigenPod` on behalf of staker, if this has not been done already * See [`EigenPod.stake`](./EigenPod.md#stake) *Requirements*: @@ -82,143 +114,258 @@ Allows a Staker to deposit 32 ETH into the beacon chain deposit contract, provid --- -### Withdrawal Processing +## Withdrawal Processing + +These methods are callable ONLY by the DelegationManager, and are used when processing undelegations and withdrawals. -The `DelegationManager` is the entry point for all undelegation and withdrawals, which must be queued for a time before being completed. When a withdrawal is initiated, the `DelegationManager` calls the following method: -* [`removeShares`](#removeshares) +**Concepts**: +* [Shares Accounting - Handling Beacon Chain Balance Decreases](./accounting/SharesAccounting.md#handling-beacon-chain-balance-decreases-in-eigenpods) +* [Deposit Shares and Beacon Chain Slashing](#deposit-shares-and-beacon-chain-slashing) -When completing a queued undelegation or withdrawal, the `DelegationManager` calls one of these two methods: +**Methods**: +* [`removeDepositShares`](#removeDepositShares) * [`addShares`](#addshares) * [`withdrawSharesAsTokens`](#withdrawsharesastokens) -#### `removeShares` +#### Deposit Shares and Beacon Chain Slashing + +The `EigenPodManager` tracks a staker's _deposit shares_ and _beacon chain slashing factor_ using the following state variables: ```solidity -function removeShares( - address podOwner, - uint256 shares -) - external +/** + * @notice mapping from pod owner to the deposit shares they have in the virtual beacon chain ETH strategy + * + * @dev When an EigenPod registers a balance increase, deposit shares are increased. When registering a balance + * decrease, however, deposit shares are NOT decreased. Instead, the pod owner's beacon chain slashing factor + * is decreased proportional to the balance decrease. This impacts the number of shares that will be withdrawn + * when the deposit shares are queued for withdrawal in the DelegationManager. + * + * Note that prior to the slashing release, deposit shares were decreased when balance decreases occurred. + * In certain cases, a combination of queueing a withdrawal plus registering a balance decrease could result + * in a staker having negative deposit shares in this mapping. This negative value would be corrected when the + * staker completes a withdrawal (as tokens or as shares). + * + * With the slashing release, negative shares are no longer possible. However, a staker can still have negative + * shares if they met the conditions for them before the slashing release. If this is the case, that staker + * should complete any outstanding queued withdrawal in the DelegationManager ("as shares"). This will correct + * the negative share count and allow the staker to continue using their pod as normal. + */ +mapping(address podOwner => int256 shares) public podOwnerDepositShares; + +/** + * @notice The amount of beacon chain slashing experienced by a pod owner as a proportion of WAD + * @param isSet whether the slashingFactor has ever been updated. Used to distinguish between + * a value of "0" and an uninitialized value. + * @param slashingFactor the proportion of the pod owner's balance that has been decreased due to + * slashing or other beacon chain balance decreases. + * @dev NOTE: if !isSet, `slashingFactor` should be treated as WAD. `slashingFactor` is monotonically + * decreasing and can hit 0 if fully slashed. + */ +struct BeaconChainSlashingFactor { + bool isSet; + uint64 slashingFactor; +} + +/// @notice Returns the slashing factor applied to the `staker` for the `beaconChainETHStrategy` +/// Note: this value starts at 1 WAD (1e18) for all stakers, and is updated when a staker's pod registers +/// a balance decrease. +mapping(address staker => BeaconChainSlashingFactor) internal _beaconChainSlashingFactor; +``` + +#### `removeDepositShares` + +```solidity +/** + * @notice Used by the DelegationManager to remove a pod owner's deposit shares when they enter the withdrawal queue. + * Simply decreases the `podOwner`'s shares by `shares`, down to a minimum of zero. + * @dev This function reverts if it would result in `podOwnerDepositShares[podOwner]` being less than zero, i.e. it is forbidden for this function to + * result in the `podOwner` incurring a "share deficit". This behavior prevents a Staker from queuing a withdrawal which improperly removes excessive + * shares from the operator to whom the staker is delegated. + * @dev The delegation manager validates that the podOwner is not address(0) + */ +function removeDepositShares( + address podOwner, + IStrategy strategy, + uint256 depositSharesToRemove +) + external onlyDelegationManager ``` -The `DelegationManager` calls this method when a Staker queues a withdrawal (or undelegates, which also queues a withdrawal). The shares are removed while the withdrawal is in the queue, and when the queue completes, the shares will either be re-awarded or withdrawn as tokens (`addShares` and `withdrawSharesAsTokens`, respectively). +The `DelegationManager` calls this method when a staker queues a withdrawal (or undelegates, which also queues a withdrawal). The shares are removed while the withdrawal is in the queue, and when the queue completes, the shares will either be re-awarded or withdrawn as tokens (`addShares` and `withdrawSharesAsTokens`, respectively). -The Staker's share balance is decreased by the removed `shares`. +The staker's share balance is decreased by `depositSharesToRemove`. -This method is not allowed to cause the `Staker's` balance to go negative. This prevents a Staker from queueing a withdrawal for more shares than they have (or more shares than they delegated to an Operator). +This method is not allowed to cause the `staker's` balance to go negative. This prevents a staker from queueing a withdrawal for more shares than they have (or more shares than they delegated to an operator). -*Entry Points*: -* `DelegationManager.undelegate` -* `DelegationManager.queueWithdrawals` +Note that the amount of deposit shares removed while in the withdrawal queue may not equal the amount credited when the withdrawal is completed. The staker may receive fewer if slashing occurred; see [`DelegationManager.md`](./DelegationManager.md) for details. *Effects*: -* Removes `shares` from `podOwner's` share balance +* Removes `depositSharesToRemove` from `podOwner` share balance in `podOwnerDepositShares` +* Emits a `NewTotalShares` event *Requirements*: -* `podOwner` MUST NOT be zero -* `shares` MUST NOT be negative when converted to `int256` -* `shares` MUST NOT be greater than `podOwner's` share balance -* `shares` MUST be a whole Gwei amount +* Caller MUST be the `DelegationManager` +* `strategy` MUST be `beaconChainETHStrategy` +* `staker` MUST NOT be zero +* `depositSharesToRemove` MUST be less than `staker` share balance in `podOwnerDepositShares` #### `addShares` ```solidity +/** + * @notice Increases the `podOwner`'s shares by `shares`, paying off negative shares if needed. + * Used by the DelegationManager to award a pod owner shares on exiting the withdrawal queue + * @return existingDepositShares the pod owner's shares prior to any additions. Returns 0 if negative + * @return addedShares the number of shares added to the staker's balance above 0. This means that if, + * after shares are added, the staker's balance is non-positive, this will return 0. + */ function addShares( - address podOwner, + address staker, + IStrategy strategy, uint256 shares -) - external - onlyDelegationManager - returns (uint256) +) + external + onlyDelegationManager + returns (uint256, uint256) ``` -The `DelegationManager` calls this method when a queued withdrawal is completed and the withdrawer specifies that they want to receive the withdrawal as "shares" (rather than as the underlying tokens). A Pod Owner might want to do this in order to change their delegated Operator without needing to fully exit their validators. - -Note that typically, shares from completed withdrawals are awarded to a `withdrawer` specified when the withdrawal is initiated in `DelegationManager.queueWithdrawals`. However, because beacon chain ETH shares are linked to proofs provided to a Pod Owner's `EigenPod`, this method is used to award shares to the original Pod Owner. +The `DelegationManager` calls this method when a queued withdrawal is completed and the withdrawer specifies that they want to receive the withdrawal "as shares" (rather than as the underlying tokens). A staker might want to do this in order to change their delegated operator without needing to fully exit their validators. -If the Pod Owner has a share deficit (negative shares), the deficit is repaid out of the added `shares`. If the Pod Owner's positive share count increases, this change is returned to the `DelegationManager` to be delegated to the Pod Owner's Operator (if they have one). +This method credits the input deposit shares to the staker. In most cases, the input `shares` equal the same shares originally removed when the withdrawal was queued. However, if the staker's operator was slashed (or the staker experienced beacon chain slashing), they may receive less. See [`DelegationManager.md`](./DelegationManager.md) for details. -*Entry Points*: -* `DelegationManager.completeQueuedWithdrawal` -* `DelegationManager.completeQueuedWithdrawals` +If the staker has a share deficit (negative shares), the deficit is repaid out of the added `shares`. If the Pod Owner's positive share count increases, this change is returned to the `DelegationManager` to be delegated to the staker's operator (if they have one). *Effects*: -* The `podOwner's` share balance is increased by `shares` +* Increases `staker`'s deposit share balance in `podOwnerDepositShares` by `shares` *Requirements*: -* `podOwner` MUST NOT be zero +* Caller MUST be the `DelegationManager` +* `strategy` MUST be `beaconChainETHStrategy` +* `staker` MUST NOT be `address(0)` * `shares` MUST NOT be negative when converted to an `int256` -* `shares` MUST be a whole Gwei amount +* Emits `PodSharesUpdated` and `NewTotalShares` events #### `withdrawSharesAsTokens` ```solidity +/** + * @notice Used by the DelegationManager to complete a withdrawal, sending tokens to the pod owner + * @dev Prioritizes decreasing the podOwner's share deficit, if they have one + * @dev This function assumes that `removeShares` has already been called by the delegationManager, hence why + * we do not need to update the podOwnerDepositShares if `currentpodOwnerDepositShares` is positive + */ function withdrawSharesAsTokens( - address podOwner, - address destination, + address podOwner, + IStrategy strategy, + IERC20, uint256 shares -) - external +) + external onlyDelegationManager ``` -The `DelegationManager` calls this method when a queued withdrawal is completed and the withdrawer specifies that they want to receive the withdrawal as tokens (rather than shares). This can be used to "fully exit" some amount of beacon chain ETH and send it to a recipient (via `EigenPod.withdrawRestakedBeaconChainETH`). +The `DelegationManager` calls this method when a queued withdrawal is completed and the withdrawer specifies that they want to receive the withdrawal as the tokens underlying the shares. This can be used to "fully exit" some amount of native ETH and send it to the pod owner (via `EigenPod.withdrawRestakedBeaconChainETH`). -Note that because this method entails withdrawing and sending beacon chain ETH, two conditions must be met for this method to succeed: (i) the ETH being withdrawn should already be in the `EigenPod`, and (ii) the amount being withdrawn should be accounted for in `EigenPod.withdrawableRestakedExecutionLayerGwei`. This latter condition can be achieved by completing an `EigenPod` checkpoint just prior to completing a queued `DelegationManager` withdrawal (see [EigenPod: Checkpointing Validators](./EigenPod.md#checkpointing-validators) for details). +Note that because this method entails withdrawing and sending native ETH, two conditions must be met for this method to succeed: (i) the ETH being withdrawn should already be in the `EigenPod`, and (ii) the amount being withdrawn should be accounted for in `EigenPod.withdrawableExecutionLayerGwei`. This latter condition can be achieved by completing an `EigenPod` checkpoint just prior to completing a queued `DelegationManager` withdrawal (see [EigenPod: Checkpointing Validators](./EigenPod.md#checkpointing-validators) for details). Also note that, like `addShares`, if the original Pod Owner has a share deficit (negative shares), the deficit is repaid out of the withdrawn `shares` before any native ETH is withdrawn. -*Entry Points*: -* `DelegationManager.completeQueuedWithdrawal` -* `DelegationManager.completeQueuedWithdrawals` - *Effects*: -* If `podOwner's` share balance is negative, `shares` are added until the balance hits 0 - * Any remaining shares are converted 1:1 to ETH and sent to `destination` (see [`EigenPod.withdrawRestakedBeaconChainETH`](./EigenPod.md#withdrawrestakedbeaconchaineth)) +* If `staker`'s share balance in `podOwnerDepositShares` is negative (i.e. the staker has a *deficit*): + * If `shares` is greater than the current deficit: + * Sets `staker` balance in `podOwnerDepositShares` to 0 + * Subtracts `|deficit|` from `shares` and converts remaining shares 1:1 to ETH (see [`EigenPod.withdrawRestakedBeaconChainETH`](./EigenPod.md#withdrawrestakedbeaconchaineth)) + * If `shares` is less than or equal to the current deficit: + * Increases `staker` negative balance in `podOwnerDepositShares` by `shares`, bringing it closer to 0 + * Does *not* withdraw any shares +* Emits `PodSharesUpdated` and `NewTotalShares` events *Requirements*: -* `podOwner` MUST NOT be zero -* `destination` MUST NOT be zero +* Caller MUST be the `DelegationManager` +* `strategy` MUST be `beaconChainETHStrategy` +* `staker` MUST NOT be `address(0)` * `shares` MUST NOT be negative when converted to an `int256` -* `shares` MUST be a whole Gwei amount * See [`EigenPod.withdrawRestakedBeaconChainETH`](./EigenPod.md#withdrawrestakedbeaconchaineth) --- -### Other Methods +## Other Methods + +**Methods**: +* [`recordBeaconChainETHBalanceUpdate`](#recordbeaconchainethbalanceupdate) +* [`increaseBurnableShares`](#increaseburnableshares) #### `recordBeaconChainETHBalanceUpdate` ```solidity +/** + * @notice Adds any positive share delta to the pod owner's deposit shares, and delegates them to the pod + * owner's operator (if applicable). A negative share delta does NOT impact the pod owner's deposit shares, + * but will reduce their beacon chain slashing factor and delegated shares accordingly. + * @param podOwner is the pod owner whose balance is being updated. + * @param prevRestakedBalanceWei is the total amount restaked through the pod before the balance update, including + * any amount currently in the withdrawal queue. + * @param balanceDeltaWei is the amount the balance changed + * @dev Callable only by the podOwner's EigenPod contract. + * @dev Reverts if `sharesDelta` is not a whole Gwei amount + */ function recordBeaconChainETHBalanceUpdate( address podOwner, - int256 sharesDelta -) - external - onlyEigenPod(podOwner) + uint256 prevRestakedBalanceWei, + int256 balanceDeltaWei +) + external + onlyEigenPod(podOwner) nonReentrant ``` -This method is called by an `EigenPod` to report a change in its Pod Owner's shares. It accepts a positive or negative `sharesDelta`, which is added/subtracted against the Pod Owner's shares. The delta is also communicated to the `DelegationManager`, which updates the number of shares the Pod Owner has delegated to an Operator. +This method is called by an `EigenPod` to report a change in its pod owner's shares. It accepts a positive or negative `balanceDeltaWei`. A positive delta is added to the pod owner's _deposit shares,_ and delegated to their operator if applicable. A negative delta is NOT removed from the pod owner's deposit shares. Instead, the proportion of the balance decrease is used to update the pod owner's beacon chain slashing factor and decrease the number of shares delegated to their operator (if applicable). -Note that this method _may_ result in a Pod Owner's shares going negative. This can occur when: -* The Pod Owner has queued a withdrawal for all their Beacon Chain ETH shares via `DelegationManager.queueWithdrawals` - * This will set the `EigenPodManager.podOwnerShares[podOwner]` to 0 -* The Pod Owner's pod reports a negative delta, perhaps due to the Pod Owner getting slashed on the beacon chain. +**Note** that prior to the slashing release, negative balance deltas subtracted from the pod owner's shares, and could, in certain cases, result in a negative share balance. As of the slashing release, negative balance deltas no longer subtract from share balances, updating the beacon chain slashing factor instead. -In this case, the Pod Owner's `podOwnerShares` will go negative. - -*Entry Points*: -* `EigenPod.verifyWithdrawalCredentials` -* `EigenPod.startCheckpoint` -* `EigenPod.verifyCheckpointProofs` +If a staker has negative shares as of the slashing release, this method will REVERT, preventing any further balance updates from their pod while the negative share balance persists. In order to fix this and restore the use of their pod, the staker should complete any outstanding withdrawals in the `DelegationManager` "as shares," which will correct the share deficit. *Effects*: -* Adds or removes `sharesDelta` from the Pod Owner's shares -* If `sharesDelta` is negative: see [`DelegationManager.decreaseDelegatedShares`](./DelegationManager.md#decreasedelegatedshares) -* If `sharesDelta` is positive: see [`DelegationManager.increaseDelegatedShares`](./DelegationManager.md#increasedelegatedshares) +* If `balanceDeltaWei` is positive or 0: + * Adds `shares` to `podOwnerDepositShares` for `podOwner` + * Emits `PodSharesUpdated` and `NewTotalShares` events + * Calls [`DelegationManager.increaseDelegatedShares`](./DelegationManager.md#increasedelegatedshares) +* If `balanceDeltaWei` is negative: + * Reduces slashing factor proportional to relative balance decrease + * Emits `BeaconChainSlashingFactorDecreased` event + * Calls [`DelegationManager.decreaseDelegatedShares`](./DelegationManager.md#decreasedelegatedshares) *Requirements*: * Caller MUST be the `EigenPod` associated with the passed-in `podOwner` -* `sharesDelta` MUST be a whole Gwei amount +* `podOwner` MUST NOT be `address(0)` +* `balanceDeltaWei` MUST be a whole Gwei amount +* Legacy withdrawals MUST be complete (i.e. `currentDepositShares >= 0`) + +#### `increaseBurnableShares` + +```solidity +/** + * @notice Increase the amount of burnable shares for a given Strategy. This is called by the DelegationManager + * when an operator is slashed in EigenLayer. + * @param strategy The strategy to burn shares in. + * @param addedSharesToBurn The amount of added shares to burn. + * @dev This function is only called by the DelegationManager when an operator is slashed. + */ +function increaseBurnableShares( + IStrategy strategy, + uint256 addedSharesToBurn +) + external + onlyDelegationManager +``` + +The `DelegationManager` calls this method when an operator is slashed, calculating the number of slashable shares and marking them for burning here. + +Unlike in the `StrategyManager`, there is no current mechanism to burn these shares, as burning requires the Pectra hard fork to be able to eject validators. This will be added in a future update. + +*Effects*: +* Increases `burnableShares` for the beacon chain ETH strategy by `addedSharesToBurn` + +*Requirements*: +* Can only be called by the `DelegationManager` \ No newline at end of file diff --git a/docs/core/StrategyManager.md b/docs/core/StrategyManager.md index 346ced740d..34e4d8797d 100644 --- a/docs/core/StrategyManager.md +++ b/docs/core/StrategyManager.md @@ -1,50 +1,58 @@ ## StrategyManager -| File | Type | Proxy | -| -------- | -------- | -------- | -| [`StrategyManager.sol`](../../src/contracts/core/StrategyManager.sol) | Singleton | Transparent proxy | -| [`StrategyFactory.sol`](../../src/contracts/core/StrategyFactory.sol) | Singleton | Transparent proxy | -| [`StrategyBaseTVLLimits.sol`](../../src/contracts/strategies/StrategyBaseTVLLimits.sol) | Instanced, one per supported token | - Strategies deployed outside the `StrategyFactory` use transparent proxies
- Anything deployed via the `StrategyFactory` uses a Beacon proxy | +| File | Notes | +| -------- | -------- | +| [`StrategyManager.sol`](../../src/contracts/core/StrategyManager.sol) | singleton share manager hooked into core | +| [`StrategyManagerStorage.sol`](../../src/contracts/core/StrategyManagerStorage.sol) | state variables | +| [`IStrategyManager.sol`](../../src/contracts/interfaces/IStrategyManager.sol) | interface | -The primary function of the `StrategyManager` is to handle accounting for individual Stakers as they deposit and withdraw supported tokens from their corresponding strategies. It is responsible for (i) allowing Stakers to deposit tokens into the corresponding strategy, (ii) allowing the `DelegationManager` to remove shares when a Staker queues a withdrawal, and (iii) allowing the `DelegationManager` to complete a withdrawal by either adding shares back to the Staker or withdrawing the shares as tokens via the corresponding strategy. +StrategyFactory: -Any ERC20-compatible token can be supported by deploying a `StrategyBaseTVLLimits` instance from the `StrategyFactory`. The `StrategyFactory` only allows a strategy to be deployed once per token, and automatically whitelists newly-deployed strategies. This is further documented in [Strategies](#strategies) below. +| File | Notes | +| -------- | -------- | +| [`StrategyFactory.sol`](../../src/contracts/core/StrategyFactory.sol) | allows deployment of `StrategyBase` for ERC20 tokens | +| [`StrategyBase.sol`](../../src/contracts/strategies/StrategyBase.sol) | deployed as a beacon proxy via `StrategyFactory` | -Each supported token has its own instance of `StrategyBaseTVLLimits`, has two main functions (`deposit` and `withdraw`), both of which can only be called by the `StrategyManager`. These `StrategyBaseTVLLimits` contracts are fairly simple deposit/withdraw contracts that hold tokens deposited by Stakers. Because these strategies are essentially extensions of the `StrategyManager`, their functions are documented in this file (see [Strategies](#strategies) below). +Individual strategies: -Note that for the EIGEN/bEIGEN token specifically, the `EigenStrategy` contract is used instead of `StrategyBaseTVLLimits`. Additionally, the EIGEN/bEIGEN token and several LSTs whitelisted prior to the existence of the `StrategyFactory` are blacklisted within the `StrategyFactory` to prevent duplicate strategies from being deployed for these tokens. +| File | Notes | +| -------- | -------- | +| [`StrategyBaseTVLLimits.sol`](../../src/contracts/strategies/StrategyBaseTVLLimits.sol) | Pre-StrategyFactory, deployed for certain LSTs. Each instances uses a transparent proxy pattern | +| [`EigenStrategy.sol`](../../src/contracts/strategies/EigenStrategy.sol) | One-off strategy deployed to support EIGEN/bEIGEN | -#### High-level Concepts +## Overview -This document organizes methods according to the following themes (click each to be taken to the relevant section): +The primary function of the `StrategyManager` is to handle _deposit share_ accounting for individual stakers as they deposit and withdraw supported tokens from their corresponding strategies. Note that the `StrategyManager` only handles _deposit shares_. When the word _shares_ is used in this document, it refers to _deposit shares,_ specifically. For an explanation of other share types, see [Shares Accounting - Terminology](./accounting/SharesAccounting.md#terminology). + +The `StrategyManager` is responsible for (i) allowing stakers to deposit tokens into the corresponding strategy, (ii) allowing the `DelegationManager` to remove deposit shares when a staker queues a withdrawal, and (iii) allowing the `DelegationManager` to complete a withdrawal by either adding deposit shares back to the staker or withdrawing the deposit shares as tokens via the corresponding strategy. + +Any ERC20-compatible token can be supported by deploying a `StrategyBase` instance from the `StrategyFactory`. Under the hood, the `StrategyFactory` uses the beacon proxy pattern and only allows a strategy to be deployed once per token. Deployed strategies are automatically whitelists for deposit in the `StrategyManager`. For details, see [Strategies](#strategies) below. + +**Note**: for the EIGEN/bEIGEN token specifically, the `EigenStrategy` contract is used instead of `StrategyBase`. Additionally, the EIGEN/bEIGEN token are blacklisted within the `StrategyFactory` to prevent duplicate strategies from being deployed for these tokens. + +**Note**: for certain LST tokens, the `StrategyBaseTVLLimits` contract is used instead of `StrategyBase`. These strategies were deployed before the `StrategyFactory` allowed arbitrary ERC20 strategies. Unlike strategies deployed through the `StrategyFactory`, these `StrategyBaseTVLLimits` contracts use the transparent proxy pattern. For all intents and purposes, these instances behave the same as `StrategyBase` instances deployed from the `StrategyFactory`. The "TVL Limits" capability of these instances has never been used. Any tokens using one of these instances are blacklisted in the `StrategyFactory` to prevent duplicate strategies from being deployed for these tokens. + +The `StrategyManager's` responsibilities can be broken down into the following concepts: * [Depositing Into Strategies](#depositing-into-strategies) * [Withdrawal Processing](#withdrawal-processing) +* [Burning Slashed Shares](#burning-slashed-shares) * [Strategies](#strategies) * [System Configuration](#system-configuration) -#### Important state variables - -* `mapping(address => mapping(IStrategy => uint256)) public stakerStrategyShares`: Tracks the current balance a Staker holds in a given strategy. Updated on deposit/withdraw. -* `mapping(address => IStrategy[]) public stakerStrategyList`: Maintains a list of the strategies a Staker holds a nonzero number of shares in. - * Updated as needed when Stakers deposit and withdraw: if a Staker has a zero balance in a Strategy, it is removed from the list. Likewise, if a Staker deposits into a Strategy and did not previously have a balance, it is added to the list. -* `mapping(IStrategy => bool) public strategyIsWhitelistedForDeposit`: The `strategyWhitelister` is (as of M2) a permissioned role that can be changed by the contract owner. The `strategyWhitelister` has currently whitelisted 3 `StrategyBaseTVLLimits` contracts in this mapping, one for each supported LST. -* `mapping(IStrategy => bool) public thirdPartyTransfersForbidden`: The `strategyWhitelister` can disable third party transfers for a given strategy. If `thirdPartyTransfersForbidden[strategy] == true`: - * Users cannot deposit on behalf of someone else (see [`depositIntoStrategyWithSignature`](#depositintostrategywithsignature)). - * Users cannot withdraw on behalf of someone else. (see [`DelegationManager.queueWithdrawals`](./DelegationManager.md#queuewithdrawals)) - -#### Helpful definitions +## Parameterization -* `stakerStrategyListLength(address staker) -> (uint)`: - * Gives `stakerStrategyList[staker].length` - * Used (especially by the `DelegationManager`) to determine whether a Staker has shares in any strategy in the `StrategyManager` (will be 0 if not) -* `uint256 constant MAX_TOTAL_SHARES = 1e38 - 1` - * The maximum total shares a single strategy can handle. This maximum prevents overflow in offchain services. +* `MAX_TOTAL_SHARES = 1e38 - 1` + * The maximum total shares a single strategy can handle. This maximum prevents overflow in offchain services. Deposits that would increase a strategy's total shares beyond this value will revert. +* `MAX_STAKER_STRATEGY_LIST_LENGTH = 32` + * The maximum number of unique `StrategyManager` strategies a staker can have deposits in. Any deposits that cause this number to be exceeded will revert. +* `DEFAULT_BURN_ADDRESS = 0x00000000000000000000000000000000000E16E4` + * When slashed shares are burned, they are converted to tokens and transferred to this address, where they are unrecoverable. --- -### Depositing Into Strategies +## Depositing Into Strategies -The following methods are called by Stakers as they (i) deposit LSTs into strategies to receive shares: +The following methods are called by stakers as they (i) deposit ERC20 tokens into strategies to receive deposit shares: * [`StrategyManager.depositIntoStrategy`](#depositintostrategy) * [`StrategyManager.depositIntoStrategyWithSignature`](#depositintostrategywithsignature) @@ -54,39 +62,67 @@ Withdrawals are performed through the `DelegationManager` (see [`DelegationManag #### `depositIntoStrategy` ```solidity +/** + * @notice Deposits `amount` of `token` into the specified `strategy` and credits shares to the caller + * @param strategy the strategy that handles `token` + * @param token the token from which the `amount` will be transferred + * @param amount the number of tokens to deposit + * @return depositShares the number of deposit shares credited to the caller + * @dev The caller must have previously approved this contract to transfer at least `amount` of `token` on their behalf. + * + * WARNING: Be extremely cautious when depositing tokens that do not strictly adhere to ERC20 standards. + * Tokens that diverge significantly from ERC20 norms can cause unexpected behavior in token balances for + * that strategy, e.g. ERC-777 tokens allowing cross-contract reentrancy. + */ function depositIntoStrategy( - IStrategy strategy, - IERC20 token, + IStrategy strategy, + IERC20 token, uint256 amount ) external onlyWhenNotPaused(PAUSED_DEPOSITS) - onlyNotFrozen(msg.sender) nonReentrant - returns (uint256 shares) + returns (uint256 depositShares) ``` -Allows a Staker to deposit some `amount` of `token` into the specified `strategy` in exchange for shares of that strategy. The underlying `strategy` must be one of the whitelisted `StrategyBaseTVLLimits` instances, and the `token` parameter corresponds to the actual token being transferred as part of the deposit. +Allows a staker to deposit some `amount` of `token` into the specified `strategy` in exchange for deposit shares in that strategy. The underlying `strategy` must be whitelisted for deposits, meaning it has either been deployed via the `StrategyFactory`, or is an existing `StrategyBaseTVLLimits/EigenStrategy` instance. The `token` parameter should correspond to the strategy's supported token. The number of shares received is calculated by the `strategy` using an internal exchange rate that depends on the previous number of tokens deposited. -If the Staker is delegated to an Operator, the Operator's delegated shares are increased in the `DelegationManager`. +After processing a deposit, the `StrategyManager` forwards the deposit information to the `DelegationManager`, which updates the staker's deposit scaling factor and delegates shares to the staker's operator (if applicable). See [`DelegationManager.increaseDelegatedShares`](./DelegationManager.md#increasedelegatedshares) for details. *Effects*: * `token.safeTransferFrom`: Transfers `amount` of `token` to `strategy` on behalf of the caller. -* See [`StrategyBaseTVLLimits.deposit`](#strategybasetvllimitsdeposit) -* `StrategyManager` awards the Staker with the newly-created shares +* `StrategyManager` awards the staker with the newly-created deposit shares +* See [`StrategyBase.deposit`](#strategybasedeposit) * See [`DelegationManager.increaseDelegatedShares`](./DelegationManager.md#increasedelegatedshares) *Requirements*: * Pause status MUST NOT be set: `PAUSED_DEPOSITS` * Caller MUST allow at least `amount` of `token` to be transferred by `StrategyManager` to the strategy -* `strategy` in question MUST be whitelisted for deposits. -* See [`StrategyBaseTVLLimits.deposit`](#strategybasetvllimitsdeposit) +* `strategy` in question MUST be whitelisted for deposits. +* See [`StrategyBaseTVLLimits.deposit`](#strategybasedeposit) #### `depositIntoStrategyWithSignature` ```solidity +/** + * @notice Deposits `amount` of `token` into the specified `strategy` and credits shares to the `staker` + * Note tokens are transferred from `msg.sender`, NOT from `staker`. This method allows the caller, using a + * signature, to deposit their tokens to another staker's balance. + * @param strategy the strategy that handles `token` + * @param token the token from which the `amount` will be transferred + * @param amount the number of tokens to transfer from the caller to the strategy + * @param staker the staker that the deposited assets will be credited to + * @param expiry the timestamp at which the signature expires + * @param signature a valid ECDSA or EIP-1271 signature from `staker` + * @return depositShares the number of deposit shares credited to `staker` + * @dev The caller must have previously approved this contract to transfer at least `amount` of `token` on their behalf. + * + * WARNING: Be extremely cautious when depositing tokens that do not strictly adhere to ERC20 standards. + * Tokens that diverge significantly from ERC20 norms can cause unexpected behavior in token balances for + * that strategy, e.g. ERC-777 tokens allowing cross-contract reentrancy. + */ function depositIntoStrategyWithSignature( IStrategy strategy, IERC20 token, @@ -97,134 +133,220 @@ function depositIntoStrategyWithSignature( ) external onlyWhenNotPaused(PAUSED_DEPOSITS) - onlyNotFrozen(staker) nonReentrant - returns (uint256 shares) + returns (uint256 depositShares) ``` -This method has a similar purpose as `depositIntoStrategy()`, except it is intended to be used when submitting a deposit on behalf of `staker` which will be credited with the new shares. +This method works like `depositIntoStrategy()`, transferring tokens _from the caller_ to the `strategy` contract. Unlike `depositIntoStrategy`, the resulting deposit shares are credited to the passed-in `staker` address, which must sign off on this intent. *Effects*: See `depositIntoStrategy` above. Additionally: -* The Staker's nonce is incremented +* The staker's nonce is incremented *Requirements*: See `depositIntoStrategy` above. Additionally: * Caller MUST provide a valid, unexpired signature over the correct fields -* `thirdPartyTransfersForbidden[strategy]` MUST be false --- -### Withdrawal Processing +## Withdrawal Processing These methods are callable ONLY by the `DelegationManager`, and are used when processing undelegations and withdrawals: -* [`StrategyManager.removeShares`](#removeshares) +* [`StrategyManager.removeDepositShares`](#removedepositshares) * [`StrategyManager.addShares`](#addshares) * [`StrategyManager.withdrawSharesAsTokens`](#withdrawsharesastokens) See [`DelegationManager.md`](./DelegationManager.md) for more context on how these methods are used. -#### `removeShares` +#### `removeDepositShares` ```solidity -function removeShares( +/// @notice Used by the DelegationManager to remove a Staker's shares from a particular strategy when entering the withdrawal queue +/// @dev strategy must be beaconChainETH when talking to the EigenPodManager +function removeDepositShares( address staker, IStrategy strategy, - uint256 shares + uint256 depositSharesToRemove ) external onlyDelegationManager ``` -The `DelegationManager` calls this method when a Staker queues a withdrawal (or undelegates, which also queues a withdrawal). The shares are removed while the withdrawal is in the queue, and when the queue completes, the shares will either be re-awarded or withdrawn as tokens (`addShares` and `withdrawSharesAsTokens`, respectively). +The `DelegationManager` calls this method when a staker queues a withdrawal (or undelegates, which also queues a withdrawal). The staker's deposit shares are removed while the withdrawal is in the queue, and when the withdrawal is completed, the staker can choose whether to be re-awarded the shares, or to convert and receive them as tokens (`addShares` and `withdrawSharesAsTokens`, respectively). -The Staker's share balance for the `strategy` is decreased by the removed `shares`. If this causes the Staker's share balance to hit zero, the `strategy` is removed from the Staker's strategy list. +The staker's deposit share balance for the `strategy` is decreased by the removed `depositSharesToRemove`. If this causes the staker's share balance to hit zero, the `strategy` is removed from the staker's strategy list. -*Entry Points*: -* `DelegationManager.undelegate` -* `DelegationManager.queueWithdrawals` +Note that the amount of deposit shares removed while in the withdrawal queue may not equal the amount credited when the withdrawal is completed. The staker may receive fewer if slashing occurred; see [`DelegationManager.md`](./DelegationManager.md) for details. *Effects*: -* The Staker's share balance for the given `strategy` is decreased by the given `shares` - * If this causes the balance to hit zero, the `strategy` is removed from the Staker's strategy list +* Decrease the staker's deposit share balance for the given `strategy` by the given `depositSharesToRemove` + * If this causes the balance to hit zero, the `strategy` is removed from the staker's strategy list *Requirements*: * Caller MUST be the `DelegationManager` -* `staker` parameter MUST NOT be zero -* `shares` parameter MUST NOT be zero -* `staker` MUST have at least `shares` balance for the given `strategy` +* `depositSharesToRemove` parameter MUST NOT be zero +* `staker` MUST have at least `depositSharesToRemove` balance for the given `strategy` #### `addShares` ```solidity +/// @notice Used by the DelegationManager to award a Staker some shares that have passed through the withdrawal queue +/// @dev strategy must be beaconChainETH when talking to the EigenPodManager +/// @return existingDepositShares the shares the staker had before any were added +/// @return addedShares the new shares added to the staker's balance function addShares( address staker, IStrategy strategy, uint256 shares -) - external +) + external onlyDelegationManager + returns (uint256, uint256) ``` -The `DelegationManager` calls this method when a queued withdrawal is completed and the withdrawer specifies that they want to receive the withdrawal as "shares" (rather than as the underlying tokens). In this case, the `shares` originally removed (via `removeShares`) are awarded to the `staker` passed in by the `DelegationManager`. +The `DelegationManager` calls this method when a queued withdrawal is completed and the withdrawer specifies that they want to receive the withdrawal "as shares" (rather than as the underlying tokens). -*Entry Points*: -* `DelegationManager.completeQueuedWithdrawal` -* `DelegationManager.completeQueuedWithdrawals` +This method credits the input deposit shares to the staker. In most cases, the input `shares` equal the same shares originally removed when the withdrawal was queued. However, if the staker's operator was slashed, they may receive less. See [`DelegationManager.md`](./DelegationManager.md) for details. + +**Note** that if the staker has deposits in `MAX_STAKER_STRATEGY_LIST_LENGTH` unique strategies (and the input `strategy` is not among them), this method will revert. The staker can still choose to complete the withdrawal "as tokens" (See [`DelegationManager.completeQueuedWithdrawal`](./DelegationManager.md#completequeuedwithdrawal)). *Effects*: -* The `staker's` share balance for the given `strategy` is increased by `shares` +* Increase the `staker's` deposit share balance for the given `strategy` by `shares` * If the prior balance was zero, the `strategy` is added to the `staker's` strategy list +* Emit a `Deposit` event *Requirements*: * Caller MUST be the `DelegationManager` * `staker` parameter MUST NOT be zero * `shares` parameter MUST NOT be zero +* Length of `stakerStrategyList` for the `staker` MUST NOT exceed `MAX_STAKER_STRATEGY_LIST_LENGTH` #### `withdrawSharesAsTokens` ```solidity +/// @notice Used by the DelegationManager to convert deposit shares to tokens and send them to a staker +/// @dev strategy must be beaconChainETH when talking to the EigenPodManager +/// @dev token is not validated when talking to the EigenPodManager function withdrawSharesAsTokens( - address recipient, + address staker, IStrategy strategy, - uint shares, - IERC20 token + IERC20 token, + uint256 shares ) external onlyDelegationManager ``` -The `DelegationManager` calls this method when a queued withdrawal is completed and the withdrawer specifies that they want to receive the withdrawal as the tokens underlying the shares. In this case, the `shares` originally removed (via `removeShares`) are converted to tokens within the `strategy` and sent to the `recipient`. +The `DelegationManager` calls this method when a queued withdrawal is completed and the withdrawer specifies that they want to receive the withdrawal as the tokens underlying the shares. -*Entry Points*: -* `DelegationManager.completeQueuedWithdrawal` -* `DelegationManager.completeQueuedWithdrawals` +This method directs the `strategy` to convert the input deposit shares to tokens and send them to the `staker`. In most cases, the input `shares` equal the same shares originally removed when the withdrawal was queued. However, if the staker's operator was slashed, they may receive less. See [`DelegationManager.md`](./DelegationManager.md) for details. *Effects*: -* Calls [`StrategyBaseTVLLimits.withdraw`](#strategybasetvllimitswithdraw) +* Calls [`StrategyBase.withdraw`](#strategybasewithdraw) *Requirements*: * Caller MUST be the `DelegationManager` -* See [`StrategyBaseTVLLimits.withdraw`](#strategybasetvllimitswithdraw) +* See [`StrategyBase.withdraw`](#strategybasewithdraw) --- -### Strategies +## Burning Slashed Shares + +Slashed shares are marked as burnable, and anyone can call `burnShares` to transfer them to the default burn address. Burnable shares are stored in `burnableShares`, an [EnumerableMap](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.9.0/contracts/utils/structs/EnumerableMap.sol) with strategy contract addresses as keys and associated view functions. The following methods handle burning of slashed shares: +* [`StrategyManager.increaseBurnableShares`](#increaseburnableshares) +* [`StrategyManager.burnShares`](#burnshares) -`StrategyBaseTVLLimits` only has two methods of note, and both can only be called by the `StrategyManager`. Documentation for these methods are included below, rather than in a separate file: -* [`StrategyBaseTVLLimits.deposit`](#strategybasetvllimitsdeposit) -* [`StrategyBaseTVLLimits.withdraw`](#strategybasetvllimitswithdraw) +#### `increaseBurnableShares` -Additionally, using the `StrategyFactory`, anyone can deploy a new `StrategyBaseTVLLimits` instance for a particular token. The `StrategyFactory` manages these deployments and other strategy whitelisting features in the following methods: +```solidity +/** + * @notice Increase the amount of burnable shares for a given Strategy. This is called by the DelegationManager + * when an operator is slashed in EigenLayer. + * @param strategy The strategy to burn shares in. + * @param addedSharesToBurn The amount of added shares to burn. + * @dev This function is only called by the DelegationManager when an operator is slashed. + */ +function increaseBurnableShares( + IStrategy strategy, + uint256 addedSharesToBurn +) + external + onlyDelegationManager +``` + +The `DelegationManager` calls this method when an operator is slashed, calculating the number of slashable shares and marking them for burning here. + +Anyone can then convert the shares to tokens and trigger a burn via `burnShares`. This asynchronous burning method was added to mitigate potential DoS vectors when slashing. + +*Effects*: +* Increases `burnableShares` for the given `strategy` by `addedSharesToBurn` + +*Requirements*: +* Can only be called by the `DelegationManager` + +#### `burnShares` + +```solidity +/** + * @notice Burns Strategy shares for the given strategy by calling into the strategy to transfer + * to the default burn address. + * @param strategy The strategy to burn shares in. + */ +function burnShares( + IStrategy strategy +) + external +``` + +Anyone can call this method to burn slashed shares previously added by the `DelegationManager` via `increaseBurnableShares`. This method resets the strategy's burnable shares to 0, and directs the corresponding `strategy` to convert the shares to tokens and transfer them to `DEFAULT_BURN_ADDRESS`, rendering them unrecoverable. + +The `strategy` is not called if the strategy had no burnable shares. + +*Effects*: +* Resets the strategy's burnable shares to 0 +* Calls `withdraw` on the `strategy`, withdrawing shares and sending a corresponding amount of tokens to the `DEFAULT_BURN_ADDRESS` + +--- + +## Strategies + +**Concepts**: +* [StrategyBase vs StrategyBaseTVLLimits](#strategybase-vs-strategybasetvllimits) + +**Methods**: +* [`StrategyBase.deposit`](#strategybasedeposit) +* [`StrategyBase.withdraw`](#strategybasewithdraw) * [`StrategyFactory.deployNewStrategy`](#strategyfactorydeploynewstrategy) * [`StrategyFactory.blacklistTokens`](#strategyfactoryblacklisttokens) * [`StrategyFactory.whitelistStrategies`](#strategyfactorywhiteliststrategies) -* [`StrategyFactory.setThirdPartyTransfersForbidden`](#strategyfactorysetthirdpartytransfersforbidden) * [`StrategyFactory.removeStrategiesFromWhitelist`](#strategyfactoryremovestrategiesfromwhitelist) -#### `StrategyBaseTVLLimits.deposit` +#### `StrategyBase` vs `StrategyBaseTVLLimits` + +Before the introduction of the `StrategyFactory`, strategies were manually deployed and whitelisted in the `StrategyManager`. These strategies used `StrategyBaseTVLLimits.sol`, and were deployed using the transparent proxy pattern. With the introduction of the `StrategyFactory`, anyone can create a depositable strategy for any ERC20 (provided it does not have a deployed strategy yet). The `StrategyFactory` deploys beacon proxies, each of which points at a single implementation of `StrategyBase.sol`. + +Though these are two different contracts, `StrategyBaseTVLLimits` inherits all its basic functionality from `StrategyBase`, and only implements a "TVL limits" capability on top of them. In short, this additional functionality checks, before each deposit, whether: +1. the deposit amount exceeds a configured `maxPerDeposit` +2. the total token balance after the deposit exceeds a configured `maxTotalDeposits` + +To this date, however, these "TVL limits" capabilities have _never_ been used. The values for both of the variables mentioned above have been set to `type(uint).max` since deployment, and there is no plan to change these. Effectively, all instances of `StrategyBaseTVLLimits` behave identically to instances of `StrategyBase` - with the exception being that the former uses a transparent proxy, and the latter a beacon proxy. + +#### `StrategyBase.deposit` ```solidity +/** + * @notice Used to deposit tokens into this Strategy + * @param token is the ERC20 token being deposited + * @param amount is the amount of token being deposited + * @dev This function is only callable by the strategyManager contract. It is invoked inside of the strategyManager's + * `depositIntoStrategy` function, and individual share balances are recorded in the strategyManager as well. + * @dev Note that the assumption is made that `amount` of `token` has already been transferred directly to this contract + * (as performed in the StrategyManager's deposit functions). In particular, setting the `underlyingToken` of this contract + * to be a fee-on-transfer token will break the assumption that the amount this contract *received* of the token is equal to + * the amount that was input when the transfer was performed (i.e. the amount transferred 'out' of the depositor's balance). + * @dev Note that any validation of `token` is done inside `_beforeDeposit`. This can be overridden if needed. + * @return newShares is the number of new shares issued at the current exchange ratio. + */ function deposit( - IERC20 token, + IERC20 token, uint256 amount ) external @@ -233,13 +355,9 @@ function deposit( returns (uint256 newShares) ``` -The `StrategyManager` calls this method when Stakers deposit LSTs into a strategy. At the time this method is called, the tokens have already been transferred to the strategy. The role of this method is to (i) calculate the number of shares the deposited tokens represent according to the exchange rate, and (ii) add the new shares to the strategy's recorded total shares. +The `StrategyManager` calls this method when stakers deposit ERC20 tokens into a strategy. At the time this method is called, the tokens have already been transferred to the strategy. The role of this method is to (i) calculate the number of deposit shares the tokens represent according to the exchange rate, and (ii) add the new deposit shares to the strategy's recorded total shares. -The new shares created are returned to the `StrategyManager` to be added to the Staker's strategy share balance. - -*Entry Points*: -* `StrategyManager.depositIntoStrategy` -* `StrategyManager.depositIntoStrategyWithSignature` +The number of new shares created are returned to the `StrategyManager` to be added to the staker's strategy share balance. *Effects*: * `StrategyBaseTVLLimits.totalShares` is increased to account for the new shares created by the deposit @@ -249,18 +367,26 @@ The new shares created are returned to the `StrategyManager` to be added to the * Pause status MUST NOT be set: `PAUSED_DEPOSITS` * The passed-in `token` MUST match the strategy's `underlyingToken` * The token amount being deposited MUST NOT exceed the per-deposit cap -* After deposit, the strategy's current token balance MUST NOT exceed the total-deposit cap * When converted to shares via the strategy's exchange rate: * The `amount` of `token` deposited MUST represent at least 1 new share for the depositor * The new total shares awarded by the strategy MUST NOT exceed `MAX_TOTAL_SHARES` -#### `StrategyBaseTVLLimits.withdraw` +#### `StrategyBase.withdraw` ```solidity +/** + * @notice Used to withdraw tokens from this Strategy, to the `recipient`'s address + * @param recipient is the address to receive the withdrawn funds + * @param token is the ERC20 token being transferred out + * @param amountShares is the amount of shares being withdrawn + * @dev This function is only callable by the strategyManager contract. It is invoked inside of the strategyManager's + * other functions, and individual share balances are recorded in the strategyManager as well. + * @dev Note that any validation of `token` is done inside `_beforeWithdrawal`. This can be overridden if needed. + */ function withdraw( - address recipient, - IERC20 token, + address recipient, + IERC20 token, uint256 amountShares ) external @@ -268,13 +394,9 @@ function withdraw( onlyStrategyManager ``` -The `StrategyManager` calls this method when a queued withdrawal is completed and the withdrawer has specified they would like to convert their withdrawn shares to tokens. +The `StrategyManager` calls this method to convert a number of deposit shares to tokens, and transfer them to a `recipient`. Typically, this method is invoked as part of the withdrawal completion flow (see [`DelegationManager.completeQueuedWithdrawal`](./DelegationManager.md#completequeuedwithdrawal)). However, this method may also be invoked during the share burning flow (see [`StrategyManager.burnShares`](#burnshares)). -This method converts the withdrawal shares back into tokens using the strategy's exchange rate. The strategy's total shares are decreased to reflect the withdrawal before transferring the tokens to the `recipient`. - -*Entry Points*: -* `DelegationManager.completeQueuedWithdrawal` -* `DelegationManager.completeQueuedWithdrawals` +This method converts the deposit shares back into tokens using the strategy's exchange rate. The strategy's total shares are decreased to reflect the withdrawal before transferring the tokens to the `recipient`. *Effects*: * `StrategyBaseTVLLimits.totalShares` is decreased to account for the shares being withdrawn @@ -290,20 +412,26 @@ This method converts the withdrawal shares back into tokens using the strategy's #### `StrategyFactory.deployNewStrategy` ```solidity +/** + * @notice Deploy a new StrategyBase contract for the ERC20 token, using a beacon proxy + * @dev A strategy contract must not yet exist for the token. + * @dev Immense caution is warranted for non-standard ERC20 tokens, particularly "reentrant" tokens + * like those that conform to ERC777. + */ function deployNewStrategy(IERC20 token) external onlyWhenNotPaused(PAUSED_NEW_STRATEGIES) returns (IStrategy newStrategy) ``` -Allows anyone to deploy a new `StrategyBaseTVLLimits` instance that supports deposits/withdrawals using the provided `token`. As part of calling this method, the `StrategyFactory` automatically whitelists the new strategy in the `StrategyManager`. +Allows anyone to deploy a new `StrategyBase` instance that supports deposits/withdrawals using the provided `token`. As part of calling this method, the `StrategyFactory` automatically whitelists the new strategy for deposits via the `StrategyManager`. Note that the `StrategyFactory` only permits ONE strategy deployment per `token`. Once a `token` has an associated strategy deployed via this method, `deployNewStrategy` cannot be used to deploy a strategy for `token` again. Additionally, `deployNewStrategy` will reject any `token` placed onto the `StrategyFactory` blacklist. This feature was added to prevent the deployment of strategies that existed _before_ the `StrategyFactory` was created. For details, see [`StrategyFactory.blacklistTokens`](#strategyfactoryblacklisttokens). **NOTE: Use caution when deploying strategies for tokens that do not strictly conform to ERC20 standards. Rebasing tokens similar to already-whitelisted LSTs should be supported, but please DYOR if your token falls outside of ERC20 norms.** Specific things to look out for include (but are not limited to): exotic rebasing tokens, tokens that support reentrant behavior (like ERC-777), and other nonstandard ERC20 derivatives. *Effects*: -* Deploys a new `BeaconProxy` for the `token`, which references the current `StrategyBaseTVLLimits` implementation +* Deploys a new `BeaconProxy` for the `token`, which references the current `StrategyBase` implementation * Updates the `tokenStrategy` mapping for the `token`, preventing a second strategy deployment for the same token * See `StrategyManager.addStrategiesToDepositWhitelist` @@ -316,7 +444,13 @@ Note that the `StrategyFactory` only permits ONE strategy deployment per `token` #### `StrategyFactory.blacklistTokens` ```solidity -function blacklistTokens(IERC20[] calldata tokens) external onlyOwner +/** + * @notice Owner-only function to prevent strategies from being created for given tokens. + * @param tokens An array of token addresses to blacklist. + */ +function blacklistTokens(IERC20[] calldata tokens) + external + onlyOwner ``` Allows the owner to prevent certain `tokens` from having strategies deployed via `StrategyFactory.deployNewStrategy`. This method was added to prevent the deployment of strategies for tokens that already have strategies deployed/whitelisted through other means. @@ -333,11 +467,13 @@ Note that once the owner adds tokens to the blacklist, they cannot be removed. T #### `StrategyFactory.whitelistStrategies` ```solidity +/** + * @notice Owner-only function to pass through a call to `StrategyManager.addStrategiesToDepositWhitelist` + */ function whitelistStrategies( - IStrategy[] calldata strategiesToWhitelist, - bool[] calldata thirdPartyTransfersForbiddenValues -) - external + IStrategy[] calldata strategiesToWhitelist +) + external onlyOwner ``` @@ -350,25 +486,17 @@ Allows the owner to explicitly whitelist strategies in the `StrategyManager`. Th * Caller MUST be the owner * See `StrategyManager.addStrategiesToDepositWhitelist` -#### `StrategyFactory.setThirdPartyTransfersForbidden` - -```solidity -function setThirdPartyTransfersForbidden(IStrategy strategy, bool value) external onlyOwner -``` - -Allows the owner to explicitly enable or disable third party transfers in the `StrategyManager`. This method is used as a passthrough for the `StrategyManager.setThirdPartyTransfersForbidden`, in case the owner needs to modify these values. - -*Effects*: -* See `StrategyManager.setThirdPartyTransfersForbidden` - -*Requirements*: -* Caller MUST be the owner -* See `StrategyManager.setThirdPartyTransfersForbidden` - #### `StrategyFactory.removeStrategiesFromWhitelist` ```solidity -function removeStrategiesFromWhitelist(IStrategy[] calldata strategiesToRemoveFromWhitelist) external +/** + * @notice Owner-only function to pass through a call to `StrategyManager.removeStrategiesFromDepositWhitelist` + */ +function removeStrategiesFromWhitelist( + IStrategy[] calldata strategiesToRemoveFromWhitelist +) + external + onlyOwner ``` Allows the owner to remove strategies from the `StrategyManager` strategy whitelist. This method is used as a passthrough for the `StrategyManager.removeStrategiesFromDepositWhitelist`, in case the owner needs to access this method. @@ -382,17 +510,20 @@ Allows the owner to remove strategies from the `StrategyManager` strategy whitel --- -### System Configuration +## System Configuration The Strategy Whitelister role has the ability to permit/remove strategies from being depositable via the `StrategyManager`. This role is held by the `StrategyFactory` (which is fully documented in [Strategies](#strategies)). The following methods concern the Strategy Whitelister role and its abilities within the `StrategyManager`: * [`StrategyManager.setStrategyWhitelister`](#setstrategywhitelister) * [`StrategyManager.addStrategiesToDepositWhitelist`](#addstrategiestodepositwhitelist) * [`StrategyManager.removeStrategiesFromDepositWhitelist`](#removestrategiesfromdepositwhitelist) -* [`StrategyManager.setThirdPartyTransfersForbidden`](#setthirdpartytransfersforbidden) #### `setStrategyWhitelister` ```solidity +/** + * @notice Owner-only function to change the `strategyWhitelister` address. + * @param newStrategyWhitelister new address for the `strategyWhitelister`. + */ function setStrategyWhitelister(address newStrategyWhitelister) external onlyOwner ``` @@ -407,11 +538,14 @@ Allows the `owner` to update the Strategy Whitelister address. Currently, the St #### `addStrategiesToDepositWhitelist` ```solidity +/** + * @notice Owner-only function that adds the provided Strategies to the 'whitelist' of strategies that stakers can deposit into + * @param strategiesToWhitelist Strategies that will be added to the `strategyIsWhitelistedForDeposit` mapping (if they aren't in it already) + */ function addStrategiesToDepositWhitelist( - IStrategy[] calldata strategiesToWhitelist, - bool[] calldata thirdPartyTransfersForbiddenValues -) - external + IStrategy[] calldata strategiesToWhitelist +) + external onlyStrategyWhitelister ``` @@ -419,7 +553,6 @@ Allows the Strategy Whitelister to add any number of strategies to the `Strategy *Effects*: * Adds entries to `StrategyManager.strategyIsWhitelistedForDeposit` -* Sets `thirdPartyTransfersForbidden` for each added strategy *Requirements*: * Caller MUST be the `strategyWhitelister` @@ -427,38 +560,21 @@ Allows the Strategy Whitelister to add any number of strategies to the `Strategy #### `removeStrategiesFromDepositWhitelist` ```solidity +/** + * @notice Owner-only function that removes the provided Strategies from the 'whitelist' of strategies that stakers can deposit into + * @param strategiesToRemoveFromWhitelist Strategies that will be removed to the `strategyIsWhitelistedForDeposit` mapping (if they are in it) + */ function removeStrategiesFromDepositWhitelist( IStrategy[] calldata strategiesToRemoveFromWhitelist -) - external +) + external onlyStrategyWhitelister ``` -Allows the Strategy Whitelister to remove any number of strategies from the `StrategyManager` whitelist. The removed strategies will no longer be eligible for deposit via `depositIntoStrategy`. However, withdrawals for previously-whitelisted strategies may still be initiated and completed, as long as the Staker has shares to withdraw. +Allows the Strategy Whitelister to remove any number of strategies from the `StrategyManager` whitelist. The removed strategies will no longer be eligible for deposit via `depositIntoStrategy`. However, withdrawals for previously-whitelisted strategies may still be initiated and completed, as long as the staker has shares to withdraw. *Effects*: * Removes entries from `StrategyManager.strategyIsWhitelistedForDeposit` *Requirements*: * Caller MUST be the `strategyWhitelister` - -#### `setThirdPartyTransfersForbidden` - -```solidity -function setThirdPartyTransfersForbidden( - IStrategy strategy, - bool value -) - external - onlyStrategyWhitelister -``` - -Allows the Strategy Whitelister to enable or disable third-party transfers for any `strategy`. If third-party transfers are disabled: -* Deposits via [`depositIntoStrategyWithSiganture`](#depositintostrategywithsignature) are disabled. -* Withdrawals to a different address via [`DelegationManager.queueWithdrawals`](./DelegationManager.md#queuewithdrawals) are disabled. - -*Effects*: -* Sets `thirdPartyTransfersForbidden[strategy]`, even if that strategy is not currently whitelisted - -*Requirements*: -* Caller MUST be the `strategyWhitelister` diff --git a/docs/core/accounting/SharesAccounting.md b/docs/core/accounting/SharesAccounting.md index 940dfab0a1..7e17cfbaf1 100644 --- a/docs/core/accounting/SharesAccounting.md +++ b/docs/core/accounting/SharesAccounting.md @@ -162,6 +162,67 @@ See implementation in: * [`StrategyManager.depositIntoStrategy`](../../../src/contracts/core/StrategyManager.sol) * [`EigenPodManager.recordBeaconChainETHBalanceUpdate`](../../../src/contracts/pods/EigenPodManager.sol) + +--- + +### Delegation + +Suppose we have an undelegated staker who decides to delegate to an operator. +We have the following properties that should be preserved. + +#### Operator Level + +Operator shares should be increased by the amount of delegatable shares the staker has, this is synonymous to their withdrawable shares $a_n$. Therefore, + +$$ +op_{n+1} = op_{n} + a_n +$$ + +$$ += op_{n} + s_n k_n l_n m_n +$$ + + +#### Staker Level + +withdrawable shares should remain unchanged + +$$ +a_{n+1} = a_n +$$ + +deposit shares should remain unchanged + +$$ +s_{n+1} = s_n +$$ + +beaconChainSlashingFactor and maxMagnitude should also remain unchanged. In this case, since the staker is not delegated, then their maxMagnitude should by default be equal to 1. + +$$ +l_{n+1} = l_n +$$ + +Now the question is what is the new depositScalingFactor equal to? + +$$ +a_{n+1} = a_n +$$ + +$$ +=> s_{n+1} k_{n+1} l_{n+1} m_{n+1} = s_n k_n l_n m_n +$$ + +$$ +=> s_{n} k_{n+1} l_{n} m_{n+1} = s_n k_n l_n m_n +$$ + +$$ +=> k_{n+1} = \frac {k_n m_n} { m_{n+1} } +$$ + +Notice how the staker variables that update $k_{n+1}$ and $m_{n+1}$ do not affect previously queued withdrawals and shares received upon withdrawal completion. This is because the maxMagnitude that is looked up is dependent on the operator at the time of the queued withdrawal and the $k_n$ is effectively stored in the scaled shares field. + --- ### Slashing @@ -297,6 +358,8 @@ $$ Note that when a withdrawal is queued, a `Withdrawal` struct is created with _scaled shares_ defined as $q_t = x_t k_t$ where $t$ is the time of the queuing. The reason we define and store scaled shares like this will be clearer in [Complete Withdrawal](#complete-withdrawal) below. +Additionally, we reset the depositScalingFactor when a user queues a withdrawal for all their shares, either through un/redelegation or directly. This is because the DSF at the time of withdrawal is stored in the scaled shares, and any "new" deposits or delegations by the staker should be considered as new. Note that withdrawal completion is treated as a kind of deposit when done as shares, which again will be clearer below. + See implementation in: * `DelegationManager.queueWithdrawals` * `SlashingLib.scaleForQueueWithdrawal` diff --git a/docs/core/accounting/SharesAccountingEdgeCases.md b/docs/core/accounting/SharesAccountingEdgeCases.md index 918196157f..7c7c98ae50 100644 --- a/docs/core/accounting/SharesAccountingEdgeCases.md +++ b/docs/core/accounting/SharesAccountingEdgeCases.md @@ -145,6 +145,28 @@ Since the operatorShares are simply incrementing by the exact depositShares, the Granted the initial deposit amount was `4.418e28` which is magnitudes larger than the discrepancy here but this its important to note the side effects of the redesigned accounting model. Instead of purely incremented/decremented amounts, we have introduced magnitudes and scaling factor variables which now result in small amounts of rounding error from division in several places. We deem this rounding behavior to be tolerable given the costs associated for the number of transactions to emulate this and the proportional error is very small. +### Slashing and Rounding Up Operator Shares and Rounding down on Staker Withdrawable Shares + +As can be observed in the `SlashingLib.sol` library, we round up on the operatorShares when slashing and round down on the staker's withdrawableShares. If we look at a core invariant of the shares accounting model, we ideally want to preserve the following: + +$$ +op_n = \sum_{i=1}^{k} a_{n,i} +$$ + +where $op_n$ is the operatorShares at time $n$ and $a_{n,i}$ is the staker's withdrawableShares at time $n$ for the $i^{th}$ staker. + +However due to rounding limitations, there will be some error introduced in calculating the amount of operator shares to slash above and also in calculating the staker's withdrawableShares. To prevent a situation where all stakers were to attempt to withdraw and the operatorShares underflows, we round up on the operatorShares when slashing and round down on the staker's withdrawableShares. + +So in practice, the above invariant becomes. + +$$ +op_n \geq \sum_{i=1}^{k} a_{n,i} +$$ + +Upwards rounding on calculating the amount of operatorShares to give to an operator after slashing is intentionally performed in `SlashingLib.calcSlashedAmount`. +For calculating a staker's withdrawableShares, there are many different factors to consider such as calculating their depositScalingFactor, their slashingFactor, and calculating the amount of withdrawable shares altogether with their depositShares. These variables are all by default rounded down in calculation and is expected behavior for stakers. + + ## Upper bound on Residual Operator Shares Related to the above rounding error on deposits, we want to calculate what is the worst case rounding error for a staker depositing shares into EigenLayer. diff --git a/docs/core/accounting/SlashingEdgeCase.md b/docs/core/accounting/SlashingEdgeCase.md new file mode 100644 index 0000000000..4bfd54adc5 --- /dev/null +++ b/docs/core/accounting/SlashingEdgeCase.md @@ -0,0 +1,117 @@ +# Dual Slashing Edge Case + +This document describes edge cases surrounding the slashing of a staker for native ETH by the beacon chain (BC) and an AVS. + +## Prior Reading + +* [ELIP-002: Slashing via Unique Stake and Operator Sets](https://github.com/eigenfoundation/ELIPs/blob/main/ELIPs/ELIP-002.md) +* [ELIP-004: Slashing-Aware EigenPods](https://github.com/eigenfoundation/ELIPs/blob/main/ELIPs/ELIP-004.md) +* [Shares Accounting](./SharesAccounting.md) + +## Scenario + +Consider a staker, Alice who is in the following state: + +1. Alice has verified a validator. `withdrawble: 32 ETH` +2. Alice's operator is slashed for 75%. `withdrawable: 8 ETH` +
+ Calculation + + * `depositShares: 32` + * `maxMagnitude: 0.25` + * `BCSF: 1` + * `DSF: 1` + * `withdrawable = 32 * 0.25 * 1 * 1 = 8 ETH` +
+3. Alice is slashed by 16 ETH on the beacon chain + +## Restaking + +We define restaking as **reusing staked ETH as security for AVSs. Thus, the same Native ETH that is securing the BC (beacon chain) can also be slashed by an AVS, with priority burning rights going to the BC.** + +In the above scenario, let's say the Alice now proves a checkpoint. + +4. A checkpoint of BC state is proven. `withdrawable: 4 ETH` +
+ Calculation + + * `depositShares: 16` + * `maxMagnitude: 0.25` + * `BCSF: 1` + * `DSF: 1` + * `withdrawable = 16 * 0.25 * 1 * 1 = 4 ETH` +
+ +The checkpoint slash has devalued Alice's currently withdrawable assets by 50%. The AVS slashes from what's left due to the BC getting priority burning rights. Thus, AVSs must factor Native ETH (or an LST) being slashed by the beacon chain when designing their slashing conditions. The below diagram illustrates this behavior: + +
+AVS and Beacon Chain Slashing Behavior +
Diagram showing how AVS slashing is applied after Beacon Chain slashing, with BC having priority burning rights
+
+ +Note that the portion that is marked as BC Slash and BC + AVS Slash has priority burning rights by the beacon chain. 12 ETH has been slashed "twice", but this is by design given our definition of restaking. + +The behavior of BC and AVS slashings for Native ETH mimics the behavior of slashings for an LST in isolation (see below for an additional edge case). This ensures that Native ETH security is not disadvantaged compared to LST security. ELIP-004 explains this in [more detail](https://github.com/eigenfoundation/ELIPs/blob/main/ELIPs/ELIP-004.md#why-do-eigenpods-need-to-upgrade). + +## Ordering of EigenPod Actions + +**When an AVS slashes, its attributable slashed amount is between 0 and the originally slashed amount. The attributable slashed amount decreases in the event of BC slashes.** We see this behavior in the above example, where the 12 ETH that was attributed to the AVS is less than the original 24 ETH that was slashed. + +However, given the asynchronous nature of the EigenPod proof system, Alice may have a different number of withdrawable shares depending on the ordering of her actions. Note that even in this case, **assets are not overslashed**. + +Let's start with our above scenario. + +Scenario A: + +4. Alice verifies another validator. `withdrawable: 40 ETH` +
+ Calculation + + * `depositShares: 64` + * `maxMagnitude: 0.25` + * `BCSF: 1` + * `DSF = 40 / (32 + 32) / 0.25 = 2.5` + * `withdrawable = 64 * 0.25 * 1 * 2.5 = 40 ETH` +
+ +5. Alice checkpoints all her pods. `withdrawable: 30 ETH` +
+ Calculation + + * `depositShares: 64` + * `maxMagnitude: 0.25` + * `BCSF = 48 / 64 = 0.75` + * `DSF: 2.5` + * `withdrawable = 64 * 0.25 * 0.75 * 2.5 = 30 ETH` +
+ +In this scenario, 25% of Alice’s currently proven assets are slashed. Similarly, the AVSs attributable slashed amount has been decreased by 25% (24 → 18 ETH). + + +Scenario B: + +4. Alice checkpoints her pod. `withdrawable: 4 ETH` +
+ Calculation + + * `depositShares: 32` + * `maxMagnitude: 0.25` + * `BCSF = 16 / 32 = 0.5` + * `DSF: 1` + * `withdrawable = 32 * 0.25 * 0.5 * 1 = 4 ETH` +
+ +5. Alice verifies another validator. `withdrawable: 40 ETH` +
+ Calculation + + * `depositShares: 64` + * `maxMagnitude: 0.25` + * `BCSF: 0.5` + * `DSF = 36 / (32 + 32) / 0.125 = 4.5` + * `withdrawable = 64 * 0.25 * 0.5 * 4.5 = 36 ETH` +
+ +In scenario B, 50% of Alice’s currently proven assets are slashed, along with a commensurate decrease in the AVSs attributable slashed amount. In both cases Alice’s withdrawable shares and the AVSs attributable slashed amount decrease by the same percentage. + +We acknowledge this edge case. A benefit of this system is that stakers are incentivized to immediatley prove BC slashed. Eigen Labs runs an off-chain process (EigenPod Health Checker) that monitors BC slashings and starts checkpoints as needed. Conversely, when Native-ETH burning is implemented, AVSs are incentivized to immediately exit stakers from the BC to recoup the maximum possible attributable slashed amount. \ No newline at end of file diff --git a/docs/images/avs-bc-slash.png b/docs/images/avs-bc-slash.png new file mode 100644 index 0000000000..e53cedaae1 Binary files /dev/null and b/docs/images/avs-bc-slash.png differ diff --git a/docs/permissions/PermissionController.md b/docs/permissions/PermissionController.md index 8eeec0ed60..f0ff11a2bd 100644 --- a/docs/permissions/PermissionController.md +++ b/docs/permissions/PermissionController.md @@ -4,27 +4,51 @@ | -------- | -------- | -------- | | [`PermissionController.sol`](../../src/contracts/permissions/PermissionController.sol) | Singleton | Transparent proxy | -The `PermissionController` handles user permissions for protocol contracts which explicitly integrate it. Note that "users" in the context of the `PermissionController` refers to **AVSs** and **Operators**; it does *not* refer to **Stakers**. +The `PermissionController` handles user permissions for protocol contracts which explicitly integrate it. Note that "users" in the context of the `PermissionController` refers to **AVSs** and **operators**; it does *not* refer to **stakers**. -The `PermissionController` defines three different roles: -* [Accounts](#accounts) -* [Admins](#admins) -* [Appointees](#appointees) - -The core contracts using the `PermissionController` as a dependency are the: +The `PermissionController` is integrated into other core contracts, enabling (for specific methods) AVSs and operators to designate _other accounts_ ("appointees") that can call these methods on their behalf. The core contracts using the `PermissionController` as a dependency are the: * `DelegationManager` * `AllocationManager` * `RewardsCoordinator` -Note that the `AVSDirectory` will soon be deprecated and thus does not support this contract. +The `PermissionController` defines three different roles: +* [Accounts](#accounts) +* [Admins](#admins) +* [Appointees](#appointees) --- ## Accounts -**Accounts** refer to the Ethereum address through which one interacts with the protocol. Accounts have the ability to set and remove **admins** and/or **appointees**, which can take actions on an account's behalf depending on their role. - -Note that an account cannot appoint an address to *register* on its behalf. In other words, the address a user registers with is their account, and they can then transfer admin of that account in a subsequent tx. Similarly, the account of an AVS is the address they use to initialize state in the `AllocationManager`. +**Accounts** refer to the Ethereum address through which one interacts with the protocol _if no appointees are set_. From the core contracts' perspective, accounts are the "state holder," i.e. the address referenced in storage when a contract method interacts with state. For example, in the `DelegationManager`, the `operator` address that holds shares in the `operatorShares` mapping is an "account." In the `AllocationManager`, an AVS's "account" is the address under which operator sets are created. + +The `PermissionController` allows an account to designate **admins** and/or **appointees** to take certain actions on its behalf. Note that setting up admins/appointees is _optional_, and carries with it a significant responsibility to **ensure the designated actors are intentionally being granted authority**. + +Both admins AND appointees can be granted authority to act on an account's behalf. Admins are granted full reign over any `PermissionController`-enabled functions, while appointees must be granted authority to call specific functions on specific contracts. The list of methods that are `PermissionController`-enabled follow. + +For operators: +* `AllocationManager.modifyAllocations` +* `AllocationManager.registerForOperatorSets` +* `AllocationManager.deregisterFromOperatorSets` +* `AllocationManager.setAllocationDelay` +* `DelegationManager.modifyOperatorDetails` +* `DelegationManager.updateOperatorMetadataURI` +* `DelegationManager.undelegate` +* `RewardsCoordinator.setClaimerFor` +* `RewardsCoordinator.setClaimerFor` +* `RewardsCoordinator.setOperatorAVSSplit` +* `RewardsCoordinator.setOperatorPISplit` + +For AVSs: +* `AllocationManager.slashOperator` +* `AllocationManager.deregisterFromOperatorSets` +* `AllocationManager.setAVSRegistrar` +* `AllocationManager.updateAVSMetadataURI` +* `AllocationManager.createOperatorSets` +* `AllocationManager.addStrategiesToOperatorSet` +* `AllocationManager.removeStrategiesFromOperatorSet` +* `RewardsCoordinator.createOperatorDirectedAVSRewardsSubmission` +* `RewardsCoordinator.setClaimerFor` ### Account Permissions @@ -53,7 +77,9 @@ By default, no other address can perform an action on behalf of a given account. ## Admins -Admins are able to take any action on behalf of an original account -- including adding or removing admins. This enables operations like key rotation for operators, or creating a backup admin which is stored on a cold key. +Admins are able to take ANY action on behalf of an original account -- including adding or removing admins. This enables operations like key rotation for operators, or creating a backup admin which is stored on a cold key. + +**Note:** by default, an account is its own admin. However, once an admin is added, this is no longer the case; only the admins listed in `_permissions.admins` are admins. If an account wants to both add admins AND continue acting as its own admin, _it must be added to the admins list_. ### Adding an Admin @@ -66,27 +92,41 @@ The relevant functions for admin addition are: #### `addPendingAdmin` ```solidity +/** + * @notice Sets a pending admin of an account + * @param account to set pending admin for + * @param admin to set + * @dev Multiple admins can be set for an account + */ function addPendingAdmin(address account, address admin) external onlyAdmin(account); ``` -When adding an admin, an account must call `addPendingAdmin()`. Then, the pending admin must call `acceptAdmin()` for the given account, completing the process. An account cannot force an admin role upon another account. +When adding a new admin, an account or admin must first call `addPendingAdmin()`. Then, the pending admin must call `acceptAdmin()` to complete the process. An account cannot force an admin role upon another account. + +Pending admins do not have any particular authority, but are granted the full authority of an admin once they call `acceptAdmin()`. *Effects*: * An address is added to the `pendingAdmins` set for the account * A `PendingAdminAdded` event is emitted specifying the account for which a pending admin was added *Requirements*: -* The proposed admin MUST NOT already be an admin for the account -* The proposed admin MUST NOT be a pending admin for the account -* Caller MUST be an admin for the account, or the account's address itself if no admin is set +* The proposed admin MUST NOT already be an admin for the `account` +* The proposed admin MUST NOT be a pending admin for the `account` +* Caller MUST be an admin for the `account`, or the `account` itself if no admin is set #### `removePendingAdmin` ```solidity +/** + * @notice Removes a pending admin of an account + * @param account to remove pending admin for + * @param admin to remove + * @dev Only the admin of the account can remove a pending admin + */ function removePendingAdmin(address account, address admin) external onlyAdmin(account); ``` -An account, if it wishes to retract the pending admin offer, can call `removePendingAdmin()` to prevent the potential admin from accepting their role. However, this will only work if `acceptAdmin()` has not yet been called by the potential admin. +An account or admin can call `removePendingAdmin()` to prevent a pending admin from accepting their role. However, this will only work if the pending admin has not already called `acceptAdmin()`. If this occurs, an admin can call `removeAdmin` to remove the unwanted admin. *Effects*: * An address is removed from the `pendingAdmins` set for the account @@ -99,12 +139,17 @@ An account, if it wishes to retract the pending admin offer, can call `removePen #### `acceptAdmin` ```solidity +/** + * @notice Accepts the admin role of an account + * @param account to accept admin for + * @dev Only a pending admin for the account can become an admin + */ function acceptAdmin(address account) external; ``` -To claim the admin role for an account, the pending admin must call `acceptAdmin()` passing in the relevant account. +Called by a pending admin to claim the admin role for an account. The caller must have been previously added as a pending admin. -Note that an account has successfully added an admin (i.e. the pending admin has called `acceptAdmin()`), **the account's address itself no longer has admin privileges**. This behavior benefits operators seeking to perform a *key rotation*, as adding an admin allows them to remove permissions from their original, potentially compromised, key. If an account wants to retain admin privileges for its own address, it is recommended to first add itself as an admin, then add any other admins as desired. +Note that once an account has successfully added an admin (i.e. the pending admin has called `acceptAdmin()`), **the account's address itself no longer has its default admin privileges**. This behavior benefits accounts seeking to perform a *key rotation*, as adding an admin allows them to remove permissions from their original, potentially compromised, key. If an account wants to retain admin privileges for its own address, it is recommended to first add itself as an admin, then add any other admins as desired. *Effects*: * The caller is removed from the `pendingAdmins` set for the account @@ -119,13 +164,18 @@ Note that an account has successfully added an admin (i.e. the pending admin has #### `removeAdmin` ```solidity +/** + * @notice Remove an admin of an account + * @param account to remove admin for + * @param admin to remove + * @dev Only the admin of the account can remove an admin + * @dev Reverts when an admin is removed such that no admins are remaining + */ function removeAdmin(address account, address admin) external onlyAdmin(account); ``` An admin of an account can call `removeAdmin()` to remove any other admins of the same account. However, one admin must always remain for any given account. In other words, once an account has added an admin, it must always have at least one admin in perpetuity. -Note that once an admin has been added to an account, at least one must remain on the account. - *Effects*: * The specified admin is removed from the `admins` set for the account * An `AdminRemoved` event is emitted specifying the accuont for which an admin was removed @@ -139,15 +189,23 @@ Note that once an admin has been added to an account, at least one must remain o Appointees are able to act as another account *for a specific function for a specific contract*, granting accounts granular access control. -Specifically, an account (or its admins) can grant an appointee access to a specific `selector` (i.e [function](https://solidity-by-example.org/function-selector/)) on a given `target` (i.e. contract). The `target` and `selector` are combined in the form of the `targetSelector` and serve to uniquely identify a permissioned function. +Specifically, an account (or its admins) can grant an appointee access to a specific `selector` (i.e [function](https://solidity-by-example.org/function-selector/)) on a given `target` (i.e. contract). The `target` and `selector` are combined in the form of the `targetSelector` and serve to uniquely identify a permissioned function on a specific contract. -Appointees can be appointed more than once so that they can access additional functions on a given contract and/or additional functions on *other* contracts. Each new `targetSelector` permission granted requires setting the appointee from scratch, and revoking the appointee's permission requires revoking each individual `targetSelector` permission, as described below. +Appointees can be granted access to multiple functions/contracts. Each new `targetSelector` permission granted requires setting the appointee from scratch, and revoking the appointee's permission requires revoking each individual `targetSelector` permission, as described below. ### Adding an Appointee #### `setAppointee` ```solidity +/** + * @notice Set an appointee for a given account + * @param account to set appointee for + * @param appointee to set + * @param target to set appointee for + * @param selector to set appointee for + * @dev Only the admin of the account can set an appointee + */ function setAppointee( address account, address appointee, @@ -156,7 +214,9 @@ function setAppointee( ) external onlyAdmin(account); ``` -An account (or its admins) can call `setAppointee()` to give another address the ability to call a specific function on a given contract. That address is then only able to call that specific function on that specific contract. +An account (or its admins) can call `setAppointee()` to give another address the ability to call a specific function on a given contract. That address is then only able to call that specific function on that specific contract on behalf of `account`. + +Note that unlike the process to become an admin, there is no requirement for the `appointee` to accept the appointment. *Effects*: * The `targetSelector` is added to the specified `appointee` set within the `appointeePermissions` mapping @@ -172,6 +232,14 @@ An account (or its admins) can call `setAppointee()` to give another address the #### `removeAppointee` ```solidity +/** + * Removes an appointee for a given account + * @param account to remove appointee for + * @param appointee to remove + * @param target to remove appointee for + * @param selector to remove appointee for + * @dev Only the admin of the account can remove an appointee + */ function removeAppointee( address account, address appointee, @@ -180,7 +248,9 @@ function removeAppointee( ) external onlyAdmin(account); ``` -Similarly, an account (or its admins) can call `removeAppointee()` to remove that address's permissions for a given contract/function pair. Note that there does not exist any way currently to remove all permissions for a given appointee, or all appointees for a given function selector. +An account (or its admins) can call `removeAppointee()` to remove an `appointee's` permissions for a given contract/function pair. Note that there does not exist any way currently to atomically remove all permissions for a given appointee, or all appointees for a given function selector - each permission must be revoked individually. + +Also note that permissions to specific functions/contracts cannot be revoked for _admins_. Admins always have full access, unless another admin removes them from the admin list. *Effects*: * The `targetSelector` is removed from the specified `appointee` set within the `appointeePermissions` mapping @@ -189,34 +259,4 @@ Similarly, an account (or its admins) can call `removeAppointee()` to remove tha *Requirements*: * Caller MUST be an admin for the account, or the account's address itself if no admin is set -* The proposed appointee MUST already have permissions for the given `targetSelector` - ---- - -## Functions using the PermissionController - -Below are the functions for which the PermissionController can be used to specify access controls. - -### DelegationManager - -* [`modifyOperatorDetails`](../core/DelegationManager.md#modifyOperatorDetails) -* [`updateOperatorMetadataURI`](../core/DelegationManager.md#updateOperatorMetadataURI) -* [`undelegate`](../core/DelegationManager.md#undelegate) - -### AllocationManager - -* [`slashOperator`](../core/AllocationManager.md#slashOperator) -* [`modifyAllocations`](../core/AllocationManager.md#modifyAllocations) -* [`registerForOperatorSets`](../core/AllocationManager.md#registerForOperatorSets) -* [`deregisterFromOperatorSets`](../core/AllocationManager.md#deregisterFromOperatorSets) -* [`setAllocationDelay`](../core/AllocationManager.md#setAllocationDelay) -* [`setAVSRegistrar`](../core/AllocationManager.md#setAVSRegistrar) -* [`updateAVSMetadataURI`](../core/AllocationManager.md#updateAVSMetadataURI) -* [`createOperatorSets`](../core/AllocationManager.md#createOperatorSets) -* [`addStrategiesToOperatorSet`](../core/AllocationManager.md#addStrategiesToOperatorSet) -* [`removeStrategiesFromOperatorSet`](../core/AllocationManager.md#removeStrategiesFromOperatorSet) - -### RewardsCoordinator - -* [`createAVSRewardsSubmission`](../core/RewardsCoordinator.md#createAVSRewardsSubmission) -* [`setClaimerFor`](../core/RewardsCoordinator.md#setClaimerFor) +* The proposed appointee MUST already have permissions for the given `targetSelector` \ No newline at end of file diff --git a/docs/storage-report/StrategyManager.md b/docs/storage-report/StrategyManager.md index 8749413c82..00d71e7439 100644 --- a/docs/storage-report/StrategyManager.md +++ b/docs/storage-report/StrategyManager.md @@ -44,8 +44,8 @@ |----------------------------------------------------------+------------------------------------------------------------+------+--------+-------+--------------------------------------------------------| | __deprecated_thirdPartyTransfersForbidden | mapping(contract IStrategy => bool) | 211 | 0 | 32 | src/contracts/core/StrategyManager.sol:StrategyManager | |----------------------------------------------------------+------------------------------------------------------------+------+--------+-------+--------------------------------------------------------| -| burnableShares | mapping(contract IStrategy => uint256) | 212 | 0 | 32 | src/contracts/core/StrategyManager.sol:StrategyManager | +| burnableShares | struct EnumerableMap.AddressToUintMap | 212 | 0 | 96 | src/contracts/core/StrategyManager.sol:StrategyManager | |----------------------------------------------------------+------------------------------------------------------------+------+--------+-------+--------------------------------------------------------| -| __gap | uint256[38] | 213 | 0 | 1216 | src/contracts/core/StrategyManager.sol:StrategyManager | +| __gap | uint256[36] | 215 | 0 | 1152 | src/contracts/core/StrategyManager.sol:StrategyManager | ╰----------------------------------------------------------+------------------------------------------------------------+------+--------+-------+--------------------------------------------------------╯ diff --git a/docs/storage-report/StrategyManagerStorage.md b/docs/storage-report/StrategyManagerStorage.md index 16a2c41f94..93290950f5 100644 --- a/docs/storage-report/StrategyManagerStorage.md +++ b/docs/storage-report/StrategyManagerStorage.md @@ -24,8 +24,8 @@ |----------------------------------------------------------+------------------------------------------------------------+------+--------+-------+----------------------------------------------------------------------| | __deprecated_thirdPartyTransfersForbidden | mapping(contract IStrategy => bool) | 10 | 0 | 32 | src/contracts/core/StrategyManagerStorage.sol:StrategyManagerStorage | |----------------------------------------------------------+------------------------------------------------------------+------+--------+-------+----------------------------------------------------------------------| -| burnableShares | mapping(contract IStrategy => uint256) | 11 | 0 | 32 | src/contracts/core/StrategyManagerStorage.sol:StrategyManagerStorage | +| burnableShares | struct EnumerableMap.AddressToUintMap | 11 | 0 | 96 | src/contracts/core/StrategyManagerStorage.sol:StrategyManagerStorage | |----------------------------------------------------------+------------------------------------------------------------+------+--------+-------+----------------------------------------------------------------------| -| __gap | uint256[38] | 12 | 0 | 1216 | src/contracts/core/StrategyManagerStorage.sol:StrategyManagerStorage | +| __gap | uint256[36] | 14 | 0 | 1152 | src/contracts/core/StrategyManagerStorage.sol:StrategyManagerStorage | ╰----------------------------------------------------------+------------------------------------------------------------+------+--------+-------+----------------------------------------------------------------------╯ diff --git a/foundry.toml b/foundry.toml index d3bc79b268..3aa90dad09 100644 --- a/foundry.toml +++ b/foundry.toml @@ -15,6 +15,7 @@ remappings = [ "forge-std/=lib/forge-std/src/" ] sparse_mode = true +internal_expect_revert = true # A list of ignored solc error codes diff --git a/pkg/bindings/AVSDirectory/binding.go b/pkg/bindings/AVSDirectory/binding.go index a3c580a40e..a37af907a5 100644 --- a/pkg/bindings/AVSDirectory/binding.go +++ b/pkg/bindings/AVSDirectory/binding.go @@ -38,8 +38,8 @@ type ISignatureUtilsSignatureWithSaltAndExpiry struct { // AVSDirectoryMetaData contains all meta data concerning the AVSDirectory contract. var AVSDirectoryMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_delegation\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"},{\"name\":\"_pauserRegistry\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"OPERATOR_AVS_REGISTRATION_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"OPERATOR_SET_FORCE_DEREGISTRATION_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"OPERATOR_SET_REGISTRATION_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"avsOperatorStatus\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"enumIAVSDirectoryTypes.OperatorAVSRegistrationStatus\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"calculateOperatorAVSRegistrationDigestHash\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"cancelSalt\",\"inputs\":[{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegation\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"deregisterOperatorFromAVS\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"domainSeparator\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"operatorSaltIsSpent\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"isSpent\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"pauseAll\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[{\"name\":\"index\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pauserRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"registerOperatorToAVS\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSignature\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtils.SignatureWithSaltAndExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateAVSMetadataURI\",\"inputs\":[{\"name\":\"metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"AVSMetadataURIUpdated\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"AVSMigratedToOperatorSets\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorAVSRegistrationStatusUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"status\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"enumIAVSDirectoryTypes.OperatorAVSRegistrationStatus\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorMigratedToOperatorSets\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operatorSetIds\",\"type\":\"uint32[]\",\"indexed\":false,\"internalType\":\"uint32[]\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"CurrentlyPaused\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidNewPausedStatus\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidSignature\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyPauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyUnpauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorAlreadyRegisteredToAVS\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorNotRegisteredToAVS\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorNotRegisteredToEigenLayer\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SaltSpent\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SignatureExpired\",\"inputs\":[]}]", - Bin: "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", + ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_delegation\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"},{\"name\":\"_pauserRegistry\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"OPERATOR_AVS_REGISTRATION_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"OPERATOR_SET_FORCE_DEREGISTRATION_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"OPERATOR_SET_REGISTRATION_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"avsOperatorStatus\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"enumIAVSDirectoryTypes.OperatorAVSRegistrationStatus\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"calculateOperatorAVSRegistrationDigestHash\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"cancelSalt\",\"inputs\":[{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegation\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"deregisterOperatorFromAVS\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"domainSeparator\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"operatorSaltIsSpent\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"isSpent\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"pauseAll\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[{\"name\":\"index\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pauserRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"registerOperatorToAVS\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSignature\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtils.SignatureWithSaltAndExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateAVSMetadataURI\",\"inputs\":[{\"name\":\"metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"AVSMetadataURIUpdated\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorAVSRegistrationStatusUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"status\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"enumIAVSDirectoryTypes.OperatorAVSRegistrationStatus\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"CurrentlyPaused\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidNewPausedStatus\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidSignature\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyPauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyUnpauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorAlreadyRegisteredToAVS\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorNotRegisteredToAVS\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorNotRegisteredToEigenLayer\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SaltSpent\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SignatureExpired\",\"inputs\":[]}]", + Bin: "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", } // AVSDirectoryABI is the input ABI used to generate the binding from. @@ -936,150 +936,6 @@ func (_AVSDirectory *AVSDirectoryFilterer) ParseAVSMetadataURIUpdated(log types. return event, nil } -// AVSDirectoryAVSMigratedToOperatorSetsIterator is returned from FilterAVSMigratedToOperatorSets and is used to iterate over the raw logs and unpacked data for AVSMigratedToOperatorSets events raised by the AVSDirectory contract. -type AVSDirectoryAVSMigratedToOperatorSetsIterator struct { - Event *AVSDirectoryAVSMigratedToOperatorSets // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *AVSDirectoryAVSMigratedToOperatorSetsIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(AVSDirectoryAVSMigratedToOperatorSets) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(AVSDirectoryAVSMigratedToOperatorSets) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *AVSDirectoryAVSMigratedToOperatorSetsIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *AVSDirectoryAVSMigratedToOperatorSetsIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// AVSDirectoryAVSMigratedToOperatorSets represents a AVSMigratedToOperatorSets event raised by the AVSDirectory contract. -type AVSDirectoryAVSMigratedToOperatorSets struct { - Avs common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterAVSMigratedToOperatorSets is a free log retrieval operation binding the contract event 0x702b0c1f6cb1cf511aaa81f72bc05a215bb3497632d72c690c822b044ab494bf. -// -// Solidity: event AVSMigratedToOperatorSets(address indexed avs) -func (_AVSDirectory *AVSDirectoryFilterer) FilterAVSMigratedToOperatorSets(opts *bind.FilterOpts, avs []common.Address) (*AVSDirectoryAVSMigratedToOperatorSetsIterator, error) { - - var avsRule []interface{} - for _, avsItem := range avs { - avsRule = append(avsRule, avsItem) - } - - logs, sub, err := _AVSDirectory.contract.FilterLogs(opts, "AVSMigratedToOperatorSets", avsRule) - if err != nil { - return nil, err - } - return &AVSDirectoryAVSMigratedToOperatorSetsIterator{contract: _AVSDirectory.contract, event: "AVSMigratedToOperatorSets", logs: logs, sub: sub}, nil -} - -// WatchAVSMigratedToOperatorSets is a free log subscription operation binding the contract event 0x702b0c1f6cb1cf511aaa81f72bc05a215bb3497632d72c690c822b044ab494bf. -// -// Solidity: event AVSMigratedToOperatorSets(address indexed avs) -func (_AVSDirectory *AVSDirectoryFilterer) WatchAVSMigratedToOperatorSets(opts *bind.WatchOpts, sink chan<- *AVSDirectoryAVSMigratedToOperatorSets, avs []common.Address) (event.Subscription, error) { - - var avsRule []interface{} - for _, avsItem := range avs { - avsRule = append(avsRule, avsItem) - } - - logs, sub, err := _AVSDirectory.contract.WatchLogs(opts, "AVSMigratedToOperatorSets", avsRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(AVSDirectoryAVSMigratedToOperatorSets) - if err := _AVSDirectory.contract.UnpackLog(event, "AVSMigratedToOperatorSets", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseAVSMigratedToOperatorSets is a log parse operation binding the contract event 0x702b0c1f6cb1cf511aaa81f72bc05a215bb3497632d72c690c822b044ab494bf. -// -// Solidity: event AVSMigratedToOperatorSets(address indexed avs) -func (_AVSDirectory *AVSDirectoryFilterer) ParseAVSMigratedToOperatorSets(log types.Log) (*AVSDirectoryAVSMigratedToOperatorSets, error) { - event := new(AVSDirectoryAVSMigratedToOperatorSets) - if err := _AVSDirectory.contract.UnpackLog(event, "AVSMigratedToOperatorSets", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - // AVSDirectoryInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the AVSDirectory contract. type AVSDirectoryInitializedIterator struct { Event *AVSDirectoryInitialized // Event containing the contract specifics and raw log @@ -1368,160 +1224,6 @@ func (_AVSDirectory *AVSDirectoryFilterer) ParseOperatorAVSRegistrationStatusUpd return event, nil } -// AVSDirectoryOperatorMigratedToOperatorSetsIterator is returned from FilterOperatorMigratedToOperatorSets and is used to iterate over the raw logs and unpacked data for OperatorMigratedToOperatorSets events raised by the AVSDirectory contract. -type AVSDirectoryOperatorMigratedToOperatorSetsIterator struct { - Event *AVSDirectoryOperatorMigratedToOperatorSets // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *AVSDirectoryOperatorMigratedToOperatorSetsIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(AVSDirectoryOperatorMigratedToOperatorSets) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(AVSDirectoryOperatorMigratedToOperatorSets) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *AVSDirectoryOperatorMigratedToOperatorSetsIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *AVSDirectoryOperatorMigratedToOperatorSetsIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// AVSDirectoryOperatorMigratedToOperatorSets represents a OperatorMigratedToOperatorSets event raised by the AVSDirectory contract. -type AVSDirectoryOperatorMigratedToOperatorSets struct { - Operator common.Address - Avs common.Address - OperatorSetIds []uint32 - Raw types.Log // Blockchain specific contextual infos -} - -// FilterOperatorMigratedToOperatorSets is a free log retrieval operation binding the contract event 0x54f33cfdd1ca703d795986b986fd47d742eab1904ecd2a5fdb8d6595e5904a01. -// -// Solidity: event OperatorMigratedToOperatorSets(address indexed operator, address indexed avs, uint32[] operatorSetIds) -func (_AVSDirectory *AVSDirectoryFilterer) FilterOperatorMigratedToOperatorSets(opts *bind.FilterOpts, operator []common.Address, avs []common.Address) (*AVSDirectoryOperatorMigratedToOperatorSetsIterator, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - var avsRule []interface{} - for _, avsItem := range avs { - avsRule = append(avsRule, avsItem) - } - - logs, sub, err := _AVSDirectory.contract.FilterLogs(opts, "OperatorMigratedToOperatorSets", operatorRule, avsRule) - if err != nil { - return nil, err - } - return &AVSDirectoryOperatorMigratedToOperatorSetsIterator{contract: _AVSDirectory.contract, event: "OperatorMigratedToOperatorSets", logs: logs, sub: sub}, nil -} - -// WatchOperatorMigratedToOperatorSets is a free log subscription operation binding the contract event 0x54f33cfdd1ca703d795986b986fd47d742eab1904ecd2a5fdb8d6595e5904a01. -// -// Solidity: event OperatorMigratedToOperatorSets(address indexed operator, address indexed avs, uint32[] operatorSetIds) -func (_AVSDirectory *AVSDirectoryFilterer) WatchOperatorMigratedToOperatorSets(opts *bind.WatchOpts, sink chan<- *AVSDirectoryOperatorMigratedToOperatorSets, operator []common.Address, avs []common.Address) (event.Subscription, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - var avsRule []interface{} - for _, avsItem := range avs { - avsRule = append(avsRule, avsItem) - } - - logs, sub, err := _AVSDirectory.contract.WatchLogs(opts, "OperatorMigratedToOperatorSets", operatorRule, avsRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(AVSDirectoryOperatorMigratedToOperatorSets) - if err := _AVSDirectory.contract.UnpackLog(event, "OperatorMigratedToOperatorSets", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseOperatorMigratedToOperatorSets is a log parse operation binding the contract event 0x54f33cfdd1ca703d795986b986fd47d742eab1904ecd2a5fdb8d6595e5904a01. -// -// Solidity: event OperatorMigratedToOperatorSets(address indexed operator, address indexed avs, uint32[] operatorSetIds) -func (_AVSDirectory *AVSDirectoryFilterer) ParseOperatorMigratedToOperatorSets(log types.Log) (*AVSDirectoryOperatorMigratedToOperatorSets, error) { - event := new(AVSDirectoryOperatorMigratedToOperatorSets) - if err := _AVSDirectory.contract.UnpackLog(event, "OperatorMigratedToOperatorSets", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - // AVSDirectoryOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the AVSDirectory contract. type AVSDirectoryOwnershipTransferredIterator struct { Event *AVSDirectoryOwnershipTransferred // Event containing the contract specifics and raw log diff --git a/pkg/bindings/AVSDirectoryStorage/binding.go b/pkg/bindings/AVSDirectoryStorage/binding.go index 6d8203bf40..9ac3cb91bd 100644 --- a/pkg/bindings/AVSDirectoryStorage/binding.go +++ b/pkg/bindings/AVSDirectoryStorage/binding.go @@ -38,7 +38,7 @@ type ISignatureUtilsSignatureWithSaltAndExpiry struct { // AVSDirectoryStorageMetaData contains all meta data concerning the AVSDirectoryStorage contract. var AVSDirectoryStorageMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"function\",\"name\":\"OPERATOR_AVS_REGISTRATION_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"OPERATOR_SET_FORCE_DEREGISTRATION_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"OPERATOR_SET_REGISTRATION_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"avsOperatorStatus\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"enumIAVSDirectoryTypes.OperatorAVSRegistrationStatus\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"calculateOperatorAVSRegistrationDigestHash\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"cancelSalt\",\"inputs\":[{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegation\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"deregisterOperatorFromAVS\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"operatorSaltIsSpent\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"isSpent\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"registerOperatorToAVS\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSignature\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtils.SignatureWithSaltAndExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateAVSMetadataURI\",\"inputs\":[{\"name\":\"metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"AVSMetadataURIUpdated\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"AVSMigratedToOperatorSets\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorAVSRegistrationStatusUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"status\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"enumIAVSDirectoryTypes.OperatorAVSRegistrationStatus\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorMigratedToOperatorSets\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operatorSetIds\",\"type\":\"uint32[]\",\"indexed\":false,\"internalType\":\"uint32[]\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"InvalidSignature\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorAlreadyRegisteredToAVS\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorNotRegisteredToAVS\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorNotRegisteredToEigenLayer\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SaltSpent\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SignatureExpired\",\"inputs\":[]}]", + ABI: "[{\"type\":\"function\",\"name\":\"OPERATOR_AVS_REGISTRATION_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"OPERATOR_SET_FORCE_DEREGISTRATION_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"OPERATOR_SET_REGISTRATION_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"avsOperatorStatus\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"enumIAVSDirectoryTypes.OperatorAVSRegistrationStatus\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"calculateOperatorAVSRegistrationDigestHash\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"cancelSalt\",\"inputs\":[{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegation\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"deregisterOperatorFromAVS\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"operatorSaltIsSpent\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"isSpent\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"registerOperatorToAVS\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSignature\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtils.SignatureWithSaltAndExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateAVSMetadataURI\",\"inputs\":[{\"name\":\"metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"AVSMetadataURIUpdated\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorAVSRegistrationStatusUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"status\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"enumIAVSDirectoryTypes.OperatorAVSRegistrationStatus\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"InvalidSignature\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorAlreadyRegisteredToAVS\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorNotRegisteredToAVS\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorNotRegisteredToEigenLayer\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SaltSpent\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SignatureExpired\",\"inputs\":[]}]", } // AVSDirectoryStorageABI is the input ABI used to generate the binding from. @@ -654,150 +654,6 @@ func (_AVSDirectoryStorage *AVSDirectoryStorageFilterer) ParseAVSMetadataURIUpda return event, nil } -// AVSDirectoryStorageAVSMigratedToOperatorSetsIterator is returned from FilterAVSMigratedToOperatorSets and is used to iterate over the raw logs and unpacked data for AVSMigratedToOperatorSets events raised by the AVSDirectoryStorage contract. -type AVSDirectoryStorageAVSMigratedToOperatorSetsIterator struct { - Event *AVSDirectoryStorageAVSMigratedToOperatorSets // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *AVSDirectoryStorageAVSMigratedToOperatorSetsIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(AVSDirectoryStorageAVSMigratedToOperatorSets) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(AVSDirectoryStorageAVSMigratedToOperatorSets) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *AVSDirectoryStorageAVSMigratedToOperatorSetsIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *AVSDirectoryStorageAVSMigratedToOperatorSetsIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// AVSDirectoryStorageAVSMigratedToOperatorSets represents a AVSMigratedToOperatorSets event raised by the AVSDirectoryStorage contract. -type AVSDirectoryStorageAVSMigratedToOperatorSets struct { - Avs common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterAVSMigratedToOperatorSets is a free log retrieval operation binding the contract event 0x702b0c1f6cb1cf511aaa81f72bc05a215bb3497632d72c690c822b044ab494bf. -// -// Solidity: event AVSMigratedToOperatorSets(address indexed avs) -func (_AVSDirectoryStorage *AVSDirectoryStorageFilterer) FilterAVSMigratedToOperatorSets(opts *bind.FilterOpts, avs []common.Address) (*AVSDirectoryStorageAVSMigratedToOperatorSetsIterator, error) { - - var avsRule []interface{} - for _, avsItem := range avs { - avsRule = append(avsRule, avsItem) - } - - logs, sub, err := _AVSDirectoryStorage.contract.FilterLogs(opts, "AVSMigratedToOperatorSets", avsRule) - if err != nil { - return nil, err - } - return &AVSDirectoryStorageAVSMigratedToOperatorSetsIterator{contract: _AVSDirectoryStorage.contract, event: "AVSMigratedToOperatorSets", logs: logs, sub: sub}, nil -} - -// WatchAVSMigratedToOperatorSets is a free log subscription operation binding the contract event 0x702b0c1f6cb1cf511aaa81f72bc05a215bb3497632d72c690c822b044ab494bf. -// -// Solidity: event AVSMigratedToOperatorSets(address indexed avs) -func (_AVSDirectoryStorage *AVSDirectoryStorageFilterer) WatchAVSMigratedToOperatorSets(opts *bind.WatchOpts, sink chan<- *AVSDirectoryStorageAVSMigratedToOperatorSets, avs []common.Address) (event.Subscription, error) { - - var avsRule []interface{} - for _, avsItem := range avs { - avsRule = append(avsRule, avsItem) - } - - logs, sub, err := _AVSDirectoryStorage.contract.WatchLogs(opts, "AVSMigratedToOperatorSets", avsRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(AVSDirectoryStorageAVSMigratedToOperatorSets) - if err := _AVSDirectoryStorage.contract.UnpackLog(event, "AVSMigratedToOperatorSets", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseAVSMigratedToOperatorSets is a log parse operation binding the contract event 0x702b0c1f6cb1cf511aaa81f72bc05a215bb3497632d72c690c822b044ab494bf. -// -// Solidity: event AVSMigratedToOperatorSets(address indexed avs) -func (_AVSDirectoryStorage *AVSDirectoryStorageFilterer) ParseAVSMigratedToOperatorSets(log types.Log) (*AVSDirectoryStorageAVSMigratedToOperatorSets, error) { - event := new(AVSDirectoryStorageAVSMigratedToOperatorSets) - if err := _AVSDirectoryStorage.contract.UnpackLog(event, "AVSMigratedToOperatorSets", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - // AVSDirectoryStorageOperatorAVSRegistrationStatusUpdatedIterator is returned from FilterOperatorAVSRegistrationStatusUpdated and is used to iterate over the raw logs and unpacked data for OperatorAVSRegistrationStatusUpdated events raised by the AVSDirectoryStorage contract. type AVSDirectoryStorageOperatorAVSRegistrationStatusUpdatedIterator struct { Event *AVSDirectoryStorageOperatorAVSRegistrationStatusUpdated // Event containing the contract specifics and raw log @@ -951,157 +807,3 @@ func (_AVSDirectoryStorage *AVSDirectoryStorageFilterer) ParseOperatorAVSRegistr event.Raw = log return event, nil } - -// AVSDirectoryStorageOperatorMigratedToOperatorSetsIterator is returned from FilterOperatorMigratedToOperatorSets and is used to iterate over the raw logs and unpacked data for OperatorMigratedToOperatorSets events raised by the AVSDirectoryStorage contract. -type AVSDirectoryStorageOperatorMigratedToOperatorSetsIterator struct { - Event *AVSDirectoryStorageOperatorMigratedToOperatorSets // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *AVSDirectoryStorageOperatorMigratedToOperatorSetsIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(AVSDirectoryStorageOperatorMigratedToOperatorSets) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(AVSDirectoryStorageOperatorMigratedToOperatorSets) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *AVSDirectoryStorageOperatorMigratedToOperatorSetsIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *AVSDirectoryStorageOperatorMigratedToOperatorSetsIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// AVSDirectoryStorageOperatorMigratedToOperatorSets represents a OperatorMigratedToOperatorSets event raised by the AVSDirectoryStorage contract. -type AVSDirectoryStorageOperatorMigratedToOperatorSets struct { - Operator common.Address - Avs common.Address - OperatorSetIds []uint32 - Raw types.Log // Blockchain specific contextual infos -} - -// FilterOperatorMigratedToOperatorSets is a free log retrieval operation binding the contract event 0x54f33cfdd1ca703d795986b986fd47d742eab1904ecd2a5fdb8d6595e5904a01. -// -// Solidity: event OperatorMigratedToOperatorSets(address indexed operator, address indexed avs, uint32[] operatorSetIds) -func (_AVSDirectoryStorage *AVSDirectoryStorageFilterer) FilterOperatorMigratedToOperatorSets(opts *bind.FilterOpts, operator []common.Address, avs []common.Address) (*AVSDirectoryStorageOperatorMigratedToOperatorSetsIterator, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - var avsRule []interface{} - for _, avsItem := range avs { - avsRule = append(avsRule, avsItem) - } - - logs, sub, err := _AVSDirectoryStorage.contract.FilterLogs(opts, "OperatorMigratedToOperatorSets", operatorRule, avsRule) - if err != nil { - return nil, err - } - return &AVSDirectoryStorageOperatorMigratedToOperatorSetsIterator{contract: _AVSDirectoryStorage.contract, event: "OperatorMigratedToOperatorSets", logs: logs, sub: sub}, nil -} - -// WatchOperatorMigratedToOperatorSets is a free log subscription operation binding the contract event 0x54f33cfdd1ca703d795986b986fd47d742eab1904ecd2a5fdb8d6595e5904a01. -// -// Solidity: event OperatorMigratedToOperatorSets(address indexed operator, address indexed avs, uint32[] operatorSetIds) -func (_AVSDirectoryStorage *AVSDirectoryStorageFilterer) WatchOperatorMigratedToOperatorSets(opts *bind.WatchOpts, sink chan<- *AVSDirectoryStorageOperatorMigratedToOperatorSets, operator []common.Address, avs []common.Address) (event.Subscription, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - var avsRule []interface{} - for _, avsItem := range avs { - avsRule = append(avsRule, avsItem) - } - - logs, sub, err := _AVSDirectoryStorage.contract.WatchLogs(opts, "OperatorMigratedToOperatorSets", operatorRule, avsRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(AVSDirectoryStorageOperatorMigratedToOperatorSets) - if err := _AVSDirectoryStorage.contract.UnpackLog(event, "OperatorMigratedToOperatorSets", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseOperatorMigratedToOperatorSets is a log parse operation binding the contract event 0x54f33cfdd1ca703d795986b986fd47d742eab1904ecd2a5fdb8d6595e5904a01. -// -// Solidity: event OperatorMigratedToOperatorSets(address indexed operator, address indexed avs, uint32[] operatorSetIds) -func (_AVSDirectoryStorage *AVSDirectoryStorageFilterer) ParseOperatorMigratedToOperatorSets(log types.Log) (*AVSDirectoryStorageOperatorMigratedToOperatorSets, error) { - event := new(AVSDirectoryStorageOperatorMigratedToOperatorSets) - if err := _AVSDirectoryStorage.contract.UnpackLog(event, "OperatorMigratedToOperatorSets", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} diff --git a/pkg/bindings/AllocationManager/binding.go b/pkg/bindings/AllocationManager/binding.go index b9cf3bd456..626018f3ec 100644 --- a/pkg/bindings/AllocationManager/binding.go +++ b/pkg/bindings/AllocationManager/binding.go @@ -80,8 +80,8 @@ type OperatorSet struct { // AllocationManagerMetaData contains all meta data concerning the AllocationManager contract. var AllocationManagerMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_delegation\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"},{\"name\":\"_pauserRegistry\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"},{\"name\":\"_permissionController\",\"type\":\"address\",\"internalType\":\"contractIPermissionController\"},{\"name\":\"_DEALLOCATION_DELAY\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"_ALLOCATION_CONFIGURATION_DELAY\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"ALLOCATION_CONFIGURATION_DELAY\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"DEALLOCATION_DELAY\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"addStrategiesToOperatorSet\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetId\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"clearDeallocationQueue\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"numToClear\",\"type\":\"uint16[]\",\"internalType\":\"uint16[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"createOperatorSets\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"params\",\"type\":\"tuple[]\",\"internalType\":\"structIAllocationManagerTypes.CreateSetParams[]\",\"components\":[{\"name\":\"operatorSetId\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegation\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"deregisterFromOperatorSets\",\"inputs\":[{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIAllocationManagerTypes.DeregisterParams\",\"components\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetIds\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"encumberedMagnitude\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAVSRegistrar\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIAVSRegistrar\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocatableMagnitude\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocatedSets\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structOperatorSet[]\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocatedStrategies\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocation\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIAllocationManagerTypes.Allocation\",\"components\":[{\"name\":\"currentMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"pendingDiff\",\"type\":\"int128\",\"internalType\":\"int128\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocationDelay\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocations\",\"inputs\":[{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structIAllocationManagerTypes.Allocation[]\",\"components\":[{\"name\":\"currentMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"pendingDiff\",\"type\":\"int128\",\"internalType\":\"int128\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMaxMagnitude\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMaxMagnitudes\",\"inputs\":[{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64[]\",\"internalType\":\"uint64[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMaxMagnitudes\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64[]\",\"internalType\":\"uint64[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMaxMagnitudesAtBlock\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"blockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64[]\",\"internalType\":\"uint64[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMemberCount\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMembers\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"address[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMinimumSlashableStake\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"futureBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"slashableStake\",\"type\":\"uint256[][]\",\"internalType\":\"uint256[][]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorSetCount\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getRegisteredSets\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structOperatorSet[]\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStrategiesInOperatorSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStrategyAllocations\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structOperatorSet[]\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structIAllocationManagerTypes.Allocation[]\",\"components\":[{\"name\":\"currentMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"pendingDiff\",\"type\":\"int128\",\"internalType\":\"int128\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"isMemberOfOperatorSet\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isOperatorSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"modifyAllocations\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"params\",\"type\":\"tuple[]\",\"internalType\":\"structIAllocationManagerTypes.AllocateParams[]\",\"components\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"newMagnitudes\",\"type\":\"uint64[]\",\"internalType\":\"uint64[]\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"pauseAll\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[{\"name\":\"index\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pauserRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"permissionController\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPermissionController\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"registerForOperatorSets\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIAllocationManagerTypes.RegisterParams\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetIds\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"},{\"name\":\"data\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"removeStrategiesFromOperatorSet\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetId\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setAVSRegistrar\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"registrar\",\"type\":\"address\",\"internalType\":\"contractIAVSRegistrar\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setAllocationDelay\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delay\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"slashOperator\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIAllocationManagerTypes.SlashingParams\",\"components\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetId\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"wadsToSlash\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"description\",\"type\":\"string\",\"internalType\":\"string\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateAVSMetadataURI\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"AVSMetadataURIUpdated\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"AVSRegistrarSet\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"registrar\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIAVSRegistrar\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"AllocationDelaySet\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"delay\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"AllocationUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"magnitude\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"EncumberedMagnitudeUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"encumberedMagnitude\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"MaxMagnitudeUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"maxMagnitude\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorAddedToOperatorSet\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorRemovedFromOperatorSet\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSetCreated\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSlashed\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategies\",\"type\":\"address[]\",\"indexed\":false,\"internalType\":\"contractIStrategy[]\"},{\"name\":\"wadSlashed\",\"type\":\"uint256[]\",\"indexed\":false,\"internalType\":\"uint256[]\"},{\"name\":\"description\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyAddedToOperatorSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyRemovedFromOperatorSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"AlreadyMemberOfSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CurrentlyPaused\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"Empty\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputArrayLengthMismatch\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InsufficientMagnitude\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidCaller\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidNewPausedStatus\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidOperator\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidOperatorSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidPermissions\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidSnapshotOrdering\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidWadToSlash\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ModificationAlreadyPending\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NotMemberOfSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyPauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyUnpauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorNotSlashable\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OutOfBounds\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SameMagnitude\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategiesMustBeInAscendingOrder\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategyAlreadyInOperatorSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategyNotInOperatorSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"UninitializedAllocationDelay\",\"inputs\":[]}]", - Bin: "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", + ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_delegation\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"},{\"name\":\"_pauserRegistry\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"},{\"name\":\"_permissionController\",\"type\":\"address\",\"internalType\":\"contractIPermissionController\"},{\"name\":\"_DEALLOCATION_DELAY\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"_ALLOCATION_CONFIGURATION_DELAY\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"ALLOCATION_CONFIGURATION_DELAY\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"DEALLOCATION_DELAY\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"addStrategiesToOperatorSet\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetId\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"clearDeallocationQueue\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"numToClear\",\"type\":\"uint16[]\",\"internalType\":\"uint16[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"createOperatorSets\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"params\",\"type\":\"tuple[]\",\"internalType\":\"structIAllocationManagerTypes.CreateSetParams[]\",\"components\":[{\"name\":\"operatorSetId\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegation\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"deregisterFromOperatorSets\",\"inputs\":[{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIAllocationManagerTypes.DeregisterParams\",\"components\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetIds\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"getAVSRegistrar\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIAVSRegistrar\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocatableMagnitude\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocatedSets\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structOperatorSet[]\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocatedStake\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256[][]\",\"internalType\":\"uint256[][]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocatedStrategies\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocation\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIAllocationManagerTypes.Allocation\",\"components\":[{\"name\":\"currentMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"pendingDiff\",\"type\":\"int128\",\"internalType\":\"int128\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocationDelay\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocations\",\"inputs\":[{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structIAllocationManagerTypes.Allocation[]\",\"components\":[{\"name\":\"currentMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"pendingDiff\",\"type\":\"int128\",\"internalType\":\"int128\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getEncumberedMagnitude\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMaxMagnitude\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMaxMagnitudes\",\"inputs\":[{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64[]\",\"internalType\":\"uint64[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMaxMagnitudes\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64[]\",\"internalType\":\"uint64[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMaxMagnitudesAtBlock\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"blockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64[]\",\"internalType\":\"uint64[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMemberCount\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMembers\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"address[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMinimumSlashableStake\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"futureBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"slashableStake\",\"type\":\"uint256[][]\",\"internalType\":\"uint256[][]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorSetCount\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getRegisteredSets\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structOperatorSet[]\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStrategiesInOperatorSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStrategyAllocations\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structOperatorSet[]\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structIAllocationManagerTypes.Allocation[]\",\"components\":[{\"name\":\"currentMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"pendingDiff\",\"type\":\"int128\",\"internalType\":\"int128\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"isMemberOfOperatorSet\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isOperatorSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isOperatorSlashable\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"modifyAllocations\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"params\",\"type\":\"tuple[]\",\"internalType\":\"structIAllocationManagerTypes.AllocateParams[]\",\"components\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"newMagnitudes\",\"type\":\"uint64[]\",\"internalType\":\"uint64[]\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"pauseAll\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[{\"name\":\"index\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pauserRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"permissionController\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPermissionController\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"registerForOperatorSets\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIAllocationManagerTypes.RegisterParams\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetIds\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"},{\"name\":\"data\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"removeStrategiesFromOperatorSet\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetId\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setAVSRegistrar\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"registrar\",\"type\":\"address\",\"internalType\":\"contractIAVSRegistrar\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setAllocationDelay\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delay\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"slashOperator\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIAllocationManagerTypes.SlashingParams\",\"components\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetId\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"wadsToSlash\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"description\",\"type\":\"string\",\"internalType\":\"string\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateAVSMetadataURI\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"AVSMetadataURIUpdated\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"AVSRegistrarSet\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"registrar\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIAVSRegistrar\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"AllocationDelaySet\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"delay\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"AllocationUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"magnitude\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"EncumberedMagnitudeUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"encumberedMagnitude\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"MaxMagnitudeUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"maxMagnitude\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorAddedToOperatorSet\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorRemovedFromOperatorSet\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSetCreated\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSlashed\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategies\",\"type\":\"address[]\",\"indexed\":false,\"internalType\":\"contractIStrategy[]\"},{\"name\":\"wadSlashed\",\"type\":\"uint256[]\",\"indexed\":false,\"internalType\":\"uint256[]\"},{\"name\":\"description\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyAddedToOperatorSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyRemovedFromOperatorSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"AlreadyMemberOfSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CurrentlyPaused\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"Empty\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputArrayLengthMismatch\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InsufficientMagnitude\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidCaller\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidNewPausedStatus\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidOperator\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidOperatorSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidPermissions\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidSnapshotOrdering\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidWadToSlash\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ModificationAlreadyPending\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NotMemberOfSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyPauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyUnpauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorNotSlashable\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OutOfBounds\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SameMagnitude\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategiesMustBeInAscendingOrder\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategyAlreadyInOperatorSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategyNotInOperatorSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"UninitializedAllocationDelay\",\"inputs\":[]}]", + Bin: "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", } // AllocationManagerABI is the input ABI used to generate the binding from. @@ -344,37 +344,6 @@ func (_AllocationManager *AllocationManagerCallerSession) Delegation() (common.A return _AllocationManager.Contract.Delegation(&_AllocationManager.CallOpts) } -// EncumberedMagnitude is a free data retrieval call binding the contract method 0xa984eb3a. -// -// Solidity: function encumberedMagnitude(address operator, address strategy) view returns(uint64) -func (_AllocationManager *AllocationManagerCaller) EncumberedMagnitude(opts *bind.CallOpts, operator common.Address, strategy common.Address) (uint64, error) { - var out []interface{} - err := _AllocationManager.contract.Call(opts, &out, "encumberedMagnitude", operator, strategy) - - if err != nil { - return *new(uint64), err - } - - out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) - - return out0, err - -} - -// EncumberedMagnitude is a free data retrieval call binding the contract method 0xa984eb3a. -// -// Solidity: function encumberedMagnitude(address operator, address strategy) view returns(uint64) -func (_AllocationManager *AllocationManagerSession) EncumberedMagnitude(operator common.Address, strategy common.Address) (uint64, error) { - return _AllocationManager.Contract.EncumberedMagnitude(&_AllocationManager.CallOpts, operator, strategy) -} - -// EncumberedMagnitude is a free data retrieval call binding the contract method 0xa984eb3a. -// -// Solidity: function encumberedMagnitude(address operator, address strategy) view returns(uint64) -func (_AllocationManager *AllocationManagerCallerSession) EncumberedMagnitude(operator common.Address, strategy common.Address) (uint64, error) { - return _AllocationManager.Contract.EncumberedMagnitude(&_AllocationManager.CallOpts, operator, strategy) -} - // GetAVSRegistrar is a free data retrieval call binding the contract method 0x304c10cd. // // Solidity: function getAVSRegistrar(address avs) view returns(address) @@ -468,6 +437,37 @@ func (_AllocationManager *AllocationManagerCallerSession) GetAllocatedSets(opera return _AllocationManager.Contract.GetAllocatedSets(&_AllocationManager.CallOpts, operator) } +// GetAllocatedStake is a free data retrieval call binding the contract method 0x2b453a9a. +// +// Solidity: function getAllocatedStake((address,uint32) operatorSet, address[] operators, address[] strategies) view returns(uint256[][]) +func (_AllocationManager *AllocationManagerCaller) GetAllocatedStake(opts *bind.CallOpts, operatorSet OperatorSet, operators []common.Address, strategies []common.Address) ([][]*big.Int, error) { + var out []interface{} + err := _AllocationManager.contract.Call(opts, &out, "getAllocatedStake", operatorSet, operators, strategies) + + if err != nil { + return *new([][]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([][]*big.Int)).(*[][]*big.Int) + + return out0, err + +} + +// GetAllocatedStake is a free data retrieval call binding the contract method 0x2b453a9a. +// +// Solidity: function getAllocatedStake((address,uint32) operatorSet, address[] operators, address[] strategies) view returns(uint256[][]) +func (_AllocationManager *AllocationManagerSession) GetAllocatedStake(operatorSet OperatorSet, operators []common.Address, strategies []common.Address) ([][]*big.Int, error) { + return _AllocationManager.Contract.GetAllocatedStake(&_AllocationManager.CallOpts, operatorSet, operators, strategies) +} + +// GetAllocatedStake is a free data retrieval call binding the contract method 0x2b453a9a. +// +// Solidity: function getAllocatedStake((address,uint32) operatorSet, address[] operators, address[] strategies) view returns(uint256[][]) +func (_AllocationManager *AllocationManagerCallerSession) GetAllocatedStake(operatorSet OperatorSet, operators []common.Address, strategies []common.Address) ([][]*big.Int, error) { + return _AllocationManager.Contract.GetAllocatedStake(&_AllocationManager.CallOpts, operatorSet, operators, strategies) +} + // GetAllocatedStrategies is a free data retrieval call binding the contract method 0xc221d8ae. // // Solidity: function getAllocatedStrategies(address operator, (address,uint32) operatorSet) view returns(address[]) @@ -593,6 +593,37 @@ func (_AllocationManager *AllocationManagerCallerSession) GetAllocations(operato return _AllocationManager.Contract.GetAllocations(&_AllocationManager.CallOpts, operators, operatorSet, strategy) } +// GetEncumberedMagnitude is a free data retrieval call binding the contract method 0xf605ce08. +// +// Solidity: function getEncumberedMagnitude(address operator, address strategy) view returns(uint64) +func (_AllocationManager *AllocationManagerCaller) GetEncumberedMagnitude(opts *bind.CallOpts, operator common.Address, strategy common.Address) (uint64, error) { + var out []interface{} + err := _AllocationManager.contract.Call(opts, &out, "getEncumberedMagnitude", operator, strategy) + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// GetEncumberedMagnitude is a free data retrieval call binding the contract method 0xf605ce08. +// +// Solidity: function getEncumberedMagnitude(address operator, address strategy) view returns(uint64) +func (_AllocationManager *AllocationManagerSession) GetEncumberedMagnitude(operator common.Address, strategy common.Address) (uint64, error) { + return _AllocationManager.Contract.GetEncumberedMagnitude(&_AllocationManager.CallOpts, operator, strategy) +} + +// GetEncumberedMagnitude is a free data retrieval call binding the contract method 0xf605ce08. +// +// Solidity: function getEncumberedMagnitude(address operator, address strategy) view returns(uint64) +func (_AllocationManager *AllocationManagerCallerSession) GetEncumberedMagnitude(operator common.Address, strategy common.Address) (uint64, error) { + return _AllocationManager.Contract.GetEncumberedMagnitude(&_AllocationManager.CallOpts, operator, strategy) +} + // GetMaxMagnitude is a free data retrieval call binding the contract method 0xa9333ec8. // // Solidity: function getMaxMagnitude(address operator, address strategy) view returns(uint64) @@ -997,6 +1028,37 @@ func (_AllocationManager *AllocationManagerCallerSession) IsOperatorSet(operator return _AllocationManager.Contract.IsOperatorSet(&_AllocationManager.CallOpts, operatorSet) } +// IsOperatorSlashable is a free data retrieval call binding the contract method 0x1352c3e6. +// +// Solidity: function isOperatorSlashable(address operator, (address,uint32) operatorSet) view returns(bool) +func (_AllocationManager *AllocationManagerCaller) IsOperatorSlashable(opts *bind.CallOpts, operator common.Address, operatorSet OperatorSet) (bool, error) { + var out []interface{} + err := _AllocationManager.contract.Call(opts, &out, "isOperatorSlashable", operator, operatorSet) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsOperatorSlashable is a free data retrieval call binding the contract method 0x1352c3e6. +// +// Solidity: function isOperatorSlashable(address operator, (address,uint32) operatorSet) view returns(bool) +func (_AllocationManager *AllocationManagerSession) IsOperatorSlashable(operator common.Address, operatorSet OperatorSet) (bool, error) { + return _AllocationManager.Contract.IsOperatorSlashable(&_AllocationManager.CallOpts, operator, operatorSet) +} + +// IsOperatorSlashable is a free data retrieval call binding the contract method 0x1352c3e6. +// +// Solidity: function isOperatorSlashable(address operator, (address,uint32) operatorSet) view returns(bool) +func (_AllocationManager *AllocationManagerCallerSession) IsOperatorSlashable(operator common.Address, operatorSet OperatorSet) (bool, error) { + return _AllocationManager.Contract.IsOperatorSlashable(&_AllocationManager.CallOpts, operator, operatorSet) +} + // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. // // Solidity: function owner() view returns(address) diff --git a/pkg/bindings/AllocationManagerStorage/binding.go b/pkg/bindings/AllocationManagerStorage/binding.go index 7e8e815c8b..d7168bcaa5 100644 --- a/pkg/bindings/AllocationManagerStorage/binding.go +++ b/pkg/bindings/AllocationManagerStorage/binding.go @@ -80,7 +80,7 @@ type OperatorSet struct { // AllocationManagerStorageMetaData contains all meta data concerning the AllocationManagerStorage contract. var AllocationManagerStorageMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"function\",\"name\":\"ALLOCATION_CONFIGURATION_DELAY\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"DEALLOCATION_DELAY\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"addStrategiesToOperatorSet\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetId\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"clearDeallocationQueue\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"numToClear\",\"type\":\"uint16[]\",\"internalType\":\"uint16[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"createOperatorSets\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"params\",\"type\":\"tuple[]\",\"internalType\":\"structIAllocationManagerTypes.CreateSetParams[]\",\"components\":[{\"name\":\"operatorSetId\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegation\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"deregisterFromOperatorSets\",\"inputs\":[{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIAllocationManagerTypes.DeregisterParams\",\"components\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetIds\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"encumberedMagnitude\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAVSRegistrar\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIAVSRegistrar\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocatableMagnitude\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocatedSets\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structOperatorSet[]\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocatedStrategies\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocation\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIAllocationManagerTypes.Allocation\",\"components\":[{\"name\":\"currentMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"pendingDiff\",\"type\":\"int128\",\"internalType\":\"int128\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocationDelay\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"isSet\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"delay\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocations\",\"inputs\":[{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structIAllocationManagerTypes.Allocation[]\",\"components\":[{\"name\":\"currentMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"pendingDiff\",\"type\":\"int128\",\"internalType\":\"int128\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMaxMagnitude\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMaxMagnitudes\",\"inputs\":[{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64[]\",\"internalType\":\"uint64[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMaxMagnitudes\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64[]\",\"internalType\":\"uint64[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMaxMagnitudesAtBlock\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"blockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64[]\",\"internalType\":\"uint64[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMemberCount\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMembers\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMinimumSlashableStake\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"futureBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"slashableStake\",\"type\":\"uint256[][]\",\"internalType\":\"uint256[][]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorSetCount\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getRegisteredSets\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"operatorSets\",\"type\":\"tuple[]\",\"internalType\":\"structOperatorSet[]\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStrategiesInOperatorSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStrategyAllocations\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structOperatorSet[]\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structIAllocationManagerTypes.Allocation[]\",\"components\":[{\"name\":\"currentMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"pendingDiff\",\"type\":\"int128\",\"internalType\":\"int128\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"isMemberOfOperatorSet\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isOperatorSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"modifyAllocations\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"params\",\"type\":\"tuple[]\",\"internalType\":\"structIAllocationManagerTypes.AllocateParams[]\",\"components\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"newMagnitudes\",\"type\":\"uint64[]\",\"internalType\":\"uint64[]\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"registerForOperatorSets\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIAllocationManagerTypes.RegisterParams\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetIds\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"},{\"name\":\"data\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"removeStrategiesFromOperatorSet\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetId\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setAVSRegistrar\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"registrar\",\"type\":\"address\",\"internalType\":\"contractIAVSRegistrar\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setAllocationDelay\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delay\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"slashOperator\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIAllocationManagerTypes.SlashingParams\",\"components\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetId\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"wadsToSlash\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"description\",\"type\":\"string\",\"internalType\":\"string\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateAVSMetadataURI\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"AVSMetadataURIUpdated\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"AVSRegistrarSet\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"registrar\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIAVSRegistrar\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"AllocationDelaySet\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"delay\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"AllocationUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"magnitude\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"EncumberedMagnitudeUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"encumberedMagnitude\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"MaxMagnitudeUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"maxMagnitude\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorAddedToOperatorSet\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorRemovedFromOperatorSet\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSetCreated\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSlashed\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategies\",\"type\":\"address[]\",\"indexed\":false,\"internalType\":\"contractIStrategy[]\"},{\"name\":\"wadSlashed\",\"type\":\"uint256[]\",\"indexed\":false,\"internalType\":\"uint256[]\"},{\"name\":\"description\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyAddedToOperatorSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyRemovedFromOperatorSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"AlreadyMemberOfSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputArrayLengthMismatch\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InsufficientMagnitude\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidCaller\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidOperator\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidOperatorSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidWadToSlash\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ModificationAlreadyPending\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NotMemberOfSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorNotSlashable\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SameMagnitude\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategiesMustBeInAscendingOrder\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategyAlreadyInOperatorSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategyNotInOperatorSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"UninitializedAllocationDelay\",\"inputs\":[]}]", + ABI: "[{\"type\":\"function\",\"name\":\"ALLOCATION_CONFIGURATION_DELAY\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"DEALLOCATION_DELAY\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"addStrategiesToOperatorSet\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetId\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"clearDeallocationQueue\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"numToClear\",\"type\":\"uint16[]\",\"internalType\":\"uint16[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"createOperatorSets\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"params\",\"type\":\"tuple[]\",\"internalType\":\"structIAllocationManagerTypes.CreateSetParams[]\",\"components\":[{\"name\":\"operatorSetId\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegation\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"deregisterFromOperatorSets\",\"inputs\":[{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIAllocationManagerTypes.DeregisterParams\",\"components\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetIds\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"getAVSRegistrar\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIAVSRegistrar\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocatableMagnitude\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocatedSets\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structOperatorSet[]\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocatedStake\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"slashableStake\",\"type\":\"uint256[][]\",\"internalType\":\"uint256[][]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocatedStrategies\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocation\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIAllocationManagerTypes.Allocation\",\"components\":[{\"name\":\"currentMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"pendingDiff\",\"type\":\"int128\",\"internalType\":\"int128\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocationDelay\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"isSet\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"delay\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocations\",\"inputs\":[{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structIAllocationManagerTypes.Allocation[]\",\"components\":[{\"name\":\"currentMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"pendingDiff\",\"type\":\"int128\",\"internalType\":\"int128\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getEncumberedMagnitude\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMaxMagnitude\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMaxMagnitudes\",\"inputs\":[{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64[]\",\"internalType\":\"uint64[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMaxMagnitudes\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64[]\",\"internalType\":\"uint64[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMaxMagnitudesAtBlock\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"blockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64[]\",\"internalType\":\"uint64[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMemberCount\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMembers\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMinimumSlashableStake\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"futureBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"slashableStake\",\"type\":\"uint256[][]\",\"internalType\":\"uint256[][]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorSetCount\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getRegisteredSets\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"operatorSets\",\"type\":\"tuple[]\",\"internalType\":\"structOperatorSet[]\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStrategiesInOperatorSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStrategyAllocations\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structOperatorSet[]\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structIAllocationManagerTypes.Allocation[]\",\"components\":[{\"name\":\"currentMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"pendingDiff\",\"type\":\"int128\",\"internalType\":\"int128\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"isMemberOfOperatorSet\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isOperatorSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isOperatorSlashable\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"modifyAllocations\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"params\",\"type\":\"tuple[]\",\"internalType\":\"structIAllocationManagerTypes.AllocateParams[]\",\"components\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"newMagnitudes\",\"type\":\"uint64[]\",\"internalType\":\"uint64[]\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"registerForOperatorSets\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIAllocationManagerTypes.RegisterParams\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetIds\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"},{\"name\":\"data\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"removeStrategiesFromOperatorSet\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetId\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setAVSRegistrar\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"registrar\",\"type\":\"address\",\"internalType\":\"contractIAVSRegistrar\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setAllocationDelay\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delay\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"slashOperator\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIAllocationManagerTypes.SlashingParams\",\"components\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetId\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"wadsToSlash\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"description\",\"type\":\"string\",\"internalType\":\"string\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateAVSMetadataURI\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"AVSMetadataURIUpdated\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"AVSRegistrarSet\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"registrar\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIAVSRegistrar\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"AllocationDelaySet\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"delay\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"AllocationUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"magnitude\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"EncumberedMagnitudeUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"encumberedMagnitude\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"MaxMagnitudeUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"maxMagnitude\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorAddedToOperatorSet\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorRemovedFromOperatorSet\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSetCreated\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSlashed\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategies\",\"type\":\"address[]\",\"indexed\":false,\"internalType\":\"contractIStrategy[]\"},{\"name\":\"wadSlashed\",\"type\":\"uint256[]\",\"indexed\":false,\"internalType\":\"uint256[]\"},{\"name\":\"description\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyAddedToOperatorSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyRemovedFromOperatorSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"AlreadyMemberOfSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputArrayLengthMismatch\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InsufficientMagnitude\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidCaller\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidOperator\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidOperatorSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidWadToSlash\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ModificationAlreadyPending\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NotMemberOfSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorNotSlashable\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SameMagnitude\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategiesMustBeInAscendingOrder\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategyAlreadyInOperatorSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategyNotInOperatorSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"UninitializedAllocationDelay\",\"inputs\":[]}]", } // AllocationManagerStorageABI is the input ABI used to generate the binding from. @@ -322,37 +322,6 @@ func (_AllocationManagerStorage *AllocationManagerStorageCallerSession) Delegati return _AllocationManagerStorage.Contract.Delegation(&_AllocationManagerStorage.CallOpts) } -// EncumberedMagnitude is a free data retrieval call binding the contract method 0xa984eb3a. -// -// Solidity: function encumberedMagnitude(address operator, address strategy) view returns(uint64) -func (_AllocationManagerStorage *AllocationManagerStorageCaller) EncumberedMagnitude(opts *bind.CallOpts, operator common.Address, strategy common.Address) (uint64, error) { - var out []interface{} - err := _AllocationManagerStorage.contract.Call(opts, &out, "encumberedMagnitude", operator, strategy) - - if err != nil { - return *new(uint64), err - } - - out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) - - return out0, err - -} - -// EncumberedMagnitude is a free data retrieval call binding the contract method 0xa984eb3a. -// -// Solidity: function encumberedMagnitude(address operator, address strategy) view returns(uint64) -func (_AllocationManagerStorage *AllocationManagerStorageSession) EncumberedMagnitude(operator common.Address, strategy common.Address) (uint64, error) { - return _AllocationManagerStorage.Contract.EncumberedMagnitude(&_AllocationManagerStorage.CallOpts, operator, strategy) -} - -// EncumberedMagnitude is a free data retrieval call binding the contract method 0xa984eb3a. -// -// Solidity: function encumberedMagnitude(address operator, address strategy) view returns(uint64) -func (_AllocationManagerStorage *AllocationManagerStorageCallerSession) EncumberedMagnitude(operator common.Address, strategy common.Address) (uint64, error) { - return _AllocationManagerStorage.Contract.EncumberedMagnitude(&_AllocationManagerStorage.CallOpts, operator, strategy) -} - // GetAVSRegistrar is a free data retrieval call binding the contract method 0x304c10cd. // // Solidity: function getAVSRegistrar(address avs) view returns(address) @@ -446,6 +415,37 @@ func (_AllocationManagerStorage *AllocationManagerStorageCallerSession) GetAlloc return _AllocationManagerStorage.Contract.GetAllocatedSets(&_AllocationManagerStorage.CallOpts, operator) } +// GetAllocatedStake is a free data retrieval call binding the contract method 0x2b453a9a. +// +// Solidity: function getAllocatedStake((address,uint32) operatorSet, address[] operators, address[] strategies) view returns(uint256[][] slashableStake) +func (_AllocationManagerStorage *AllocationManagerStorageCaller) GetAllocatedStake(opts *bind.CallOpts, operatorSet OperatorSet, operators []common.Address, strategies []common.Address) ([][]*big.Int, error) { + var out []interface{} + err := _AllocationManagerStorage.contract.Call(opts, &out, "getAllocatedStake", operatorSet, operators, strategies) + + if err != nil { + return *new([][]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([][]*big.Int)).(*[][]*big.Int) + + return out0, err + +} + +// GetAllocatedStake is a free data retrieval call binding the contract method 0x2b453a9a. +// +// Solidity: function getAllocatedStake((address,uint32) operatorSet, address[] operators, address[] strategies) view returns(uint256[][] slashableStake) +func (_AllocationManagerStorage *AllocationManagerStorageSession) GetAllocatedStake(operatorSet OperatorSet, operators []common.Address, strategies []common.Address) ([][]*big.Int, error) { + return _AllocationManagerStorage.Contract.GetAllocatedStake(&_AllocationManagerStorage.CallOpts, operatorSet, operators, strategies) +} + +// GetAllocatedStake is a free data retrieval call binding the contract method 0x2b453a9a. +// +// Solidity: function getAllocatedStake((address,uint32) operatorSet, address[] operators, address[] strategies) view returns(uint256[][] slashableStake) +func (_AllocationManagerStorage *AllocationManagerStorageCallerSession) GetAllocatedStake(operatorSet OperatorSet, operators []common.Address, strategies []common.Address) ([][]*big.Int, error) { + return _AllocationManagerStorage.Contract.GetAllocatedStake(&_AllocationManagerStorage.CallOpts, operatorSet, operators, strategies) +} + // GetAllocatedStrategies is a free data retrieval call binding the contract method 0xc221d8ae. // // Solidity: function getAllocatedStrategies(address operator, (address,uint32) operatorSet) view returns(address[]) @@ -584,6 +584,37 @@ func (_AllocationManagerStorage *AllocationManagerStorageCallerSession) GetAlloc return _AllocationManagerStorage.Contract.GetAllocations(&_AllocationManagerStorage.CallOpts, operators, operatorSet, strategy) } +// GetEncumberedMagnitude is a free data retrieval call binding the contract method 0xf605ce08. +// +// Solidity: function getEncumberedMagnitude(address operator, address strategy) view returns(uint64) +func (_AllocationManagerStorage *AllocationManagerStorageCaller) GetEncumberedMagnitude(opts *bind.CallOpts, operator common.Address, strategy common.Address) (uint64, error) { + var out []interface{} + err := _AllocationManagerStorage.contract.Call(opts, &out, "getEncumberedMagnitude", operator, strategy) + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// GetEncumberedMagnitude is a free data retrieval call binding the contract method 0xf605ce08. +// +// Solidity: function getEncumberedMagnitude(address operator, address strategy) view returns(uint64) +func (_AllocationManagerStorage *AllocationManagerStorageSession) GetEncumberedMagnitude(operator common.Address, strategy common.Address) (uint64, error) { + return _AllocationManagerStorage.Contract.GetEncumberedMagnitude(&_AllocationManagerStorage.CallOpts, operator, strategy) +} + +// GetEncumberedMagnitude is a free data retrieval call binding the contract method 0xf605ce08. +// +// Solidity: function getEncumberedMagnitude(address operator, address strategy) view returns(uint64) +func (_AllocationManagerStorage *AllocationManagerStorageCallerSession) GetEncumberedMagnitude(operator common.Address, strategy common.Address) (uint64, error) { + return _AllocationManagerStorage.Contract.GetEncumberedMagnitude(&_AllocationManagerStorage.CallOpts, operator, strategy) +} + // GetMaxMagnitude is a free data retrieval call binding the contract method 0xa9333ec8. // // Solidity: function getMaxMagnitude(address operator, address strategy) view returns(uint64) @@ -988,6 +1019,37 @@ func (_AllocationManagerStorage *AllocationManagerStorageCallerSession) IsOperat return _AllocationManagerStorage.Contract.IsOperatorSet(&_AllocationManagerStorage.CallOpts, operatorSet) } +// IsOperatorSlashable is a free data retrieval call binding the contract method 0x1352c3e6. +// +// Solidity: function isOperatorSlashable(address operator, (address,uint32) operatorSet) view returns(bool) +func (_AllocationManagerStorage *AllocationManagerStorageCaller) IsOperatorSlashable(opts *bind.CallOpts, operator common.Address, operatorSet OperatorSet) (bool, error) { + var out []interface{} + err := _AllocationManagerStorage.contract.Call(opts, &out, "isOperatorSlashable", operator, operatorSet) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsOperatorSlashable is a free data retrieval call binding the contract method 0x1352c3e6. +// +// Solidity: function isOperatorSlashable(address operator, (address,uint32) operatorSet) view returns(bool) +func (_AllocationManagerStorage *AllocationManagerStorageSession) IsOperatorSlashable(operator common.Address, operatorSet OperatorSet) (bool, error) { + return _AllocationManagerStorage.Contract.IsOperatorSlashable(&_AllocationManagerStorage.CallOpts, operator, operatorSet) +} + +// IsOperatorSlashable is a free data retrieval call binding the contract method 0x1352c3e6. +// +// Solidity: function isOperatorSlashable(address operator, (address,uint32) operatorSet) view returns(bool) +func (_AllocationManagerStorage *AllocationManagerStorageCallerSession) IsOperatorSlashable(operator common.Address, operatorSet OperatorSet) (bool, error) { + return _AllocationManagerStorage.Contract.IsOperatorSlashable(&_AllocationManagerStorage.CallOpts, operator, operatorSet) +} + // AddStrategiesToOperatorSet is a paid mutator transaction binding the contract method 0x50feea20. // // Solidity: function addStrategiesToOperatorSet(address avs, uint32 operatorSetId, address[] strategies) returns() diff --git a/pkg/bindings/BackingEigen/binding.go b/pkg/bindings/BackingEigen/binding.go index 773e13f221..5367ed4b91 100644 --- a/pkg/bindings/BackingEigen/binding.go +++ b/pkg/bindings/BackingEigen/binding.go @@ -38,7 +38,7 @@ type ERC20VotesUpgradeableCheckpoint struct { // BackingEigenMetaData contains all meta data concerning the BackingEigen contract. var BackingEigenMetaData = &bind.MetaData{ ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_EIGEN\",\"type\":\"address\",\"internalType\":\"contractIERC20\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"CLOCK_MODE\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"DOMAIN_SEPARATOR\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"EIGEN\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIERC20\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"allowance\",\"inputs\":[{\"name\":\"owner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"allowedFrom\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"allowedTo\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"approve\",\"inputs\":[{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"balanceOf\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"burn\",\"inputs\":[{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"checkpoints\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"pos\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structERC20VotesUpgradeable.Checkpoint\",\"components\":[{\"name\":\"fromBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"votes\",\"type\":\"uint224\",\"internalType\":\"uint224\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"clock\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint48\",\"internalType\":\"uint48\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"decimals\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"decreaseAllowance\",\"inputs\":[{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"subtractedValue\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegate\",\"inputs\":[{\"name\":\"delegatee\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegateBySig\",\"inputs\":[{\"name\":\"delegatee\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"v\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"r\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"s\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegates\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"disableTransferRestrictions\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"eip712Domain\",\"inputs\":[],\"outputs\":[{\"name\":\"fields\",\"type\":\"bytes1\",\"internalType\":\"bytes1\"},{\"name\":\"name\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"version\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"chainId\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"verifyingContract\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"extensions\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getPastTotalSupply\",\"inputs\":[{\"name\":\"timepoint\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getPastVotes\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"timepoint\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getVotes\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"increaseAllowance\",\"inputs\":[{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"addedValue\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"isMinter\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"mint\",\"inputs\":[{\"name\":\"to\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"name\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"nonces\",\"inputs\":[{\"name\":\"owner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"numCheckpoints\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"permit\",\"inputs\":[{\"name\":\"owner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"deadline\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"v\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"r\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"s\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setAllowedFrom\",\"inputs\":[{\"name\":\"from\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"isAllowedFrom\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setAllowedTo\",\"inputs\":[{\"name\":\"to\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"isAllowedTo\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setIsMinter\",\"inputs\":[{\"name\":\"minterAddress\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"newStatus\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"symbol\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"totalSupply\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"transfer\",\"inputs\":[{\"name\":\"to\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"transferFrom\",\"inputs\":[{\"name\":\"from\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"to\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"transferRestrictionsDisabledAfter\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"event\",\"name\":\"Approval\",\"inputs\":[{\"name\":\"owner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"spender\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Backed\",\"inputs\":[],\"anonymous\":false},{\"type\":\"event\",\"name\":\"DelegateChanged\",\"inputs\":[{\"name\":\"delegator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"fromDelegate\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"toDelegate\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"DelegateVotesChanged\",\"inputs\":[{\"name\":\"delegate\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"previousBalance\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"newBalance\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"EIP712DomainChanged\",\"inputs\":[],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"IsMinterModified\",\"inputs\":[{\"name\":\"minterAddress\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newStatus\",\"type\":\"bool\",\"indexed\":false,\"internalType\":\"bool\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"SetAllowedFrom\",\"inputs\":[{\"name\":\"from\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"isAllowedFrom\",\"type\":\"bool\",\"indexed\":false,\"internalType\":\"bool\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"SetAllowedTo\",\"inputs\":[{\"name\":\"to\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"isAllowedTo\",\"type\":\"bool\",\"indexed\":false,\"internalType\":\"bool\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Transfer\",\"inputs\":[{\"name\":\"from\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"to\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"TransferRestrictionsDisabled\",\"inputs\":[],\"anonymous\":false}]", - Bin: "0x60a060405234801561000f575f5ffd5b50604051612d11380380612d1183398101604081905261002e91610105565b6001600160a01b038116608052610043610049565b50610132565b5f54610100900460ff16156100b45760405162461bcd60e51b815260206004820152602760248201527f496e697469616c697a61626c653a20636f6e747261637420697320696e697469604482015266616c697a696e6760c81b606482015260840160405180910390fd5b5f5460ff90811614610103575f805460ff191660ff9081179091556040519081527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15b565b5f60208284031215610115575f5ffd5b81516001600160a01b038116811461012b575f5ffd5b9392505050565b608051612bb261015f5f395f81816105e901528181610dae01528181610dd90152610e040152612bb25ff3fe608060405234801561000f575f5ffd5b506004361061023f575f3560e01c80637ecebe0011610135578063aa271e1a116100b4578063dd62ed3e11610079578063dd62ed3e14610579578063eb415f451461058c578063f1127ed814610594578063f2fde38b146105d1578063fdc371ce146105e4575f5ffd5b8063aa271e1a1461050a578063b8c255941461052d578063c3cda52014610540578063c4d66de814610553578063d505accf14610566575f5ffd5b806395d89b41116100fa57806395d89b41146104bf5780639ab24eb0146104c75780639aec4bae146104da578063a457c2d7146104e4578063a9059cbb146104f7575f5ffd5b80637ecebe001461044e57806384b0196e146104615780638da5cb5b1461047c5780638e539e8c1461048d57806391ddadf4146104a0575f5ffd5b806340c10f19116101c157806366eb399f1161018657806366eb399f146103c05780636fcfff45146103d357806370a08231146103fb578063715018a61461042357806378aa33ba1461042b575f5ffd5b806340c10f191461031a57806342966c681461032d5780634bf5d7e914610340578063587cde1e1461036a5780635c19a95c146103ad575f5ffd5b806323b872dd1161020757806323b872dd146102ca578063313ce567146102dd5780633644e515146102ec57806339509351146102f45780633a46b1a814610307575f5ffd5b80630455e6941461024357806306fdde031461027b578063095ea7b31461029057806318160ddd146102a35780631ffacdef146102b5575b5f5ffd5b610266610251366004612682565b6101316020525f908152604090205460ff1681565b60405190151581526020015b60405180910390f35b61028361060b565b60405161027291906126c9565b61026661029e3660046126db565b61069b565b6067545b604051908152602001610272565b6102c86102c3366004612703565b6106b4565b005b6102666102d836600461273c565b6106ca565b60405160128152602001610272565b6102a76106ed565b6102666103023660046126db565b6106fb565b6102a76103153660046126db565b61071c565b6102c86103283660046126db565b6107a4565b6102c861033b366004612776565b61081f565b60408051808201909152600e81526d06d6f64653d74696d657374616d760941b6020820152610283565b610395610378366004612682565b6001600160a01b039081165f90815260fe60205260409020541690565b6040516001600160a01b039091168152602001610272565b6102c86103bb366004612682565b61082c565b6102c86103ce366004612703565b610836565b6103e66103e1366004612682565b6108ae565b60405163ffffffff9091168152602001610272565b6102a7610409366004612682565b6001600160a01b03165f9081526065602052604090205490565b6102c86108cf565b610266610439366004612682565b6101326020525f908152604090205460ff1681565b6102a761045c366004612682565b6108e2565b6104696108ff565b604051610272979695949392919061278d565b6033546001600160a01b0316610395565b6102a761049b366004612776565b610998565b6104a86109ff565b60405165ffffffffffff9091168152602001610272565b610283610a09565b6102a76104d5366004612682565b610a18565b6102a76101305481565b6102666104f23660046126db565b610a95565b6102666105053660046126db565b610b0f565b610266610518366004612682565b6101336020525f908152604090205460ff1681565b6102c861053b366004612703565b610b1c565b6102c861054e366004612833565b610b2e565b6102c8610561366004612682565b610c63565b6102c8610574366004612887565b610ea5565b6102a76105873660046128ed565b611006565b6102c8611030565b6105a76105a236600461291e565b6110fe565b60408051825163ffffffff1681526020928301516001600160e01b03169281019290925201610272565b6102c86105df366004612682565b61117f565b6103957f000000000000000000000000000000000000000000000000000000000000000081565b60606068805461061a90612950565b80601f016020809104026020016040519081016040528092919081815260200182805461064690612950565b80156106915780601f1061066857610100808354040283529160200191610691565b820191905f5260205f20905b81548152906001019060200180831161067457829003601f168201915b5050505050905090565b5f336106a88185856111f5565b60019150505b92915050565b6106bc611318565b6106c68282611372565b5050565b5f336106d78582856113d2565b6106e285858561144a565b506001949350505050565b5f6106f6611604565b905090565b5f336106a881858561070d8383611006565b6107179190612996565b6111f5565b5f6107256109ff565b65ffffffffffff16821061077c5760405162461bcd60e51b815260206004820152601960248201527804552433230566f7465733a20667574757265206c6f6f6b757603c1b60448201526064015b60405180910390fd5b6001600160a01b0383165f90815260ff6020526040902061079d908361160d565b9392505050565b335f908152610133602052604090205460ff166108155760405162461bcd60e51b815260206004820152602960248201527f4261636b696e67456967656e2e6d696e743a2063616c6c6572206973206e6f7460448201526810309036b4b73a32b960b91b6064820152608401610773565b6106c682826116ee565b6108293382611779565b50565b6108293382611792565b61083e611318565b816001600160a01b03167f0124b12503bddc2616c0f3f54fd23ed283f5ef0c1483a75409e42612176b8bde8260405161087b911515815260200190565b60405180910390a26001600160a01b03919091165f90815261013360205260409020805460ff1916911515919091179055565b6001600160a01b0381165f90815260ff60205260408120546106ae9061180b565b6108d7611318565b6108e05f611873565b565b6001600160a01b0381165f90815260cb60205260408120546106ae565b5f6060805f5f5f60606097545f5f1b14801561091b5750609854155b61095f5760405162461bcd60e51b81526020600482015260156024820152741152540dcc4c8e88155b9a5b9a5d1a585b1a5e9959605a1b6044820152606401610773565b6109676118c4565b61096f6118d3565b604080515f80825260208201909252600f60f81b9b939a50919850469750309650945092509050565b5f6109a16109ff565b65ffffffffffff1682106109f35760405162461bcd60e51b815260206004820152601960248201527804552433230566f7465733a20667574757265206c6f6f6b757603c1b6044820152606401610773565b6106ae6101008361160d565b5f6106f6426118e2565b60606069805461061a90612950565b6001600160a01b0381165f90815260ff60205260408120548015610a83576001600160a01b0383165f90815260ff6020526040902080545f198301908110610a6257610a626129bd565b5f9182526020909120015464010000000090046001600160e01b0316610a85565b5f5b6001600160e01b03169392505050565b5f3381610aa28286611006565b905083811015610b025760405162461bcd60e51b815260206004820152602560248201527f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f77604482015264207a65726f60d81b6064820152608401610773565b6106e282868684036111f5565b5f336106a881858561144a565b610b24611318565b6106c68282611948565b83421115610b7e5760405162461bcd60e51b815260206004820152601d60248201527f4552433230566f7465733a207369676e617475726520657870697265640000006044820152606401610773565b604080517fe48329057bfd03d55e49b547132e39cffd9c1820ad7b9d4c5307691425d15adf60208201526001600160a01b0388169181019190915260608101869052608081018590525f90610bf790610bef9060a001604051602081830303815290604052805190602001206119a0565b8585856119cc565b9050610c02816119f2565b8614610c505760405162461bcd60e51b815260206004820152601960248201527f4552433230566f7465733a20696e76616c6964206e6f6e6365000000000000006044820152606401610773565b610c5a8188611792565b50505050505050565b5f54610100900460ff1615808015610c8157505f54600160ff909116105b80610c9a5750303b158015610c9a57505f5460ff166001145b610cfd5760405162461bcd60e51b815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201526d191e481a5b9a5d1a585b1a5e995960921b6064820152608401610773565b5f805460ff191660011790558015610d1e575f805461ff0019166101001790555b610d26611a19565b610d736040518060400160405280600d81526020016c2130b1b5b4b7339022b4b3b2b760991b815250604051806040016040528060068152602001653122a4a3a2a760d11b815250611a47565b610d7c82611873565b610da3604051806040016040528060068152602001653122a4a3a2a760d11b815250611a77565b5f1961013055610dd47f00000000000000000000000000000000000000000000000000000000000000006001611372565b610dff7f00000000000000000000000000000000000000000000000000000000000000006001611948565b610e357f00000000000000000000000000000000000000000000000000000000000000006b05686877afb5cbccbf7340006116ee565b6040517fb7c23c1e2e36f298e9879a88ecfcd07e28fbb439bcfa9c78ca1363ca14370d26905f90a180156106c6575f805461ff0019169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15050565b83421115610ef55760405162461bcd60e51b815260206004820152601d60248201527f45524332305065726d69743a206578706972656420646561646c696e650000006044820152606401610773565b5f7f6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9888888610f238c6119f2565b6040805160208101969096526001600160a01b0394851690860152929091166060840152608083015260a082015260c0810186905260e0016040516020818303038152906040528051906020012090505f610f7d826119a0565b90505f610f8c828787876119cc565b9050896001600160a01b0316816001600160a01b031614610fef5760405162461bcd60e51b815260206004820152601e60248201527f45524332305065726d69743a20696e76616c6964207369676e617475726500006044820152606401610773565b610ffa8a8a8a6111f5565b50505050505050505050565b6001600160a01b039182165f90815260666020908152604080832093909416825291909152205490565b611038611318565b5f1961013054146110ce5760405162461bcd60e51b815260206004820152605460248201527f4261636b696e67456967656e2e64697361626c655472616e736665725265737460448201527f72696374696f6e733a207472616e73666572207265737472696374696f6e7320606482015273185c9948185b1c9958591e48191a5cd8589b195960621b608482015260a401610773565b5f6101308190556040517f2b18986d3ba809db2f13a5d7bf17f60d357b37d9cbb55dd71cbbac8dc4060f649190a1565b604080518082019091525f80825260208201526001600160a01b0383165f90815260ff60205260409020805463ffffffff8416908110611140576111406129bd565b5f9182526020918290206040805180820190915291015463ffffffff8116825264010000000090046001600160e01b0316918101919091529392505050565b611187611318565b6001600160a01b0381166111ec5760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b6064820152608401610773565b61082981611873565b6001600160a01b0383166112575760405162461bcd60e51b8152602060048201526024808201527f45524332303a20617070726f76652066726f6d20746865207a65726f206164646044820152637265737360e01b6064820152608401610773565b6001600160a01b0382166112b85760405162461bcd60e51b815260206004820152602260248201527f45524332303a20617070726f766520746f20746865207a65726f206164647265604482015261737360f01b6064820152608401610773565b6001600160a01b038381165f8181526066602090815260408083209487168084529482529182902085905590518481527f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925910160405180910390a3505050565b6033546001600160a01b031633146108e05760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152606401610773565b6001600160a01b0382165f8181526101316020908152604091829020805460ff191685151590811790915591519182527fcf20b1ecb604b0e8888d579c64e8a3b10e590d45c1c2dddb393bed284362227191015b60405180910390a25050565b5f6113dd8484611006565b90505f19811461144457818110156114375760405162461bcd60e51b815260206004820152601d60248201527f45524332303a20696e73756666696369656e7420616c6c6f77616e63650000006044820152606401610773565b61144484848484036111f5565b50505050565b6001600160a01b0383166114ae5760405162461bcd60e51b815260206004820152602560248201527f45524332303a207472616e736665722066726f6d20746865207a65726f206164604482015264647265737360d81b6064820152608401610773565b6001600160a01b0382166115105760405162461bcd60e51b815260206004820152602360248201527f45524332303a207472616e7366657220746f20746865207a65726f206164647260448201526265737360e81b6064820152608401610773565b61151b838383611ac0565b6001600160a01b0383165f90815260656020526040902054818110156115925760405162461bcd60e51b815260206004820152602660248201527f45524332303a207472616e7366657220616d6f756e7420657863656564732062604482015265616c616e636560d01b6064820152608401610773565b6001600160a01b038085165f8181526065602052604080822086860390559286168082529083902080548601905591517fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef906115f19086815260200190565b60405180910390a3611444848484611b9c565b5f6106f6611bcd565b81545f9081816005811115611664575f61162684611c40565b61163090856129d1565b5f88815260209020909150869082015463ffffffff16111561165457809150611662565b61165f816001612996565b92505b505b808210156116af575f6116778383611d24565b5f88815260209020909150869082015463ffffffff16111561169b578091506116a9565b6116a6816001612996565b92505b50611664565b80156116d9575f8681526020902081015f19015464010000000090046001600160e01b03166116db565b5f5b6001600160e01b03169695505050505050565b6116f88282611d3e565b6067546001600160e01b03101561176a5760405162461bcd60e51b815260206004820152603060248201527f4552433230566f7465733a20746f74616c20737570706c79207269736b73206f60448201526f766572666c6f77696e6720766f74657360801b6064820152608401610773565b611444610100611e0f83611e1a565b6117838282611f86565b6114446101006120c983611e1a565b6001600160a01b038281165f81815260fe6020818152604080842080546065845282862054949093528787166001600160a01b03198416811790915590519190951694919391928592917f3134e8a2e6d97e929a7e54011ea5485d7d196dd5f0ba4d4ef95803e8e3fc257f9190a46114448284836120d4565b5f63ffffffff82111561186f5760405162461bcd60e51b815260206004820152602660248201527f53616665436173743a2076616c756520646f65736e27742066697420696e203360448201526532206269747360d01b6064820152608401610773565b5090565b603380546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0905f90a35050565b60606099805461061a90612950565b6060609a805461061a90612950565b5f65ffffffffffff82111561186f5760405162461bcd60e51b815260206004820152602660248201527f53616665436173743a2076616c756520646f65736e27742066697420696e203460448201526538206269747360d01b6064820152608401610773565b6001600160a01b0382165f8181526101326020908152604091829020805460ff191685151590811790915591519182527f72a561d1af7409467dae4f1e9fc52590a9335a1dda17727e2b6aa8c4db35109b91016113c6565b5f6106ae6119ac611604565b8360405161190160f01b8152600281019290925260228201526042902090565b5f5f5f6119db8787878761220e565b915091506119e8816122cb565b5095945050505050565b6001600160a01b0381165f90815260cb602052604090208054600181018255905b50919050565b5f54610100900460ff16611a3f5760405162461bcd60e51b8152600401610773906129e4565b6108e0612414565b5f54610100900460ff16611a6d5760405162461bcd60e51b8152600401610773906129e4565b6106c68282612443565b5f54610100900460ff16611a9d5760405162461bcd60e51b8152600401610773906129e4565b61082981604051806040016040528060018152602001603160f81b815250612482565b610130544211611b97576001600160a01b0383165f908152610131602052604090205460ff1680611b0957506001600160a01b0382165f908152610132602052604090205460ff165b80611b1b57506001600160a01b038316155b611b975760405162461bcd60e51b815260206004820152604160248201527f4261636b696e67456967656e2e5f6265666f7265546f6b656e5472616e73666560448201527f723a2066726f6d206f7220746f206d7573742062652077686974656c697374656064820152601960fa1b608482015260a401610773565b505050565b6001600160a01b038381165f90815260fe6020526040808220548584168352912054611b97929182169116836120d4565b5f7f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f611bf76124cf565b611bff612527565b60408051602081019490945283019190915260608201524660808201523060a082015260c00160405160208183030381529060405280519060200120905090565b5f815f03611c4f57505f919050565b5f6001611c5b84612557565b901c6001901b90506001818481611c7457611c74612a2f565b048201901c90506001818481611c8c57611c8c612a2f565b048201901c90506001818481611ca457611ca4612a2f565b048201901c90506001818481611cbc57611cbc612a2f565b048201901c90506001818481611cd457611cd4612a2f565b048201901c90506001818481611cec57611cec612a2f565b048201901c90506001818481611d0457611d04612a2f565b048201901c905061079d81828581611d1e57611d1e612a2f565b046125ea565b5f611d326002848418612a43565b61079d90848416612996565b6001600160a01b038216611d945760405162461bcd60e51b815260206004820152601f60248201527f45524332303a206d696e7420746f20746865207a65726f2061646472657373006044820152606401610773565b611d9f5f8383611ac0565b8060675f828254611db09190612996565b90915550506001600160a01b0382165f818152606560209081526040808320805486019055518481527fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a36106c65f8383611b9c565b5f61079d8284612996565b82545f908190818115611e64575f8781526020902082015f190160408051808201909152905463ffffffff8116825264010000000090046001600160e01b03166020820152611e78565b604080518082019091525f80825260208201525b905080602001516001600160e01b03169350611e9884868863ffffffff16565b92505f82118015611ec05750611eac6109ff565b65ffffffffffff16815f015163ffffffff16145b15611f0357611ece836125ff565b5f8881526020902083015f190180546001600160e01b03929092166401000000000263ffffffff909216919091179055611f7c565b866040518060400160405280611f27611f1a6109ff565b65ffffffffffff1661180b565b63ffffffff168152602001611f3b866125ff565b6001600160e01b0390811690915282546001810184555f938452602093849020835194909301519091166401000000000263ffffffff909316929092179101555b5050935093915050565b6001600160a01b038216611fe65760405162461bcd60e51b815260206004820152602160248201527f45524332303a206275726e2066726f6d20746865207a65726f206164647265736044820152607360f81b6064820152608401610773565b611ff1825f83611ac0565b6001600160a01b0382165f90815260656020526040902054818110156120645760405162461bcd60e51b815260206004820152602260248201527f45524332303a206275726e20616d6f756e7420657863656564732062616c616e604482015261636560f01b6064820152608401610773565b6001600160a01b0383165f8181526065602090815260408083208686039055606780548790039055518581529192917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a3611b97835f84611b9c565b5f61079d82846129d1565b816001600160a01b0316836001600160a01b0316141580156120f557505f81115b15611b97576001600160a01b03831615612182576001600160a01b0383165f90815260ff60205260408120819061212f906120c985611e1a565b91509150846001600160a01b03167fdec2bacdd2f05b59de34da9b523dff8be42e5e38e818c82fdb0bae774387a7248383604051612177929190918252602082015260400190565b60405180910390a250505b6001600160a01b03821615611b97576001600160a01b0382165f90815260ff6020526040812081906121b790611e0f85611e1a565b91509150836001600160a01b03167fdec2bacdd2f05b59de34da9b523dff8be42e5e38e818c82fdb0bae774387a72483836040516121ff929190918252602082015260400190565b60405180910390a25050505050565b5f807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a083111561224357505f905060036122c2565b604080515f8082526020820180845289905260ff881692820192909252606081018690526080810185905260019060a0016020604051602081039080840390855afa158015612294573d5f5f3e3d5ffd5b5050604051601f1901519150506001600160a01b0381166122bc575f600192509250506122c2565b91505f90505b94509492505050565b5f8160048111156122de576122de612a62565b036122e65750565b60018160048111156122fa576122fa612a62565b036123475760405162461bcd60e51b815260206004820152601860248201527f45434453413a20696e76616c6964207369676e617475726500000000000000006044820152606401610773565b600281600481111561235b5761235b612a62565b036123a85760405162461bcd60e51b815260206004820152601f60248201527f45434453413a20696e76616c6964207369676e6174757265206c656e677468006044820152606401610773565b60038160048111156123bc576123bc612a62565b036108295760405162461bcd60e51b815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202773272076616c604482015261756560f01b6064820152608401610773565b5f54610100900460ff1661243a5760405162461bcd60e51b8152600401610773906129e4565b6108e033611873565b5f54610100900460ff166124695760405162461bcd60e51b8152600401610773906129e4565b60686124758382612ac1565b506069611b978282612ac1565b5f54610100900460ff166124a85760405162461bcd60e51b8152600401610773906129e4565b60996124b48382612ac1565b50609a6124c18282612ac1565b50505f609781905560985550565b5f5f6124d96118c4565b8051909150156124f0578051602090910120919050565b60975480156124ff5792915050565b7fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a4709250505090565b5f5f6125316118d3565b805190915015612548578051602090910120919050565b60985480156124ff5792915050565b5f80608083901c1561256b57608092831c92015b604083901c1561257d57604092831c92015b602083901c1561258f57602092831c92015b601083901c156125a157601092831c92015b600883901c156125b357600892831c92015b600483901c156125c557600492831c92015b600283901c156125d757600292831c92015b600183901c156106ae5760010192915050565b5f8183106125f8578161079d565b5090919050565b5f6001600160e01b0382111561186f5760405162461bcd60e51b815260206004820152602760248201527f53616665436173743a2076616c756520646f65736e27742066697420696e20326044820152663234206269747360c81b6064820152608401610773565b80356001600160a01b038116811461267d575f5ffd5b919050565b5f60208284031215612692575f5ffd5b61079d82612667565b5f81518084528060208401602086015e5f602082860101526020601f19601f83011685010191505092915050565b602081525f61079d602083018461269b565b5f5f604083850312156126ec575f5ffd5b6126f583612667565b946020939093013593505050565b5f5f60408385031215612714575f5ffd5b61271d83612667565b915060208301358015158114612731575f5ffd5b809150509250929050565b5f5f5f6060848603121561274e575f5ffd5b61275784612667565b925061276560208501612667565b929592945050506040919091013590565b5f60208284031215612786575f5ffd5b5035919050565b60ff60f81b8816815260e060208201525f6127ab60e083018961269b565b82810360408401526127bd818961269b565b606084018890526001600160a01b038716608085015260a0840186905283810360c0850152845180825260208087019350909101905f5b818110156128125783518352602093840193909201916001016127f4565b50909b9a5050505050505050505050565b803560ff8116811461267d575f5ffd5b5f5f5f5f5f5f60c08789031215612848575f5ffd5b61285187612667565b9550602087013594506040870135935061286d60608801612823565b9598949750929560808101359460a0909101359350915050565b5f5f5f5f5f5f5f60e0888a03121561289d575f5ffd5b6128a688612667565b96506128b460208901612667565b955060408801359450606088013593506128d060808901612823565b9699959850939692959460a0840135945060c09093013592915050565b5f5f604083850312156128fe575f5ffd5b61290783612667565b915061291560208401612667565b90509250929050565b5f5f6040838503121561292f575f5ffd5b61293883612667565b9150602083013563ffffffff81168114612731575f5ffd5b600181811c9082168061296457607f821691505b602082108103611a1357634e487b7160e01b5f52602260045260245ffd5b634e487b7160e01b5f52601160045260245ffd5b808201808211156106ae576106ae612982565b634e487b7160e01b5f52604160045260245ffd5b634e487b7160e01b5f52603260045260245ffd5b818103818111156106ae576106ae612982565b6020808252602b908201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960408201526a6e697469616c697a696e6760a81b606082015260800190565b634e487b7160e01b5f52601260045260245ffd5b5f82612a5d57634e487b7160e01b5f52601260045260245ffd5b500490565b634e487b7160e01b5f52602160045260245ffd5b601f821115611b9757805f5260205f20601f840160051c81016020851015612a9b5750805b601f840160051c820191505b81811015612aba575f8155600101612aa7565b5050505050565b815167ffffffffffffffff811115612adb57612adb6129a9565b612aef81612ae98454612950565b84612a76565b6020601f821160018114612b21575f8315612b0a5750848201515b5f19600385901b1c1916600184901b178455612aba565b5f84815260208120601f198516915b82811015612b505787850151825560209485019460019092019101612b30565b5084821015612b6d57868401515f19600387901b60f8161c191681555b50505050600190811b0190555056fea2646970667358221220e867b134dc261d7025b320d04b24d156f209a884537e24f3f733872669a3444264736f6c634300081b0033", + Bin: "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", } // BackingEigenABI is the input ABI used to generate the binding from. diff --git a/pkg/bindings/BeaconChainProofs/binding.go b/pkg/bindings/BeaconChainProofs/binding.go index bca107b999..3e48868c16 100644 --- a/pkg/bindings/BeaconChainProofs/binding.go +++ b/pkg/bindings/BeaconChainProofs/binding.go @@ -32,7 +32,7 @@ var ( // BeaconChainProofsMetaData contains all meta data concerning the BeaconChainProofs contract. var BeaconChainProofsMetaData = &bind.MetaData{ ABI: "[{\"type\":\"error\",\"name\":\"InvalidProof\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidProofLength\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidValidatorFieldsLength\",\"inputs\":[]}]", - Bin: "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea264697066735822122008cce030eef89bfa5bdc495fd3132a80b290f7c5211b5ff5314d2604022ce60764736f6c634300081b0033", + Bin: "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220b786d81c68c50488570935b357a548005dc46a3e40dcde8c9c3cfe80240891a564736f6c634300081b0033", } // BeaconChainProofsABI is the input ABI used to generate the binding from. diff --git a/pkg/bindings/BytesLib/binding.go b/pkg/bindings/BytesLib/binding.go index 23d7c38887..80d08fb9da 100644 --- a/pkg/bindings/BytesLib/binding.go +++ b/pkg/bindings/BytesLib/binding.go @@ -32,7 +32,7 @@ var ( // BytesLibMetaData contains all meta data concerning the BytesLib contract. var BytesLibMetaData = &bind.MetaData{ ABI: "[{\"type\":\"error\",\"name\":\"OutOfBounds\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"Overflow\",\"inputs\":[]}]", - Bin: "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212201c49718c32c7b9955558fe081b9edb8db636f523f0b3ec1bfeea2696a9f7424464736f6c634300081b0033", + Bin: "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220517c792f82001a69d55f8c03043251e3baff982c0b3c945ebf5259c111341b5664736f6c634300081b0033", } // BytesLibABI is the input ABI used to generate the binding from. diff --git a/pkg/bindings/DelegationManager/binding.go b/pkg/bindings/DelegationManager/binding.go index 5103fc3537..a43057d2bb 100644 --- a/pkg/bindings/DelegationManager/binding.go +++ b/pkg/bindings/DelegationManager/binding.go @@ -55,8 +55,8 @@ type ISignatureUtilsSignatureWithExpiry struct { // DelegationManagerMetaData contains all meta data concerning the DelegationManager contract. var DelegationManagerMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_strategyManager\",\"type\":\"address\",\"internalType\":\"contractIStrategyManager\"},{\"name\":\"_eigenPodManager\",\"type\":\"address\",\"internalType\":\"contractIEigenPodManager\"},{\"name\":\"_allocationManager\",\"type\":\"address\",\"internalType\":\"contractIAllocationManager\"},{\"name\":\"_pauserRegistry\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"},{\"name\":\"_permissionController\",\"type\":\"address\",\"internalType\":\"contractIPermissionController\"},{\"name\":\"_MIN_WITHDRAWAL_DELAY\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"DELEGATION_APPROVAL_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"allocationManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIAllocationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"beaconChainETHStrategy\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"burnOperatorShares\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"prevMaxMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"newMaxMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"calculateDelegationApprovalDigestHash\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"approver\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"approverSalt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"calculateWithdrawalRoot\",\"inputs\":[{\"name\":\"withdrawal\",\"type\":\"tuple\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"completeQueuedWithdrawal\",\"inputs\":[{\"name\":\"withdrawal\",\"type\":\"tuple\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"tokens\",\"type\":\"address[]\",\"internalType\":\"contractIERC20[]\"},{\"name\":\"receiveAsTokens\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"completeQueuedWithdrawals\",\"inputs\":[{\"name\":\"withdrawals\",\"type\":\"tuple[]\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal[]\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"tokens\",\"type\":\"address[][]\",\"internalType\":\"contractIERC20[][]\"},{\"name\":\"receiveAsTokens\",\"type\":\"bool[]\",\"internalType\":\"bool[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"convertToDepositShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"withdrawableShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"cumulativeWithdrawalsQueued\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"totalQueued\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"decreaseDelegatedShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"curDepositShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"beaconChainSlashingFactorDecrease\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegateTo\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"approverSignatureAndExpiry\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtils.SignatureWithExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"approverSalt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegatedTo\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"delegationApprover\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"delegationApproverSaltIsSpent\",\"inputs\":[{\"name\":\"delegationApprover\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"spent\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"depositScalingFactor\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"domainSeparator\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"eigenPodManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEigenPodManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getDepositedShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorShares\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorsShares\",\"inputs\":[{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256[][]\",\"internalType\":\"uint256[][]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getQueuedWithdrawal\",\"inputs\":[{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getQueuedWithdrawals\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"withdrawals\",\"type\":\"tuple[]\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal[]\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"shares\",\"type\":\"uint256[][]\",\"internalType\":\"uint256[][]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getSlashableSharesInQueue\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getWithdrawableShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"withdrawableShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"depositShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"increaseDelegatedShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"prevDepositShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"addedShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"isDelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isOperator\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"minWithdrawalDelayBlocks\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"modifyOperatorDetails\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"newDelegationApprover\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"operatorShares\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"pauseAll\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[{\"name\":\"index\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pauserRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pendingWithdrawals\",\"inputs\":[{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"pending\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"permissionController\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPermissionController\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"queueWithdrawals\",\"inputs\":[{\"name\":\"params\",\"type\":\"tuple[]\",\"internalType\":\"structIDelegationManagerTypes.QueuedWithdrawalParams[]\",\"components\":[{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"depositShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"__deprecated_withdrawer\",\"type\":\"address\",\"internalType\":\"address\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"redelegate\",\"inputs\":[{\"name\":\"newOperator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"newOperatorApproverSig\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtils.SignatureWithExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"approverSalt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"withdrawalRoots\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"registerAsOperator\",\"inputs\":[{\"name\":\"initDelegationApprover\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"allocationDelay\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"strategyManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategyManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"undelegate\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"withdrawalRoots\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateOperatorMetadataURI\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"DelegationApproverUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newDelegationApprover\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"DepositScalingFactorUpdated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"newDepositScalingFactor\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorMetadataURIUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorRegistered\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"delegationApprover\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSharesBurned\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSharesDecreased\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSharesIncreased\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"SlashingWithdrawalCompleted\",\"inputs\":[{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"SlashingWithdrawalQueued\",\"inputs\":[{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"},{\"name\":\"withdrawal\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structIDelegationManagerTypes.Withdrawal\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"sharesToWithdraw\",\"type\":\"uint256[]\",\"indexed\":false,\"internalType\":\"uint256[]\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StakerDelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StakerForceUndelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StakerUndelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"ActivelyDelegated\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CallerCannotUndelegate\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CurrentlyPaused\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"FullySlashed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputArrayLengthMismatch\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputArrayLengthZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidNewPausedStatus\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidPermissions\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidSignature\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidSnapshotOrdering\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NotActivelyDelegated\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyAllocationManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyEigenPodManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyPauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyStrategyManagerOrEigenPodManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyUnpauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorNotRegistered\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorsCannotUndelegate\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SaltSpent\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SignatureExpired\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"WithdrawalDelayNotElapsed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"WithdrawalNotQueued\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"WithdrawerNotCaller\",\"inputs\":[]}]", - Bin: "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", + ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_strategyManager\",\"type\":\"address\",\"internalType\":\"contractIStrategyManager\"},{\"name\":\"_eigenPodManager\",\"type\":\"address\",\"internalType\":\"contractIEigenPodManager\"},{\"name\":\"_allocationManager\",\"type\":\"address\",\"internalType\":\"contractIAllocationManager\"},{\"name\":\"_pauserRegistry\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"},{\"name\":\"_permissionController\",\"type\":\"address\",\"internalType\":\"contractIPermissionController\"},{\"name\":\"_MIN_WITHDRAWAL_DELAY\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"DELEGATION_APPROVAL_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"allocationManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIAllocationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"beaconChainETHStrategy\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"calculateDelegationApprovalDigestHash\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"approver\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"approverSalt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"calculateWithdrawalRoot\",\"inputs\":[{\"name\":\"withdrawal\",\"type\":\"tuple\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"completeQueuedWithdrawal\",\"inputs\":[{\"name\":\"withdrawal\",\"type\":\"tuple\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"tokens\",\"type\":\"address[]\",\"internalType\":\"contractIERC20[]\"},{\"name\":\"receiveAsTokens\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"completeQueuedWithdrawals\",\"inputs\":[{\"name\":\"withdrawals\",\"type\":\"tuple[]\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal[]\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"tokens\",\"type\":\"address[][]\",\"internalType\":\"contractIERC20[][]\"},{\"name\":\"receiveAsTokens\",\"type\":\"bool[]\",\"internalType\":\"bool[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"convertToDepositShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"withdrawableShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"cumulativeWithdrawalsQueued\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"totalQueued\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"decreaseDelegatedShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"curDepositShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"beaconChainSlashingFactorDecrease\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegateTo\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"approverSignatureAndExpiry\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtils.SignatureWithExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"approverSalt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegatedTo\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"delegationApprover\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"delegationApproverSaltIsSpent\",\"inputs\":[{\"name\":\"delegationApprover\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"spent\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"depositScalingFactor\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"domainSeparator\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"eigenPodManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEigenPodManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getDepositedShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorShares\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorsShares\",\"inputs\":[{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256[][]\",\"internalType\":\"uint256[][]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getQueuedWithdrawal\",\"inputs\":[{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getQueuedWithdrawalRoots\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getQueuedWithdrawals\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"withdrawals\",\"type\":\"tuple[]\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal[]\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"shares\",\"type\":\"uint256[][]\",\"internalType\":\"uint256[][]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getSlashableSharesInQueue\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getWithdrawableShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"withdrawableShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"depositShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"increaseDelegatedShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"prevDepositShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"addedShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"isDelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isOperator\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"minWithdrawalDelayBlocks\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"modifyOperatorDetails\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"newDelegationApprover\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"operatorShares\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"pauseAll\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[{\"name\":\"index\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pauserRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pendingWithdrawals\",\"inputs\":[{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"pending\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"permissionController\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPermissionController\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"queueWithdrawals\",\"inputs\":[{\"name\":\"params\",\"type\":\"tuple[]\",\"internalType\":\"structIDelegationManagerTypes.QueuedWithdrawalParams[]\",\"components\":[{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"depositShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"__deprecated_withdrawer\",\"type\":\"address\",\"internalType\":\"address\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"redelegate\",\"inputs\":[{\"name\":\"newOperator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"newOperatorApproverSig\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtils.SignatureWithExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"approverSalt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"withdrawalRoots\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"registerAsOperator\",\"inputs\":[{\"name\":\"initDelegationApprover\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"allocationDelay\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"slashOperatorShares\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"prevMaxMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"newMaxMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"strategyManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategyManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"undelegate\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"withdrawalRoots\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateOperatorMetadataURI\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"DelegationApproverUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newDelegationApprover\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"DepositScalingFactorUpdated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"newDepositScalingFactor\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorMetadataURIUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorRegistered\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"delegationApprover\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSharesDecreased\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSharesIncreased\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"SlashingWithdrawalCompleted\",\"inputs\":[{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"SlashingWithdrawalQueued\",\"inputs\":[{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"},{\"name\":\"withdrawal\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structIDelegationManagerTypes.Withdrawal\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"sharesToWithdraw\",\"type\":\"uint256[]\",\"indexed\":false,\"internalType\":\"uint256[]\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StakerDelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StakerForceUndelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StakerUndelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"ActivelyDelegated\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CallerCannotUndelegate\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CurrentlyPaused\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"FullySlashed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputArrayLengthMismatch\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputArrayLengthZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidNewPausedStatus\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidPermissions\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidSignature\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidSnapshotOrdering\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NotActivelyDelegated\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyAllocationManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyEigenPodManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyPauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyStrategyManagerOrEigenPodManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyUnpauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorNotRegistered\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorsCannotUndelegate\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SaltSpent\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SignatureExpired\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"WithdrawalDelayNotElapsed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"WithdrawalNotQueued\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"WithdrawerNotCaller\",\"inputs\":[]}]", + Bin: "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", } // DelegationManagerABI is the input ABI used to generate the binding from. @@ -754,6 +754,37 @@ func (_DelegationManager *DelegationManagerCallerSession) GetQueuedWithdrawal(wi return _DelegationManager.Contract.GetQueuedWithdrawal(&_DelegationManager.CallOpts, withdrawalRoot) } +// GetQueuedWithdrawalRoots is a free data retrieval call binding the contract method 0xfd8aa88d. +// +// Solidity: function getQueuedWithdrawalRoots(address staker) view returns(bytes32[]) +func (_DelegationManager *DelegationManagerCaller) GetQueuedWithdrawalRoots(opts *bind.CallOpts, staker common.Address) ([][32]byte, error) { + var out []interface{} + err := _DelegationManager.contract.Call(opts, &out, "getQueuedWithdrawalRoots", staker) + + if err != nil { + return *new([][32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([][32]byte)).(*[][32]byte) + + return out0, err + +} + +// GetQueuedWithdrawalRoots is a free data retrieval call binding the contract method 0xfd8aa88d. +// +// Solidity: function getQueuedWithdrawalRoots(address staker) view returns(bytes32[]) +func (_DelegationManager *DelegationManagerSession) GetQueuedWithdrawalRoots(staker common.Address) ([][32]byte, error) { + return _DelegationManager.Contract.GetQueuedWithdrawalRoots(&_DelegationManager.CallOpts, staker) +} + +// GetQueuedWithdrawalRoots is a free data retrieval call binding the contract method 0xfd8aa88d. +// +// Solidity: function getQueuedWithdrawalRoots(address staker) view returns(bytes32[]) +func (_DelegationManager *DelegationManagerCallerSession) GetQueuedWithdrawalRoots(staker common.Address) ([][32]byte, error) { + return _DelegationManager.Contract.GetQueuedWithdrawalRoots(&_DelegationManager.CallOpts, staker) +} + // GetQueuedWithdrawals is a free data retrieval call binding the contract method 0x5dd68579. // // Solidity: function getQueuedWithdrawals(address staker) view returns((address,address,address,uint256,uint32,address[],uint256[])[] withdrawals, uint256[][] shares) @@ -1216,27 +1247,6 @@ func (_DelegationManager *DelegationManagerCallerSession) StrategyManager() (com return _DelegationManager.Contract.StrategyManager(&_DelegationManager.CallOpts) } -// BurnOperatorShares is a paid mutator transaction binding the contract method 0xee74937f. -// -// Solidity: function burnOperatorShares(address operator, address strategy, uint64 prevMaxMagnitude, uint64 newMaxMagnitude) returns() -func (_DelegationManager *DelegationManagerTransactor) BurnOperatorShares(opts *bind.TransactOpts, operator common.Address, strategy common.Address, prevMaxMagnitude uint64, newMaxMagnitude uint64) (*types.Transaction, error) { - return _DelegationManager.contract.Transact(opts, "burnOperatorShares", operator, strategy, prevMaxMagnitude, newMaxMagnitude) -} - -// BurnOperatorShares is a paid mutator transaction binding the contract method 0xee74937f. -// -// Solidity: function burnOperatorShares(address operator, address strategy, uint64 prevMaxMagnitude, uint64 newMaxMagnitude) returns() -func (_DelegationManager *DelegationManagerSession) BurnOperatorShares(operator common.Address, strategy common.Address, prevMaxMagnitude uint64, newMaxMagnitude uint64) (*types.Transaction, error) { - return _DelegationManager.Contract.BurnOperatorShares(&_DelegationManager.TransactOpts, operator, strategy, prevMaxMagnitude, newMaxMagnitude) -} - -// BurnOperatorShares is a paid mutator transaction binding the contract method 0xee74937f. -// -// Solidity: function burnOperatorShares(address operator, address strategy, uint64 prevMaxMagnitude, uint64 newMaxMagnitude) returns() -func (_DelegationManager *DelegationManagerTransactorSession) BurnOperatorShares(operator common.Address, strategy common.Address, prevMaxMagnitude uint64, newMaxMagnitude uint64) (*types.Transaction, error) { - return _DelegationManager.Contract.BurnOperatorShares(&_DelegationManager.TransactOpts, operator, strategy, prevMaxMagnitude, newMaxMagnitude) -} - // CompleteQueuedWithdrawal is a paid mutator transaction binding the contract method 0xe4cc3f90. // // Solidity: function completeQueuedWithdrawal((address,address,address,uint256,uint32,address[],uint256[]) withdrawal, address[] tokens, bool receiveAsTokens) returns() @@ -1510,6 +1520,27 @@ func (_DelegationManager *DelegationManagerTransactorSession) RenounceOwnership( return _DelegationManager.Contract.RenounceOwnership(&_DelegationManager.TransactOpts) } +// SlashOperatorShares is a paid mutator transaction binding the contract method 0x601bb36f. +// +// Solidity: function slashOperatorShares(address operator, address strategy, uint64 prevMaxMagnitude, uint64 newMaxMagnitude) returns() +func (_DelegationManager *DelegationManagerTransactor) SlashOperatorShares(opts *bind.TransactOpts, operator common.Address, strategy common.Address, prevMaxMagnitude uint64, newMaxMagnitude uint64) (*types.Transaction, error) { + return _DelegationManager.contract.Transact(opts, "slashOperatorShares", operator, strategy, prevMaxMagnitude, newMaxMagnitude) +} + +// SlashOperatorShares is a paid mutator transaction binding the contract method 0x601bb36f. +// +// Solidity: function slashOperatorShares(address operator, address strategy, uint64 prevMaxMagnitude, uint64 newMaxMagnitude) returns() +func (_DelegationManager *DelegationManagerSession) SlashOperatorShares(operator common.Address, strategy common.Address, prevMaxMagnitude uint64, newMaxMagnitude uint64) (*types.Transaction, error) { + return _DelegationManager.Contract.SlashOperatorShares(&_DelegationManager.TransactOpts, operator, strategy, prevMaxMagnitude, newMaxMagnitude) +} + +// SlashOperatorShares is a paid mutator transaction binding the contract method 0x601bb36f. +// +// Solidity: function slashOperatorShares(address operator, address strategy, uint64 prevMaxMagnitude, uint64 newMaxMagnitude) returns() +func (_DelegationManager *DelegationManagerTransactorSession) SlashOperatorShares(operator common.Address, strategy common.Address, prevMaxMagnitude uint64, newMaxMagnitude uint64) (*types.Transaction, error) { + return _DelegationManager.Contract.SlashOperatorShares(&_DelegationManager.TransactOpts, operator, strategy, prevMaxMagnitude, newMaxMagnitude) +} + // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. // // Solidity: function transferOwnership(address newOwner) returns() @@ -2299,152 +2330,6 @@ func (_DelegationManager *DelegationManagerFilterer) ParseOperatorRegistered(log return event, nil } -// DelegationManagerOperatorSharesBurnedIterator is returned from FilterOperatorSharesBurned and is used to iterate over the raw logs and unpacked data for OperatorSharesBurned events raised by the DelegationManager contract. -type DelegationManagerOperatorSharesBurnedIterator struct { - Event *DelegationManagerOperatorSharesBurned // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *DelegationManagerOperatorSharesBurnedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(DelegationManagerOperatorSharesBurned) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(DelegationManagerOperatorSharesBurned) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *DelegationManagerOperatorSharesBurnedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *DelegationManagerOperatorSharesBurnedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// DelegationManagerOperatorSharesBurned represents a OperatorSharesBurned event raised by the DelegationManager contract. -type DelegationManagerOperatorSharesBurned struct { - Operator common.Address - Strategy common.Address - Shares *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterOperatorSharesBurned is a free log retrieval operation binding the contract event 0xeff6aab2bc3f7c648896e1522eae71d6c22e3b0e218206b3f40af0e4d204716b. -// -// Solidity: event OperatorSharesBurned(address indexed operator, address strategy, uint256 shares) -func (_DelegationManager *DelegationManagerFilterer) FilterOperatorSharesBurned(opts *bind.FilterOpts, operator []common.Address) (*DelegationManagerOperatorSharesBurnedIterator, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - - logs, sub, err := _DelegationManager.contract.FilterLogs(opts, "OperatorSharesBurned", operatorRule) - if err != nil { - return nil, err - } - return &DelegationManagerOperatorSharesBurnedIterator{contract: _DelegationManager.contract, event: "OperatorSharesBurned", logs: logs, sub: sub}, nil -} - -// WatchOperatorSharesBurned is a free log subscription operation binding the contract event 0xeff6aab2bc3f7c648896e1522eae71d6c22e3b0e218206b3f40af0e4d204716b. -// -// Solidity: event OperatorSharesBurned(address indexed operator, address strategy, uint256 shares) -func (_DelegationManager *DelegationManagerFilterer) WatchOperatorSharesBurned(opts *bind.WatchOpts, sink chan<- *DelegationManagerOperatorSharesBurned, operator []common.Address) (event.Subscription, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - - logs, sub, err := _DelegationManager.contract.WatchLogs(opts, "OperatorSharesBurned", operatorRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(DelegationManagerOperatorSharesBurned) - if err := _DelegationManager.contract.UnpackLog(event, "OperatorSharesBurned", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseOperatorSharesBurned is a log parse operation binding the contract event 0xeff6aab2bc3f7c648896e1522eae71d6c22e3b0e218206b3f40af0e4d204716b. -// -// Solidity: event OperatorSharesBurned(address indexed operator, address strategy, uint256 shares) -func (_DelegationManager *DelegationManagerFilterer) ParseOperatorSharesBurned(log types.Log) (*DelegationManagerOperatorSharesBurned, error) { - event := new(DelegationManagerOperatorSharesBurned) - if err := _DelegationManager.contract.UnpackLog(event, "OperatorSharesBurned", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - // DelegationManagerOperatorSharesDecreasedIterator is returned from FilterOperatorSharesDecreased and is used to iterate over the raw logs and unpacked data for OperatorSharesDecreased events raised by the DelegationManager contract. type DelegationManagerOperatorSharesDecreasedIterator struct { Event *DelegationManagerOperatorSharesDecreased // Event containing the contract specifics and raw log diff --git a/pkg/bindings/DelegationManagerStorage/binding.go b/pkg/bindings/DelegationManagerStorage/binding.go index 853043487a..82f7a6fdf4 100644 --- a/pkg/bindings/DelegationManagerStorage/binding.go +++ b/pkg/bindings/DelegationManagerStorage/binding.go @@ -55,7 +55,7 @@ type ISignatureUtilsSignatureWithExpiry struct { // DelegationManagerStorageMetaData contains all meta data concerning the DelegationManagerStorage contract. var DelegationManagerStorageMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"function\",\"name\":\"DELEGATION_APPROVAL_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"allocationManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIAllocationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"beaconChainETHStrategy\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"burnOperatorShares\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"prevMaxMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"newMaxMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"calculateDelegationApprovalDigestHash\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_delegationApprover\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"approverSalt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"calculateWithdrawalRoot\",\"inputs\":[{\"name\":\"withdrawal\",\"type\":\"tuple\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"completeQueuedWithdrawal\",\"inputs\":[{\"name\":\"withdrawal\",\"type\":\"tuple\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"tokens\",\"type\":\"address[]\",\"internalType\":\"contractIERC20[]\"},{\"name\":\"receiveAsTokens\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"completeQueuedWithdrawals\",\"inputs\":[{\"name\":\"withdrawals\",\"type\":\"tuple[]\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal[]\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"tokens\",\"type\":\"address[][]\",\"internalType\":\"contractIERC20[][]\"},{\"name\":\"receiveAsTokens\",\"type\":\"bool[]\",\"internalType\":\"bool[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"convertToDepositShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"withdrawableShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"cumulativeWithdrawalsQueued\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"totalQueued\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"decreaseDelegatedShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"curDepositShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"beaconChainSlashingFactorDecrease\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegateTo\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"approverSignatureAndExpiry\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtils.SignatureWithExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"approverSalt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegatedTo\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"delegationApprover\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"delegationApproverSaltIsSpent\",\"inputs\":[{\"name\":\"delegationApprover\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"spent\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"depositScalingFactor\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"eigenPodManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEigenPodManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getDepositedShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorShares\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorsShares\",\"inputs\":[{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256[][]\",\"internalType\":\"uint256[][]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getQueuedWithdrawal\",\"inputs\":[{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getQueuedWithdrawals\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"withdrawals\",\"type\":\"tuple[]\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal[]\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"shares\",\"type\":\"uint256[][]\",\"internalType\":\"uint256[][]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getSlashableSharesInQueue\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getWithdrawableShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"withdrawableShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"depositShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"increaseDelegatedShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"prevDepositShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"addedShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"isDelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isOperator\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"minWithdrawalDelayBlocks\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"modifyOperatorDetails\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"newDelegationApprover\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"operatorShares\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pendingWithdrawals\",\"inputs\":[{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"pending\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"queueWithdrawals\",\"inputs\":[{\"name\":\"params\",\"type\":\"tuple[]\",\"internalType\":\"structIDelegationManagerTypes.QueuedWithdrawalParams[]\",\"components\":[{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"depositShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"__deprecated_withdrawer\",\"type\":\"address\",\"internalType\":\"address\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"redelegate\",\"inputs\":[{\"name\":\"newOperator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"newOperatorApproverSig\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtils.SignatureWithExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"approverSalt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"withdrawalRoots\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"registerAsOperator\",\"inputs\":[{\"name\":\"initDelegationApprover\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"allocationDelay\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"strategyManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategyManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"undelegate\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"withdrawalRoots\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateOperatorMetadataURI\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"DelegationApproverUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newDelegationApprover\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"DepositScalingFactorUpdated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"newDepositScalingFactor\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorMetadataURIUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorRegistered\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"delegationApprover\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSharesBurned\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSharesDecreased\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSharesIncreased\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"SlashingWithdrawalCompleted\",\"inputs\":[{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"SlashingWithdrawalQueued\",\"inputs\":[{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"},{\"name\":\"withdrawal\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structIDelegationManagerTypes.Withdrawal\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"sharesToWithdraw\",\"type\":\"uint256[]\",\"indexed\":false,\"internalType\":\"uint256[]\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StakerDelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StakerForceUndelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StakerUndelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"ActivelyDelegated\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CallerCannotUndelegate\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"FullySlashed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputArrayLengthMismatch\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputArrayLengthZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidSignature\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NotActivelyDelegated\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyAllocationManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyEigenPodManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyStrategyManagerOrEigenPodManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorNotRegistered\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorsCannotUndelegate\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SaltSpent\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SignatureExpired\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"WithdrawalDelayNotElapsed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"WithdrawalNotQueued\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"WithdrawerNotCaller\",\"inputs\":[]}]", + ABI: "[{\"type\":\"function\",\"name\":\"DELEGATION_APPROVAL_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"allocationManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIAllocationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"beaconChainETHStrategy\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"calculateDelegationApprovalDigestHash\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_delegationApprover\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"approverSalt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"calculateWithdrawalRoot\",\"inputs\":[{\"name\":\"withdrawal\",\"type\":\"tuple\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"completeQueuedWithdrawal\",\"inputs\":[{\"name\":\"withdrawal\",\"type\":\"tuple\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"tokens\",\"type\":\"address[]\",\"internalType\":\"contractIERC20[]\"},{\"name\":\"receiveAsTokens\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"completeQueuedWithdrawals\",\"inputs\":[{\"name\":\"withdrawals\",\"type\":\"tuple[]\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal[]\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"tokens\",\"type\":\"address[][]\",\"internalType\":\"contractIERC20[][]\"},{\"name\":\"receiveAsTokens\",\"type\":\"bool[]\",\"internalType\":\"bool[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"convertToDepositShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"withdrawableShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"cumulativeWithdrawalsQueued\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"totalQueued\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"decreaseDelegatedShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"curDepositShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"beaconChainSlashingFactorDecrease\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegateTo\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"approverSignatureAndExpiry\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtils.SignatureWithExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"approverSalt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegatedTo\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"delegationApprover\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"delegationApproverSaltIsSpent\",\"inputs\":[{\"name\":\"delegationApprover\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"spent\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"depositScalingFactor\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"eigenPodManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEigenPodManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getDepositedShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorShares\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorsShares\",\"inputs\":[{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256[][]\",\"internalType\":\"uint256[][]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getQueuedWithdrawal\",\"inputs\":[{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getQueuedWithdrawalRoots\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getQueuedWithdrawals\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"withdrawals\",\"type\":\"tuple[]\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal[]\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"shares\",\"type\":\"uint256[][]\",\"internalType\":\"uint256[][]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getSlashableSharesInQueue\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getWithdrawableShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"withdrawableShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"depositShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"increaseDelegatedShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"prevDepositShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"addedShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"isDelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isOperator\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"minWithdrawalDelayBlocks\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"modifyOperatorDetails\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"newDelegationApprover\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"operatorShares\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pendingWithdrawals\",\"inputs\":[{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"pending\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"queueWithdrawals\",\"inputs\":[{\"name\":\"params\",\"type\":\"tuple[]\",\"internalType\":\"structIDelegationManagerTypes.QueuedWithdrawalParams[]\",\"components\":[{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"depositShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"__deprecated_withdrawer\",\"type\":\"address\",\"internalType\":\"address\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"redelegate\",\"inputs\":[{\"name\":\"newOperator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"newOperatorApproverSig\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtils.SignatureWithExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"approverSalt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"withdrawalRoots\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"registerAsOperator\",\"inputs\":[{\"name\":\"initDelegationApprover\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"allocationDelay\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"slashOperatorShares\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"prevMaxMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"newMaxMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"strategyManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategyManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"undelegate\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"withdrawalRoots\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateOperatorMetadataURI\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"DelegationApproverUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newDelegationApprover\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"DepositScalingFactorUpdated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"newDepositScalingFactor\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorMetadataURIUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorRegistered\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"delegationApprover\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSharesDecreased\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSharesIncreased\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"SlashingWithdrawalCompleted\",\"inputs\":[{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"SlashingWithdrawalQueued\",\"inputs\":[{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"},{\"name\":\"withdrawal\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structIDelegationManagerTypes.Withdrawal\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"sharesToWithdraw\",\"type\":\"uint256[]\",\"indexed\":false,\"internalType\":\"uint256[]\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StakerDelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StakerForceUndelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StakerUndelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"ActivelyDelegated\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CallerCannotUndelegate\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"FullySlashed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputArrayLengthMismatch\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputArrayLengthZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidSignature\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NotActivelyDelegated\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyAllocationManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyEigenPodManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyStrategyManagerOrEigenPodManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorNotRegistered\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorsCannotUndelegate\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SaltSpent\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SignatureExpired\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"WithdrawalDelayNotElapsed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"WithdrawalNotQueued\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"WithdrawerNotCaller\",\"inputs\":[]}]", } // DelegationManagerStorageABI is the input ABI used to generate the binding from. @@ -701,6 +701,37 @@ func (_DelegationManagerStorage *DelegationManagerStorageCallerSession) GetQueue return _DelegationManagerStorage.Contract.GetQueuedWithdrawal(&_DelegationManagerStorage.CallOpts, withdrawalRoot) } +// GetQueuedWithdrawalRoots is a free data retrieval call binding the contract method 0xfd8aa88d. +// +// Solidity: function getQueuedWithdrawalRoots(address staker) view returns(bytes32[]) +func (_DelegationManagerStorage *DelegationManagerStorageCaller) GetQueuedWithdrawalRoots(opts *bind.CallOpts, staker common.Address) ([][32]byte, error) { + var out []interface{} + err := _DelegationManagerStorage.contract.Call(opts, &out, "getQueuedWithdrawalRoots", staker) + + if err != nil { + return *new([][32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([][32]byte)).(*[][32]byte) + + return out0, err + +} + +// GetQueuedWithdrawalRoots is a free data retrieval call binding the contract method 0xfd8aa88d. +// +// Solidity: function getQueuedWithdrawalRoots(address staker) view returns(bytes32[]) +func (_DelegationManagerStorage *DelegationManagerStorageSession) GetQueuedWithdrawalRoots(staker common.Address) ([][32]byte, error) { + return _DelegationManagerStorage.Contract.GetQueuedWithdrawalRoots(&_DelegationManagerStorage.CallOpts, staker) +} + +// GetQueuedWithdrawalRoots is a free data retrieval call binding the contract method 0xfd8aa88d. +// +// Solidity: function getQueuedWithdrawalRoots(address staker) view returns(bytes32[]) +func (_DelegationManagerStorage *DelegationManagerStorageCallerSession) GetQueuedWithdrawalRoots(staker common.Address) ([][32]byte, error) { + return _DelegationManagerStorage.Contract.GetQueuedWithdrawalRoots(&_DelegationManagerStorage.CallOpts, staker) +} + // GetQueuedWithdrawals is a free data retrieval call binding the contract method 0x5dd68579. // // Solidity: function getQueuedWithdrawals(address staker) view returns((address,address,address,uint256,uint32,address[],uint256[])[] withdrawals, uint256[][] shares) @@ -1008,27 +1039,6 @@ func (_DelegationManagerStorage *DelegationManagerStorageCallerSession) Strategy return _DelegationManagerStorage.Contract.StrategyManager(&_DelegationManagerStorage.CallOpts) } -// BurnOperatorShares is a paid mutator transaction binding the contract method 0xee74937f. -// -// Solidity: function burnOperatorShares(address operator, address strategy, uint64 prevMaxMagnitude, uint64 newMaxMagnitude) returns() -func (_DelegationManagerStorage *DelegationManagerStorageTransactor) BurnOperatorShares(opts *bind.TransactOpts, operator common.Address, strategy common.Address, prevMaxMagnitude uint64, newMaxMagnitude uint64) (*types.Transaction, error) { - return _DelegationManagerStorage.contract.Transact(opts, "burnOperatorShares", operator, strategy, prevMaxMagnitude, newMaxMagnitude) -} - -// BurnOperatorShares is a paid mutator transaction binding the contract method 0xee74937f. -// -// Solidity: function burnOperatorShares(address operator, address strategy, uint64 prevMaxMagnitude, uint64 newMaxMagnitude) returns() -func (_DelegationManagerStorage *DelegationManagerStorageSession) BurnOperatorShares(operator common.Address, strategy common.Address, prevMaxMagnitude uint64, newMaxMagnitude uint64) (*types.Transaction, error) { - return _DelegationManagerStorage.Contract.BurnOperatorShares(&_DelegationManagerStorage.TransactOpts, operator, strategy, prevMaxMagnitude, newMaxMagnitude) -} - -// BurnOperatorShares is a paid mutator transaction binding the contract method 0xee74937f. -// -// Solidity: function burnOperatorShares(address operator, address strategy, uint64 prevMaxMagnitude, uint64 newMaxMagnitude) returns() -func (_DelegationManagerStorage *DelegationManagerStorageTransactorSession) BurnOperatorShares(operator common.Address, strategy common.Address, prevMaxMagnitude uint64, newMaxMagnitude uint64) (*types.Transaction, error) { - return _DelegationManagerStorage.Contract.BurnOperatorShares(&_DelegationManagerStorage.TransactOpts, operator, strategy, prevMaxMagnitude, newMaxMagnitude) -} - // CompleteQueuedWithdrawal is a paid mutator transaction binding the contract method 0xe4cc3f90. // // Solidity: function completeQueuedWithdrawal((address,address,address,uint256,uint32,address[],uint256[]) withdrawal, address[] tokens, bool receiveAsTokens) returns() @@ -1239,6 +1249,27 @@ func (_DelegationManagerStorage *DelegationManagerStorageTransactorSession) Regi return _DelegationManagerStorage.Contract.RegisterAsOperator(&_DelegationManagerStorage.TransactOpts, initDelegationApprover, allocationDelay, metadataURI) } +// SlashOperatorShares is a paid mutator transaction binding the contract method 0x601bb36f. +// +// Solidity: function slashOperatorShares(address operator, address strategy, uint64 prevMaxMagnitude, uint64 newMaxMagnitude) returns() +func (_DelegationManagerStorage *DelegationManagerStorageTransactor) SlashOperatorShares(opts *bind.TransactOpts, operator common.Address, strategy common.Address, prevMaxMagnitude uint64, newMaxMagnitude uint64) (*types.Transaction, error) { + return _DelegationManagerStorage.contract.Transact(opts, "slashOperatorShares", operator, strategy, prevMaxMagnitude, newMaxMagnitude) +} + +// SlashOperatorShares is a paid mutator transaction binding the contract method 0x601bb36f. +// +// Solidity: function slashOperatorShares(address operator, address strategy, uint64 prevMaxMagnitude, uint64 newMaxMagnitude) returns() +func (_DelegationManagerStorage *DelegationManagerStorageSession) SlashOperatorShares(operator common.Address, strategy common.Address, prevMaxMagnitude uint64, newMaxMagnitude uint64) (*types.Transaction, error) { + return _DelegationManagerStorage.Contract.SlashOperatorShares(&_DelegationManagerStorage.TransactOpts, operator, strategy, prevMaxMagnitude, newMaxMagnitude) +} + +// SlashOperatorShares is a paid mutator transaction binding the contract method 0x601bb36f. +// +// Solidity: function slashOperatorShares(address operator, address strategy, uint64 prevMaxMagnitude, uint64 newMaxMagnitude) returns() +func (_DelegationManagerStorage *DelegationManagerStorageTransactorSession) SlashOperatorShares(operator common.Address, strategy common.Address, prevMaxMagnitude uint64, newMaxMagnitude uint64) (*types.Transaction, error) { + return _DelegationManagerStorage.Contract.SlashOperatorShares(&_DelegationManagerStorage.TransactOpts, operator, strategy, prevMaxMagnitude, newMaxMagnitude) +} + // Undelegate is a paid mutator transaction binding the contract method 0xda8be864. // // Solidity: function undelegate(address staker) returns(bytes32[] withdrawalRoots) @@ -1852,152 +1883,6 @@ func (_DelegationManagerStorage *DelegationManagerStorageFilterer) ParseOperator return event, nil } -// DelegationManagerStorageOperatorSharesBurnedIterator is returned from FilterOperatorSharesBurned and is used to iterate over the raw logs and unpacked data for OperatorSharesBurned events raised by the DelegationManagerStorage contract. -type DelegationManagerStorageOperatorSharesBurnedIterator struct { - Event *DelegationManagerStorageOperatorSharesBurned // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *DelegationManagerStorageOperatorSharesBurnedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(DelegationManagerStorageOperatorSharesBurned) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(DelegationManagerStorageOperatorSharesBurned) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *DelegationManagerStorageOperatorSharesBurnedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *DelegationManagerStorageOperatorSharesBurnedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// DelegationManagerStorageOperatorSharesBurned represents a OperatorSharesBurned event raised by the DelegationManagerStorage contract. -type DelegationManagerStorageOperatorSharesBurned struct { - Operator common.Address - Strategy common.Address - Shares *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterOperatorSharesBurned is a free log retrieval operation binding the contract event 0xeff6aab2bc3f7c648896e1522eae71d6c22e3b0e218206b3f40af0e4d204716b. -// -// Solidity: event OperatorSharesBurned(address indexed operator, address strategy, uint256 shares) -func (_DelegationManagerStorage *DelegationManagerStorageFilterer) FilterOperatorSharesBurned(opts *bind.FilterOpts, operator []common.Address) (*DelegationManagerStorageOperatorSharesBurnedIterator, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - - logs, sub, err := _DelegationManagerStorage.contract.FilterLogs(opts, "OperatorSharesBurned", operatorRule) - if err != nil { - return nil, err - } - return &DelegationManagerStorageOperatorSharesBurnedIterator{contract: _DelegationManagerStorage.contract, event: "OperatorSharesBurned", logs: logs, sub: sub}, nil -} - -// WatchOperatorSharesBurned is a free log subscription operation binding the contract event 0xeff6aab2bc3f7c648896e1522eae71d6c22e3b0e218206b3f40af0e4d204716b. -// -// Solidity: event OperatorSharesBurned(address indexed operator, address strategy, uint256 shares) -func (_DelegationManagerStorage *DelegationManagerStorageFilterer) WatchOperatorSharesBurned(opts *bind.WatchOpts, sink chan<- *DelegationManagerStorageOperatorSharesBurned, operator []common.Address) (event.Subscription, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - - logs, sub, err := _DelegationManagerStorage.contract.WatchLogs(opts, "OperatorSharesBurned", operatorRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(DelegationManagerStorageOperatorSharesBurned) - if err := _DelegationManagerStorage.contract.UnpackLog(event, "OperatorSharesBurned", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseOperatorSharesBurned is a log parse operation binding the contract event 0xeff6aab2bc3f7c648896e1522eae71d6c22e3b0e218206b3f40af0e4d204716b. -// -// Solidity: event OperatorSharesBurned(address indexed operator, address strategy, uint256 shares) -func (_DelegationManagerStorage *DelegationManagerStorageFilterer) ParseOperatorSharesBurned(log types.Log) (*DelegationManagerStorageOperatorSharesBurned, error) { - event := new(DelegationManagerStorageOperatorSharesBurned) - if err := _DelegationManagerStorage.contract.UnpackLog(event, "OperatorSharesBurned", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - // DelegationManagerStorageOperatorSharesDecreasedIterator is returned from FilterOperatorSharesDecreased and is used to iterate over the raw logs and unpacked data for OperatorSharesDecreased events raised by the DelegationManagerStorage contract. type DelegationManagerStorageOperatorSharesDecreasedIterator struct { Event *DelegationManagerStorageOperatorSharesDecreased // Event containing the contract specifics and raw log diff --git a/pkg/bindings/Eigen/binding.go b/pkg/bindings/Eigen/binding.go index 093f64d84c..5662a0b235 100644 --- a/pkg/bindings/Eigen/binding.go +++ b/pkg/bindings/Eigen/binding.go @@ -38,7 +38,7 @@ type ERC20VotesUpgradeableCheckpoint struct { // EigenMetaData contains all meta data concerning the Eigen contract. var EigenMetaData = &bind.MetaData{ ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_bEIGEN\",\"type\":\"address\",\"internalType\":\"contractIERC20\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"CLOCK_MODE\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"DOMAIN_SEPARATOR\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"allowance\",\"inputs\":[{\"name\":\"owner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"allowedFrom\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"allowedTo\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"approve\",\"inputs\":[{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"bEIGEN\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIERC20\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"balanceOf\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"checkpoints\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"pos\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structERC20VotesUpgradeable.Checkpoint\",\"components\":[{\"name\":\"fromBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"votes\",\"type\":\"uint224\",\"internalType\":\"uint224\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"clock\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint48\",\"internalType\":\"uint48\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"decimals\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"decreaseAllowance\",\"inputs\":[{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"subtractedValue\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegate\",\"inputs\":[{\"name\":\"delegatee\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegateBySig\",\"inputs\":[{\"name\":\"delegatee\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"v\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"r\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"s\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegates\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"disableTransferRestrictions\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"eip712Domain\",\"inputs\":[],\"outputs\":[{\"name\":\"fields\",\"type\":\"bytes1\",\"internalType\":\"bytes1\"},{\"name\":\"name\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"version\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"chainId\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"verifyingContract\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"extensions\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getPastTotalSupply\",\"inputs\":[{\"name\":\"timepoint\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getPastVotes\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"timepoint\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getVotes\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"increaseAllowance\",\"inputs\":[{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"addedValue\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"minters\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"mintingAllowances\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"mintAllowedAfters\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"mint\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"mintAllowedAfter\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"mintingAllowance\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"multisend\",\"inputs\":[{\"name\":\"receivers\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"amounts\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"name\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"nonces\",\"inputs\":[{\"name\":\"owner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"numCheckpoints\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"permit\",\"inputs\":[{\"name\":\"owner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"deadline\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"v\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"r\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"s\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setAllowedFrom\",\"inputs\":[{\"name\":\"from\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"isAllowedFrom\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setAllowedTo\",\"inputs\":[{\"name\":\"to\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"isAllowedTo\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"symbol\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"totalSupply\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"transfer\",\"inputs\":[{\"name\":\"to\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"transferFrom\",\"inputs\":[{\"name\":\"from\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"to\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"transferRestrictionsDisabledAfter\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"unwrap\",\"inputs\":[{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"wrap\",\"inputs\":[{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"Approval\",\"inputs\":[{\"name\":\"owner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"spender\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"DelegateChanged\",\"inputs\":[{\"name\":\"delegator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"fromDelegate\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"toDelegate\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"DelegateVotesChanged\",\"inputs\":[{\"name\":\"delegate\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"previousBalance\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"newBalance\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"EIP712DomainChanged\",\"inputs\":[],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Mint\",\"inputs\":[{\"name\":\"minter\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"SetAllowedFrom\",\"inputs\":[{\"name\":\"from\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"isAllowedFrom\",\"type\":\"bool\",\"indexed\":false,\"internalType\":\"bool\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"SetAllowedTo\",\"inputs\":[{\"name\":\"to\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"isAllowedTo\",\"type\":\"bool\",\"indexed\":false,\"internalType\":\"bool\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Transfer\",\"inputs\":[{\"name\":\"from\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"to\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"TransferRestrictionsDisabled\",\"inputs\":[],\"anonymous\":false}]", - Bin: "0x60a060405234801561000f575f5ffd5b5060405161352938038061352983398101604081905261002e91610105565b6001600160a01b038116608052610043610049565b50610132565b5f54610100900460ff16156100b45760405162461bcd60e51b815260206004820152602760248201527f496e697469616c697a61626c653a20636f6e747261637420697320696e697469604482015266616c697a696e6760c81b606482015260840160405180910390fd5b5f5460ff90811614610103575f805460ff191660ff9081179091556040519081527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15b565b5f60208284031215610115575f5ffd5b81516001600160a01b038116811461012b575f5ffd5b9392505050565b6080516133ca61015f5f395f81816103410152818161083e0152818161149e015261158a01526133ca5ff3fe608060405234801561000f575f5ffd5b5060043610610255575f3560e01c806381b9716111610140578063a9059cbb116100bf578063dd62ed3e11610084578063dd62ed3e146105b9578063de0e9a3e146105cc578063ea598cb0146105df578063eb415f45146105f2578063f1127ed8146105fa578063f2fde38b14610637575f5ffd5b8063a9059cbb1461055a578063aad41a411461056d578063b8c2559414610580578063c3cda52014610593578063d505accf146105a6575f5ffd5b806395d89b411161010557806395d89b411461050f5780639ab24eb0146105175780639aec4bae1461052a578063a457c2d714610534578063a7d1195d14610547575f5ffd5b806381b971611461049157806384b0196e146104b15780638da5cb5b146104cc5780638e539e8c146104dd57806391ddadf4146104f0575f5ffd5b80633a46b1a8116101d75780635c19a95c1161019c5780635c19a95c146103f05780636fcfff451461040357806370a082311461042b578063715018a61461045357806378aa33ba1461045b5780637ecebe001461047e575f5ffd5b80633a46b1a8146103295780633f4da4c61461033c5780634bf5d7e91461037b57806353957125146103a5578063587cde1e146103c5575f5ffd5b80631ffacdef1161021d5780631ffacdef146102d957806323b872dd146102ec578063313ce567146102ff5780633644e5151461030e5780633950935114610316575f5ffd5b80630455e6941461025957806306fdde0314610291578063095ea7b3146102a65780631249c58b146102b957806318160ddd146102c3575b5f5ffd5b61027c610267366004612c01565b6101336020525f908152604090205460ff1681565b60405190151581526020015b60405180910390f35b61029961064a565b6040516102889190612c48565b61027c6102b4366004612c5a565b6106da565b6102c16106f3565b005b6102cb61083b565b604051908152602001610288565b6102c16102e7366004612c8f565b6108c1565b61027c6102fa366004612cc4565b610929565b60405160128152602001610288565b6102cb61094c565b61027c610324366004612c5a565b610955565b6102cb610337366004612c5a565b610976565b6103637f000000000000000000000000000000000000000000000000000000000000000081565b6040516001600160a01b039091168152602001610288565b60408051808201909152600e81526d06d6f64653d74696d657374616d760941b6020820152610299565b6102cb6103b3366004612c01565b6101306020525f908152604090205481565b6103636103d3366004612c01565b6001600160a01b039081165f90815260fe60205260409020541690565b6102c16103fe366004612c01565b6109f9565b610416610411366004612c01565b610a06565b60405163ffffffff9091168152602001610288565b6102cb610439366004612c01565b6001600160a01b03165f9081526065602052604090205490565b6102c1610a27565b61027c610469366004612c01565b6101346020525f908152604090205460ff1681565b6102cb61048c366004612c01565b610a3a565b6102cb61049f366004612c01565b6101316020525f908152604090205481565b6104b9610a57565b6040516102889796959493929190612cfe565b6033546001600160a01b0316610363565b6102cb6104eb366004612d94565b610af0565b6104f8610b57565b60405165ffffffffffff9091168152602001610288565b610299610b61565b6102cb610525366004612c01565b610b70565b6102cb6101325481565b61027c610542366004612c5a565b610bed565b6102c1610555366004612e73565b610c67565b61027c610568366004612c5a565b61107b565b6102c161057b366004612fb8565b611088565b6102c161058e366004612c8f565b611158565b6102c16105a1366004613034565b6111b8565b6102c16105b4366004613088565b6112ed565b6102cb6105c73660046130ee565b61144e565b6102c16105da366004612d94565b611478565b6102c16105ed366004612d94565b611568565b6102c161165d565b61060d61060836600461311f565b611724565b60408051825163ffffffff1681526020928301516001600160e01b03169281019290925201610288565b6102c1610645366004612c01565b6117a5565b60606068805461065990613151565b80601f016020809104026020016040519081016040528092919081815260200182805461068590613151565b80156106d05780601f106106a7576101008083540402835291602001916106d0565b820191905f5260205f20905b8154815290600101906020018083116106b357829003601f168201915b5050505050905090565b5f336106e781858561181b565b60019150505b92915050565b335f908152610131602052604090205461076c5760405162461bcd60e51b815260206004820152602f60248201527f456967656e2e6d696e743a206d73672e73656e64657220686173206e6f206d6960448201526e6e74696e6720616c6c6f77616e636560881b60648201526084015b60405180910390fd5b335f908152610130602052604090205442116107e45760405162461bcd60e51b815260206004820152603160248201527f456967656e2e6d696e743a206d73672e73656e646572206973206e6f7420616c6044820152701b1bddd959081d1bc81b5a5b9d081e595d607a1b6064820152608401610763565b335f81815261013160205260408120805491905590610803908261193e565b60405181815233907f0f6798a560793a54c3bcfe86a93cde1e73087d944c0ea20544137d41213968859060200160405180910390a250565b5f7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03166318160ddd6040518163ffffffff1660e01b8152600401602060405180830381865afa158015610898573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906108bc9190613183565b905090565b6108c96119d4565b6001600160a01b0382165f8181526101336020908152604091829020805460ff191685151590811790915591519182527fcf20b1ecb604b0e8888d579c64e8a3b10e590d45c1c2dddb393bed284362227191015b60405180910390a25050565b5f33610936858285611a2e565b610941858585611aa0565b506001949350505050565b5f6108bc611c5a565b5f336106e7818585610967838361144e565b61097191906131ae565b61181b565b5f61097f610b57565b65ffffffffffff1682106109d15760405162461bcd60e51b815260206004820152601960248201527804552433230566f7465733a20667574757265206c6f6f6b757603c1b6044820152606401610763565b6001600160a01b0383165f90815260ff602052604090206109f29083611c63565b9392505050565b610a033382611d44565b50565b6001600160a01b0381165f90815260ff60205260408120546106ed90611dbd565b610a2f6119d4565b610a385f611e25565b565b6001600160a01b0381165f90815260cb60205260408120546106ed565b5f6060805f5f5f60606097545f5f1b148015610a735750609854155b610ab75760405162461bcd60e51b81526020600482015260156024820152741152540dcc4c8e88155b9a5b9a5d1a585b1a5e9959605a1b6044820152606401610763565b610abf611e76565b610ac7611e85565b604080515f80825260208201909252600f60f81b9b939a50919850469750309650945092509050565b5f610af9610b57565b65ffffffffffff168210610b4b5760405162461bcd60e51b815260206004820152601960248201527804552433230566f7465733a20667574757265206c6f6f6b757603c1b6044820152606401610763565b6106ed61010083611c63565b5f6108bc42611e94565b60606069805461065990613151565b6001600160a01b0381165f90815260ff60205260408120548015610bdb576001600160a01b0383165f90815260ff6020526040902080545f198301908110610bba57610bba6131c1565b5f9182526020909120015464010000000090046001600160e01b0316610bdd565b5f5b6001600160e01b03169392505050565b5f3381610bfa828661144e565b905083811015610c5a5760405162461bcd60e51b815260206004820152602560248201527f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f77604482015264207a65726f60d81b6064820152608401610763565b610941828686840361181b565b5f54610100900460ff1615808015610c8557505f54600160ff909116105b80610c9e5750303b158015610c9e57505f5460ff166001145b610d015760405162461bcd60e51b815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201526d191e481a5b9a5d1a585b1a5e995960921b6064820152608401610763565b5f805460ff191660011790558015610d22575f805461ff0019166101001790555b610d2a611efa565b610d6e6040518060400160405280600581526020016422b4b3b2b760d91b8152506040518060400160405280600581526020016422a4a3a2a760d91b815250611f28565b610d7785611e25565b610d9d6040518060400160405280600581526020016422a4a3a2a760d91b815250611f5c565b8251845114610e245760405162461bcd60e51b815260206004820152604760248201527f456967656e2e696e697469616c697a653a206d696e7465727320616e64206d6960448201527f6e74696e67416c6c6f77616e636573206d757374206265207468652073616d65606482015266040d8cadccee8d60cb1b608482015260a401610763565b8151845114610eab5760405162461bcd60e51b815260206004820152604760248201527f456967656e2e696e697469616c697a653a206d696e7465727320616e64206d6960448201527f6e74416c6c6f776564416674657273206d757374206265207468652073616d65606482015266040d8cadccee8d60cb1b608482015260a401610763565b5f5b845181101561102857838181518110610ec857610ec86131c1565b60200260200101516101315f878481518110610ee657610ee66131c1565b60200260200101516001600160a01b03166001600160a01b031681526020019081526020015f2081905550828181518110610f2357610f236131c1565b60200260200101516101305f878481518110610f4157610f416131c1565b60200260200101516001600160a01b03166001600160a01b031681526020019081526020015f208190555060016101335f878481518110610f8457610f846131c1565b60200260200101516001600160a01b03166001600160a01b031681526020019081526020015f205f6101000a81548160ff021916908315150217905550848181518110610fd357610fd36131c1565b60200260200101516001600160a01b03167fcf20b1ecb604b0e8888d579c64e8a3b10e590d45c1c2dddb393bed28436222716001604051611018911515815260200190565b60405180910390a2600101610ead565b505f19610132558015611074575f805461ff0019169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15b5050505050565b5f336106e7818585611aa0565b8281146110fd5760405162461bcd60e51b815260206004820152603e60248201527f456967656e2e6d756c746973656e643a2072656365697665727320616e64206160448201527f6d6f756e7473206d757374206265207468652073616d65206c656e67746800006064820152608401610763565b5f5b83811015611074576111503386868481811061111d5761111d6131c1565b90506020020160208101906111329190612c01565b858585818110611144576111446131c1565b90506020020135611aa0565b6001016110ff565b6111606119d4565b6001600160a01b0382165f8181526101346020908152604091829020805460ff191685151590811790915591519182527f72a561d1af7409467dae4f1e9fc52590a9335a1dda17727e2b6aa8c4db35109b910161091d565b834211156112085760405162461bcd60e51b815260206004820152601d60248201527f4552433230566f7465733a207369676e617475726520657870697265640000006044820152606401610763565b604080517fe48329057bfd03d55e49b547132e39cffd9c1820ad7b9d4c5307691425d15adf60208201526001600160a01b0388169181019190915260608101869052608081018590525f90611281906112799060a00160405160208183030381529060405280519060200120611fa5565b858585611fd1565b905061128c81611ff7565b86146112da5760405162461bcd60e51b815260206004820152601960248201527f4552433230566f7465733a20696e76616c6964206e6f6e6365000000000000006044820152606401610763565b6112e48188611d44565b50505050505050565b8342111561133d5760405162461bcd60e51b815260206004820152601d60248201527f45524332305065726d69743a206578706972656420646561646c696e650000006044820152606401610763565b5f7f6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c988888861136b8c611ff7565b6040805160208101969096526001600160a01b0394851690860152929091166060840152608083015260a082015260c0810186905260e0016040516020818303038152906040528051906020012090505f6113c582611fa5565b90505f6113d482878787611fd1565b9050896001600160a01b0316816001600160a01b0316146114375760405162461bcd60e51b815260206004820152601e60248201527f45524332305065726d69743a20696e76616c6964207369676e617475726500006044820152606401610763565b6114428a8a8a61181b565b50505050505050505050565b6001600160a01b039182165f90815260666020908152604080832093909416825291909152205490565b611482338261201e565b60405163a9059cbb60e01b8152336004820152602481018290527f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03169063a9059cbb906044016020604051808303815f875af11580156114ec573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061151091906131d5565b610a035760405162461bcd60e51b8152602060048201526024808201527f456967656e2e756e777261703a2062454947454e207472616e736665722066616044820152631a5b195960e21b6064820152608401610763565b6040516323b872dd60e01b8152336004820152306024820152604481018290527f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316906323b872dd906064016020604051808303815f875af11580156115d8573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906115fc91906131d5565b6116535760405162461bcd60e51b815260206004820152602260248201527f456967656e2e777261703a2062454947454e207472616e73666572206661696c604482015261195960f21b6064820152608401610763565b610a03338261193e565b6116656119d4565b5f1961013254146116f45760405162461bcd60e51b815260206004820152604d60248201527f456967656e2e64697361626c655472616e736665725265737472696374696f6e60448201527f733a207472616e73666572207265737472696374696f6e732061726520616c7260648201526c1958591e48191a5cd8589b1959609a1b608482015260a401610763565b5f6101328190556040517f2b18986d3ba809db2f13a5d7bf17f60d357b37d9cbb55dd71cbbac8dc4060f649190a1565b604080518082019091525f80825260208201526001600160a01b0383165f90815260ff60205260409020805463ffffffff8416908110611766576117666131c1565b5f9182526020918290206040805180820190915291015463ffffffff8116825264010000000090046001600160e01b0316918101919091529392505050565b6117ad6119d4565b6001600160a01b0381166118125760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b6064820152608401610763565b610a0381611e25565b6001600160a01b03831661187d5760405162461bcd60e51b8152602060048201526024808201527f45524332303a20617070726f76652066726f6d20746865207a65726f206164646044820152637265737360e01b6064820152608401610763565b6001600160a01b0382166118de5760405162461bcd60e51b815260206004820152602260248201527f45524332303a20617070726f766520746f20746865207a65726f206164647265604482015261737360f01b6064820152608401610763565b6001600160a01b038381165f8181526066602090815260408083209487168084529482529182902085905590518481527f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925910160405180910390a3505050565b6119488282612037565b6001600160e01b0361195861083b565b11156119bf5760405162461bcd60e51b815260206004820152603060248201527f4552433230566f7465733a20746f74616c20737570706c79207269736b73206f60448201526f766572666c6f77696e6720766f74657360801b6064820152608401610763565b6119ce61010061210883612113565b50505050565b6033546001600160a01b03163314610a385760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152606401610763565b5f611a39848461144e565b90505f1981146119ce5781811015611a935760405162461bcd60e51b815260206004820152601d60248201527f45524332303a20696e73756666696369656e7420616c6c6f77616e63650000006044820152606401610763565b6119ce848484840361181b565b6001600160a01b038316611b045760405162461bcd60e51b815260206004820152602560248201527f45524332303a207472616e736665722066726f6d20746865207a65726f206164604482015264647265737360d81b6064820152608401610763565b6001600160a01b038216611b665760405162461bcd60e51b815260206004820152602360248201527f45524332303a207472616e7366657220746f20746865207a65726f206164647260448201526265737360e81b6064820152608401610763565b611b7183838361227f565b6001600160a01b0383165f9081526065602052604090205481811015611be85760405162461bcd60e51b815260206004820152602660248201527f45524332303a207472616e7366657220616d6f756e7420657863656564732062604482015265616c616e636560d01b6064820152608401610763565b6001600160a01b038085165f8181526065602052604080822086860390559286168082529083902080548601905591517fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef90611c479086815260200190565b60405180910390a36119ce848484612363565b5f6108bc612394565b81545f9081816005811115611cba575f611c7c84612407565b611c8690856131f0565b5f88815260209020909150869082015463ffffffff161115611caa57809150611cb8565b611cb58160016131ae565b92505b505b80821015611d05575f611ccd83836124eb565b5f88815260209020909150869082015463ffffffff161115611cf157809150611cff565b611cfc8160016131ae565b92505b50611cba565b8015611d2f575f8681526020902081015f19015464010000000090046001600160e01b0316611d31565b5f5b6001600160e01b03169695505050505050565b6001600160a01b038281165f81815260fe6020818152604080842080546065845282862054949093528787166001600160a01b03198416811790915590519190951694919391928592917f3134e8a2e6d97e929a7e54011ea5485d7d196dd5f0ba4d4ef95803e8e3fc257f9190a46119ce828483612505565b5f63ffffffff821115611e215760405162461bcd60e51b815260206004820152602660248201527f53616665436173743a2076616c756520646f65736e27742066697420696e203360448201526532206269747360d01b6064820152608401610763565b5090565b603380546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0905f90a35050565b60606099805461065990613151565b6060609a805461065990613151565b5f65ffffffffffff821115611e215760405162461bcd60e51b815260206004820152602660248201527f53616665436173743a2076616c756520646f65736e27742066697420696e203460448201526538206269747360d01b6064820152608401610763565b5f54610100900460ff16611f205760405162461bcd60e51b815260040161076390613203565b610a3861263f565b5f54610100900460ff16611f4e5760405162461bcd60e51b815260040161076390613203565b611f58828261266e565b5050565b5f54610100900460ff16611f825760405162461bcd60e51b815260040161076390613203565b610a0381604051806040016040528060018152602001603160f81b8152506126ad565b5f6106ed611fb1611c5a565b8360405161190160f01b8152600281019290925260228201526042902090565b5f5f5f611fe0878787876126fa565b91509150611fed816127b7565b5095945050505050565b6001600160a01b0381165f90815260cb602052604090208054600181018255905b50919050565b6120288282612900565b6119ce610100612a4383612113565b6001600160a01b03821661208d5760405162461bcd60e51b815260206004820152601f60248201527f45524332303a206d696e7420746f20746865207a65726f2061646472657373006044820152606401610763565b6120985f838361227f565b8060675f8282546120a991906131ae565b90915550506001600160a01b0382165f818152606560209081526040808320805486019055518481527fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a3611f585f8383612363565b5f6109f282846131ae565b82545f90819081811561215d575f8781526020902082015f190160408051808201909152905463ffffffff8116825264010000000090046001600160e01b03166020820152612171565b604080518082019091525f80825260208201525b905080602001516001600160e01b0316935061219184868863ffffffff16565b92505f821180156121b957506121a5610b57565b65ffffffffffff16815f015163ffffffff16145b156121fc576121c783612a4e565b5f8881526020902083015f190180546001600160e01b03929092166401000000000263ffffffff909216919091179055612275565b866040518060400160405280612220612213610b57565b65ffffffffffff16611dbd565b63ffffffff16815260200161223486612a4e565b6001600160e01b0390811690915282546001810184555f938452602093849020835194909301519091166401000000000263ffffffff909316929092179101555b5050935093915050565b61013254421161235e576001600160a01b03831615806122a657506001600160a01b038216155b806122c957506001600160a01b0383165f908152610133602052604090205460ff165b806122ec57506001600160a01b0382165f908152610134602052604090205460ff165b61235e5760405162461bcd60e51b815260206004820152603a60248201527f456967656e2e5f6265666f7265546f6b656e5472616e736665723a2066726f6d60448201527f206f7220746f206d7573742062652077686974656c69737465640000000000006064820152608401610763565b505050565b6001600160a01b038381165f90815260fe602052604080822054858416835291205461235e92918216911683612505565b5f7f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f6123be612ab6565b6123c6612b0e565b60408051602081019490945283019190915260608201524660808201523060a082015260c00160405160208183030381529060405280519060200120905090565b5f815f0361241657505f919050565b5f600161242284612b3e565b901c6001901b9050600181848161243b5761243b61324e565b048201901c905060018184816124535761245361324e565b048201901c9050600181848161246b5761246b61324e565b048201901c905060018184816124835761248361324e565b048201901c9050600181848161249b5761249b61324e565b048201901c905060018184816124b3576124b361324e565b048201901c905060018184816124cb576124cb61324e565b048201901c90506109f2818285816124e5576124e561324e565b04612bd1565b5f6124f96002848418613262565b6109f2908484166131ae565b816001600160a01b0316836001600160a01b03161415801561252657505f81115b1561235e576001600160a01b038316156125b3576001600160a01b0383165f90815260ff60205260408120819061256090612a4385612113565b91509150846001600160a01b03167fdec2bacdd2f05b59de34da9b523dff8be42e5e38e818c82fdb0bae774387a72483836040516125a8929190918252602082015260400190565b60405180910390a250505b6001600160a01b0382161561235e576001600160a01b0382165f90815260ff6020526040812081906125e89061210885612113565b91509150836001600160a01b03167fdec2bacdd2f05b59de34da9b523dff8be42e5e38e818c82fdb0bae774387a7248383604051612630929190918252602082015260400190565b60405180910390a25050505050565b5f54610100900460ff166126655760405162461bcd60e51b815260040161076390613203565b610a3833611e25565b5f54610100900460ff166126945760405162461bcd60e51b815260040161076390613203565b60686126a083826132c5565b50606961235e82826132c5565b5f54610100900460ff166126d35760405162461bcd60e51b815260040161076390613203565b60996126df83826132c5565b50609a6126ec82826132c5565b50505f609781905560985550565b5f807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a083111561272f57505f905060036127ae565b604080515f8082526020820180845289905260ff881692820192909252606081018690526080810185905260019060a0016020604051602081039080840390855afa158015612780573d5f5f3e3d5ffd5b5050604051601f1901519150506001600160a01b0381166127a8575f600192509250506127ae565b91505f90505b94509492505050565b5f8160048111156127ca576127ca613380565b036127d25750565b60018160048111156127e6576127e6613380565b036128335760405162461bcd60e51b815260206004820152601860248201527f45434453413a20696e76616c6964207369676e617475726500000000000000006044820152606401610763565b600281600481111561284757612847613380565b036128945760405162461bcd60e51b815260206004820152601f60248201527f45434453413a20696e76616c6964207369676e6174757265206c656e677468006044820152606401610763565b60038160048111156128a8576128a8613380565b03610a035760405162461bcd60e51b815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202773272076616c604482015261756560f01b6064820152608401610763565b6001600160a01b0382166129605760405162461bcd60e51b815260206004820152602160248201527f45524332303a206275726e2066726f6d20746865207a65726f206164647265736044820152607360f81b6064820152608401610763565b61296b825f8361227f565b6001600160a01b0382165f90815260656020526040902054818110156129de5760405162461bcd60e51b815260206004820152602260248201527f45524332303a206275726e20616d6f756e7420657863656564732062616c616e604482015261636560f01b6064820152608401610763565b6001600160a01b0383165f8181526065602090815260408083208686039055606780548790039055518581529192917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a361235e835f84612363565b5f6109f282846131f0565b5f6001600160e01b03821115611e215760405162461bcd60e51b815260206004820152602760248201527f53616665436173743a2076616c756520646f65736e27742066697420696e20326044820152663234206269747360c81b6064820152608401610763565b5f5f612ac0611e76565b805190915015612ad7578051602090910120919050565b6097548015612ae65792915050565b7fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a4709250505090565b5f5f612b18611e85565b805190915015612b2f578051602090910120919050565b6098548015612ae65792915050565b5f80608083901c15612b5257608092831c92015b604083901c15612b6457604092831c92015b602083901c15612b7657602092831c92015b601083901c15612b8857601092831c92015b600883901c15612b9a57600892831c92015b600483901c15612bac57600492831c92015b600283901c15612bbe57600292831c92015b600183901c156106ed5760010192915050565b5f818310612bdf57816109f2565b5090919050565b80356001600160a01b0381168114612bfc575f5ffd5b919050565b5f60208284031215612c11575f5ffd5b6109f282612be6565b5f81518084528060208401602086015e5f602082860101526020601f19601f83011685010191505092915050565b602081525f6109f26020830184612c1a565b5f5f60408385031215612c6b575f5ffd5b612c7483612be6565b946020939093013593505050565b8015158114610a03575f5ffd5b5f5f60408385031215612ca0575f5ffd5b612ca983612be6565b91506020830135612cb981612c82565b809150509250929050565b5f5f5f60608486031215612cd6575f5ffd5b612cdf84612be6565b9250612ced60208501612be6565b929592945050506040919091013590565b60ff60f81b8816815260e060208201525f612d1c60e0830189612c1a565b8281036040840152612d2e8189612c1a565b606084018890526001600160a01b038716608085015260a0840186905283810360c0850152845180825260208087019350909101905f5b81811015612d83578351835260209384019390920191600101612d65565b50909b9a5050505050505050505050565b5f60208284031215612da4575f5ffd5b5035919050565b634e487b7160e01b5f52604160045260245ffd5b604051601f8201601f1916810167ffffffffffffffff81118282101715612de857612de8612dab565b604052919050565b5f67ffffffffffffffff821115612e0957612e09612dab565b5060051b60200190565b5f82601f830112612e22575f5ffd5b8135612e35612e3082612df0565b612dbf565b8082825260208201915060208360051b860101925085831115612e56575f5ffd5b602085015b83811015611fed578035835260209283019201612e5b565b5f5f5f5f60808587031215612e86575f5ffd5b612e8f85612be6565b9350602085013567ffffffffffffffff811115612eaa575f5ffd5b8501601f81018713612eba575f5ffd5b8035612ec8612e3082612df0565b8082825260208201915060208360051b850101925089831115612ee9575f5ffd5b6020840193505b82841015612f1257612f0184612be6565b825260209384019390910190612ef0565b9550505050604085013567ffffffffffffffff811115612f30575f5ffd5b612f3c87828801612e13565b925050606085013567ffffffffffffffff811115612f58575f5ffd5b612f6487828801612e13565b91505092959194509250565b5f5f83601f840112612f80575f5ffd5b50813567ffffffffffffffff811115612f97575f5ffd5b6020830191508360208260051b8501011115612fb1575f5ffd5b9250929050565b5f5f5f5f60408587031215612fcb575f5ffd5b843567ffffffffffffffff811115612fe1575f5ffd5b612fed87828801612f70565b909550935050602085013567ffffffffffffffff81111561300c575f5ffd5b61301887828801612f70565b95989497509550505050565b803560ff81168114612bfc575f5ffd5b5f5f5f5f5f5f60c08789031215613049575f5ffd5b61305287612be6565b9550602087013594506040870135935061306e60608801613024565b9598949750929560808101359460a0909101359350915050565b5f5f5f5f5f5f5f60e0888a03121561309e575f5ffd5b6130a788612be6565b96506130b560208901612be6565b955060408801359450606088013593506130d160808901613024565b9699959850939692959460a0840135945060c09093013592915050565b5f5f604083850312156130ff575f5ffd5b61310883612be6565b915061311660208401612be6565b90509250929050565b5f5f60408385031215613130575f5ffd5b61313983612be6565b9150602083013563ffffffff81168114612cb9575f5ffd5b600181811c9082168061316557607f821691505b60208210810361201857634e487b7160e01b5f52602260045260245ffd5b5f60208284031215613193575f5ffd5b5051919050565b634e487b7160e01b5f52601160045260245ffd5b808201808211156106ed576106ed61319a565b634e487b7160e01b5f52603260045260245ffd5b5f602082840312156131e5575f5ffd5b81516109f281612c82565b818103818111156106ed576106ed61319a565b6020808252602b908201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960408201526a6e697469616c697a696e6760a81b606082015260800190565b634e487b7160e01b5f52601260045260245ffd5b5f8261327c57634e487b7160e01b5f52601260045260245ffd5b500490565b601f82111561235e57805f5260205f20601f840160051c810160208510156132a65750805b601f840160051c820191505b81811015611074575f81556001016132b2565b815167ffffffffffffffff8111156132df576132df612dab565b6132f3816132ed8454613151565b84613281565b6020601f821160018114613325575f831561330e5750848201515b5f19600385901b1c1916600184901b178455611074565b5f84815260208120601f198516915b828110156133545787850151825560209485019460019092019101613334565b508482101561337157868401515f19600387901b60f8161c191681555b50505050600190811b01905550565b634e487b7160e01b5f52602160045260245ffdfea2646970667358221220288064199d2be90b93729dff2dcc2497b661bd2af455c43da5f6db62c74e88c364736f6c634300081b0033", + Bin: "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", } // EigenABI is the input ABI used to generate the binding from. diff --git a/pkg/bindings/EigenPod/binding.go b/pkg/bindings/EigenPod/binding.go index 2a8f47921b..e918812a07 100644 --- a/pkg/bindings/EigenPod/binding.go +++ b/pkg/bindings/EigenPod/binding.go @@ -74,7 +74,7 @@ type IEigenPodTypesValidatorInfo struct { // EigenPodMetaData contains all meta data concerning the EigenPod contract. var EigenPodMetaData = &bind.MetaData{ ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_ethPOS\",\"type\":\"address\",\"internalType\":\"contractIETHPOSDeposit\"},{\"name\":\"_eigenPodManager\",\"type\":\"address\",\"internalType\":\"contractIEigenPodManager\"},{\"name\":\"_GENESIS_TIME\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"receive\",\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"GENESIS_TIME\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"activeValidatorCount\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"checkpointBalanceExitedGwei\",\"inputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"currentCheckpoint\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIEigenPodTypes.Checkpoint\",\"components\":[{\"name\":\"beaconBlockRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"proofsRemaining\",\"type\":\"uint24\",\"internalType\":\"uint24\"},{\"name\":\"podBalanceGwei\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"balanceDeltasGwei\",\"type\":\"int64\",\"internalType\":\"int64\"},{\"name\":\"prevBeaconBalanceGwei\",\"type\":\"uint64\",\"internalType\":\"uint64\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"currentCheckpointTimestamp\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"eigenPodManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEigenPodManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"ethPOS\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIETHPOSDeposit\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getParentBlockRoot\",\"inputs\":[{\"name\":\"timestamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"_podOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"lastCheckpointTimestamp\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"podOwner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"proofSubmitter\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"recoverTokens\",\"inputs\":[{\"name\":\"tokenList\",\"type\":\"address[]\",\"internalType\":\"contractIERC20[]\"},{\"name\":\"amountsToWithdraw\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"recipient\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setProofSubmitter\",\"inputs\":[{\"name\":\"newProofSubmitter\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"stake\",\"inputs\":[{\"name\":\"pubkey\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"depositDataRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"startCheckpoint\",\"inputs\":[{\"name\":\"revertIfNoBalance\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"validatorPubkeyHashToInfo\",\"inputs\":[{\"name\":\"validatorPubkeyHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIEigenPodTypes.ValidatorInfo\",\"components\":[{\"name\":\"validatorIndex\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"restakedBalanceGwei\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"lastCheckpointedAt\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"status\",\"type\":\"uint8\",\"internalType\":\"enumIEigenPodTypes.VALIDATOR_STATUS\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"validatorPubkeyToInfo\",\"inputs\":[{\"name\":\"validatorPubkey\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIEigenPodTypes.ValidatorInfo\",\"components\":[{\"name\":\"validatorIndex\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"restakedBalanceGwei\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"lastCheckpointedAt\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"status\",\"type\":\"uint8\",\"internalType\":\"enumIEigenPodTypes.VALIDATOR_STATUS\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"validatorStatus\",\"inputs\":[{\"name\":\"validatorPubkey\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"enumIEigenPodTypes.VALIDATOR_STATUS\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"validatorStatus\",\"inputs\":[{\"name\":\"pubkeyHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"enumIEigenPodTypes.VALIDATOR_STATUS\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"verifyCheckpointProofs\",\"inputs\":[{\"name\":\"balanceContainerProof\",\"type\":\"tuple\",\"internalType\":\"structBeaconChainProofs.BalanceContainerProof\",\"components\":[{\"name\":\"balanceContainerRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"proof\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]},{\"name\":\"proofs\",\"type\":\"tuple[]\",\"internalType\":\"structBeaconChainProofs.BalanceProof[]\",\"components\":[{\"name\":\"pubkeyHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"balanceRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"proof\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"verifyStaleBalance\",\"inputs\":[{\"name\":\"beaconTimestamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"stateRootProof\",\"type\":\"tuple\",\"internalType\":\"structBeaconChainProofs.StateRootProof\",\"components\":[{\"name\":\"beaconStateRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"proof\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]},{\"name\":\"proof\",\"type\":\"tuple\",\"internalType\":\"structBeaconChainProofs.ValidatorProof\",\"components\":[{\"name\":\"validatorFields\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"},{\"name\":\"proof\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"verifyWithdrawalCredentials\",\"inputs\":[{\"name\":\"beaconTimestamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"stateRootProof\",\"type\":\"tuple\",\"internalType\":\"structBeaconChainProofs.StateRootProof\",\"components\":[{\"name\":\"beaconStateRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"proof\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]},{\"name\":\"validatorIndices\",\"type\":\"uint40[]\",\"internalType\":\"uint40[]\"},{\"name\":\"validatorFieldsProofs\",\"type\":\"bytes[]\",\"internalType\":\"bytes[]\"},{\"name\":\"validatorFields\",\"type\":\"bytes32[][]\",\"internalType\":\"bytes32[][]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"withdrawRestakedBeaconChainETH\",\"inputs\":[{\"name\":\"recipient\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amountWei\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"withdrawableRestakedExecutionLayerGwei\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"event\",\"name\":\"CheckpointCreated\",\"inputs\":[{\"name\":\"checkpointTimestamp\",\"type\":\"uint64\",\"indexed\":true,\"internalType\":\"uint64\"},{\"name\":\"beaconBlockRoot\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"},{\"name\":\"validatorCount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"CheckpointFinalized\",\"inputs\":[{\"name\":\"checkpointTimestamp\",\"type\":\"uint64\",\"indexed\":true,\"internalType\":\"uint64\"},{\"name\":\"totalShareDeltaWei\",\"type\":\"int256\",\"indexed\":false,\"internalType\":\"int256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"EigenPodStaked\",\"inputs\":[{\"name\":\"pubkey\",\"type\":\"bytes\",\"indexed\":false,\"internalType\":\"bytes\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"NonBeaconChainETHReceived\",\"inputs\":[{\"name\":\"amountReceived\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"ProofSubmitterUpdated\",\"inputs\":[{\"name\":\"prevProofSubmitter\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"newProofSubmitter\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"RestakedBeaconChainETHWithdrawn\",\"inputs\":[{\"name\":\"recipient\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"ValidatorBalanceUpdated\",\"inputs\":[{\"name\":\"validatorIndex\",\"type\":\"uint40\",\"indexed\":false,\"internalType\":\"uint40\"},{\"name\":\"balanceTimestamp\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"},{\"name\":\"newValidatorBalanceGwei\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"ValidatorCheckpointed\",\"inputs\":[{\"name\":\"checkpointTimestamp\",\"type\":\"uint64\",\"indexed\":true,\"internalType\":\"uint64\"},{\"name\":\"validatorIndex\",\"type\":\"uint40\",\"indexed\":true,\"internalType\":\"uint40\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"ValidatorRestaked\",\"inputs\":[{\"name\":\"validatorIndex\",\"type\":\"uint40\",\"indexed\":false,\"internalType\":\"uint40\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"ValidatorWithdrawn\",\"inputs\":[{\"name\":\"checkpointTimestamp\",\"type\":\"uint64\",\"indexed\":true,\"internalType\":\"uint64\"},{\"name\":\"validatorIndex\",\"type\":\"uint40\",\"indexed\":true,\"internalType\":\"uint40\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"BeaconTimestampTooFarInPast\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CannotCheckpointTwiceInSingleBlock\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CheckpointAlreadyActive\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CredentialsAlreadyVerified\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CurrentlyPaused\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputArrayLengthMismatch\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InsufficientWithdrawableBalance\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidEIP4788Response\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidProof\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidProofLength\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidProofLength\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidPubKeyLength\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidValidatorFieldsLength\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"MsgValueNot32ETH\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NoActiveCheckpoint\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NoBalanceToCheckpoint\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyEigenPodManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyEigenPodOwner\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyEigenPodOwnerOrProofSubmitter\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"TimestampOutOfRange\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ValidatorInactiveOnBeaconChain\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ValidatorIsExitingBeaconChain\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ValidatorNotActiveInPod\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ValidatorNotSlashedOnBeaconChain\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"WithdrawalCredentialsNotForEigenPod\",\"inputs\":[]}]", - Bin: "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", + Bin: "0x60e060405234801561000f575f5ffd5b50604051613c7c380380613c7c83398101604081905261002e91610131565b6001600160a01b03808416608052821660a0526001600160401b03811660c05261005661005e565b505050610186565b5f54610100900460ff16156100c95760405162461bcd60e51b815260206004820152602760248201527f496e697469616c697a61626c653a20636f6e747261637420697320696e697469604482015266616c697a696e6760c81b606482015260840160405180910390fd5b5f5460ff90811614610118575f805460ff191660ff9081179091556040519081527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15b565b6001600160a01b038116811461012e575f5ffd5b50565b5f5f5f60608486031215610143575f5ffd5b835161014e8161011a565b602085015190935061015f8161011a565b60408501519092506001600160401b038116811461017b575f5ffd5b809150509250925092565b60805160a05160c051613a7f6101fd5f395f61060401525f81816102a90152818161063f015281816106e7015281816109ab01528181610b7501528181610e4e01528181610ef50152818161112b01528181611479015281816115ad01526127bb01525f81816104c60152610f5e0152613a7f5ff3fe608060405260043610610164575f3560e01c80636fcd0e53116100cd578063c490744211610087578063dda3346c11610062578063dda3346c14610596578063ee94d67c146105b5578063f074ba62146105d4578063f2882461146105f3575f5ffd5b8063c490744214610539578063c4d66de814610558578063d06d558714610577575f5ffd5b80636fcd0e53146104545780637439841f1461048057806374cdd798146104b557806388676cad146104e85780639b4e463414610507578063b522538a1461051a575f5ffd5b80634665bcda1161011e5780634665bcda1461029857806347d28372146102cb57806352396a59146103b657806358753357146103ea57806358eaee79146104095780636c0d2d5a14610435575f5ffd5b8063039157d2146101a25780630b18ff66146101c35780632340e8d3146101ff5780633474aa16146102225780633f65cf191461025357806342ecff2a14610272575f5ffd5b3661019e576040513481527f6fdd3dbdb173299608c0aa9f368735857c8842b581f8389238bf05bd04b3bf499060200160405180910390a1005b5f5ffd5b3480156101ad575f5ffd5b506101c16101bc366004612ff3565b610626565b005b3480156101ce575f5ffd5b506033546101e2906001600160a01b031681565b6040516001600160a01b0390911681526020015b60405180910390f35b34801561020a575f5ffd5b5061021460395481565b6040519081526020016101f6565b34801561022d575f5ffd5b506034546001600160401b03165b6040516001600160401b0390911681526020016101f6565b34801561025e575f5ffd5b506101c161026d3660046130ac565b610952565b34801561027d575f5ffd5b50603a5461023b90600160401b90046001600160401b031681565b3480156102a3575f5ffd5b506101e27f000000000000000000000000000000000000000000000000000000000000000081565b3480156102d6575f5ffd5b5061035b6040805160a0810182525f80825260208201819052918101829052606081018290526080810191909152506040805160a081018252603c548152603d5462ffffff811660208301526001600160401b0363010000008204811693830193909352600160581b810460070b6060830152600160981b9004909116608082015290565b6040516101f691905f60a0820190508251825262ffffff60208401511660208301526001600160401b036040840151166040830152606083015160070b60608301526001600160401b03608084015116608083015292915050565b3480156103c1575f5ffd5b5061023b6103d0366004613181565b603b6020525f90815260409020546001600160401b031681565b3480156103f5575f5ffd5b50603e546101e2906001600160a01b031681565b348015610414575f5ffd5b506104286104233660046131de565b610bda565b6040516101f69190613250565b348015610440575f5ffd5b5061021461044f366004613181565b610c3c565b34801561045f575f5ffd5b5061047361046e36600461325e565b610d4a565b6040516101f69190613275565b34801561048b575f5ffd5b5061042861049a36600461325e565b5f90815260366020526040902054600160c01b900460ff1690565b3480156104c0575f5ffd5b506101e27f000000000000000000000000000000000000000000000000000000000000000081565b3480156104f3575f5ffd5b506101c16105023660046132d8565b610df5565b6101c16105153660046132f3565b610eea565b348015610525575f5ffd5b506104736105343660046131de565b611031565b348015610544575f5ffd5b506101c1610553366004613383565b611120565b348015610563575f5ffd5b506101c16105723660046133ad565b611257565b348015610582575f5ffd5b506101c16105913660046133ad565b6113a1565b3480156105a1575f5ffd5b506101c16105b0366004613498565b611435565b3480156105c0575f5ffd5b50603a5461023b906001600160401b031681565b3480156105df575f5ffd5b506101c16105ee36600461356a565b611594565b3480156105fe575f5ffd5b5061023b7f000000000000000000000000000000000000000000000000000000000000000081565b604051635ac86ab760e01b8152600660048201819052907f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031690635ac86ab790602401602060405180830381865afa15801561068c573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906106b091906135d1565b156106ce5760405163840a48d560e01b815260040160405180910390fd5b604051635ac86ab760e01b8152600860048201819052907f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031690635ac86ab790602401602060405180830381865afa158015610734573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061075891906135d1565b156107765760405163840a48d560e01b815260040160405180910390fd5b5f6107ba61078485806135ec565b808060200260200160405190810160405280939291908181526020018383602002808284375f9201919091525061199192505050565b5f818152603660209081526040808320815160808101835281546001600160401b038082168352600160401b8204811695830195909552600160801b8104909416928101929092529394509192906060830190600160c01b900460ff1660028111156108285761082861321c565b60028111156108395761083961321c565b81525050905080604001516001600160401b0316876001600160401b031611610875576040516337e07ffd60e01b815260040160405180910390fd5b60018160600151600281111561088d5761088d61321c565b146108ab5760405163d49e19a760e01b815260040160405180910390fd5b6108ee6108b886806135ec565b808060200260200160405190810160405280939291908181526020018383602002808284375f920191909152506119b392505050565b61090b5760405163161ce5ed60e31b815260040160405180910390fd5b61091d61091788610c3c565b876119db565b610940863561092c87806135ec565b61093960208a018a613631565b8651611a80565b6109495f611ba7565b50505050505050565b6033546001600160a01b03163314806109755750603e546001600160a01b031633145b6109925760405163427a777960e01b815260040160405180910390fd5b604051635ac86ab760e01b8152600260048201819052907f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031690635ac86ab790602401602060405180830381865afa1580156109f8573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610a1c91906135d1565b15610a3a5760405163840a48d560e01b815260040160405180910390fd5b8584148015610a4857508382145b610a65576040516343714afd60e01b815260040160405180910390fd5b603a546001600160401b03600160401b9091048116908a1611610a9b576040516337e07ffd60e01b815260040160405180910390fd5b610aad610aa78a610c3c565b896119db565b5f805b87811015610b4557610b318a358a8a84818110610acf57610acf613673565b9050602002016020810190610ae49190613687565b898985818110610af657610af6613673565b9050602002810190610b089190613631565b898987818110610b1a57610b1a613673565b9050602002810190610b2c91906135ec565b611d27565b610b3b90836136bf565b9150600101610ab0565b5060335460405163a1ca780b60e01b81526001600160a01b0391821660048201525f6024820152604481018390527f00000000000000000000000000000000000000000000000000000000000000009091169063a1ca780b906064015f604051808303815f87803b158015610bb8575f5ffd5b505af1158015610bca573d5f5f3e3d5ffd5b5050505050505050505050505050565b5f5f610c1a84848080601f0160208091040260200160405190810160405280939291908181526020018383808284375f920191909152506121dc92505050565b5f90815260366020526040902054600160c01b900460ff169150505b92915050565b5f610c4a611fff600c6136d2565b610c5d6001600160401b038416426136e9565b10610c7b57604051637944e66d60e11b815260040160405180910390fd5b604080516001600160401b03841660208201525f918291720f3df6d732807ef1319fb7b8bb8522d0beac02910160408051601f1981840301815290829052610cc291613713565b5f60405180830381855afa9150503d805f8114610cfa576040519150601f19603f3d011682016040523d82523d5f602084013e610cff565b606091505b5091509150818015610d1157505f8151115b610d2e5760405163558ad0a360e01b815260040160405180910390fd5b80806020019051810190610d42919061371e565b949350505050565b610d71604080516080810182525f8082526020820181905291810182905290606082015290565b5f82815260366020908152604091829020825160808101845281546001600160401b038082168352600160401b8204811694830194909452600160801b810490931693810193909352906060830190600160c01b900460ff166002811115610ddb57610ddb61321c565b6002811115610dec57610dec61321c565b90525092915050565b6033546001600160a01b0316331480610e185750603e546001600160a01b031633145b610e355760405163427a777960e01b815260040160405180910390fd5b604051635ac86ab760e01b8152600660048201819052907f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031690635ac86ab790602401602060405180830381865afa158015610e9b573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610ebf91906135d1565b15610edd5760405163840a48d560e01b815260040160405180910390fd5b610ee682611ba7565b5050565b336001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001614610f3357604051633213a66160e21b815260040160405180910390fd5b346801bc16d674ec80000014610f5c5760405163049696b360e31b815260040160405180910390fd5b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031663228951186801bc16d674ec8000008787610f9f61226d565b8888886040518863ffffffff1660e01b8152600401610fc39695949392919061378b565b5f604051808303818588803b158015610fda575f5ffd5b505af1158015610fec573d5f5f3e3d5ffd5b50505050507f606865b7934a25d4aed43f6cdb426403353fa4b3009c4d228407474581b01e2385856040516110229291906137d9565b60405180910390a15050505050565b611058604080516080810182525f8082526020820181905291810182905290606082015290565b60365f61109985858080601f0160208091040260200160405190810160405280939291908181526020018383808284375f920191909152506121dc92505050565b815260208082019290925260409081015f20815160808101835281546001600160401b038082168352600160401b8204811695830195909552600160801b81049094169281019290925290916060830190600160c01b900460ff1660028111156111055761110561321c565b60028111156111165761111661321c565b9052509392505050565b336001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000161461116957604051633213a66160e21b815260040160405180910390fd5b5f611178633b9aca0083613800565b9050611191633b9aca006001600160401b0383166136d2565b6034549092506001600160401b0390811690821611156111c4576040516302c6f54760e21b815260040160405180910390fd5b603480548291905f906111e19084906001600160401b0316613813565b92506101000a8154816001600160401b0302191690836001600160401b03160217905550826001600160a01b03167f8947fd2ce07ef9cc302c4e8f0461015615d91ce851564839e91cc804c2f49d8e8360405161124091815260200190565b60405180910390a261125283836122b1565b505050565b5f54610100900460ff161580801561127557505f54600160ff909116105b8061128e5750303b15801561128e57505f5460ff166001145b6112f65760405162461bcd60e51b815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201526d191e481a5b9a5d1a585b1a5e995960921b60648201526084015b60405180910390fd5b5f805460ff191660011790558015611317575f805461ff0019166101001790555b6001600160a01b03821661133e576040516339b190bb60e11b815260040160405180910390fd5b603380546001600160a01b0319166001600160a01b0384161790558015610ee6575f805461ff0019169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15050565b6033546001600160a01b031633146113cc5760405163719f370360e11b815260040160405180910390fd5b603e54604080516001600160a01b03928316815291831660208301527ffb8129080a19d34dceac04ba253fc50304dc86c729bd63cdca4a969ad19a5eac910160405180910390a1603e80546001600160a01b0319166001600160a01b0392909216919091179055565b6033546001600160a01b031633146114605760405163719f370360e11b815260040160405180910390fd5b604051635ac86ab760e01b8152600560048201819052907f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031690635ac86ab790602401602060405180830381865afa1580156114c6573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906114ea91906135d1565b156115085760405163840a48d560e01b815260040160405180910390fd5b825184511461152a576040516343714afd60e01b815260040160405180910390fd5b5f5b845181101561158d576115858385838151811061154b5761154b613673565b602002602001015187848151811061156557611565613673565b60200260200101516001600160a01b03166123c69092919063ffffffff16565b60010161152c565b5050505050565b604051635ac86ab760e01b8152600760048201819052907f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031690635ac86ab790602401602060405180830381865afa1580156115fa573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061161e91906135d1565b1561163c5760405163840a48d560e01b815260040160405180910390fd5b603a54600160401b90046001600160401b03165f81900361167057604051631a544f4960e01b815260040160405180910390fd5b6040805160a081018252603c54808252603d5462ffffff811660208401526001600160401b0363010000008204811694840194909452600160581b810460070b6060840152600160981b90049092166080820152906116cf9087612418565b5f805b8581101561193857368787838181106116ed576116ed613673565b90506020028101906116ff9190613832565b80355f908152603660209081526040808320815160808101835281546001600160401b038082168352600160401b8204811695830195909552600160801b8104909416928101929092529394509192906060830190600160c01b900460ff16600281111561176f5761176f61321c565b60028111156117805761178061321c565b905250905060018160600151600281111561179d5761179d61321c565b146117a9575050611930565b856001600160401b031681604001516001600160401b0316106117cd575050611930565b5f80806117dd848a8f35886124c9565b60208b01805193965091945092506117f482613850565b62ffffff1690525060808801805184919061181090839061386d565b6001600160401b031690525060608801805183919061183090839061388c565b60070b905250611840818861386d565b85355f908152603660209081526040918290208751815492890151938901516001600160401b03908116600160801b0267ffffffffffffffff60801b19958216600160401b026001600160801b0319909516919092161792909217928316821781556060880151939a50879390929091839160ff60c01b1990911668ffffffffffffffffff60801b1990911617600160c01b8360028111156118e4576118e461321c565b021790555050845160405164ffffffffff90911691506001600160401b038b16907fa91c59033c3423e18b54d0acecebb4972f9ea95aedf5f4cae3b677b02eaf3a3f905f90a350505050505b6001016116d2565b506001600160401b038084165f908152603b60205260408120805484939192916119649185911661386d565b92506101000a8154816001600160401b0302191690836001600160401b03160217905550610949826125ec565b5f815f815181106119a4576119a4613673565b60200260200101519050919050565b5f816003815181106119c7576119c7613673565b60200260200101515f5f1b14159050919050565b6119e7600360206136d2565b6119f46020830183613631565b905014611a14576040516313717da960e21b815260040160405180910390fd5b611a63611a246020830183613631565b8080601f0160208091040260200160405190810160405280939291908181526020018383808284375f920191909152508692505084359050600361281b565b610ee6576040516309bde33960e01b815260040160405180910390fd5b60088414611aa15760405163200591bd60e01b815260040160405180910390fd5b6005611aaf602860016136bf565b611ab991906136bf565b611ac49060206136d2565b8214611ae3576040516313717da960e21b815260040160405180910390fd5b5f611b1f8686808060200260200160405190810160405280939291908181526020018383602002808284375f9201919091525061283292505050565b90505f64ffffffffff8316611b36602860016136bf565b600b901b179050611b8085858080601f0160208091040260200160405190810160405280939291908181526020018383808284375f920191909152508c925086915085905061281b565b611b9d576040516309bde33960e01b815260040160405180910390fd5b5050505050505050565b603a54600160401b90046001600160401b031615611bd75760405162be9bc360e81b815260040160405180910390fd5b603a546001600160401b03428116911603611c05576040516367db5b8b60e01b815260040160405180910390fd5b6034545f906001600160401b0316611c21633b9aca0047613800565b611c2b9190613813565b9050818015611c4157506001600160401b038116155b15611c5f576040516332dea95960e21b815260040160405180910390fd5b5f6040518060a00160405280611c7442610c3c565b815260395462ffffff1660208201526001600160401b0380851660408301525f60608301819052608090920191909152603a805442909216600160401b026fffffffffffffffff0000000000000000199092169190911790559050611cd8816125ec565b805160208083015160405162ffffff90911681526001600160401b034216917f575796133bbed337e5b39aa49a30dc2556a91e0c6c2af4b7b886ae77ebef1076910160405180910390a3505050565b5f5f611d648484808060200260200160405190810160405280939291908181526020018383602002808284375f9201919091525061199192505050565b5f818152603660209081526040808320815160808101835281546001600160401b038082168352600160401b8204811695830195909552600160801b8104909416928101929092529394509192906060830190600160c01b900460ff166002811115611dd257611dd261321c565b6002811115611de357611de361321c565b90525090505f81606001516002811115611dff57611dff61321c565b14611e1d576040516335e09e9d60e01b815260040160405180910390fd5b6001600160401b038016611e628686808060200260200160405190810160405280939291908181526020018383602002808284375f92019190915250612ac292505050565b6001600160401b031603611e8957604051631958236d60e21b815260040160405180910390fd5b6001600160401b038016611ece8686808060200260200160405190810160405280939291908181526020018383602002808284375f92019190915250612ae692505050565b6001600160401b031614611ef557604051632eade63760e01b815260040160405180910390fd5b611efd61226d565b611f06906138bb565b611f418686808060200260200160405190810160405280939291908181526020018383602002808284375f92019190915250612afd92505050565b14611f5f57604051633772dd5360e11b815260040160405180910390fd5b5f611f9b8686808060200260200160405190810160405280939291908181526020018383602002808284375f92019190915250612b1192505050565b9050611fab8a87878b8b8e611a80565b60398054905f611fba836138de565b9091555050603a545f90600160401b90046001600160401b031615611ff157603a54600160401b90046001600160401b0316611ffe565b603a546001600160401b03165b6040805160808101825264ffffffffff8d1681526001600160401b03858116602083015283169181019190915290915060608101600190525f858152603660209081526040918290208351815492850151938501516001600160401b03908116600160801b0267ffffffffffffffff60801b19958216600160401b026001600160801b031990951691909216179290921792831682178155606084015190929091839160ff60c01b1990911668ffffffffffffffffff60801b1990911617600160c01b8360028111156120d3576120d361321c565b021790555050603d80548492506013906120fe908490600160981b90046001600160401b031661386d565b92506101000a8154816001600160401b0302191690836001600160401b031602179055507f2d0800bbc377ea54a08c5db6a87aafff5e3e9c8fead0eda110e40e0c104414498a60405161215e919064ffffffffff91909116815260200190565b60405180910390a16040805164ffffffffff8c1681526001600160401b03838116602083015284168183015290517f0e5fac175b83177cc047381e030d8fb3b42b37bd1c025e22c280facad62c32df9181900360600190a16121cd633b9aca006001600160401b0384166136d2565b9b9a5050505050505050505050565b5f81516030146121ff57604051634f88323960e11b815260040160405180910390fd5b6040516002906122159084905f906020016138f6565b60408051601f198184030181529082905261222f91613713565b602060405180830381855afa15801561224a573d5f5f3e3d5ffd5b5050506040513d601f19601f82011682018060405250810190610c36919061371e565b60408051600160f81b60208201525f602182015230606090811b6bffffffffffffffffffffffff1916602c8301529101604051602081830303815290604052905090565b804710156123015760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a20696e73756666696369656e742062616c616e636500000060448201526064016112ed565b5f826001600160a01b0316826040515f6040518083038185875af1925050503d805f811461234a576040519150601f19603f3d011682016040523d82523d5f602084013e61234f565b606091505b50509050806112525760405162461bcd60e51b815260206004820152603a60248201527f416464726573733a20756e61626c6520746f2073656e642076616c75652c207260448201527f6563697069656e74206d6179206861766520726576657274656400000000000060648201526084016112ed565b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180516001600160e01b031663a9059cbb60e01b179052611252908490612b28565b612424600560036136bf565b61242f9060206136d2565b61243c6020830183613631565b90501461245c576040516313717da960e21b815260040160405180910390fd5b606c6124ac61246e6020840184613631565b8080601f0160208091040260200160405190810160405280939291908181526020018383808284375f9201919091525087925050853590508461281b565b611252576040516309bde33960e01b815260040160405180910390fd5b83516020850151905f908190816124e1878388612bfb565b9050846001600160401b0316816001600160401b03161461255b57612506858261391a565b6040805164ffffffffff851681526001600160401b038b8116602083015284168183015290519195507f0e5fac175b83177cc047381e030d8fb3b42b37bd1c025e22c280facad62c32df919081900360600190a15b6001600160401b0380821660208b0181905290891660408b01525f036125e05760398054905f61258a83613949565b9091555050600260608a015261259f8461395e565b92508164ffffffffff16886001600160401b03167f2a02361ffa66cf2c2da4682c2355a6adcaa9f6c227b6e6563e68480f9587626a60405160405180910390a35b50509450945094915050565b602081015162ffffff161561268c578051603c556020810151603d80546040840151606085015160809095015162ffffff9094166affffffffffffffffffffff199092169190911763010000006001600160401b0392831602176fffffffffffffffffffffffffffffffff60581b1916600160581b9482169490940267ffffffffffffffff60981b191693909317600160981b9390921692909202179055565b60808101516034545f916126a8916001600160401b031661386d565b90505f826060015183604001516126bf919061388c565b60408401516034805492935090915f906126e39084906001600160401b031661386d565b82546101009290920a6001600160401b03818102199093169183160217909155603a8054600160401b810483166001600160801b03199091161790555f915061273390633b9aca009085166136d2565b90505f612748633b9aca00600785900b613983565b603a546040518281529192506001600160401b0316907f525408c201bc1576eb44116f6478f1c2a54775b19a043bcfdc708364f74f8e449060200160405180910390a260335460405163a1ca780b60e01b81526001600160a01b03918216600482015260248101849052604481018390527f00000000000000000000000000000000000000000000000000000000000000009091169063a1ca780b906064015f604051808303815f87803b1580156127fe575f5ffd5b505af1158015612810573d5f5f3e3d5ffd5b505050505050505050565b5f83612828868585612cd9565b1495945050505050565b5f5f600283516128429190613800565b90505f816001600160401b0381111561285d5761285d6133c8565b604051908082528060200260200182016040528015612886578160200160208202803683370190505b5090505f5b82811015612980576002856128a083836136d2565b815181106128b0576128b0613673565b6020026020010151868360026128c691906136d2565b6128d19060016136bf565b815181106128e1576128e1613673565b6020026020010151604051602001612903929190918252602082015260400190565b60408051601f198184030181529082905261291d91613713565b602060405180830381855afa158015612938573d5f5f3e3d5ffd5b5050506040513d601f19601f8201168201806040525081019061295b919061371e565b82828151811061296d5761296d613673565b602090810291909101015260010161288b565b5061298c600283613800565b91505b8115612a9f575f5b82811015612a8c576002826129ac83836136d2565b815181106129bc576129bc613673565b6020026020010151838360026129d291906136d2565b6129dd9060016136bf565b815181106129ed576129ed613673565b6020026020010151604051602001612a0f929190918252602082015260400190565b60408051601f1981840301815290829052612a2991613713565b602060405180830381855afa158015612a44573d5f5f3e3d5ffd5b5050506040513d601f19601f82011682018060405250810190612a67919061371e565b828281518110612a7957612a79613673565b6020908102919091010152600101612997565b50612a98600283613800565b915061298f565b805f81518110612ab157612ab1613673565b602002602001015192505050919050565b5f610c3682600581518110612ad957612ad9613673565b6020026020010151612dad565b5f610c3682600681518110612ad957612ad9613673565b5f816001815181106119a4576119a4613673565b5f610c3682600281518110612ad957612ad9613673565b5f612b7c826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b0316612e149092919063ffffffff16565b905080515f1480612b9c575080806020019051810190612b9c91906135d1565b6112525760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6044820152691bdd081cdd58d8d9595960b21b60648201526084016112ed565b5f612c08602660016136bf565b612c139060206136d2565b612c206040840184613631565b905014612c40576040516313717da960e21b815260040160405180910390fd5b5f612c4c6004856139b2565b64ffffffffff169050612ca5612c656040850185613631565b8080601f0160208091040260200160405190810160405280939291908181526020018383808284375f92019190915250899250505060208601358461281b565b612cc2576040516309bde33960e01b815260040160405180910390fd5b612cd0836020013585612e22565b95945050505050565b5f83515f14158015612cf6575060208451612cf491906139db565b155b612d13576040516313717da960e21b815260040160405180910390fd5b604080516020808201909252848152905b85518111612da357612d376002856139db565b5f03612d695781515f528086015160205260208260405f60026107d05a03fa612d5e575f5ffd5b600284049350612d91565b808601515f52815160205260208260405f60026107d05a03fa612d8a575f5ffd5b6002840493505b612d9c6020826136bf565b9050612d24565b5051949350505050565b60f881901c60e882901c61ff00161760d882901c62ff0000161760c882901c63ff000000161764ff0000000060b883901c161765ff000000000060a883901c161766ff000000000000609883901c161767ff0000000000000060889290921c919091161790565b6060610d4284845f85612e4e565b5f80612e2f6004846139ee565b612e3a906040613a17565b64ffffffffff169050610d4284821b612dad565b606082471015612eaf5760405162461bcd60e51b815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f6044820152651c8818d85b1b60d21b60648201526084016112ed565b5f5f866001600160a01b03168587604051612eca9190613713565b5f6040518083038185875af1925050503d805f8114612f04576040519150601f19603f3d011682016040523d82523d5f602084013e612f09565b606091505b5091509150612f1a87838387612f25565b979650505050505050565b60608315612f935782515f03612f8c576001600160a01b0385163b612f8c5760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e747261637400000060448201526064016112ed565b5081610d42565b610d428383815115612fa85781518083602001fd5b8060405162461bcd60e51b81526004016112ed9190613a37565b80356001600160401b0381168114612fd8575f5ffd5b919050565b5f60408284031215612fed575f5ffd5b50919050565b5f5f5f60608486031215613005575f5ffd5b61300e84612fc2565b925060208401356001600160401b03811115613028575f5ffd5b61303486828701612fdd565b92505060408401356001600160401b0381111561304f575f5ffd5b61305b86828701612fdd565b9150509250925092565b5f5f83601f840112613075575f5ffd5b5081356001600160401b0381111561308b575f5ffd5b6020830191508360208260051b85010111156130a5575f5ffd5b9250929050565b5f5f5f5f5f5f5f5f60a0898b0312156130c3575f5ffd5b6130cc89612fc2565b975060208901356001600160401b038111156130e6575f5ffd5b6130f28b828c01612fdd565b97505060408901356001600160401b0381111561310d575f5ffd5b6131198b828c01613065565b90975095505060608901356001600160401b03811115613137575f5ffd5b6131438b828c01613065565b90955093505060808901356001600160401b03811115613161575f5ffd5b61316d8b828c01613065565b999c989b5096995094979396929594505050565b5f60208284031215613191575f5ffd5b61319a82612fc2565b9392505050565b5f5f83601f8401126131b1575f5ffd5b5081356001600160401b038111156131c7575f5ffd5b6020830191508360208285010111156130a5575f5ffd5b5f5f602083850312156131ef575f5ffd5b82356001600160401b03811115613204575f5ffd5b613210858286016131a1565b90969095509350505050565b634e487b7160e01b5f52602160045260245ffd5b6003811061324c57634e487b7160e01b5f52602160045260245ffd5b9052565b60208101610c368284613230565b5f6020828403121561326e575f5ffd5b5035919050565b5f6080820190506001600160401b0383511682526001600160401b0360208401511660208301526001600160401b03604084015116604083015260608301516132c16060840182613230565b5092915050565b80151581146132d5575f5ffd5b50565b5f602082840312156132e8575f5ffd5b813561319a816132c8565b5f5f5f5f5f60608688031215613307575f5ffd5b85356001600160401b0381111561331c575f5ffd5b613328888289016131a1565b90965094505060208601356001600160401b03811115613346575f5ffd5b613352888289016131a1565b96999598509660400135949350505050565b6001600160a01b03811681146132d5575f5ffd5b8035612fd881613364565b5f5f60408385031215613394575f5ffd5b823561339f81613364565b946020939093013593505050565b5f602082840312156133bd575f5ffd5b813561319a81613364565b634e487b7160e01b5f52604160045260245ffd5b604051601f8201601f191681016001600160401b0381118282101715613404576134046133c8565b604052919050565b5f6001600160401b03821115613424576134246133c8565b5060051b60200190565b5f82601f83011261343d575f5ffd5b813561345061344b8261340c565b6133dc565b8082825260208201915060208360051b860101925085831115613471575f5ffd5b602085015b8381101561348e578035835260209283019201613476565b5095945050505050565b5f5f5f606084860312156134aa575f5ffd5b83356001600160401b038111156134bf575f5ffd5b8401601f810186136134cf575f5ffd5b80356134dd61344b8261340c565b8082825260208201915060208360051b8501019250888311156134fe575f5ffd5b6020840193505b8284101561352957833561351881613364565b825260209384019390910190613505565b955050505060208401356001600160401b03811115613546575f5ffd5b6135528682870161342e565b92505061356160408501613378565b90509250925092565b5f5f5f6040848603121561357c575f5ffd5b83356001600160401b03811115613591575f5ffd5b61359d86828701612fdd565b93505060208401356001600160401b038111156135b8575f5ffd5b6135c486828701613065565b9497909650939450505050565b5f602082840312156135e1575f5ffd5b815161319a816132c8565b5f5f8335601e19843603018112613601575f5ffd5b8301803591506001600160401b0382111561361a575f5ffd5b6020019150600581901b36038213156130a5575f5ffd5b5f5f8335601e19843603018112613646575f5ffd5b8301803591506001600160401b0382111561365f575f5ffd5b6020019150368190038213156130a5575f5ffd5b634e487b7160e01b5f52603260045260245ffd5b5f60208284031215613697575f5ffd5b813564ffffffffff8116811461319a575f5ffd5b634e487b7160e01b5f52601160045260245ffd5b80820180821115610c3657610c366136ab565b8082028115828204841417610c3657610c366136ab565b81810381811115610c3657610c366136ab565b5f81518060208401855e5f93019283525090919050565b5f61319a82846136fc565b5f6020828403121561372e575f5ffd5b5051919050565b81835281816020850137505f828201602090810191909152601f909101601f19169091010190565b5f81518084528060208401602086015e5f602082860101526020601f19601f83011685010191505092915050565b608081525f61379e60808301888a613735565b82810360208401526137b0818861375d565b905082810360408401526137c5818688613735565b915050826060830152979650505050505050565b602081525f610d42602083018486613735565b634e487b7160e01b5f52601260045260245ffd5b5f8261380e5761380e6137ec565b500490565b6001600160401b038281168282160390811115610c3657610c366136ab565b5f8235605e19833603018112613846575f5ffd5b9190910192915050565b5f62ffffff821680613864576138646136ab565b5f190192915050565b6001600160401b038181168382160190811115610c3657610c366136ab565b600781810b9083900b01677fffffffffffffff8113677fffffffffffffff1982121715610c3657610c366136ab565b80516020808301519190811015612fed575f1960209190910360031b1b16919050565b5f600182016138ef576138ef6136ab565b5060010190565b5f61390182856136fc565b6001600160801b03199390931683525050601001919050565b600782810b9082900b03677fffffffffffffff198112677fffffffffffffff82131715610c3657610c366136ab565b5f81613957576139576136ab565b505f190190565b5f8160070b677fffffffffffffff19810361397b5761397b6136ab565b5f0392915050565b8082025f8212600160ff1b8414161561399e5761399e6136ab565b8181058314821517610c3657610c366136ab565b5f64ffffffffff8316806139c8576139c86137ec565b8064ffffffffff84160491505092915050565b5f826139e9576139e96137ec565b500690565b5f64ffffffffff831680613a0457613a046137ec565b8064ffffffffff84160691505092915050565b64ffffffffff81811683821602908116908181146132c1576132c16136ab565b602081525f61319a602083018461375d56fea2646970667358221220b0eaf8d41aaf00a3ebab3f4140a4ab05e7c299032448e83819d997d107d3974364736f6c634300081b0033", } // EigenPodABI is the input ABI used to generate the binding from. diff --git a/pkg/bindings/EigenPodManager/binding.go b/pkg/bindings/EigenPodManager/binding.go index 2fb328a3f8..63c5fafe19 100644 --- a/pkg/bindings/EigenPodManager/binding.go +++ b/pkg/bindings/EigenPodManager/binding.go @@ -31,8 +31,8 @@ var ( // EigenPodManagerMetaData contains all meta data concerning the EigenPodManager contract. var EigenPodManagerMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_ethPOS\",\"type\":\"address\",\"internalType\":\"contractIETHPOSDeposit\"},{\"name\":\"_eigenPodBeacon\",\"type\":\"address\",\"internalType\":\"contractIBeacon\"},{\"name\":\"_delegationManager\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"},{\"name\":\"_pauserRegistry\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"addShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"beaconChainETHStrategy\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"beaconChainSlashingFactor\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"createPod\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegationManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"eigenPodBeacon\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIBeacon\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"ethPOS\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIETHPOSDeposit\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getPod\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEigenPod\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"hasPod\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_initPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"numPods\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"ownerToPod\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEigenPod\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"pauseAll\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[{\"name\":\"index\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pauserRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"podOwnerDepositShares\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"shares\",\"type\":\"int256\",\"internalType\":\"int256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"recordBeaconChainETHBalanceUpdate\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"prevRestakedBalanceWei\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"balanceDeltaWei\",\"type\":\"int256\",\"internalType\":\"int256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"removeDepositShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"depositSharesToRemove\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"stake\",\"inputs\":[{\"name\":\"pubkey\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"depositDataRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"stakerDepositShares\",\"inputs\":[{\"name\":\"user\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"depositShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"withdrawSharesAsTokens\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"BeaconChainETHDeposited\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"BeaconChainETHWithdrawalCompleted\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"nonce\",\"type\":\"uint96\",\"indexed\":false,\"internalType\":\"uint96\"},{\"name\":\"delegatedAddress\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"BeaconChainSlashingFactorDecreased\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"prevBeaconChainSlashingFactor\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"},{\"name\":\"newBeaconChainSlashingFactor\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"NewTotalShares\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newTotalShares\",\"type\":\"int256\",\"indexed\":false,\"internalType\":\"int256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"PodDeployed\",\"inputs\":[{\"name\":\"eigenPod\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"PodSharesUpdated\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"sharesDelta\",\"type\":\"int256\",\"indexed\":false,\"internalType\":\"int256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"CurrentlyPaused\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"EigenPodAlreadyExists\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidNewPausedStatus\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidStrategy\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"LegacyWithdrawalsNotCompleted\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyDelegationManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyEigenPod\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyPauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyUnpauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SharesNegative\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SharesNotMultipleOfGwei\",\"inputs\":[]}]", - Bin: "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", + ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_ethPOS\",\"type\":\"address\",\"internalType\":\"contractIETHPOSDeposit\"},{\"name\":\"_eigenPodBeacon\",\"type\":\"address\",\"internalType\":\"contractIBeacon\"},{\"name\":\"_delegationManager\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"},{\"name\":\"_pauserRegistry\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"addShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"beaconChainETHStrategy\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"beaconChainSlashingFactor\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"burnableETHShares\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"createPod\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegationManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"eigenPodBeacon\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIBeacon\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"ethPOS\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIETHPOSDeposit\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getPod\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEigenPod\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"hasPod\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"increaseBurnableShares\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"addedSharesToBurn\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_initPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"numPods\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"ownerToPod\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEigenPod\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"pauseAll\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[{\"name\":\"index\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pauserRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"podOwnerDepositShares\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"shares\",\"type\":\"int256\",\"internalType\":\"int256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"recordBeaconChainETHBalanceUpdate\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"prevRestakedBalanceWei\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"balanceDeltaWei\",\"type\":\"int256\",\"internalType\":\"int256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"removeDepositShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"depositSharesToRemove\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"stake\",\"inputs\":[{\"name\":\"pubkey\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"depositDataRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"stakerDepositShares\",\"inputs\":[{\"name\":\"user\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"depositShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"withdrawSharesAsTokens\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"BeaconChainETHDeposited\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"BeaconChainETHWithdrawalCompleted\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"nonce\",\"type\":\"uint96\",\"indexed\":false,\"internalType\":\"uint96\"},{\"name\":\"delegatedAddress\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"BeaconChainSlashingFactorDecreased\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"prevBeaconChainSlashingFactor\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"},{\"name\":\"newBeaconChainSlashingFactor\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"BurnableETHSharesIncreased\",\"inputs\":[{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"NewTotalShares\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newTotalShares\",\"type\":\"int256\",\"indexed\":false,\"internalType\":\"int256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"PodDeployed\",\"inputs\":[{\"name\":\"eigenPod\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"PodSharesUpdated\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"sharesDelta\",\"type\":\"int256\",\"indexed\":false,\"internalType\":\"int256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"CurrentlyPaused\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"EigenPodAlreadyExists\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidNewPausedStatus\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidStrategy\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"LegacyWithdrawalsNotCompleted\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyDelegationManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyEigenPod\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyPauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyUnpauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SharesNegative\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SharesNotMultipleOfGwei\",\"inputs\":[]}]", + Bin: "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", } // EigenPodManagerABI is the input ABI used to generate the binding from. @@ -264,6 +264,37 @@ func (_EigenPodManager *EigenPodManagerCallerSession) BeaconChainSlashingFactor( return _EigenPodManager.Contract.BeaconChainSlashingFactor(&_EigenPodManager.CallOpts, podOwner) } +// BurnableETHShares is a free data retrieval call binding the contract method 0xf5d4fed3. +// +// Solidity: function burnableETHShares() view returns(uint256) +func (_EigenPodManager *EigenPodManagerCaller) BurnableETHShares(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _EigenPodManager.contract.Call(opts, &out, "burnableETHShares") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// BurnableETHShares is a free data retrieval call binding the contract method 0xf5d4fed3. +// +// Solidity: function burnableETHShares() view returns(uint256) +func (_EigenPodManager *EigenPodManagerSession) BurnableETHShares() (*big.Int, error) { + return _EigenPodManager.Contract.BurnableETHShares(&_EigenPodManager.CallOpts) +} + +// BurnableETHShares is a free data retrieval call binding the contract method 0xf5d4fed3. +// +// Solidity: function burnableETHShares() view returns(uint256) +func (_EigenPodManager *EigenPodManagerCallerSession) BurnableETHShares() (*big.Int, error) { + return _EigenPodManager.Contract.BurnableETHShares(&_EigenPodManager.CallOpts) +} + // DelegationManager is a free data retrieval call binding the contract method 0xea4d3c9b. // // Solidity: function delegationManager() view returns(address) @@ -667,25 +698,25 @@ func (_EigenPodManager *EigenPodManagerCallerSession) StakerDepositShares(user c return _EigenPodManager.Contract.StakerDepositShares(&_EigenPodManager.CallOpts, user, strategy) } -// AddShares is a paid mutator transaction binding the contract method 0xc4623ea1. +// AddShares is a paid mutator transaction binding the contract method 0x50ff7225. // -// Solidity: function addShares(address staker, address strategy, address , uint256 shares) returns(uint256, uint256) -func (_EigenPodManager *EigenPodManagerTransactor) AddShares(opts *bind.TransactOpts, staker common.Address, strategy common.Address, arg2 common.Address, shares *big.Int) (*types.Transaction, error) { - return _EigenPodManager.contract.Transact(opts, "addShares", staker, strategy, arg2, shares) +// Solidity: function addShares(address staker, address strategy, uint256 shares) returns(uint256, uint256) +func (_EigenPodManager *EigenPodManagerTransactor) AddShares(opts *bind.TransactOpts, staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { + return _EigenPodManager.contract.Transact(opts, "addShares", staker, strategy, shares) } -// AddShares is a paid mutator transaction binding the contract method 0xc4623ea1. +// AddShares is a paid mutator transaction binding the contract method 0x50ff7225. // -// Solidity: function addShares(address staker, address strategy, address , uint256 shares) returns(uint256, uint256) -func (_EigenPodManager *EigenPodManagerSession) AddShares(staker common.Address, strategy common.Address, arg2 common.Address, shares *big.Int) (*types.Transaction, error) { - return _EigenPodManager.Contract.AddShares(&_EigenPodManager.TransactOpts, staker, strategy, arg2, shares) +// Solidity: function addShares(address staker, address strategy, uint256 shares) returns(uint256, uint256) +func (_EigenPodManager *EigenPodManagerSession) AddShares(staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { + return _EigenPodManager.Contract.AddShares(&_EigenPodManager.TransactOpts, staker, strategy, shares) } -// AddShares is a paid mutator transaction binding the contract method 0xc4623ea1. +// AddShares is a paid mutator transaction binding the contract method 0x50ff7225. // -// Solidity: function addShares(address staker, address strategy, address , uint256 shares) returns(uint256, uint256) -func (_EigenPodManager *EigenPodManagerTransactorSession) AddShares(staker common.Address, strategy common.Address, arg2 common.Address, shares *big.Int) (*types.Transaction, error) { - return _EigenPodManager.Contract.AddShares(&_EigenPodManager.TransactOpts, staker, strategy, arg2, shares) +// Solidity: function addShares(address staker, address strategy, uint256 shares) returns(uint256, uint256) +func (_EigenPodManager *EigenPodManagerTransactorSession) AddShares(staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { + return _EigenPodManager.Contract.AddShares(&_EigenPodManager.TransactOpts, staker, strategy, shares) } // CreatePod is a paid mutator transaction binding the contract method 0x84d81062. @@ -709,6 +740,27 @@ func (_EigenPodManager *EigenPodManagerTransactorSession) CreatePod() (*types.Tr return _EigenPodManager.Contract.CreatePod(&_EigenPodManager.TransactOpts) } +// IncreaseBurnableShares is a paid mutator transaction binding the contract method 0xdebe1eab. +// +// Solidity: function increaseBurnableShares(address , uint256 addedSharesToBurn) returns() +func (_EigenPodManager *EigenPodManagerTransactor) IncreaseBurnableShares(opts *bind.TransactOpts, arg0 common.Address, addedSharesToBurn *big.Int) (*types.Transaction, error) { + return _EigenPodManager.contract.Transact(opts, "increaseBurnableShares", arg0, addedSharesToBurn) +} + +// IncreaseBurnableShares is a paid mutator transaction binding the contract method 0xdebe1eab. +// +// Solidity: function increaseBurnableShares(address , uint256 addedSharesToBurn) returns() +func (_EigenPodManager *EigenPodManagerSession) IncreaseBurnableShares(arg0 common.Address, addedSharesToBurn *big.Int) (*types.Transaction, error) { + return _EigenPodManager.Contract.IncreaseBurnableShares(&_EigenPodManager.TransactOpts, arg0, addedSharesToBurn) +} + +// IncreaseBurnableShares is a paid mutator transaction binding the contract method 0xdebe1eab. +// +// Solidity: function increaseBurnableShares(address , uint256 addedSharesToBurn) returns() +func (_EigenPodManager *EigenPodManagerTransactorSession) IncreaseBurnableShares(arg0 common.Address, addedSharesToBurn *big.Int) (*types.Transaction, error) { + return _EigenPodManager.Contract.IncreaseBurnableShares(&_EigenPodManager.TransactOpts, arg0, addedSharesToBurn) +} + // Initialize is a paid mutator transaction binding the contract method 0xcd6dc687. // // Solidity: function initialize(address initialOwner, uint256 _initPausedStatus) returns() @@ -1349,6 +1401,140 @@ func (_EigenPodManager *EigenPodManagerFilterer) ParseBeaconChainSlashingFactorD return event, nil } +// EigenPodManagerBurnableETHSharesIncreasedIterator is returned from FilterBurnableETHSharesIncreased and is used to iterate over the raw logs and unpacked data for BurnableETHSharesIncreased events raised by the EigenPodManager contract. +type EigenPodManagerBurnableETHSharesIncreasedIterator struct { + Event *EigenPodManagerBurnableETHSharesIncreased // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *EigenPodManagerBurnableETHSharesIncreasedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(EigenPodManagerBurnableETHSharesIncreased) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(EigenPodManagerBurnableETHSharesIncreased) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *EigenPodManagerBurnableETHSharesIncreasedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *EigenPodManagerBurnableETHSharesIncreasedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// EigenPodManagerBurnableETHSharesIncreased represents a BurnableETHSharesIncreased event raised by the EigenPodManager contract. +type EigenPodManagerBurnableETHSharesIncreased struct { + Shares *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterBurnableETHSharesIncreased is a free log retrieval operation binding the contract event 0x1ed04b7fd262c0d9e50fa02957f32a81a151f03baaa367faeedc7521b001c4a4. +// +// Solidity: event BurnableETHSharesIncreased(uint256 shares) +func (_EigenPodManager *EigenPodManagerFilterer) FilterBurnableETHSharesIncreased(opts *bind.FilterOpts) (*EigenPodManagerBurnableETHSharesIncreasedIterator, error) { + + logs, sub, err := _EigenPodManager.contract.FilterLogs(opts, "BurnableETHSharesIncreased") + if err != nil { + return nil, err + } + return &EigenPodManagerBurnableETHSharesIncreasedIterator{contract: _EigenPodManager.contract, event: "BurnableETHSharesIncreased", logs: logs, sub: sub}, nil +} + +// WatchBurnableETHSharesIncreased is a free log subscription operation binding the contract event 0x1ed04b7fd262c0d9e50fa02957f32a81a151f03baaa367faeedc7521b001c4a4. +// +// Solidity: event BurnableETHSharesIncreased(uint256 shares) +func (_EigenPodManager *EigenPodManagerFilterer) WatchBurnableETHSharesIncreased(opts *bind.WatchOpts, sink chan<- *EigenPodManagerBurnableETHSharesIncreased) (event.Subscription, error) { + + logs, sub, err := _EigenPodManager.contract.WatchLogs(opts, "BurnableETHSharesIncreased") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(EigenPodManagerBurnableETHSharesIncreased) + if err := _EigenPodManager.contract.UnpackLog(event, "BurnableETHSharesIncreased", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseBurnableETHSharesIncreased is a log parse operation binding the contract event 0x1ed04b7fd262c0d9e50fa02957f32a81a151f03baaa367faeedc7521b001c4a4. +// +// Solidity: event BurnableETHSharesIncreased(uint256 shares) +func (_EigenPodManager *EigenPodManagerFilterer) ParseBurnableETHSharesIncreased(log types.Log) (*EigenPodManagerBurnableETHSharesIncreased, error) { + event := new(EigenPodManagerBurnableETHSharesIncreased) + if err := _EigenPodManager.contract.UnpackLog(event, "BurnableETHSharesIncreased", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + // EigenPodManagerInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the EigenPodManager contract. type EigenPodManagerInitializedIterator struct { Event *EigenPodManagerInitialized // Event containing the contract specifics and raw log diff --git a/pkg/bindings/EigenPodManagerStorage/binding.go b/pkg/bindings/EigenPodManagerStorage/binding.go index c64bb1c1bd..d72f1145d2 100644 --- a/pkg/bindings/EigenPodManagerStorage/binding.go +++ b/pkg/bindings/EigenPodManagerStorage/binding.go @@ -31,7 +31,7 @@ var ( // EigenPodManagerStorageMetaData contains all meta data concerning the EigenPodManagerStorage contract. var EigenPodManagerStorageMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"function\",\"name\":\"addShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"beaconChainETHStrategy\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"beaconChainSlashingFactor\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"createPod\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegationManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"eigenPodBeacon\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIBeacon\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"ethPOS\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIETHPOSDeposit\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getPod\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEigenPod\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"hasPod\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"numPods\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"ownerToPod\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEigenPod\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"pauseAll\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[{\"name\":\"index\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pauserRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"podOwnerDepositShares\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"shares\",\"type\":\"int256\",\"internalType\":\"int256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"recordBeaconChainETHBalanceUpdate\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"prevRestakedBalanceWei\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"balanceDeltaWei\",\"type\":\"int256\",\"internalType\":\"int256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"removeDepositShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"depositSharesToRemove\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"stake\",\"inputs\":[{\"name\":\"pubkey\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"depositDataRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"stakerDepositShares\",\"inputs\":[{\"name\":\"user\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"depositShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"withdrawSharesAsTokens\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"BeaconChainETHDeposited\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"BeaconChainETHWithdrawalCompleted\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"nonce\",\"type\":\"uint96\",\"indexed\":false,\"internalType\":\"uint96\"},{\"name\":\"delegatedAddress\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"BeaconChainSlashingFactorDecreased\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"prevBeaconChainSlashingFactor\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"},{\"name\":\"newBeaconChainSlashingFactor\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"NewTotalShares\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newTotalShares\",\"type\":\"int256\",\"indexed\":false,\"internalType\":\"int256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"PodDeployed\",\"inputs\":[{\"name\":\"eigenPod\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"PodSharesUpdated\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"sharesDelta\",\"type\":\"int256\",\"indexed\":false,\"internalType\":\"int256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"CurrentlyPaused\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"EigenPodAlreadyExists\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidNewPausedStatus\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidStrategy\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"LegacyWithdrawalsNotCompleted\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyDelegationManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyEigenPod\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyPauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyUnpauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SharesNegative\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SharesNotMultipleOfGwei\",\"inputs\":[]}]", + ABI: "[{\"type\":\"function\",\"name\":\"addShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"beaconChainETHStrategy\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"beaconChainSlashingFactor\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"burnableETHShares\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"createPod\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegationManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"eigenPodBeacon\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIBeacon\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"ethPOS\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIETHPOSDeposit\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getPod\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEigenPod\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"hasPod\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"increaseBurnableShares\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"addedSharesToBurn\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"numPods\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"ownerToPod\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEigenPod\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"pauseAll\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[{\"name\":\"index\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pauserRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"podOwnerDepositShares\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"shares\",\"type\":\"int256\",\"internalType\":\"int256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"recordBeaconChainETHBalanceUpdate\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"prevRestakedBalanceWei\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"balanceDeltaWei\",\"type\":\"int256\",\"internalType\":\"int256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"removeDepositShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"depositSharesToRemove\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"stake\",\"inputs\":[{\"name\":\"pubkey\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"depositDataRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"stakerDepositShares\",\"inputs\":[{\"name\":\"user\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"depositShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"withdrawSharesAsTokens\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"BeaconChainETHDeposited\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"BeaconChainETHWithdrawalCompleted\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"nonce\",\"type\":\"uint96\",\"indexed\":false,\"internalType\":\"uint96\"},{\"name\":\"delegatedAddress\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"BeaconChainSlashingFactorDecreased\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"prevBeaconChainSlashingFactor\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"},{\"name\":\"newBeaconChainSlashingFactor\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"BurnableETHSharesIncreased\",\"inputs\":[{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"NewTotalShares\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newTotalShares\",\"type\":\"int256\",\"indexed\":false,\"internalType\":\"int256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"PodDeployed\",\"inputs\":[{\"name\":\"eigenPod\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"PodSharesUpdated\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"sharesDelta\",\"type\":\"int256\",\"indexed\":false,\"internalType\":\"int256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"CurrentlyPaused\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"EigenPodAlreadyExists\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidNewPausedStatus\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidStrategy\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"LegacyWithdrawalsNotCompleted\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyDelegationManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyEigenPod\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyPauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyUnpauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SharesNegative\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SharesNotMultipleOfGwei\",\"inputs\":[]}]", } // EigenPodManagerStorageABI is the input ABI used to generate the binding from. @@ -242,6 +242,37 @@ func (_EigenPodManagerStorage *EigenPodManagerStorageCallerSession) BeaconChainS return _EigenPodManagerStorage.Contract.BeaconChainSlashingFactor(&_EigenPodManagerStorage.CallOpts, staker) } +// BurnableETHShares is a free data retrieval call binding the contract method 0xf5d4fed3. +// +// Solidity: function burnableETHShares() view returns(uint256) +func (_EigenPodManagerStorage *EigenPodManagerStorageCaller) BurnableETHShares(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _EigenPodManagerStorage.contract.Call(opts, &out, "burnableETHShares") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// BurnableETHShares is a free data retrieval call binding the contract method 0xf5d4fed3. +// +// Solidity: function burnableETHShares() view returns(uint256) +func (_EigenPodManagerStorage *EigenPodManagerStorageSession) BurnableETHShares() (*big.Int, error) { + return _EigenPodManagerStorage.Contract.BurnableETHShares(&_EigenPodManagerStorage.CallOpts) +} + +// BurnableETHShares is a free data retrieval call binding the contract method 0xf5d4fed3. +// +// Solidity: function burnableETHShares() view returns(uint256) +func (_EigenPodManagerStorage *EigenPodManagerStorageCallerSession) BurnableETHShares() (*big.Int, error) { + return _EigenPodManagerStorage.Contract.BurnableETHShares(&_EigenPodManagerStorage.CallOpts) +} + // DelegationManager is a free data retrieval call binding the contract method 0xea4d3c9b. // // Solidity: function delegationManager() view returns(address) @@ -614,25 +645,25 @@ func (_EigenPodManagerStorage *EigenPodManagerStorageCallerSession) StakerDeposi return _EigenPodManagerStorage.Contract.StakerDepositShares(&_EigenPodManagerStorage.CallOpts, user, strategy) } -// AddShares is a paid mutator transaction binding the contract method 0xc4623ea1. +// AddShares is a paid mutator transaction binding the contract method 0x50ff7225. // -// Solidity: function addShares(address staker, address strategy, address token, uint256 shares) returns(uint256, uint256) -func (_EigenPodManagerStorage *EigenPodManagerStorageTransactor) AddShares(opts *bind.TransactOpts, staker common.Address, strategy common.Address, token common.Address, shares *big.Int) (*types.Transaction, error) { - return _EigenPodManagerStorage.contract.Transact(opts, "addShares", staker, strategy, token, shares) +// Solidity: function addShares(address staker, address strategy, uint256 shares) returns(uint256, uint256) +func (_EigenPodManagerStorage *EigenPodManagerStorageTransactor) AddShares(opts *bind.TransactOpts, staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { + return _EigenPodManagerStorage.contract.Transact(opts, "addShares", staker, strategy, shares) } -// AddShares is a paid mutator transaction binding the contract method 0xc4623ea1. +// AddShares is a paid mutator transaction binding the contract method 0x50ff7225. // -// Solidity: function addShares(address staker, address strategy, address token, uint256 shares) returns(uint256, uint256) -func (_EigenPodManagerStorage *EigenPodManagerStorageSession) AddShares(staker common.Address, strategy common.Address, token common.Address, shares *big.Int) (*types.Transaction, error) { - return _EigenPodManagerStorage.Contract.AddShares(&_EigenPodManagerStorage.TransactOpts, staker, strategy, token, shares) +// Solidity: function addShares(address staker, address strategy, uint256 shares) returns(uint256, uint256) +func (_EigenPodManagerStorage *EigenPodManagerStorageSession) AddShares(staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { + return _EigenPodManagerStorage.Contract.AddShares(&_EigenPodManagerStorage.TransactOpts, staker, strategy, shares) } -// AddShares is a paid mutator transaction binding the contract method 0xc4623ea1. +// AddShares is a paid mutator transaction binding the contract method 0x50ff7225. // -// Solidity: function addShares(address staker, address strategy, address token, uint256 shares) returns(uint256, uint256) -func (_EigenPodManagerStorage *EigenPodManagerStorageTransactorSession) AddShares(staker common.Address, strategy common.Address, token common.Address, shares *big.Int) (*types.Transaction, error) { - return _EigenPodManagerStorage.Contract.AddShares(&_EigenPodManagerStorage.TransactOpts, staker, strategy, token, shares) +// Solidity: function addShares(address staker, address strategy, uint256 shares) returns(uint256, uint256) +func (_EigenPodManagerStorage *EigenPodManagerStorageTransactorSession) AddShares(staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { + return _EigenPodManagerStorage.Contract.AddShares(&_EigenPodManagerStorage.TransactOpts, staker, strategy, shares) } // CreatePod is a paid mutator transaction binding the contract method 0x84d81062. @@ -656,6 +687,27 @@ func (_EigenPodManagerStorage *EigenPodManagerStorageTransactorSession) CreatePo return _EigenPodManagerStorage.Contract.CreatePod(&_EigenPodManagerStorage.TransactOpts) } +// IncreaseBurnableShares is a paid mutator transaction binding the contract method 0xdebe1eab. +// +// Solidity: function increaseBurnableShares(address strategy, uint256 addedSharesToBurn) returns() +func (_EigenPodManagerStorage *EigenPodManagerStorageTransactor) IncreaseBurnableShares(opts *bind.TransactOpts, strategy common.Address, addedSharesToBurn *big.Int) (*types.Transaction, error) { + return _EigenPodManagerStorage.contract.Transact(opts, "increaseBurnableShares", strategy, addedSharesToBurn) +} + +// IncreaseBurnableShares is a paid mutator transaction binding the contract method 0xdebe1eab. +// +// Solidity: function increaseBurnableShares(address strategy, uint256 addedSharesToBurn) returns() +func (_EigenPodManagerStorage *EigenPodManagerStorageSession) IncreaseBurnableShares(strategy common.Address, addedSharesToBurn *big.Int) (*types.Transaction, error) { + return _EigenPodManagerStorage.Contract.IncreaseBurnableShares(&_EigenPodManagerStorage.TransactOpts, strategy, addedSharesToBurn) +} + +// IncreaseBurnableShares is a paid mutator transaction binding the contract method 0xdebe1eab. +// +// Solidity: function increaseBurnableShares(address strategy, uint256 addedSharesToBurn) returns() +func (_EigenPodManagerStorage *EigenPodManagerStorageTransactorSession) IncreaseBurnableShares(strategy common.Address, addedSharesToBurn *big.Int) (*types.Transaction, error) { + return _EigenPodManagerStorage.Contract.IncreaseBurnableShares(&_EigenPodManagerStorage.TransactOpts, strategy, addedSharesToBurn) +} + // Pause is a paid mutator transaction binding the contract method 0x136439dd. // // Solidity: function pause(uint256 newPausedStatus) returns() @@ -1233,6 +1285,140 @@ func (_EigenPodManagerStorage *EigenPodManagerStorageFilterer) ParseBeaconChainS return event, nil } +// EigenPodManagerStorageBurnableETHSharesIncreasedIterator is returned from FilterBurnableETHSharesIncreased and is used to iterate over the raw logs and unpacked data for BurnableETHSharesIncreased events raised by the EigenPodManagerStorage contract. +type EigenPodManagerStorageBurnableETHSharesIncreasedIterator struct { + Event *EigenPodManagerStorageBurnableETHSharesIncreased // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *EigenPodManagerStorageBurnableETHSharesIncreasedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(EigenPodManagerStorageBurnableETHSharesIncreased) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(EigenPodManagerStorageBurnableETHSharesIncreased) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *EigenPodManagerStorageBurnableETHSharesIncreasedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *EigenPodManagerStorageBurnableETHSharesIncreasedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// EigenPodManagerStorageBurnableETHSharesIncreased represents a BurnableETHSharesIncreased event raised by the EigenPodManagerStorage contract. +type EigenPodManagerStorageBurnableETHSharesIncreased struct { + Shares *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterBurnableETHSharesIncreased is a free log retrieval operation binding the contract event 0x1ed04b7fd262c0d9e50fa02957f32a81a151f03baaa367faeedc7521b001c4a4. +// +// Solidity: event BurnableETHSharesIncreased(uint256 shares) +func (_EigenPodManagerStorage *EigenPodManagerStorageFilterer) FilterBurnableETHSharesIncreased(opts *bind.FilterOpts) (*EigenPodManagerStorageBurnableETHSharesIncreasedIterator, error) { + + logs, sub, err := _EigenPodManagerStorage.contract.FilterLogs(opts, "BurnableETHSharesIncreased") + if err != nil { + return nil, err + } + return &EigenPodManagerStorageBurnableETHSharesIncreasedIterator{contract: _EigenPodManagerStorage.contract, event: "BurnableETHSharesIncreased", logs: logs, sub: sub}, nil +} + +// WatchBurnableETHSharesIncreased is a free log subscription operation binding the contract event 0x1ed04b7fd262c0d9e50fa02957f32a81a151f03baaa367faeedc7521b001c4a4. +// +// Solidity: event BurnableETHSharesIncreased(uint256 shares) +func (_EigenPodManagerStorage *EigenPodManagerStorageFilterer) WatchBurnableETHSharesIncreased(opts *bind.WatchOpts, sink chan<- *EigenPodManagerStorageBurnableETHSharesIncreased) (event.Subscription, error) { + + logs, sub, err := _EigenPodManagerStorage.contract.WatchLogs(opts, "BurnableETHSharesIncreased") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(EigenPodManagerStorageBurnableETHSharesIncreased) + if err := _EigenPodManagerStorage.contract.UnpackLog(event, "BurnableETHSharesIncreased", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseBurnableETHSharesIncreased is a log parse operation binding the contract event 0x1ed04b7fd262c0d9e50fa02957f32a81a151f03baaa367faeedc7521b001c4a4. +// +// Solidity: event BurnableETHSharesIncreased(uint256 shares) +func (_EigenPodManagerStorage *EigenPodManagerStorageFilterer) ParseBurnableETHSharesIncreased(log types.Log) (*EigenPodManagerStorageBurnableETHSharesIncreased, error) { + event := new(EigenPodManagerStorageBurnableETHSharesIncreased) + if err := _EigenPodManagerStorage.contract.UnpackLog(event, "BurnableETHSharesIncreased", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + // EigenPodManagerStorageNewTotalSharesIterator is returned from FilterNewTotalShares and is used to iterate over the raw logs and unpacked data for NewTotalShares events raised by the EigenPodManagerStorage contract. type EigenPodManagerStorageNewTotalSharesIterator struct { Event *EigenPodManagerStorageNewTotalShares // Event containing the contract specifics and raw log diff --git a/pkg/bindings/EigenStrategy/binding.go b/pkg/bindings/EigenStrategy/binding.go index 4a368b131f..efedf07cce 100644 --- a/pkg/bindings/EigenStrategy/binding.go +++ b/pkg/bindings/EigenStrategy/binding.go @@ -32,7 +32,7 @@ var ( // EigenStrategyMetaData contains all meta data concerning the EigenStrategy contract. var EigenStrategyMetaData = &bind.MetaData{ ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_strategyManager\",\"type\":\"address\",\"internalType\":\"contractIStrategyManager\"},{\"name\":\"_pauserRegistry\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"EIGEN\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEigen\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"deposit\",\"inputs\":[{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"newShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"explanation\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"_EIGEN\",\"type\":\"address\",\"internalType\":\"contractIEigen\"},{\"name\":\"_bEIGEN\",\"type\":\"address\",\"internalType\":\"contractIERC20\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"_underlyingToken\",\"type\":\"address\",\"internalType\":\"contractIERC20\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"pauseAll\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[{\"name\":\"index\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pauserRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"shares\",\"inputs\":[{\"name\":\"user\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"sharesToUnderlying\",\"inputs\":[{\"name\":\"amountShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"sharesToUnderlyingView\",\"inputs\":[{\"name\":\"amountShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"strategyManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategyManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"totalShares\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"underlyingToShares\",\"inputs\":[{\"name\":\"amountUnderlying\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"underlyingToSharesView\",\"inputs\":[{\"name\":\"amountUnderlying\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"underlyingToken\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIERC20\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"userUnderlying\",\"inputs\":[{\"name\":\"user\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"userUnderlyingView\",\"inputs\":[{\"name\":\"user\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"withdraw\",\"inputs\":[{\"name\":\"recipient\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amountShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"ExchangeRateEmitted\",\"inputs\":[{\"name\":\"rate\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyTokenSet\",\"inputs\":[{\"name\":\"token\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIERC20\"},{\"name\":\"decimals\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"BalanceExceedsMaxTotalDeposits\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CurrentlyPaused\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidNewPausedStatus\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"MaxPerDepositExceedsMax\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NewSharesZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyPauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyStrategyManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyUnderlyingToken\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyUnpauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"TotalSharesExceedsMax\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"WithdrawalAmountExceedsTotalDeposits\",\"inputs\":[]}]", - Bin: "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", + Bin: "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", } // EigenStrategyABI is the input ABI used to generate the binding from. diff --git a/pkg/bindings/Endian/binding.go b/pkg/bindings/Endian/binding.go index b2a1f90fff..e2995571cc 100644 --- a/pkg/bindings/Endian/binding.go +++ b/pkg/bindings/Endian/binding.go @@ -32,7 +32,7 @@ var ( // EndianMetaData contains all meta data concerning the Endian contract. var EndianMetaData = &bind.MetaData{ ABI: "[]", - Bin: "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220d31d5c2b691cbd0a659ac6a2d7575448cb9db5c1e8b20efb6f6fe9e398049e6b64736f6c634300081b0033", + Bin: "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea264697066735822122065de58e62fc0153ec81e59074101ab95f4a50a4dc9b195d91698d58ec6e19dcb64736f6c634300081b0033", } // EndianABI is the input ABI used to generate the binding from. diff --git a/pkg/bindings/IAVSDirectory/binding.go b/pkg/bindings/IAVSDirectory/binding.go index 3d947df659..83dfe31453 100644 --- a/pkg/bindings/IAVSDirectory/binding.go +++ b/pkg/bindings/IAVSDirectory/binding.go @@ -38,7 +38,7 @@ type ISignatureUtilsSignatureWithSaltAndExpiry struct { // IAVSDirectoryMetaData contains all meta data concerning the IAVSDirectory contract. var IAVSDirectoryMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"function\",\"name\":\"OPERATOR_AVS_REGISTRATION_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"OPERATOR_SET_REGISTRATION_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"calculateOperatorAVSRegistrationDigestHash\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"cancelSalt\",\"inputs\":[{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"deregisterOperatorFromAVS\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"operatorSaltIsSpent\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"registerOperatorToAVS\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSignature\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtils.SignatureWithSaltAndExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateAVSMetadataURI\",\"inputs\":[{\"name\":\"metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"AVSMetadataURIUpdated\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"AVSMigratedToOperatorSets\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorAVSRegistrationStatusUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"status\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"enumIAVSDirectoryTypes.OperatorAVSRegistrationStatus\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorMigratedToOperatorSets\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operatorSetIds\",\"type\":\"uint32[]\",\"indexed\":false,\"internalType\":\"uint32[]\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"InvalidSignature\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorAlreadyRegisteredToAVS\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorNotRegisteredToAVS\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorNotRegisteredToEigenLayer\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SaltSpent\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SignatureExpired\",\"inputs\":[]}]", + ABI: "[{\"type\":\"function\",\"name\":\"OPERATOR_AVS_REGISTRATION_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"OPERATOR_SET_REGISTRATION_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"calculateOperatorAVSRegistrationDigestHash\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"cancelSalt\",\"inputs\":[{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"deregisterOperatorFromAVS\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"operatorSaltIsSpent\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"registerOperatorToAVS\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSignature\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtils.SignatureWithSaltAndExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateAVSMetadataURI\",\"inputs\":[{\"name\":\"metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"AVSMetadataURIUpdated\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorAVSRegistrationStatusUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"status\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"enumIAVSDirectoryTypes.OperatorAVSRegistrationStatus\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"InvalidSignature\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorAlreadyRegisteredToAVS\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorNotRegisteredToAVS\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorNotRegisteredToEigenLayer\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SaltSpent\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SignatureExpired\",\"inputs\":[]}]", } // IAVSDirectoryABI is the input ABI used to generate the binding from. @@ -561,150 +561,6 @@ func (_IAVSDirectory *IAVSDirectoryFilterer) ParseAVSMetadataURIUpdated(log type return event, nil } -// IAVSDirectoryAVSMigratedToOperatorSetsIterator is returned from FilterAVSMigratedToOperatorSets and is used to iterate over the raw logs and unpacked data for AVSMigratedToOperatorSets events raised by the IAVSDirectory contract. -type IAVSDirectoryAVSMigratedToOperatorSetsIterator struct { - Event *IAVSDirectoryAVSMigratedToOperatorSets // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *IAVSDirectoryAVSMigratedToOperatorSetsIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(IAVSDirectoryAVSMigratedToOperatorSets) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(IAVSDirectoryAVSMigratedToOperatorSets) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *IAVSDirectoryAVSMigratedToOperatorSetsIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *IAVSDirectoryAVSMigratedToOperatorSetsIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// IAVSDirectoryAVSMigratedToOperatorSets represents a AVSMigratedToOperatorSets event raised by the IAVSDirectory contract. -type IAVSDirectoryAVSMigratedToOperatorSets struct { - Avs common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterAVSMigratedToOperatorSets is a free log retrieval operation binding the contract event 0x702b0c1f6cb1cf511aaa81f72bc05a215bb3497632d72c690c822b044ab494bf. -// -// Solidity: event AVSMigratedToOperatorSets(address indexed avs) -func (_IAVSDirectory *IAVSDirectoryFilterer) FilterAVSMigratedToOperatorSets(opts *bind.FilterOpts, avs []common.Address) (*IAVSDirectoryAVSMigratedToOperatorSetsIterator, error) { - - var avsRule []interface{} - for _, avsItem := range avs { - avsRule = append(avsRule, avsItem) - } - - logs, sub, err := _IAVSDirectory.contract.FilterLogs(opts, "AVSMigratedToOperatorSets", avsRule) - if err != nil { - return nil, err - } - return &IAVSDirectoryAVSMigratedToOperatorSetsIterator{contract: _IAVSDirectory.contract, event: "AVSMigratedToOperatorSets", logs: logs, sub: sub}, nil -} - -// WatchAVSMigratedToOperatorSets is a free log subscription operation binding the contract event 0x702b0c1f6cb1cf511aaa81f72bc05a215bb3497632d72c690c822b044ab494bf. -// -// Solidity: event AVSMigratedToOperatorSets(address indexed avs) -func (_IAVSDirectory *IAVSDirectoryFilterer) WatchAVSMigratedToOperatorSets(opts *bind.WatchOpts, sink chan<- *IAVSDirectoryAVSMigratedToOperatorSets, avs []common.Address) (event.Subscription, error) { - - var avsRule []interface{} - for _, avsItem := range avs { - avsRule = append(avsRule, avsItem) - } - - logs, sub, err := _IAVSDirectory.contract.WatchLogs(opts, "AVSMigratedToOperatorSets", avsRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(IAVSDirectoryAVSMigratedToOperatorSets) - if err := _IAVSDirectory.contract.UnpackLog(event, "AVSMigratedToOperatorSets", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseAVSMigratedToOperatorSets is a log parse operation binding the contract event 0x702b0c1f6cb1cf511aaa81f72bc05a215bb3497632d72c690c822b044ab494bf. -// -// Solidity: event AVSMigratedToOperatorSets(address indexed avs) -func (_IAVSDirectory *IAVSDirectoryFilterer) ParseAVSMigratedToOperatorSets(log types.Log) (*IAVSDirectoryAVSMigratedToOperatorSets, error) { - event := new(IAVSDirectoryAVSMigratedToOperatorSets) - if err := _IAVSDirectory.contract.UnpackLog(event, "AVSMigratedToOperatorSets", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - // IAVSDirectoryOperatorAVSRegistrationStatusUpdatedIterator is returned from FilterOperatorAVSRegistrationStatusUpdated and is used to iterate over the raw logs and unpacked data for OperatorAVSRegistrationStatusUpdated events raised by the IAVSDirectory contract. type IAVSDirectoryOperatorAVSRegistrationStatusUpdatedIterator struct { Event *IAVSDirectoryOperatorAVSRegistrationStatusUpdated // Event containing the contract specifics and raw log @@ -858,157 +714,3 @@ func (_IAVSDirectory *IAVSDirectoryFilterer) ParseOperatorAVSRegistrationStatusU event.Raw = log return event, nil } - -// IAVSDirectoryOperatorMigratedToOperatorSetsIterator is returned from FilterOperatorMigratedToOperatorSets and is used to iterate over the raw logs and unpacked data for OperatorMigratedToOperatorSets events raised by the IAVSDirectory contract. -type IAVSDirectoryOperatorMigratedToOperatorSetsIterator struct { - Event *IAVSDirectoryOperatorMigratedToOperatorSets // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *IAVSDirectoryOperatorMigratedToOperatorSetsIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(IAVSDirectoryOperatorMigratedToOperatorSets) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(IAVSDirectoryOperatorMigratedToOperatorSets) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *IAVSDirectoryOperatorMigratedToOperatorSetsIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *IAVSDirectoryOperatorMigratedToOperatorSetsIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// IAVSDirectoryOperatorMigratedToOperatorSets represents a OperatorMigratedToOperatorSets event raised by the IAVSDirectory contract. -type IAVSDirectoryOperatorMigratedToOperatorSets struct { - Operator common.Address - Avs common.Address - OperatorSetIds []uint32 - Raw types.Log // Blockchain specific contextual infos -} - -// FilterOperatorMigratedToOperatorSets is a free log retrieval operation binding the contract event 0x54f33cfdd1ca703d795986b986fd47d742eab1904ecd2a5fdb8d6595e5904a01. -// -// Solidity: event OperatorMigratedToOperatorSets(address indexed operator, address indexed avs, uint32[] operatorSetIds) -func (_IAVSDirectory *IAVSDirectoryFilterer) FilterOperatorMigratedToOperatorSets(opts *bind.FilterOpts, operator []common.Address, avs []common.Address) (*IAVSDirectoryOperatorMigratedToOperatorSetsIterator, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - var avsRule []interface{} - for _, avsItem := range avs { - avsRule = append(avsRule, avsItem) - } - - logs, sub, err := _IAVSDirectory.contract.FilterLogs(opts, "OperatorMigratedToOperatorSets", operatorRule, avsRule) - if err != nil { - return nil, err - } - return &IAVSDirectoryOperatorMigratedToOperatorSetsIterator{contract: _IAVSDirectory.contract, event: "OperatorMigratedToOperatorSets", logs: logs, sub: sub}, nil -} - -// WatchOperatorMigratedToOperatorSets is a free log subscription operation binding the contract event 0x54f33cfdd1ca703d795986b986fd47d742eab1904ecd2a5fdb8d6595e5904a01. -// -// Solidity: event OperatorMigratedToOperatorSets(address indexed operator, address indexed avs, uint32[] operatorSetIds) -func (_IAVSDirectory *IAVSDirectoryFilterer) WatchOperatorMigratedToOperatorSets(opts *bind.WatchOpts, sink chan<- *IAVSDirectoryOperatorMigratedToOperatorSets, operator []common.Address, avs []common.Address) (event.Subscription, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - var avsRule []interface{} - for _, avsItem := range avs { - avsRule = append(avsRule, avsItem) - } - - logs, sub, err := _IAVSDirectory.contract.WatchLogs(opts, "OperatorMigratedToOperatorSets", operatorRule, avsRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(IAVSDirectoryOperatorMigratedToOperatorSets) - if err := _IAVSDirectory.contract.UnpackLog(event, "OperatorMigratedToOperatorSets", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseOperatorMigratedToOperatorSets is a log parse operation binding the contract event 0x54f33cfdd1ca703d795986b986fd47d742eab1904ecd2a5fdb8d6595e5904a01. -// -// Solidity: event OperatorMigratedToOperatorSets(address indexed operator, address indexed avs, uint32[] operatorSetIds) -func (_IAVSDirectory *IAVSDirectoryFilterer) ParseOperatorMigratedToOperatorSets(log types.Log) (*IAVSDirectoryOperatorMigratedToOperatorSets, error) { - event := new(IAVSDirectoryOperatorMigratedToOperatorSets) - if err := _IAVSDirectory.contract.UnpackLog(event, "OperatorMigratedToOperatorSets", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} diff --git a/pkg/bindings/IAllocationManager/binding.go b/pkg/bindings/IAllocationManager/binding.go index c57b952782..3f74f32ea9 100644 --- a/pkg/bindings/IAllocationManager/binding.go +++ b/pkg/bindings/IAllocationManager/binding.go @@ -80,7 +80,7 @@ type OperatorSet struct { // IAllocationManagerMetaData contains all meta data concerning the IAllocationManager contract. var IAllocationManagerMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"function\",\"name\":\"addStrategiesToOperatorSet\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetId\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"clearDeallocationQueue\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"numToClear\",\"type\":\"uint16[]\",\"internalType\":\"uint16[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"createOperatorSets\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"params\",\"type\":\"tuple[]\",\"internalType\":\"structIAllocationManagerTypes.CreateSetParams[]\",\"components\":[{\"name\":\"operatorSetId\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"deregisterFromOperatorSets\",\"inputs\":[{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIAllocationManagerTypes.DeregisterParams\",\"components\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetIds\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"getAVSRegistrar\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIAVSRegistrar\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocatableMagnitude\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocatedSets\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structOperatorSet[]\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocatedStrategies\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocation\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIAllocationManagerTypes.Allocation\",\"components\":[{\"name\":\"currentMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"pendingDiff\",\"type\":\"int128\",\"internalType\":\"int128\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocationDelay\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"isSet\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"delay\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocations\",\"inputs\":[{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structIAllocationManagerTypes.Allocation[]\",\"components\":[{\"name\":\"currentMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"pendingDiff\",\"type\":\"int128\",\"internalType\":\"int128\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMaxMagnitude\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMaxMagnitudes\",\"inputs\":[{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64[]\",\"internalType\":\"uint64[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMaxMagnitudes\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64[]\",\"internalType\":\"uint64[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMaxMagnitudesAtBlock\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"blockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64[]\",\"internalType\":\"uint64[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMemberCount\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMembers\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMinimumSlashableStake\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"futureBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"slashableStake\",\"type\":\"uint256[][]\",\"internalType\":\"uint256[][]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorSetCount\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getRegisteredSets\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"operatorSets\",\"type\":\"tuple[]\",\"internalType\":\"structOperatorSet[]\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStrategiesInOperatorSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStrategyAllocations\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structOperatorSet[]\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structIAllocationManagerTypes.Allocation[]\",\"components\":[{\"name\":\"currentMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"pendingDiff\",\"type\":\"int128\",\"internalType\":\"int128\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"isMemberOfOperatorSet\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isOperatorSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"modifyAllocations\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"params\",\"type\":\"tuple[]\",\"internalType\":\"structIAllocationManagerTypes.AllocateParams[]\",\"components\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"newMagnitudes\",\"type\":\"uint64[]\",\"internalType\":\"uint64[]\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"registerForOperatorSets\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIAllocationManagerTypes.RegisterParams\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetIds\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"},{\"name\":\"data\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"removeStrategiesFromOperatorSet\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetId\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setAVSRegistrar\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"registrar\",\"type\":\"address\",\"internalType\":\"contractIAVSRegistrar\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setAllocationDelay\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delay\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"slashOperator\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIAllocationManagerTypes.SlashingParams\",\"components\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetId\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"wadsToSlash\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"description\",\"type\":\"string\",\"internalType\":\"string\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateAVSMetadataURI\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"AVSMetadataURIUpdated\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"AVSRegistrarSet\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"registrar\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIAVSRegistrar\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"AllocationDelaySet\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"delay\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"AllocationUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"magnitude\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"EncumberedMagnitudeUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"encumberedMagnitude\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"MaxMagnitudeUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"maxMagnitude\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorAddedToOperatorSet\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorRemovedFromOperatorSet\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSetCreated\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSlashed\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategies\",\"type\":\"address[]\",\"indexed\":false,\"internalType\":\"contractIStrategy[]\"},{\"name\":\"wadSlashed\",\"type\":\"uint256[]\",\"indexed\":false,\"internalType\":\"uint256[]\"},{\"name\":\"description\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyAddedToOperatorSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyRemovedFromOperatorSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"AlreadyMemberOfSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputArrayLengthMismatch\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InsufficientMagnitude\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidCaller\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidOperator\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidOperatorSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidWadToSlash\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ModificationAlreadyPending\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NotMemberOfSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorNotSlashable\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SameMagnitude\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategiesMustBeInAscendingOrder\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategyAlreadyInOperatorSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategyNotInOperatorSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"UninitializedAllocationDelay\",\"inputs\":[]}]", + ABI: "[{\"type\":\"function\",\"name\":\"addStrategiesToOperatorSet\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetId\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"clearDeallocationQueue\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"numToClear\",\"type\":\"uint16[]\",\"internalType\":\"uint16[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"createOperatorSets\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"params\",\"type\":\"tuple[]\",\"internalType\":\"structIAllocationManagerTypes.CreateSetParams[]\",\"components\":[{\"name\":\"operatorSetId\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"deregisterFromOperatorSets\",\"inputs\":[{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIAllocationManagerTypes.DeregisterParams\",\"components\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetIds\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"getAVSRegistrar\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIAVSRegistrar\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocatableMagnitude\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocatedSets\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structOperatorSet[]\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocatedStake\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"slashableStake\",\"type\":\"uint256[][]\",\"internalType\":\"uint256[][]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocatedStrategies\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocation\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIAllocationManagerTypes.Allocation\",\"components\":[{\"name\":\"currentMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"pendingDiff\",\"type\":\"int128\",\"internalType\":\"int128\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocationDelay\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"isSet\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"delay\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAllocations\",\"inputs\":[{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structIAllocationManagerTypes.Allocation[]\",\"components\":[{\"name\":\"currentMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"pendingDiff\",\"type\":\"int128\",\"internalType\":\"int128\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getEncumberedMagnitude\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMaxMagnitude\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMaxMagnitudes\",\"inputs\":[{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64[]\",\"internalType\":\"uint64[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMaxMagnitudes\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64[]\",\"internalType\":\"uint64[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMaxMagnitudesAtBlock\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"blockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64[]\",\"internalType\":\"uint64[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMemberCount\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMembers\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMinimumSlashableStake\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"futureBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"slashableStake\",\"type\":\"uint256[][]\",\"internalType\":\"uint256[][]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorSetCount\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getRegisteredSets\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"operatorSets\",\"type\":\"tuple[]\",\"internalType\":\"structOperatorSet[]\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStrategiesInOperatorSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStrategyAllocations\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structOperatorSet[]\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structIAllocationManagerTypes.Allocation[]\",\"components\":[{\"name\":\"currentMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"pendingDiff\",\"type\":\"int128\",\"internalType\":\"int128\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"isMemberOfOperatorSet\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isOperatorSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isOperatorSlashable\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"modifyAllocations\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"params\",\"type\":\"tuple[]\",\"internalType\":\"structIAllocationManagerTypes.AllocateParams[]\",\"components\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"newMagnitudes\",\"type\":\"uint64[]\",\"internalType\":\"uint64[]\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"registerForOperatorSets\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIAllocationManagerTypes.RegisterParams\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetIds\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"},{\"name\":\"data\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"removeStrategiesFromOperatorSet\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetId\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setAVSRegistrar\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"registrar\",\"type\":\"address\",\"internalType\":\"contractIAVSRegistrar\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setAllocationDelay\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delay\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"slashOperator\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIAllocationManagerTypes.SlashingParams\",\"components\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetId\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"wadsToSlash\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"description\",\"type\":\"string\",\"internalType\":\"string\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateAVSMetadataURI\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"AVSMetadataURIUpdated\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"AVSRegistrarSet\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"registrar\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIAVSRegistrar\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"AllocationDelaySet\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"delay\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"AllocationUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"magnitude\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"},{\"name\":\"effectBlock\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"EncumberedMagnitudeUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"encumberedMagnitude\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"MaxMagnitudeUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"maxMagnitude\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorAddedToOperatorSet\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorRemovedFromOperatorSet\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSetCreated\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSlashed\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategies\",\"type\":\"address[]\",\"indexed\":false,\"internalType\":\"contractIStrategy[]\"},{\"name\":\"wadSlashed\",\"type\":\"uint256[]\",\"indexed\":false,\"internalType\":\"uint256[]\"},{\"name\":\"description\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyAddedToOperatorSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyRemovedFromOperatorSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"AlreadyMemberOfSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputArrayLengthMismatch\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InsufficientMagnitude\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidCaller\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidOperator\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidOperatorSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidWadToSlash\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ModificationAlreadyPending\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NotMemberOfSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorNotSlashable\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SameMagnitude\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategiesMustBeInAscendingOrder\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategyAlreadyInOperatorSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategyNotInOperatorSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"UninitializedAllocationDelay\",\"inputs\":[]}]", } // IAllocationManagerABI is the input ABI used to generate the binding from. @@ -322,6 +322,37 @@ func (_IAllocationManager *IAllocationManagerCallerSession) GetAllocatedSets(ope return _IAllocationManager.Contract.GetAllocatedSets(&_IAllocationManager.CallOpts, operator) } +// GetAllocatedStake is a free data retrieval call binding the contract method 0x2b453a9a. +// +// Solidity: function getAllocatedStake((address,uint32) operatorSet, address[] operators, address[] strategies) view returns(uint256[][] slashableStake) +func (_IAllocationManager *IAllocationManagerCaller) GetAllocatedStake(opts *bind.CallOpts, operatorSet OperatorSet, operators []common.Address, strategies []common.Address) ([][]*big.Int, error) { + var out []interface{} + err := _IAllocationManager.contract.Call(opts, &out, "getAllocatedStake", operatorSet, operators, strategies) + + if err != nil { + return *new([][]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([][]*big.Int)).(*[][]*big.Int) + + return out0, err + +} + +// GetAllocatedStake is a free data retrieval call binding the contract method 0x2b453a9a. +// +// Solidity: function getAllocatedStake((address,uint32) operatorSet, address[] operators, address[] strategies) view returns(uint256[][] slashableStake) +func (_IAllocationManager *IAllocationManagerSession) GetAllocatedStake(operatorSet OperatorSet, operators []common.Address, strategies []common.Address) ([][]*big.Int, error) { + return _IAllocationManager.Contract.GetAllocatedStake(&_IAllocationManager.CallOpts, operatorSet, operators, strategies) +} + +// GetAllocatedStake is a free data retrieval call binding the contract method 0x2b453a9a. +// +// Solidity: function getAllocatedStake((address,uint32) operatorSet, address[] operators, address[] strategies) view returns(uint256[][] slashableStake) +func (_IAllocationManager *IAllocationManagerCallerSession) GetAllocatedStake(operatorSet OperatorSet, operators []common.Address, strategies []common.Address) ([][]*big.Int, error) { + return _IAllocationManager.Contract.GetAllocatedStake(&_IAllocationManager.CallOpts, operatorSet, operators, strategies) +} + // GetAllocatedStrategies is a free data retrieval call binding the contract method 0xc221d8ae. // // Solidity: function getAllocatedStrategies(address operator, (address,uint32) operatorSet) view returns(address[]) @@ -460,6 +491,37 @@ func (_IAllocationManager *IAllocationManagerCallerSession) GetAllocations(opera return _IAllocationManager.Contract.GetAllocations(&_IAllocationManager.CallOpts, operators, operatorSet, strategy) } +// GetEncumberedMagnitude is a free data retrieval call binding the contract method 0xf605ce08. +// +// Solidity: function getEncumberedMagnitude(address operator, address strategy) view returns(uint64) +func (_IAllocationManager *IAllocationManagerCaller) GetEncumberedMagnitude(opts *bind.CallOpts, operator common.Address, strategy common.Address) (uint64, error) { + var out []interface{} + err := _IAllocationManager.contract.Call(opts, &out, "getEncumberedMagnitude", operator, strategy) + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// GetEncumberedMagnitude is a free data retrieval call binding the contract method 0xf605ce08. +// +// Solidity: function getEncumberedMagnitude(address operator, address strategy) view returns(uint64) +func (_IAllocationManager *IAllocationManagerSession) GetEncumberedMagnitude(operator common.Address, strategy common.Address) (uint64, error) { + return _IAllocationManager.Contract.GetEncumberedMagnitude(&_IAllocationManager.CallOpts, operator, strategy) +} + +// GetEncumberedMagnitude is a free data retrieval call binding the contract method 0xf605ce08. +// +// Solidity: function getEncumberedMagnitude(address operator, address strategy) view returns(uint64) +func (_IAllocationManager *IAllocationManagerCallerSession) GetEncumberedMagnitude(operator common.Address, strategy common.Address) (uint64, error) { + return _IAllocationManager.Contract.GetEncumberedMagnitude(&_IAllocationManager.CallOpts, operator, strategy) +} + // GetMaxMagnitude is a free data retrieval call binding the contract method 0xa9333ec8. // // Solidity: function getMaxMagnitude(address operator, address strategy) view returns(uint64) @@ -864,6 +926,37 @@ func (_IAllocationManager *IAllocationManagerCallerSession) IsOperatorSet(operat return _IAllocationManager.Contract.IsOperatorSet(&_IAllocationManager.CallOpts, operatorSet) } +// IsOperatorSlashable is a free data retrieval call binding the contract method 0x1352c3e6. +// +// Solidity: function isOperatorSlashable(address operator, (address,uint32) operatorSet) view returns(bool) +func (_IAllocationManager *IAllocationManagerCaller) IsOperatorSlashable(opts *bind.CallOpts, operator common.Address, operatorSet OperatorSet) (bool, error) { + var out []interface{} + err := _IAllocationManager.contract.Call(opts, &out, "isOperatorSlashable", operator, operatorSet) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsOperatorSlashable is a free data retrieval call binding the contract method 0x1352c3e6. +// +// Solidity: function isOperatorSlashable(address operator, (address,uint32) operatorSet) view returns(bool) +func (_IAllocationManager *IAllocationManagerSession) IsOperatorSlashable(operator common.Address, operatorSet OperatorSet) (bool, error) { + return _IAllocationManager.Contract.IsOperatorSlashable(&_IAllocationManager.CallOpts, operator, operatorSet) +} + +// IsOperatorSlashable is a free data retrieval call binding the contract method 0x1352c3e6. +// +// Solidity: function isOperatorSlashable(address operator, (address,uint32) operatorSet) view returns(bool) +func (_IAllocationManager *IAllocationManagerCallerSession) IsOperatorSlashable(operator common.Address, operatorSet OperatorSet) (bool, error) { + return _IAllocationManager.Contract.IsOperatorSlashable(&_IAllocationManager.CallOpts, operator, operatorSet) +} + // AddStrategiesToOperatorSet is a paid mutator transaction binding the contract method 0x50feea20. // // Solidity: function addStrategiesToOperatorSet(address avs, uint32 operatorSetId, address[] strategies) returns() diff --git a/pkg/bindings/IDelegationManager/binding.go b/pkg/bindings/IDelegationManager/binding.go index 88c15bdace..ec7567cafc 100644 --- a/pkg/bindings/IDelegationManager/binding.go +++ b/pkg/bindings/IDelegationManager/binding.go @@ -55,7 +55,7 @@ type ISignatureUtilsSignatureWithExpiry struct { // IDelegationManagerMetaData contains all meta data concerning the IDelegationManager contract. var IDelegationManagerMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"function\",\"name\":\"DELEGATION_APPROVAL_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"beaconChainETHStrategy\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"burnOperatorShares\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"prevMaxMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"newMaxMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"calculateDelegationApprovalDigestHash\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_delegationApprover\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"approverSalt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"calculateWithdrawalRoot\",\"inputs\":[{\"name\":\"withdrawal\",\"type\":\"tuple\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"completeQueuedWithdrawal\",\"inputs\":[{\"name\":\"withdrawal\",\"type\":\"tuple\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"tokens\",\"type\":\"address[]\",\"internalType\":\"contractIERC20[]\"},{\"name\":\"receiveAsTokens\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"completeQueuedWithdrawals\",\"inputs\":[{\"name\":\"withdrawals\",\"type\":\"tuple[]\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal[]\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"tokens\",\"type\":\"address[][]\",\"internalType\":\"contractIERC20[][]\"},{\"name\":\"receiveAsTokens\",\"type\":\"bool[]\",\"internalType\":\"bool[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"convertToDepositShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"withdrawableShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"cumulativeWithdrawalsQueued\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"decreaseDelegatedShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"curDepositShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"beaconChainSlashingFactorDecrease\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegateTo\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"approverSignatureAndExpiry\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtils.SignatureWithExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"approverSalt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegatedTo\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"delegationApprover\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"delegationApproverSaltIsSpent\",\"inputs\":[{\"name\":\"_delegationApprover\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"depositScalingFactor\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getDepositedShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorShares\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorsShares\",\"inputs\":[{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256[][]\",\"internalType\":\"uint256[][]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getQueuedWithdrawal\",\"inputs\":[{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getQueuedWithdrawals\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"withdrawals\",\"type\":\"tuple[]\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal[]\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"shares\",\"type\":\"uint256[][]\",\"internalType\":\"uint256[][]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getSlashableSharesInQueue\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getWithdrawableShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"withdrawableShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"depositShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"increaseDelegatedShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"prevDepositShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"addedShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"isDelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isOperator\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"minWithdrawalDelayBlocks\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"modifyOperatorDetails\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"newDelegationApprover\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"queueWithdrawals\",\"inputs\":[{\"name\":\"params\",\"type\":\"tuple[]\",\"internalType\":\"structIDelegationManagerTypes.QueuedWithdrawalParams[]\",\"components\":[{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"depositShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"__deprecated_withdrawer\",\"type\":\"address\",\"internalType\":\"address\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"redelegate\",\"inputs\":[{\"name\":\"newOperator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"newOperatorApproverSig\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtils.SignatureWithExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"approverSalt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"withdrawalRoots\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"registerAsOperator\",\"inputs\":[{\"name\":\"initDelegationApprover\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"allocationDelay\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"undelegate\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"withdrawalRoots\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateOperatorMetadataURI\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"DelegationApproverUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newDelegationApprover\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"DepositScalingFactorUpdated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"newDepositScalingFactor\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorMetadataURIUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorRegistered\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"delegationApprover\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSharesBurned\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSharesDecreased\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSharesIncreased\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"SlashingWithdrawalCompleted\",\"inputs\":[{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"SlashingWithdrawalQueued\",\"inputs\":[{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"},{\"name\":\"withdrawal\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structIDelegationManagerTypes.Withdrawal\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"sharesToWithdraw\",\"type\":\"uint256[]\",\"indexed\":false,\"internalType\":\"uint256[]\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StakerDelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StakerForceUndelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StakerUndelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"ActivelyDelegated\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CallerCannotUndelegate\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"FullySlashed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputArrayLengthMismatch\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputArrayLengthZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidSignature\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NotActivelyDelegated\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyAllocationManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyEigenPodManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyStrategyManagerOrEigenPodManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorNotRegistered\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorsCannotUndelegate\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SaltSpent\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SignatureExpired\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"WithdrawalDelayNotElapsed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"WithdrawalNotQueued\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"WithdrawerNotCaller\",\"inputs\":[]}]", + ABI: "[{\"type\":\"function\",\"name\":\"DELEGATION_APPROVAL_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"beaconChainETHStrategy\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"calculateDelegationApprovalDigestHash\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_delegationApprover\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"approverSalt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"calculateWithdrawalRoot\",\"inputs\":[{\"name\":\"withdrawal\",\"type\":\"tuple\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"completeQueuedWithdrawal\",\"inputs\":[{\"name\":\"withdrawal\",\"type\":\"tuple\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"tokens\",\"type\":\"address[]\",\"internalType\":\"contractIERC20[]\"},{\"name\":\"receiveAsTokens\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"completeQueuedWithdrawals\",\"inputs\":[{\"name\":\"withdrawals\",\"type\":\"tuple[]\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal[]\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"tokens\",\"type\":\"address[][]\",\"internalType\":\"contractIERC20[][]\"},{\"name\":\"receiveAsTokens\",\"type\":\"bool[]\",\"internalType\":\"bool[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"convertToDepositShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"withdrawableShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"cumulativeWithdrawalsQueued\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"decreaseDelegatedShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"curDepositShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"beaconChainSlashingFactorDecrease\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegateTo\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"approverSignatureAndExpiry\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtils.SignatureWithExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"approverSalt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegatedTo\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"delegationApprover\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"delegationApproverSaltIsSpent\",\"inputs\":[{\"name\":\"_delegationApprover\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"depositScalingFactor\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getDepositedShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorShares\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorsShares\",\"inputs\":[{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256[][]\",\"internalType\":\"uint256[][]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getQueuedWithdrawal\",\"inputs\":[{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getQueuedWithdrawalRoots\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getQueuedWithdrawals\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"withdrawals\",\"type\":\"tuple[]\",\"internalType\":\"structIDelegationManagerTypes.Withdrawal[]\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"shares\",\"type\":\"uint256[][]\",\"internalType\":\"uint256[][]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getSlashableSharesInQueue\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getWithdrawableShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"withdrawableShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"depositShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"increaseDelegatedShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"prevDepositShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"addedShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"isDelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isOperator\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"minWithdrawalDelayBlocks\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"modifyOperatorDetails\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"newDelegationApprover\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"queueWithdrawals\",\"inputs\":[{\"name\":\"params\",\"type\":\"tuple[]\",\"internalType\":\"structIDelegationManagerTypes.QueuedWithdrawalParams[]\",\"components\":[{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"depositShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"__deprecated_withdrawer\",\"type\":\"address\",\"internalType\":\"address\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"redelegate\",\"inputs\":[{\"name\":\"newOperator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"newOperatorApproverSig\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtils.SignatureWithExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"approverSalt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"withdrawalRoots\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"registerAsOperator\",\"inputs\":[{\"name\":\"initDelegationApprover\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"allocationDelay\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"slashOperatorShares\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"prevMaxMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"newMaxMagnitude\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"undelegate\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"withdrawalRoots\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateOperatorMetadataURI\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"DelegationApproverUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newDelegationApprover\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"DepositScalingFactorUpdated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"newDepositScalingFactor\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorMetadataURIUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorRegistered\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"delegationApprover\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSharesDecreased\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSharesIncreased\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"SlashingWithdrawalCompleted\",\"inputs\":[{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"SlashingWithdrawalQueued\",\"inputs\":[{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"},{\"name\":\"withdrawal\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structIDelegationManagerTypes.Withdrawal\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"scaledShares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"sharesToWithdraw\",\"type\":\"uint256[]\",\"indexed\":false,\"internalType\":\"uint256[]\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StakerDelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StakerForceUndelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StakerUndelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"ActivelyDelegated\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CallerCannotUndelegate\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"FullySlashed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputArrayLengthMismatch\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputArrayLengthZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidSignature\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NotActivelyDelegated\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyAllocationManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyEigenPodManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyStrategyManagerOrEigenPodManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorNotRegistered\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorsCannotUndelegate\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SaltSpent\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SignatureExpired\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"WithdrawalDelayNotElapsed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"WithdrawalNotQueued\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"WithdrawerNotCaller\",\"inputs\":[]}]", } // IDelegationManagerABI is the input ABI used to generate the binding from. @@ -639,6 +639,37 @@ func (_IDelegationManager *IDelegationManagerCallerSession) GetQueuedWithdrawal( return _IDelegationManager.Contract.GetQueuedWithdrawal(&_IDelegationManager.CallOpts, withdrawalRoot) } +// GetQueuedWithdrawalRoots is a free data retrieval call binding the contract method 0xfd8aa88d. +// +// Solidity: function getQueuedWithdrawalRoots(address staker) view returns(bytes32[]) +func (_IDelegationManager *IDelegationManagerCaller) GetQueuedWithdrawalRoots(opts *bind.CallOpts, staker common.Address) ([][32]byte, error) { + var out []interface{} + err := _IDelegationManager.contract.Call(opts, &out, "getQueuedWithdrawalRoots", staker) + + if err != nil { + return *new([][32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([][32]byte)).(*[][32]byte) + + return out0, err + +} + +// GetQueuedWithdrawalRoots is a free data retrieval call binding the contract method 0xfd8aa88d. +// +// Solidity: function getQueuedWithdrawalRoots(address staker) view returns(bytes32[]) +func (_IDelegationManager *IDelegationManagerSession) GetQueuedWithdrawalRoots(staker common.Address) ([][32]byte, error) { + return _IDelegationManager.Contract.GetQueuedWithdrawalRoots(&_IDelegationManager.CallOpts, staker) +} + +// GetQueuedWithdrawalRoots is a free data retrieval call binding the contract method 0xfd8aa88d. +// +// Solidity: function getQueuedWithdrawalRoots(address staker) view returns(bytes32[]) +func (_IDelegationManager *IDelegationManagerCallerSession) GetQueuedWithdrawalRoots(staker common.Address) ([][32]byte, error) { + return _IDelegationManager.Contract.GetQueuedWithdrawalRoots(&_IDelegationManager.CallOpts, staker) +} + // GetQueuedWithdrawals is a free data retrieval call binding the contract method 0x5dd68579. // // Solidity: function getQueuedWithdrawals(address staker) view returns((address,address,address,uint256,uint32,address[],uint256[])[] withdrawals, uint256[][] shares) @@ -853,27 +884,6 @@ func (_IDelegationManager *IDelegationManagerCallerSession) MinWithdrawalDelayBl return _IDelegationManager.Contract.MinWithdrawalDelayBlocks(&_IDelegationManager.CallOpts) } -// BurnOperatorShares is a paid mutator transaction binding the contract method 0xee74937f. -// -// Solidity: function burnOperatorShares(address operator, address strategy, uint64 prevMaxMagnitude, uint64 newMaxMagnitude) returns() -func (_IDelegationManager *IDelegationManagerTransactor) BurnOperatorShares(opts *bind.TransactOpts, operator common.Address, strategy common.Address, prevMaxMagnitude uint64, newMaxMagnitude uint64) (*types.Transaction, error) { - return _IDelegationManager.contract.Transact(opts, "burnOperatorShares", operator, strategy, prevMaxMagnitude, newMaxMagnitude) -} - -// BurnOperatorShares is a paid mutator transaction binding the contract method 0xee74937f. -// -// Solidity: function burnOperatorShares(address operator, address strategy, uint64 prevMaxMagnitude, uint64 newMaxMagnitude) returns() -func (_IDelegationManager *IDelegationManagerSession) BurnOperatorShares(operator common.Address, strategy common.Address, prevMaxMagnitude uint64, newMaxMagnitude uint64) (*types.Transaction, error) { - return _IDelegationManager.Contract.BurnOperatorShares(&_IDelegationManager.TransactOpts, operator, strategy, prevMaxMagnitude, newMaxMagnitude) -} - -// BurnOperatorShares is a paid mutator transaction binding the contract method 0xee74937f. -// -// Solidity: function burnOperatorShares(address operator, address strategy, uint64 prevMaxMagnitude, uint64 newMaxMagnitude) returns() -func (_IDelegationManager *IDelegationManagerTransactorSession) BurnOperatorShares(operator common.Address, strategy common.Address, prevMaxMagnitude uint64, newMaxMagnitude uint64) (*types.Transaction, error) { - return _IDelegationManager.Contract.BurnOperatorShares(&_IDelegationManager.TransactOpts, operator, strategy, prevMaxMagnitude, newMaxMagnitude) -} - // CompleteQueuedWithdrawal is a paid mutator transaction binding the contract method 0xe4cc3f90. // // Solidity: function completeQueuedWithdrawal((address,address,address,uint256,uint32,address[],uint256[]) withdrawal, address[] tokens, bool receiveAsTokens) returns() @@ -1084,6 +1094,27 @@ func (_IDelegationManager *IDelegationManagerTransactorSession) RegisterAsOperat return _IDelegationManager.Contract.RegisterAsOperator(&_IDelegationManager.TransactOpts, initDelegationApprover, allocationDelay, metadataURI) } +// SlashOperatorShares is a paid mutator transaction binding the contract method 0x601bb36f. +// +// Solidity: function slashOperatorShares(address operator, address strategy, uint64 prevMaxMagnitude, uint64 newMaxMagnitude) returns() +func (_IDelegationManager *IDelegationManagerTransactor) SlashOperatorShares(opts *bind.TransactOpts, operator common.Address, strategy common.Address, prevMaxMagnitude uint64, newMaxMagnitude uint64) (*types.Transaction, error) { + return _IDelegationManager.contract.Transact(opts, "slashOperatorShares", operator, strategy, prevMaxMagnitude, newMaxMagnitude) +} + +// SlashOperatorShares is a paid mutator transaction binding the contract method 0x601bb36f. +// +// Solidity: function slashOperatorShares(address operator, address strategy, uint64 prevMaxMagnitude, uint64 newMaxMagnitude) returns() +func (_IDelegationManager *IDelegationManagerSession) SlashOperatorShares(operator common.Address, strategy common.Address, prevMaxMagnitude uint64, newMaxMagnitude uint64) (*types.Transaction, error) { + return _IDelegationManager.Contract.SlashOperatorShares(&_IDelegationManager.TransactOpts, operator, strategy, prevMaxMagnitude, newMaxMagnitude) +} + +// SlashOperatorShares is a paid mutator transaction binding the contract method 0x601bb36f. +// +// Solidity: function slashOperatorShares(address operator, address strategy, uint64 prevMaxMagnitude, uint64 newMaxMagnitude) returns() +func (_IDelegationManager *IDelegationManagerTransactorSession) SlashOperatorShares(operator common.Address, strategy common.Address, prevMaxMagnitude uint64, newMaxMagnitude uint64) (*types.Transaction, error) { + return _IDelegationManager.Contract.SlashOperatorShares(&_IDelegationManager.TransactOpts, operator, strategy, prevMaxMagnitude, newMaxMagnitude) +} + // Undelegate is a paid mutator transaction binding the contract method 0xda8be864. // // Solidity: function undelegate(address staker) returns(bytes32[] withdrawalRoots) @@ -1697,152 +1728,6 @@ func (_IDelegationManager *IDelegationManagerFilterer) ParseOperatorRegistered(l return event, nil } -// IDelegationManagerOperatorSharesBurnedIterator is returned from FilterOperatorSharesBurned and is used to iterate over the raw logs and unpacked data for OperatorSharesBurned events raised by the IDelegationManager contract. -type IDelegationManagerOperatorSharesBurnedIterator struct { - Event *IDelegationManagerOperatorSharesBurned // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *IDelegationManagerOperatorSharesBurnedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(IDelegationManagerOperatorSharesBurned) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(IDelegationManagerOperatorSharesBurned) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *IDelegationManagerOperatorSharesBurnedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *IDelegationManagerOperatorSharesBurnedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// IDelegationManagerOperatorSharesBurned represents a OperatorSharesBurned event raised by the IDelegationManager contract. -type IDelegationManagerOperatorSharesBurned struct { - Operator common.Address - Strategy common.Address - Shares *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterOperatorSharesBurned is a free log retrieval operation binding the contract event 0xeff6aab2bc3f7c648896e1522eae71d6c22e3b0e218206b3f40af0e4d204716b. -// -// Solidity: event OperatorSharesBurned(address indexed operator, address strategy, uint256 shares) -func (_IDelegationManager *IDelegationManagerFilterer) FilterOperatorSharesBurned(opts *bind.FilterOpts, operator []common.Address) (*IDelegationManagerOperatorSharesBurnedIterator, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - - logs, sub, err := _IDelegationManager.contract.FilterLogs(opts, "OperatorSharesBurned", operatorRule) - if err != nil { - return nil, err - } - return &IDelegationManagerOperatorSharesBurnedIterator{contract: _IDelegationManager.contract, event: "OperatorSharesBurned", logs: logs, sub: sub}, nil -} - -// WatchOperatorSharesBurned is a free log subscription operation binding the contract event 0xeff6aab2bc3f7c648896e1522eae71d6c22e3b0e218206b3f40af0e4d204716b. -// -// Solidity: event OperatorSharesBurned(address indexed operator, address strategy, uint256 shares) -func (_IDelegationManager *IDelegationManagerFilterer) WatchOperatorSharesBurned(opts *bind.WatchOpts, sink chan<- *IDelegationManagerOperatorSharesBurned, operator []common.Address) (event.Subscription, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - - logs, sub, err := _IDelegationManager.contract.WatchLogs(opts, "OperatorSharesBurned", operatorRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(IDelegationManagerOperatorSharesBurned) - if err := _IDelegationManager.contract.UnpackLog(event, "OperatorSharesBurned", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseOperatorSharesBurned is a log parse operation binding the contract event 0xeff6aab2bc3f7c648896e1522eae71d6c22e3b0e218206b3f40af0e4d204716b. -// -// Solidity: event OperatorSharesBurned(address indexed operator, address strategy, uint256 shares) -func (_IDelegationManager *IDelegationManagerFilterer) ParseOperatorSharesBurned(log types.Log) (*IDelegationManagerOperatorSharesBurned, error) { - event := new(IDelegationManagerOperatorSharesBurned) - if err := _IDelegationManager.contract.UnpackLog(event, "OperatorSharesBurned", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - // IDelegationManagerOperatorSharesDecreasedIterator is returned from FilterOperatorSharesDecreased and is used to iterate over the raw logs and unpacked data for OperatorSharesDecreased events raised by the IDelegationManager contract. type IDelegationManagerOperatorSharesDecreasedIterator struct { Event *IDelegationManagerOperatorSharesDecreased // Event containing the contract specifics and raw log diff --git a/pkg/bindings/IEigenPodManager/binding.go b/pkg/bindings/IEigenPodManager/binding.go index 8253867da5..f29e9a0705 100644 --- a/pkg/bindings/IEigenPodManager/binding.go +++ b/pkg/bindings/IEigenPodManager/binding.go @@ -31,7 +31,7 @@ var ( // IEigenPodManagerMetaData contains all meta data concerning the IEigenPodManager contract. var IEigenPodManagerMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"function\",\"name\":\"addShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"beaconChainETHStrategy\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"beaconChainSlashingFactor\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"createPod\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"eigenPodBeacon\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIBeacon\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"ethPOS\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIETHPOSDeposit\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getPod\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEigenPod\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"hasPod\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"numPods\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"ownerToPod\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEigenPod\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"pauseAll\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[{\"name\":\"index\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pauserRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"podOwnerDepositShares\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"int256\",\"internalType\":\"int256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"recordBeaconChainETHBalanceUpdate\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"prevRestakedBalanceWei\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"balanceDeltaWei\",\"type\":\"int256\",\"internalType\":\"int256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"removeDepositShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"depositSharesToRemove\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"stake\",\"inputs\":[{\"name\":\"pubkey\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"depositDataRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"stakerDepositShares\",\"inputs\":[{\"name\":\"user\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"depositShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"withdrawSharesAsTokens\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"BeaconChainETHDeposited\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"BeaconChainETHWithdrawalCompleted\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"nonce\",\"type\":\"uint96\",\"indexed\":false,\"internalType\":\"uint96\"},{\"name\":\"delegatedAddress\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"BeaconChainSlashingFactorDecreased\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"prevBeaconChainSlashingFactor\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"},{\"name\":\"newBeaconChainSlashingFactor\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"NewTotalShares\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newTotalShares\",\"type\":\"int256\",\"indexed\":false,\"internalType\":\"int256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"PodDeployed\",\"inputs\":[{\"name\":\"eigenPod\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"PodSharesUpdated\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"sharesDelta\",\"type\":\"int256\",\"indexed\":false,\"internalType\":\"int256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"CurrentlyPaused\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"EigenPodAlreadyExists\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidNewPausedStatus\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidStrategy\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"LegacyWithdrawalsNotCompleted\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyDelegationManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyEigenPod\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyPauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyUnpauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SharesNegative\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SharesNotMultipleOfGwei\",\"inputs\":[]}]", + ABI: "[{\"type\":\"function\",\"name\":\"addShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"beaconChainETHStrategy\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"beaconChainSlashingFactor\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"burnableETHShares\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"createPod\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"eigenPodBeacon\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIBeacon\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"ethPOS\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIETHPOSDeposit\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getPod\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEigenPod\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"hasPod\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"increaseBurnableShares\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"addedSharesToBurn\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"numPods\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"ownerToPod\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEigenPod\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"pauseAll\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[{\"name\":\"index\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pauserRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"podOwnerDepositShares\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"int256\",\"internalType\":\"int256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"recordBeaconChainETHBalanceUpdate\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"prevRestakedBalanceWei\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"balanceDeltaWei\",\"type\":\"int256\",\"internalType\":\"int256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"removeDepositShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"depositSharesToRemove\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"stake\",\"inputs\":[{\"name\":\"pubkey\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"depositDataRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"stakerDepositShares\",\"inputs\":[{\"name\":\"user\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"depositShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"withdrawSharesAsTokens\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"BeaconChainETHDeposited\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"BeaconChainETHWithdrawalCompleted\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"nonce\",\"type\":\"uint96\",\"indexed\":false,\"internalType\":\"uint96\"},{\"name\":\"delegatedAddress\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"BeaconChainSlashingFactorDecreased\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"prevBeaconChainSlashingFactor\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"},{\"name\":\"newBeaconChainSlashingFactor\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"BurnableETHSharesIncreased\",\"inputs\":[{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"NewTotalShares\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newTotalShares\",\"type\":\"int256\",\"indexed\":false,\"internalType\":\"int256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"PodDeployed\",\"inputs\":[{\"name\":\"eigenPod\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"PodSharesUpdated\",\"inputs\":[{\"name\":\"podOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"sharesDelta\",\"type\":\"int256\",\"indexed\":false,\"internalType\":\"int256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"CurrentlyPaused\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"EigenPodAlreadyExists\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidNewPausedStatus\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidStrategy\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"LegacyWithdrawalsNotCompleted\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyDelegationManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyEigenPod\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyPauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyUnpauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SharesNegative\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SharesNotMultipleOfGwei\",\"inputs\":[]}]", } // IEigenPodManagerABI is the input ABI used to generate the binding from. @@ -242,6 +242,37 @@ func (_IEigenPodManager *IEigenPodManagerCallerSession) BeaconChainSlashingFacto return _IEigenPodManager.Contract.BeaconChainSlashingFactor(&_IEigenPodManager.CallOpts, staker) } +// BurnableETHShares is a free data retrieval call binding the contract method 0xf5d4fed3. +// +// Solidity: function burnableETHShares() view returns(uint256) +func (_IEigenPodManager *IEigenPodManagerCaller) BurnableETHShares(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _IEigenPodManager.contract.Call(opts, &out, "burnableETHShares") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// BurnableETHShares is a free data retrieval call binding the contract method 0xf5d4fed3. +// +// Solidity: function burnableETHShares() view returns(uint256) +func (_IEigenPodManager *IEigenPodManagerSession) BurnableETHShares() (*big.Int, error) { + return _IEigenPodManager.Contract.BurnableETHShares(&_IEigenPodManager.CallOpts) +} + +// BurnableETHShares is a free data retrieval call binding the contract method 0xf5d4fed3. +// +// Solidity: function burnableETHShares() view returns(uint256) +func (_IEigenPodManager *IEigenPodManagerCallerSession) BurnableETHShares() (*big.Int, error) { + return _IEigenPodManager.Contract.BurnableETHShares(&_IEigenPodManager.CallOpts) +} + // EigenPodBeacon is a free data retrieval call binding the contract method 0x292b7b2b. // // Solidity: function eigenPodBeacon() view returns(address) @@ -583,25 +614,25 @@ func (_IEigenPodManager *IEigenPodManagerCallerSession) StakerDepositShares(user return _IEigenPodManager.Contract.StakerDepositShares(&_IEigenPodManager.CallOpts, user, strategy) } -// AddShares is a paid mutator transaction binding the contract method 0xc4623ea1. +// AddShares is a paid mutator transaction binding the contract method 0x50ff7225. // -// Solidity: function addShares(address staker, address strategy, address token, uint256 shares) returns(uint256, uint256) -func (_IEigenPodManager *IEigenPodManagerTransactor) AddShares(opts *bind.TransactOpts, staker common.Address, strategy common.Address, token common.Address, shares *big.Int) (*types.Transaction, error) { - return _IEigenPodManager.contract.Transact(opts, "addShares", staker, strategy, token, shares) +// Solidity: function addShares(address staker, address strategy, uint256 shares) returns(uint256, uint256) +func (_IEigenPodManager *IEigenPodManagerTransactor) AddShares(opts *bind.TransactOpts, staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { + return _IEigenPodManager.contract.Transact(opts, "addShares", staker, strategy, shares) } -// AddShares is a paid mutator transaction binding the contract method 0xc4623ea1. +// AddShares is a paid mutator transaction binding the contract method 0x50ff7225. // -// Solidity: function addShares(address staker, address strategy, address token, uint256 shares) returns(uint256, uint256) -func (_IEigenPodManager *IEigenPodManagerSession) AddShares(staker common.Address, strategy common.Address, token common.Address, shares *big.Int) (*types.Transaction, error) { - return _IEigenPodManager.Contract.AddShares(&_IEigenPodManager.TransactOpts, staker, strategy, token, shares) +// Solidity: function addShares(address staker, address strategy, uint256 shares) returns(uint256, uint256) +func (_IEigenPodManager *IEigenPodManagerSession) AddShares(staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { + return _IEigenPodManager.Contract.AddShares(&_IEigenPodManager.TransactOpts, staker, strategy, shares) } -// AddShares is a paid mutator transaction binding the contract method 0xc4623ea1. +// AddShares is a paid mutator transaction binding the contract method 0x50ff7225. // -// Solidity: function addShares(address staker, address strategy, address token, uint256 shares) returns(uint256, uint256) -func (_IEigenPodManager *IEigenPodManagerTransactorSession) AddShares(staker common.Address, strategy common.Address, token common.Address, shares *big.Int) (*types.Transaction, error) { - return _IEigenPodManager.Contract.AddShares(&_IEigenPodManager.TransactOpts, staker, strategy, token, shares) +// Solidity: function addShares(address staker, address strategy, uint256 shares) returns(uint256, uint256) +func (_IEigenPodManager *IEigenPodManagerTransactorSession) AddShares(staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { + return _IEigenPodManager.Contract.AddShares(&_IEigenPodManager.TransactOpts, staker, strategy, shares) } // CreatePod is a paid mutator transaction binding the contract method 0x84d81062. @@ -625,6 +656,27 @@ func (_IEigenPodManager *IEigenPodManagerTransactorSession) CreatePod() (*types. return _IEigenPodManager.Contract.CreatePod(&_IEigenPodManager.TransactOpts) } +// IncreaseBurnableShares is a paid mutator transaction binding the contract method 0xdebe1eab. +// +// Solidity: function increaseBurnableShares(address strategy, uint256 addedSharesToBurn) returns() +func (_IEigenPodManager *IEigenPodManagerTransactor) IncreaseBurnableShares(opts *bind.TransactOpts, strategy common.Address, addedSharesToBurn *big.Int) (*types.Transaction, error) { + return _IEigenPodManager.contract.Transact(opts, "increaseBurnableShares", strategy, addedSharesToBurn) +} + +// IncreaseBurnableShares is a paid mutator transaction binding the contract method 0xdebe1eab. +// +// Solidity: function increaseBurnableShares(address strategy, uint256 addedSharesToBurn) returns() +func (_IEigenPodManager *IEigenPodManagerSession) IncreaseBurnableShares(strategy common.Address, addedSharesToBurn *big.Int) (*types.Transaction, error) { + return _IEigenPodManager.Contract.IncreaseBurnableShares(&_IEigenPodManager.TransactOpts, strategy, addedSharesToBurn) +} + +// IncreaseBurnableShares is a paid mutator transaction binding the contract method 0xdebe1eab. +// +// Solidity: function increaseBurnableShares(address strategy, uint256 addedSharesToBurn) returns() +func (_IEigenPodManager *IEigenPodManagerTransactorSession) IncreaseBurnableShares(strategy common.Address, addedSharesToBurn *big.Int) (*types.Transaction, error) { + return _IEigenPodManager.Contract.IncreaseBurnableShares(&_IEigenPodManager.TransactOpts, strategy, addedSharesToBurn) +} + // Pause is a paid mutator transaction binding the contract method 0x136439dd. // // Solidity: function pause(uint256 newPausedStatus) returns() @@ -1202,6 +1254,140 @@ func (_IEigenPodManager *IEigenPodManagerFilterer) ParseBeaconChainSlashingFacto return event, nil } +// IEigenPodManagerBurnableETHSharesIncreasedIterator is returned from FilterBurnableETHSharesIncreased and is used to iterate over the raw logs and unpacked data for BurnableETHSharesIncreased events raised by the IEigenPodManager contract. +type IEigenPodManagerBurnableETHSharesIncreasedIterator struct { + Event *IEigenPodManagerBurnableETHSharesIncreased // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IEigenPodManagerBurnableETHSharesIncreasedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IEigenPodManagerBurnableETHSharesIncreased) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IEigenPodManagerBurnableETHSharesIncreased) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IEigenPodManagerBurnableETHSharesIncreasedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IEigenPodManagerBurnableETHSharesIncreasedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IEigenPodManagerBurnableETHSharesIncreased represents a BurnableETHSharesIncreased event raised by the IEigenPodManager contract. +type IEigenPodManagerBurnableETHSharesIncreased struct { + Shares *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterBurnableETHSharesIncreased is a free log retrieval operation binding the contract event 0x1ed04b7fd262c0d9e50fa02957f32a81a151f03baaa367faeedc7521b001c4a4. +// +// Solidity: event BurnableETHSharesIncreased(uint256 shares) +func (_IEigenPodManager *IEigenPodManagerFilterer) FilterBurnableETHSharesIncreased(opts *bind.FilterOpts) (*IEigenPodManagerBurnableETHSharesIncreasedIterator, error) { + + logs, sub, err := _IEigenPodManager.contract.FilterLogs(opts, "BurnableETHSharesIncreased") + if err != nil { + return nil, err + } + return &IEigenPodManagerBurnableETHSharesIncreasedIterator{contract: _IEigenPodManager.contract, event: "BurnableETHSharesIncreased", logs: logs, sub: sub}, nil +} + +// WatchBurnableETHSharesIncreased is a free log subscription operation binding the contract event 0x1ed04b7fd262c0d9e50fa02957f32a81a151f03baaa367faeedc7521b001c4a4. +// +// Solidity: event BurnableETHSharesIncreased(uint256 shares) +func (_IEigenPodManager *IEigenPodManagerFilterer) WatchBurnableETHSharesIncreased(opts *bind.WatchOpts, sink chan<- *IEigenPodManagerBurnableETHSharesIncreased) (event.Subscription, error) { + + logs, sub, err := _IEigenPodManager.contract.WatchLogs(opts, "BurnableETHSharesIncreased") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(IEigenPodManagerBurnableETHSharesIncreased) + if err := _IEigenPodManager.contract.UnpackLog(event, "BurnableETHSharesIncreased", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseBurnableETHSharesIncreased is a log parse operation binding the contract event 0x1ed04b7fd262c0d9e50fa02957f32a81a151f03baaa367faeedc7521b001c4a4. +// +// Solidity: event BurnableETHSharesIncreased(uint256 shares) +func (_IEigenPodManager *IEigenPodManagerFilterer) ParseBurnableETHSharesIncreased(log types.Log) (*IEigenPodManagerBurnableETHSharesIncreased, error) { + event := new(IEigenPodManagerBurnableETHSharesIncreased) + if err := _IEigenPodManager.contract.UnpackLog(event, "BurnableETHSharesIncreased", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + // IEigenPodManagerNewTotalSharesIterator is returned from FilterNewTotalShares and is used to iterate over the raw logs and unpacked data for NewTotalShares events raised by the IEigenPodManager contract. type IEigenPodManagerNewTotalSharesIterator struct { Event *IEigenPodManagerNewTotalShares // Event containing the contract specifics and raw log diff --git a/pkg/bindings/IShareManager/binding.go b/pkg/bindings/IShareManager/binding.go index 6e295bf4be..11404066ab 100644 --- a/pkg/bindings/IShareManager/binding.go +++ b/pkg/bindings/IShareManager/binding.go @@ -31,7 +31,7 @@ var ( // IShareManagerMetaData contains all meta data concerning the IShareManager contract. var IShareManagerMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"function\",\"name\":\"addShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"removeDepositShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"depositSharesToRemove\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"stakerDepositShares\",\"inputs\":[{\"name\":\"user\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"depositShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"withdrawSharesAsTokens\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"}]", + ABI: "[{\"type\":\"function\",\"name\":\"addShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"increaseBurnableShares\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"addedSharesToBurn\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"removeDepositShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"depositSharesToRemove\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"stakerDepositShares\",\"inputs\":[{\"name\":\"user\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"depositShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"withdrawSharesAsTokens\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"}]", } // IShareManagerABI is the input ABI used to generate the binding from. @@ -211,25 +211,46 @@ func (_IShareManager *IShareManagerCallerSession) StakerDepositShares(user commo return _IShareManager.Contract.StakerDepositShares(&_IShareManager.CallOpts, user, strategy) } -// AddShares is a paid mutator transaction binding the contract method 0xc4623ea1. +// AddShares is a paid mutator transaction binding the contract method 0x50ff7225. // -// Solidity: function addShares(address staker, address strategy, address token, uint256 shares) returns(uint256, uint256) -func (_IShareManager *IShareManagerTransactor) AddShares(opts *bind.TransactOpts, staker common.Address, strategy common.Address, token common.Address, shares *big.Int) (*types.Transaction, error) { - return _IShareManager.contract.Transact(opts, "addShares", staker, strategy, token, shares) +// Solidity: function addShares(address staker, address strategy, uint256 shares) returns(uint256, uint256) +func (_IShareManager *IShareManagerTransactor) AddShares(opts *bind.TransactOpts, staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { + return _IShareManager.contract.Transact(opts, "addShares", staker, strategy, shares) } -// AddShares is a paid mutator transaction binding the contract method 0xc4623ea1. +// AddShares is a paid mutator transaction binding the contract method 0x50ff7225. // -// Solidity: function addShares(address staker, address strategy, address token, uint256 shares) returns(uint256, uint256) -func (_IShareManager *IShareManagerSession) AddShares(staker common.Address, strategy common.Address, token common.Address, shares *big.Int) (*types.Transaction, error) { - return _IShareManager.Contract.AddShares(&_IShareManager.TransactOpts, staker, strategy, token, shares) +// Solidity: function addShares(address staker, address strategy, uint256 shares) returns(uint256, uint256) +func (_IShareManager *IShareManagerSession) AddShares(staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { + return _IShareManager.Contract.AddShares(&_IShareManager.TransactOpts, staker, strategy, shares) } -// AddShares is a paid mutator transaction binding the contract method 0xc4623ea1. +// AddShares is a paid mutator transaction binding the contract method 0x50ff7225. // -// Solidity: function addShares(address staker, address strategy, address token, uint256 shares) returns(uint256, uint256) -func (_IShareManager *IShareManagerTransactorSession) AddShares(staker common.Address, strategy common.Address, token common.Address, shares *big.Int) (*types.Transaction, error) { - return _IShareManager.Contract.AddShares(&_IShareManager.TransactOpts, staker, strategy, token, shares) +// Solidity: function addShares(address staker, address strategy, uint256 shares) returns(uint256, uint256) +func (_IShareManager *IShareManagerTransactorSession) AddShares(staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { + return _IShareManager.Contract.AddShares(&_IShareManager.TransactOpts, staker, strategy, shares) +} + +// IncreaseBurnableShares is a paid mutator transaction binding the contract method 0xdebe1eab. +// +// Solidity: function increaseBurnableShares(address strategy, uint256 addedSharesToBurn) returns() +func (_IShareManager *IShareManagerTransactor) IncreaseBurnableShares(opts *bind.TransactOpts, strategy common.Address, addedSharesToBurn *big.Int) (*types.Transaction, error) { + return _IShareManager.contract.Transact(opts, "increaseBurnableShares", strategy, addedSharesToBurn) +} + +// IncreaseBurnableShares is a paid mutator transaction binding the contract method 0xdebe1eab. +// +// Solidity: function increaseBurnableShares(address strategy, uint256 addedSharesToBurn) returns() +func (_IShareManager *IShareManagerSession) IncreaseBurnableShares(strategy common.Address, addedSharesToBurn *big.Int) (*types.Transaction, error) { + return _IShareManager.Contract.IncreaseBurnableShares(&_IShareManager.TransactOpts, strategy, addedSharesToBurn) +} + +// IncreaseBurnableShares is a paid mutator transaction binding the contract method 0xdebe1eab. +// +// Solidity: function increaseBurnableShares(address strategy, uint256 addedSharesToBurn) returns() +func (_IShareManager *IShareManagerTransactorSession) IncreaseBurnableShares(strategy common.Address, addedSharesToBurn *big.Int) (*types.Transaction, error) { + return _IShareManager.Contract.IncreaseBurnableShares(&_IShareManager.TransactOpts, strategy, addedSharesToBurn) } // RemoveDepositShares is a paid mutator transaction binding the contract method 0x724af423. diff --git a/pkg/bindings/IStrategyManager/binding.go b/pkg/bindings/IStrategyManager/binding.go index 036a26be22..b5d574db7f 100644 --- a/pkg/bindings/IStrategyManager/binding.go +++ b/pkg/bindings/IStrategyManager/binding.go @@ -31,7 +31,7 @@ var ( // IStrategyManagerMetaData contains all meta data concerning the IStrategyManager contract. var IStrategyManagerMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"function\",\"name\":\"addShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"addStrategiesToDepositWhitelist\",\"inputs\":[{\"name\":\"strategiesToWhitelist\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"burnShares\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"sharesToBurn\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"calculateStrategyDepositDigestHash\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"delegation\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"depositIntoStrategy\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"depositIntoStrategyWithSignature\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"getDeposits\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStakerStrategyList\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialStrategyWhitelister\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"removeDepositShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"depositSharesToRemove\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"removeStrategiesFromDepositWhitelist\",\"inputs\":[{\"name\":\"strategiesToRemoveFromWhitelist\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setStrategyWhitelister\",\"inputs\":[{\"name\":\"newStrategyWhitelister\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"stakerDepositShares\",\"inputs\":[{\"name\":\"user\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"stakerStrategyListLength\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"strategyIsWhitelistedForDeposit\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"strategyWhitelister\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"withdrawSharesAsTokens\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"Deposit\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"token\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIERC20\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyAddedToDepositWhitelist\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyRemovedFromDepositWhitelist\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyWhitelisterChanged\",\"inputs\":[{\"name\":\"previousAddress\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"newAddress\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"MaxStrategiesExceeded\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyDelegationManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyStrategyWhitelister\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SharesAmountTooHigh\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SharesAmountZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StakerAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategyNotFound\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategyNotWhitelisted\",\"inputs\":[]}]", + ABI: "[{\"type\":\"function\",\"name\":\"addShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"addStrategiesToDepositWhitelist\",\"inputs\":[{\"name\":\"strategiesToWhitelist\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"burnShares\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"calculateStrategyDepositDigestHash\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"delegation\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"depositIntoStrategy\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"depositShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"depositIntoStrategyWithSignature\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[{\"name\":\"depositShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"getBurnableShares\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getDeposits\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStakerStrategyList\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStrategiesWithBurnableShares\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"increaseBurnableShares\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"addedSharesToBurn\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialStrategyWhitelister\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"removeDepositShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"depositSharesToRemove\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"removeStrategiesFromDepositWhitelist\",\"inputs\":[{\"name\":\"strategiesToRemoveFromWhitelist\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setStrategyWhitelister\",\"inputs\":[{\"name\":\"newStrategyWhitelister\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"stakerDepositShares\",\"inputs\":[{\"name\":\"user\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"stakerStrategyListLength\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"strategyIsWhitelistedForDeposit\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"strategyWhitelister\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"withdrawSharesAsTokens\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"BurnableSharesDecreased\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"BurnableSharesIncreased\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Deposit\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyAddedToDepositWhitelist\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyRemovedFromDepositWhitelist\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyWhitelisterChanged\",\"inputs\":[{\"name\":\"previousAddress\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"newAddress\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"MaxStrategiesExceeded\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyDelegationManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyStrategyWhitelister\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SharesAmountTooHigh\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SharesAmountZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StakerAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategyNotFound\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategyNotWhitelisted\",\"inputs\":[]}]", } // IStrategyManagerABI is the input ABI used to generate the binding from. @@ -242,6 +242,37 @@ func (_IStrategyManager *IStrategyManagerCallerSession) Delegation() (common.Add return _IStrategyManager.Contract.Delegation(&_IStrategyManager.CallOpts) } +// GetBurnableShares is a free data retrieval call binding the contract method 0xfd980423. +// +// Solidity: function getBurnableShares(address strategy) view returns(uint256) +func (_IStrategyManager *IStrategyManagerCaller) GetBurnableShares(opts *bind.CallOpts, strategy common.Address) (*big.Int, error) { + var out []interface{} + err := _IStrategyManager.contract.Call(opts, &out, "getBurnableShares", strategy) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetBurnableShares is a free data retrieval call binding the contract method 0xfd980423. +// +// Solidity: function getBurnableShares(address strategy) view returns(uint256) +func (_IStrategyManager *IStrategyManagerSession) GetBurnableShares(strategy common.Address) (*big.Int, error) { + return _IStrategyManager.Contract.GetBurnableShares(&_IStrategyManager.CallOpts, strategy) +} + +// GetBurnableShares is a free data retrieval call binding the contract method 0xfd980423. +// +// Solidity: function getBurnableShares(address strategy) view returns(uint256) +func (_IStrategyManager *IStrategyManagerCallerSession) GetBurnableShares(strategy common.Address) (*big.Int, error) { + return _IStrategyManager.Contract.GetBurnableShares(&_IStrategyManager.CallOpts, strategy) +} + // GetDeposits is a free data retrieval call binding the contract method 0x94f649dd. // // Solidity: function getDeposits(address staker) view returns(address[], uint256[]) @@ -305,6 +336,38 @@ func (_IStrategyManager *IStrategyManagerCallerSession) GetStakerStrategyList(st return _IStrategyManager.Contract.GetStakerStrategyList(&_IStrategyManager.CallOpts, staker) } +// GetStrategiesWithBurnableShares is a free data retrieval call binding the contract method 0x36a8c500. +// +// Solidity: function getStrategiesWithBurnableShares() view returns(address[], uint256[]) +func (_IStrategyManager *IStrategyManagerCaller) GetStrategiesWithBurnableShares(opts *bind.CallOpts) ([]common.Address, []*big.Int, error) { + var out []interface{} + err := _IStrategyManager.contract.Call(opts, &out, "getStrategiesWithBurnableShares") + + if err != nil { + return *new([]common.Address), *new([]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + out1 := *abi.ConvertType(out[1], new([]*big.Int)).(*[]*big.Int) + + return out0, out1, err + +} + +// GetStrategiesWithBurnableShares is a free data retrieval call binding the contract method 0x36a8c500. +// +// Solidity: function getStrategiesWithBurnableShares() view returns(address[], uint256[]) +func (_IStrategyManager *IStrategyManagerSession) GetStrategiesWithBurnableShares() ([]common.Address, []*big.Int, error) { + return _IStrategyManager.Contract.GetStrategiesWithBurnableShares(&_IStrategyManager.CallOpts) +} + +// GetStrategiesWithBurnableShares is a free data retrieval call binding the contract method 0x36a8c500. +// +// Solidity: function getStrategiesWithBurnableShares() view returns(address[], uint256[]) +func (_IStrategyManager *IStrategyManagerCallerSession) GetStrategiesWithBurnableShares() ([]common.Address, []*big.Int, error) { + return _IStrategyManager.Contract.GetStrategiesWithBurnableShares(&_IStrategyManager.CallOpts) +} + // StakerDepositShares is a free data retrieval call binding the contract method 0xfe243a17. // // Solidity: function stakerDepositShares(address user, address strategy) view returns(uint256 shares) @@ -429,25 +492,25 @@ func (_IStrategyManager *IStrategyManagerCallerSession) StrategyWhitelister() (c return _IStrategyManager.Contract.StrategyWhitelister(&_IStrategyManager.CallOpts) } -// AddShares is a paid mutator transaction binding the contract method 0xc4623ea1. +// AddShares is a paid mutator transaction binding the contract method 0x50ff7225. // -// Solidity: function addShares(address staker, address strategy, address token, uint256 shares) returns(uint256, uint256) -func (_IStrategyManager *IStrategyManagerTransactor) AddShares(opts *bind.TransactOpts, staker common.Address, strategy common.Address, token common.Address, shares *big.Int) (*types.Transaction, error) { - return _IStrategyManager.contract.Transact(opts, "addShares", staker, strategy, token, shares) +// Solidity: function addShares(address staker, address strategy, uint256 shares) returns(uint256, uint256) +func (_IStrategyManager *IStrategyManagerTransactor) AddShares(opts *bind.TransactOpts, staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { + return _IStrategyManager.contract.Transact(opts, "addShares", staker, strategy, shares) } -// AddShares is a paid mutator transaction binding the contract method 0xc4623ea1. +// AddShares is a paid mutator transaction binding the contract method 0x50ff7225. // -// Solidity: function addShares(address staker, address strategy, address token, uint256 shares) returns(uint256, uint256) -func (_IStrategyManager *IStrategyManagerSession) AddShares(staker common.Address, strategy common.Address, token common.Address, shares *big.Int) (*types.Transaction, error) { - return _IStrategyManager.Contract.AddShares(&_IStrategyManager.TransactOpts, staker, strategy, token, shares) +// Solidity: function addShares(address staker, address strategy, uint256 shares) returns(uint256, uint256) +func (_IStrategyManager *IStrategyManagerSession) AddShares(staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { + return _IStrategyManager.Contract.AddShares(&_IStrategyManager.TransactOpts, staker, strategy, shares) } -// AddShares is a paid mutator transaction binding the contract method 0xc4623ea1. +// AddShares is a paid mutator transaction binding the contract method 0x50ff7225. // -// Solidity: function addShares(address staker, address strategy, address token, uint256 shares) returns(uint256, uint256) -func (_IStrategyManager *IStrategyManagerTransactorSession) AddShares(staker common.Address, strategy common.Address, token common.Address, shares *big.Int) (*types.Transaction, error) { - return _IStrategyManager.Contract.AddShares(&_IStrategyManager.TransactOpts, staker, strategy, token, shares) +// Solidity: function addShares(address staker, address strategy, uint256 shares) returns(uint256, uint256) +func (_IStrategyManager *IStrategyManagerTransactorSession) AddShares(staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { + return _IStrategyManager.Contract.AddShares(&_IStrategyManager.TransactOpts, staker, strategy, shares) } // AddStrategiesToDepositWhitelist is a paid mutator transaction binding the contract method 0x5de08ff2. @@ -471,69 +534,90 @@ func (_IStrategyManager *IStrategyManagerTransactorSession) AddStrategiesToDepos return _IStrategyManager.Contract.AddStrategiesToDepositWhitelist(&_IStrategyManager.TransactOpts, strategiesToWhitelist) } -// BurnShares is a paid mutator transaction binding the contract method 0xee7a7c04. +// BurnShares is a paid mutator transaction binding the contract method 0x4b6d5d6e. // -// Solidity: function burnShares(address strategy, uint256 sharesToBurn) returns() -func (_IStrategyManager *IStrategyManagerTransactor) BurnShares(opts *bind.TransactOpts, strategy common.Address, sharesToBurn *big.Int) (*types.Transaction, error) { - return _IStrategyManager.contract.Transact(opts, "burnShares", strategy, sharesToBurn) +// Solidity: function burnShares(address strategy) returns() +func (_IStrategyManager *IStrategyManagerTransactor) BurnShares(opts *bind.TransactOpts, strategy common.Address) (*types.Transaction, error) { + return _IStrategyManager.contract.Transact(opts, "burnShares", strategy) } -// BurnShares is a paid mutator transaction binding the contract method 0xee7a7c04. +// BurnShares is a paid mutator transaction binding the contract method 0x4b6d5d6e. // -// Solidity: function burnShares(address strategy, uint256 sharesToBurn) returns() -func (_IStrategyManager *IStrategyManagerSession) BurnShares(strategy common.Address, sharesToBurn *big.Int) (*types.Transaction, error) { - return _IStrategyManager.Contract.BurnShares(&_IStrategyManager.TransactOpts, strategy, sharesToBurn) +// Solidity: function burnShares(address strategy) returns() +func (_IStrategyManager *IStrategyManagerSession) BurnShares(strategy common.Address) (*types.Transaction, error) { + return _IStrategyManager.Contract.BurnShares(&_IStrategyManager.TransactOpts, strategy) } -// BurnShares is a paid mutator transaction binding the contract method 0xee7a7c04. +// BurnShares is a paid mutator transaction binding the contract method 0x4b6d5d6e. // -// Solidity: function burnShares(address strategy, uint256 sharesToBurn) returns() -func (_IStrategyManager *IStrategyManagerTransactorSession) BurnShares(strategy common.Address, sharesToBurn *big.Int) (*types.Transaction, error) { - return _IStrategyManager.Contract.BurnShares(&_IStrategyManager.TransactOpts, strategy, sharesToBurn) +// Solidity: function burnShares(address strategy) returns() +func (_IStrategyManager *IStrategyManagerTransactorSession) BurnShares(strategy common.Address) (*types.Transaction, error) { + return _IStrategyManager.Contract.BurnShares(&_IStrategyManager.TransactOpts, strategy) } // DepositIntoStrategy is a paid mutator transaction binding the contract method 0xe7a050aa. // -// Solidity: function depositIntoStrategy(address strategy, address token, uint256 amount) returns(uint256 shares) +// Solidity: function depositIntoStrategy(address strategy, address token, uint256 amount) returns(uint256 depositShares) func (_IStrategyManager *IStrategyManagerTransactor) DepositIntoStrategy(opts *bind.TransactOpts, strategy common.Address, token common.Address, amount *big.Int) (*types.Transaction, error) { return _IStrategyManager.contract.Transact(opts, "depositIntoStrategy", strategy, token, amount) } // DepositIntoStrategy is a paid mutator transaction binding the contract method 0xe7a050aa. // -// Solidity: function depositIntoStrategy(address strategy, address token, uint256 amount) returns(uint256 shares) +// Solidity: function depositIntoStrategy(address strategy, address token, uint256 amount) returns(uint256 depositShares) func (_IStrategyManager *IStrategyManagerSession) DepositIntoStrategy(strategy common.Address, token common.Address, amount *big.Int) (*types.Transaction, error) { return _IStrategyManager.Contract.DepositIntoStrategy(&_IStrategyManager.TransactOpts, strategy, token, amount) } // DepositIntoStrategy is a paid mutator transaction binding the contract method 0xe7a050aa. // -// Solidity: function depositIntoStrategy(address strategy, address token, uint256 amount) returns(uint256 shares) +// Solidity: function depositIntoStrategy(address strategy, address token, uint256 amount) returns(uint256 depositShares) func (_IStrategyManager *IStrategyManagerTransactorSession) DepositIntoStrategy(strategy common.Address, token common.Address, amount *big.Int) (*types.Transaction, error) { return _IStrategyManager.Contract.DepositIntoStrategy(&_IStrategyManager.TransactOpts, strategy, token, amount) } // DepositIntoStrategyWithSignature is a paid mutator transaction binding the contract method 0x32e89ace. // -// Solidity: function depositIntoStrategyWithSignature(address strategy, address token, uint256 amount, address staker, uint256 expiry, bytes signature) returns(uint256 shares) +// Solidity: function depositIntoStrategyWithSignature(address strategy, address token, uint256 amount, address staker, uint256 expiry, bytes signature) returns(uint256 depositShares) func (_IStrategyManager *IStrategyManagerTransactor) DepositIntoStrategyWithSignature(opts *bind.TransactOpts, strategy common.Address, token common.Address, amount *big.Int, staker common.Address, expiry *big.Int, signature []byte) (*types.Transaction, error) { return _IStrategyManager.contract.Transact(opts, "depositIntoStrategyWithSignature", strategy, token, amount, staker, expiry, signature) } // DepositIntoStrategyWithSignature is a paid mutator transaction binding the contract method 0x32e89ace. // -// Solidity: function depositIntoStrategyWithSignature(address strategy, address token, uint256 amount, address staker, uint256 expiry, bytes signature) returns(uint256 shares) +// Solidity: function depositIntoStrategyWithSignature(address strategy, address token, uint256 amount, address staker, uint256 expiry, bytes signature) returns(uint256 depositShares) func (_IStrategyManager *IStrategyManagerSession) DepositIntoStrategyWithSignature(strategy common.Address, token common.Address, amount *big.Int, staker common.Address, expiry *big.Int, signature []byte) (*types.Transaction, error) { return _IStrategyManager.Contract.DepositIntoStrategyWithSignature(&_IStrategyManager.TransactOpts, strategy, token, amount, staker, expiry, signature) } // DepositIntoStrategyWithSignature is a paid mutator transaction binding the contract method 0x32e89ace. // -// Solidity: function depositIntoStrategyWithSignature(address strategy, address token, uint256 amount, address staker, uint256 expiry, bytes signature) returns(uint256 shares) +// Solidity: function depositIntoStrategyWithSignature(address strategy, address token, uint256 amount, address staker, uint256 expiry, bytes signature) returns(uint256 depositShares) func (_IStrategyManager *IStrategyManagerTransactorSession) DepositIntoStrategyWithSignature(strategy common.Address, token common.Address, amount *big.Int, staker common.Address, expiry *big.Int, signature []byte) (*types.Transaction, error) { return _IStrategyManager.Contract.DepositIntoStrategyWithSignature(&_IStrategyManager.TransactOpts, strategy, token, amount, staker, expiry, signature) } +// IncreaseBurnableShares is a paid mutator transaction binding the contract method 0xdebe1eab. +// +// Solidity: function increaseBurnableShares(address strategy, uint256 addedSharesToBurn) returns() +func (_IStrategyManager *IStrategyManagerTransactor) IncreaseBurnableShares(opts *bind.TransactOpts, strategy common.Address, addedSharesToBurn *big.Int) (*types.Transaction, error) { + return _IStrategyManager.contract.Transact(opts, "increaseBurnableShares", strategy, addedSharesToBurn) +} + +// IncreaseBurnableShares is a paid mutator transaction binding the contract method 0xdebe1eab. +// +// Solidity: function increaseBurnableShares(address strategy, uint256 addedSharesToBurn) returns() +func (_IStrategyManager *IStrategyManagerSession) IncreaseBurnableShares(strategy common.Address, addedSharesToBurn *big.Int) (*types.Transaction, error) { + return _IStrategyManager.Contract.IncreaseBurnableShares(&_IStrategyManager.TransactOpts, strategy, addedSharesToBurn) +} + +// IncreaseBurnableShares is a paid mutator transaction binding the contract method 0xdebe1eab. +// +// Solidity: function increaseBurnableShares(address strategy, uint256 addedSharesToBurn) returns() +func (_IStrategyManager *IStrategyManagerTransactorSession) IncreaseBurnableShares(strategy common.Address, addedSharesToBurn *big.Int) (*types.Transaction, error) { + return _IStrategyManager.Contract.IncreaseBurnableShares(&_IStrategyManager.TransactOpts, strategy, addedSharesToBurn) +} + // Initialize is a paid mutator transaction binding the contract method 0x1794bb3c. // // Solidity: function initialize(address initialOwner, address initialStrategyWhitelister, uint256 initialPausedStatus) returns() @@ -639,6 +723,276 @@ func (_IStrategyManager *IStrategyManagerTransactorSession) WithdrawSharesAsToke return _IStrategyManager.Contract.WithdrawSharesAsTokens(&_IStrategyManager.TransactOpts, staker, strategy, token, shares) } +// IStrategyManagerBurnableSharesDecreasedIterator is returned from FilterBurnableSharesDecreased and is used to iterate over the raw logs and unpacked data for BurnableSharesDecreased events raised by the IStrategyManager contract. +type IStrategyManagerBurnableSharesDecreasedIterator struct { + Event *IStrategyManagerBurnableSharesDecreased // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IStrategyManagerBurnableSharesDecreasedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IStrategyManagerBurnableSharesDecreased) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IStrategyManagerBurnableSharesDecreased) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IStrategyManagerBurnableSharesDecreasedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IStrategyManagerBurnableSharesDecreasedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IStrategyManagerBurnableSharesDecreased represents a BurnableSharesDecreased event raised by the IStrategyManager contract. +type IStrategyManagerBurnableSharesDecreased struct { + Strategy common.Address + Shares *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterBurnableSharesDecreased is a free log retrieval operation binding the contract event 0xd9d082c3ec4f3a3ffa55c324939a06407f5fbcb87d5e0ce3b9508c92c84ed839. +// +// Solidity: event BurnableSharesDecreased(address strategy, uint256 shares) +func (_IStrategyManager *IStrategyManagerFilterer) FilterBurnableSharesDecreased(opts *bind.FilterOpts) (*IStrategyManagerBurnableSharesDecreasedIterator, error) { + + logs, sub, err := _IStrategyManager.contract.FilterLogs(opts, "BurnableSharesDecreased") + if err != nil { + return nil, err + } + return &IStrategyManagerBurnableSharesDecreasedIterator{contract: _IStrategyManager.contract, event: "BurnableSharesDecreased", logs: logs, sub: sub}, nil +} + +// WatchBurnableSharesDecreased is a free log subscription operation binding the contract event 0xd9d082c3ec4f3a3ffa55c324939a06407f5fbcb87d5e0ce3b9508c92c84ed839. +// +// Solidity: event BurnableSharesDecreased(address strategy, uint256 shares) +func (_IStrategyManager *IStrategyManagerFilterer) WatchBurnableSharesDecreased(opts *bind.WatchOpts, sink chan<- *IStrategyManagerBurnableSharesDecreased) (event.Subscription, error) { + + logs, sub, err := _IStrategyManager.contract.WatchLogs(opts, "BurnableSharesDecreased") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(IStrategyManagerBurnableSharesDecreased) + if err := _IStrategyManager.contract.UnpackLog(event, "BurnableSharesDecreased", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseBurnableSharesDecreased is a log parse operation binding the contract event 0xd9d082c3ec4f3a3ffa55c324939a06407f5fbcb87d5e0ce3b9508c92c84ed839. +// +// Solidity: event BurnableSharesDecreased(address strategy, uint256 shares) +func (_IStrategyManager *IStrategyManagerFilterer) ParseBurnableSharesDecreased(log types.Log) (*IStrategyManagerBurnableSharesDecreased, error) { + event := new(IStrategyManagerBurnableSharesDecreased) + if err := _IStrategyManager.contract.UnpackLog(event, "BurnableSharesDecreased", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// IStrategyManagerBurnableSharesIncreasedIterator is returned from FilterBurnableSharesIncreased and is used to iterate over the raw logs and unpacked data for BurnableSharesIncreased events raised by the IStrategyManager contract. +type IStrategyManagerBurnableSharesIncreasedIterator struct { + Event *IStrategyManagerBurnableSharesIncreased // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IStrategyManagerBurnableSharesIncreasedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IStrategyManagerBurnableSharesIncreased) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IStrategyManagerBurnableSharesIncreased) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IStrategyManagerBurnableSharesIncreasedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IStrategyManagerBurnableSharesIncreasedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IStrategyManagerBurnableSharesIncreased represents a BurnableSharesIncreased event raised by the IStrategyManager contract. +type IStrategyManagerBurnableSharesIncreased struct { + Strategy common.Address + Shares *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterBurnableSharesIncreased is a free log retrieval operation binding the contract event 0xca3e02a4ab7ad3c47a8e36e5a624c30170791726ab720f1babfef21046d953ff. +// +// Solidity: event BurnableSharesIncreased(address strategy, uint256 shares) +func (_IStrategyManager *IStrategyManagerFilterer) FilterBurnableSharesIncreased(opts *bind.FilterOpts) (*IStrategyManagerBurnableSharesIncreasedIterator, error) { + + logs, sub, err := _IStrategyManager.contract.FilterLogs(opts, "BurnableSharesIncreased") + if err != nil { + return nil, err + } + return &IStrategyManagerBurnableSharesIncreasedIterator{contract: _IStrategyManager.contract, event: "BurnableSharesIncreased", logs: logs, sub: sub}, nil +} + +// WatchBurnableSharesIncreased is a free log subscription operation binding the contract event 0xca3e02a4ab7ad3c47a8e36e5a624c30170791726ab720f1babfef21046d953ff. +// +// Solidity: event BurnableSharesIncreased(address strategy, uint256 shares) +func (_IStrategyManager *IStrategyManagerFilterer) WatchBurnableSharesIncreased(opts *bind.WatchOpts, sink chan<- *IStrategyManagerBurnableSharesIncreased) (event.Subscription, error) { + + logs, sub, err := _IStrategyManager.contract.WatchLogs(opts, "BurnableSharesIncreased") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(IStrategyManagerBurnableSharesIncreased) + if err := _IStrategyManager.contract.UnpackLog(event, "BurnableSharesIncreased", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseBurnableSharesIncreased is a log parse operation binding the contract event 0xca3e02a4ab7ad3c47a8e36e5a624c30170791726ab720f1babfef21046d953ff. +// +// Solidity: event BurnableSharesIncreased(address strategy, uint256 shares) +func (_IStrategyManager *IStrategyManagerFilterer) ParseBurnableSharesIncreased(log types.Log) (*IStrategyManagerBurnableSharesIncreased, error) { + event := new(IStrategyManagerBurnableSharesIncreased) + if err := _IStrategyManager.contract.UnpackLog(event, "BurnableSharesIncreased", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + // IStrategyManagerDepositIterator is returned from FilterDeposit and is used to iterate over the raw logs and unpacked data for Deposit events raised by the IStrategyManager contract. type IStrategyManagerDepositIterator struct { Event *IStrategyManagerDeposit // Event containing the contract specifics and raw log @@ -709,15 +1063,14 @@ func (it *IStrategyManagerDepositIterator) Close() error { // IStrategyManagerDeposit represents a Deposit event raised by the IStrategyManager contract. type IStrategyManagerDeposit struct { Staker common.Address - Token common.Address Strategy common.Address Shares *big.Int Raw types.Log // Blockchain specific contextual infos } -// FilterDeposit is a free log retrieval operation binding the contract event 0x7cfff908a4b583f36430b25d75964c458d8ede8a99bd61be750e97ee1b2f3a96. +// FilterDeposit is a free log retrieval operation binding the contract event 0x5548c837ab068cf56a2c2479df0882a4922fd203edb7517321831d95078c5f62. // -// Solidity: event Deposit(address staker, address token, address strategy, uint256 shares) +// Solidity: event Deposit(address staker, address strategy, uint256 shares) func (_IStrategyManager *IStrategyManagerFilterer) FilterDeposit(opts *bind.FilterOpts) (*IStrategyManagerDepositIterator, error) { logs, sub, err := _IStrategyManager.contract.FilterLogs(opts, "Deposit") @@ -727,9 +1080,9 @@ func (_IStrategyManager *IStrategyManagerFilterer) FilterDeposit(opts *bind.Filt return &IStrategyManagerDepositIterator{contract: _IStrategyManager.contract, event: "Deposit", logs: logs, sub: sub}, nil } -// WatchDeposit is a free log subscription operation binding the contract event 0x7cfff908a4b583f36430b25d75964c458d8ede8a99bd61be750e97ee1b2f3a96. +// WatchDeposit is a free log subscription operation binding the contract event 0x5548c837ab068cf56a2c2479df0882a4922fd203edb7517321831d95078c5f62. // -// Solidity: event Deposit(address staker, address token, address strategy, uint256 shares) +// Solidity: event Deposit(address staker, address strategy, uint256 shares) func (_IStrategyManager *IStrategyManagerFilterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *IStrategyManagerDeposit) (event.Subscription, error) { logs, sub, err := _IStrategyManager.contract.WatchLogs(opts, "Deposit") @@ -764,9 +1117,9 @@ func (_IStrategyManager *IStrategyManagerFilterer) WatchDeposit(opts *bind.Watch }), nil } -// ParseDeposit is a log parse operation binding the contract event 0x7cfff908a4b583f36430b25d75964c458d8ede8a99bd61be750e97ee1b2f3a96. +// ParseDeposit is a log parse operation binding the contract event 0x5548c837ab068cf56a2c2479df0882a4922fd203edb7517321831d95078c5f62. // -// Solidity: event Deposit(address staker, address token, address strategy, uint256 shares) +// Solidity: event Deposit(address staker, address strategy, uint256 shares) func (_IStrategyManager *IStrategyManagerFilterer) ParseDeposit(log types.Log) (*IStrategyManagerDeposit, error) { event := new(IStrategyManagerDeposit) if err := _IStrategyManager.contract.UnpackLog(event, "Deposit", log); err != nil { diff --git a/pkg/bindings/Merkle/binding.go b/pkg/bindings/Merkle/binding.go index 0dc9f1d9c9..d1795f6605 100644 --- a/pkg/bindings/Merkle/binding.go +++ b/pkg/bindings/Merkle/binding.go @@ -32,7 +32,7 @@ var ( // MerkleMetaData contains all meta data concerning the Merkle contract. var MerkleMetaData = &bind.MetaData{ ABI: "[{\"type\":\"error\",\"name\":\"InvalidProofLength\",\"inputs\":[]}]", - Bin: "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea264697066735822122085b24342099ee34c979b25a8181cab47b19a7b5bb98497e7c396cfeef68fc84564736f6c634300081b0033", + Bin: "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212208de82ea7f1a22cc126cdf4c3791b57f420fcc4ed980bdbddf119e15f4a112e8964736f6c634300081b0033", } // MerkleABI is the input ABI used to generate the binding from. diff --git a/pkg/bindings/OperatorSetLib/binding.go b/pkg/bindings/OperatorSetLib/binding.go index 6053888ada..a48c2cefdd 100644 --- a/pkg/bindings/OperatorSetLib/binding.go +++ b/pkg/bindings/OperatorSetLib/binding.go @@ -32,7 +32,7 @@ var ( // OperatorSetLibMetaData contains all meta data concerning the OperatorSetLib contract. var OperatorSetLibMetaData = &bind.MetaData{ ABI: "[]", - Bin: "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212208e75671188dda11a78514701822a433b1e7210d9141d5e2911f793e717037afc64736f6c634300081b0033", + Bin: "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea264697066735822122023e8e6cb91eee2d3c43ff6cfc219a624b12892e20fd5158ca2b4e1484806bb9c64736f6c634300081b0033", } // OperatorSetLibABI is the input ABI used to generate the binding from. diff --git a/pkg/bindings/PauserRegistry/binding.go b/pkg/bindings/PauserRegistry/binding.go index 1e8885e369..a77ccb9e9d 100644 --- a/pkg/bindings/PauserRegistry/binding.go +++ b/pkg/bindings/PauserRegistry/binding.go @@ -32,7 +32,7 @@ var ( // PauserRegistryMetaData contains all meta data concerning the PauserRegistry contract. var PauserRegistryMetaData = &bind.MetaData{ ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_pausers\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"_unpauser\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"isPauser\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"setIsPauser\",\"inputs\":[{\"name\":\"newPauser\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"canPause\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setUnpauser\",\"inputs\":[{\"name\":\"newUnpauser\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"unpauser\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"event\",\"name\":\"PauserStatusChanged\",\"inputs\":[{\"name\":\"pauser\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"canPause\",\"type\":\"bool\",\"indexed\":false,\"internalType\":\"bool\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"UnpauserChanged\",\"inputs\":[{\"name\":\"previousUnpauser\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"newUnpauser\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"InputAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyUnpauser\",\"inputs\":[]}]", - Bin: "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", + Bin: "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", } // PauserRegistryABI is the input ABI used to generate the binding from. diff --git a/pkg/bindings/PermissionController/binding.go b/pkg/bindings/PermissionController/binding.go index 42053b7097..21f037d593 100644 --- a/pkg/bindings/PermissionController/binding.go +++ b/pkg/bindings/PermissionController/binding.go @@ -32,7 +32,7 @@ var ( // PermissionControllerMetaData contains all meta data concerning the PermissionController contract. var PermissionControllerMetaData = &bind.MetaData{ ABI: "[{\"type\":\"constructor\",\"inputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"acceptAdmin\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"addPendingAdmin\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"admin\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"canCall\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"caller\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"target\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"selector\",\"type\":\"bytes4\",\"internalType\":\"bytes4\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAdmins\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"address[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAppointeePermissions\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"appointee\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"\",\"type\":\"bytes4[]\",\"internalType\":\"bytes4[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAppointees\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"target\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"selector\",\"type\":\"bytes4\",\"internalType\":\"bytes4\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"address[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getPendingAdmins\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"address[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isAdmin\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"caller\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isPendingAdmin\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"pendingAdmin\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"removeAdmin\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"admin\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"removeAppointee\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"appointee\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"target\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"selector\",\"type\":\"bytes4\",\"internalType\":\"bytes4\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"removePendingAdmin\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"admin\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setAppointee\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"appointee\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"target\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"selector\",\"type\":\"bytes4\",\"internalType\":\"bytes4\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"AdminRemoved\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"admin\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"AdminSet\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"admin\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"AppointeeRemoved\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"appointee\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"target\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"selector\",\"type\":\"bytes4\",\"indexed\":false,\"internalType\":\"bytes4\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"AppointeeSet\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"appointee\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"target\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"selector\",\"type\":\"bytes4\",\"indexed\":false,\"internalType\":\"bytes4\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"PendingAdminAdded\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"admin\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"PendingAdminRemoved\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"admin\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"AdminAlreadyPending\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"AdminAlreadySet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"AdminNotPending\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"AdminNotSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"AppointeeAlreadySet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"AppointeeNotSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CannotHaveZeroAdmins\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NotAdmin\",\"inputs\":[]}]", - Bin: "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", + Bin: "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", } // PermissionControllerABI is the input ABI used to generate the binding from. diff --git a/pkg/bindings/RewardsCoordinator/binding.go b/pkg/bindings/RewardsCoordinator/binding.go index 81b98471e0..3c744f23a0 100644 --- a/pkg/bindings/RewardsCoordinator/binding.go +++ b/pkg/bindings/RewardsCoordinator/binding.go @@ -94,7 +94,7 @@ type IRewardsCoordinatorTypesTokenTreeMerkleLeaf struct { // RewardsCoordinatorMetaData contains all meta data concerning the RewardsCoordinator contract. var RewardsCoordinatorMetaData = &bind.MetaData{ ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_delegationManager\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"},{\"name\":\"_strategyManager\",\"type\":\"address\",\"internalType\":\"contractIStrategyManager\"},{\"name\":\"_allocationManager\",\"type\":\"address\",\"internalType\":\"contractIAllocationManager\"},{\"name\":\"_pauserRegistry\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"},{\"name\":\"_permissionController\",\"type\":\"address\",\"internalType\":\"contractIPermissionController\"},{\"name\":\"_CALCULATION_INTERVAL_SECONDS\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"_MAX_REWARDS_DURATION\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"_MAX_RETROACTIVE_LENGTH\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"_MAX_FUTURE_LENGTH\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"_GENESIS_REWARDS_TIMESTAMP\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"CALCULATION_INTERVAL_SECONDS\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"GENESIS_REWARDS_TIMESTAMP\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"MAX_FUTURE_LENGTH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"MAX_RETROACTIVE_LENGTH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"MAX_REWARDS_DURATION\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"activationDelay\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"allocationManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIAllocationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"beaconChainETHStrategy\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"calculateEarnerLeafHash\",\"inputs\":[{\"name\":\"leaf\",\"type\":\"tuple\",\"internalType\":\"structIRewardsCoordinatorTypes.EarnerTreeMerkleLeaf\",\"components\":[{\"name\":\"earner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"earnerTokenRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"calculateTokenLeafHash\",\"inputs\":[{\"name\":\"leaf\",\"type\":\"tuple\",\"internalType\":\"structIRewardsCoordinatorTypes.TokenTreeMerkleLeaf\",\"components\":[{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"cumulativeEarnings\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"checkClaim\",\"inputs\":[{\"name\":\"claim\",\"type\":\"tuple\",\"internalType\":\"structIRewardsCoordinatorTypes.RewardsMerkleClaim\",\"components\":[{\"name\":\"rootIndex\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"earnerIndex\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"earnerTreeProof\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"earnerLeaf\",\"type\":\"tuple\",\"internalType\":\"structIRewardsCoordinatorTypes.EarnerTreeMerkleLeaf\",\"components\":[{\"name\":\"earner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"earnerTokenRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}]},{\"name\":\"tokenIndices\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"},{\"name\":\"tokenTreeProofs\",\"type\":\"bytes[]\",\"internalType\":\"bytes[]\"},{\"name\":\"tokenLeaves\",\"type\":\"tuple[]\",\"internalType\":\"structIRewardsCoordinatorTypes.TokenTreeMerkleLeaf[]\",\"components\":[{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"cumulativeEarnings\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"claimerFor\",\"inputs\":[{\"name\":\"earner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"claimer\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"createAVSRewardsSubmission\",\"inputs\":[{\"name\":\"rewardsSubmissions\",\"type\":\"tuple[]\",\"internalType\":\"structIRewardsCoordinatorTypes.RewardsSubmission[]\",\"components\":[{\"name\":\"strategiesAndMultipliers\",\"type\":\"tuple[]\",\"internalType\":\"structIRewardsCoordinatorTypes.StrategyAndMultiplier[]\",\"components\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"multiplier\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"duration\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"createOperatorDirectedAVSRewardsSubmission\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorDirectedRewardsSubmissions\",\"type\":\"tuple[]\",\"internalType\":\"structIRewardsCoordinatorTypes.OperatorDirectedRewardsSubmission[]\",\"components\":[{\"name\":\"strategiesAndMultipliers\",\"type\":\"tuple[]\",\"internalType\":\"structIRewardsCoordinatorTypes.StrategyAndMultiplier[]\",\"components\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"multiplier\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"operatorRewards\",\"type\":\"tuple[]\",\"internalType\":\"structIRewardsCoordinatorTypes.OperatorReward[]\",\"components\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"startTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"duration\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"description\",\"type\":\"string\",\"internalType\":\"string\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"createRewardsForAllEarners\",\"inputs\":[{\"name\":\"rewardsSubmissions\",\"type\":\"tuple[]\",\"internalType\":\"structIRewardsCoordinatorTypes.RewardsSubmission[]\",\"components\":[{\"name\":\"strategiesAndMultipliers\",\"type\":\"tuple[]\",\"internalType\":\"structIRewardsCoordinatorTypes.StrategyAndMultiplier[]\",\"components\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"multiplier\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"duration\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"createRewardsForAllSubmission\",\"inputs\":[{\"name\":\"rewardsSubmissions\",\"type\":\"tuple[]\",\"internalType\":\"structIRewardsCoordinatorTypes.RewardsSubmission[]\",\"components\":[{\"name\":\"strategiesAndMultipliers\",\"type\":\"tuple[]\",\"internalType\":\"structIRewardsCoordinatorTypes.StrategyAndMultiplier[]\",\"components\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"multiplier\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"duration\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"cumulativeClaimed\",\"inputs\":[{\"name\":\"earner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"}],\"outputs\":[{\"name\":\"totalClaimed\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"currRewardsCalculationEndTimestamp\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"defaultOperatorSplitBips\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"delegationManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"disableRoot\",\"inputs\":[{\"name\":\"rootIndex\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"getCurrentClaimableDistributionRoot\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIRewardsCoordinatorTypes.DistributionRoot\",\"components\":[{\"name\":\"root\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"rewardsCalculationEndTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"activatedAt\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"disabled\",\"type\":\"bool\",\"internalType\":\"bool\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getCurrentDistributionRoot\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIRewardsCoordinatorTypes.DistributionRoot\",\"components\":[{\"name\":\"root\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"rewardsCalculationEndTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"activatedAt\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"disabled\",\"type\":\"bool\",\"internalType\":\"bool\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getDistributionRootAtIndex\",\"inputs\":[{\"name\":\"index\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIRewardsCoordinatorTypes.DistributionRoot\",\"components\":[{\"name\":\"root\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"rewardsCalculationEndTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"activatedAt\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"disabled\",\"type\":\"bool\",\"internalType\":\"bool\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getDistributionRootsLength\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorAVSSplit\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorPISplit\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getRootIndexFromHash\",\"inputs\":[{\"name\":\"rootHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_rewardsUpdater\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_activationDelay\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"_defaultSplitBips\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"isAVSRewardsSubmissionHash\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"hash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"valid\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isOperatorDirectedAVSRewardsSubmissionHash\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isRewardsForAllSubmitter\",\"inputs\":[{\"name\":\"submitter\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"valid\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isRewardsSubmissionForAllEarnersHash\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"hash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"valid\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isRewardsSubmissionForAllHash\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"hash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"valid\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"pauseAll\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[{\"name\":\"index\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pauserRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"permissionController\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPermissionController\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"processClaim\",\"inputs\":[{\"name\":\"claim\",\"type\":\"tuple\",\"internalType\":\"structIRewardsCoordinatorTypes.RewardsMerkleClaim\",\"components\":[{\"name\":\"rootIndex\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"earnerIndex\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"earnerTreeProof\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"earnerLeaf\",\"type\":\"tuple\",\"internalType\":\"structIRewardsCoordinatorTypes.EarnerTreeMerkleLeaf\",\"components\":[{\"name\":\"earner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"earnerTokenRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}]},{\"name\":\"tokenIndices\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"},{\"name\":\"tokenTreeProofs\",\"type\":\"bytes[]\",\"internalType\":\"bytes[]\"},{\"name\":\"tokenLeaves\",\"type\":\"tuple[]\",\"internalType\":\"structIRewardsCoordinatorTypes.TokenTreeMerkleLeaf[]\",\"components\":[{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"cumulativeEarnings\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]}]},{\"name\":\"recipient\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"processClaims\",\"inputs\":[{\"name\":\"claims\",\"type\":\"tuple[]\",\"internalType\":\"structIRewardsCoordinatorTypes.RewardsMerkleClaim[]\",\"components\":[{\"name\":\"rootIndex\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"earnerIndex\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"earnerTreeProof\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"earnerLeaf\",\"type\":\"tuple\",\"internalType\":\"structIRewardsCoordinatorTypes.EarnerTreeMerkleLeaf\",\"components\":[{\"name\":\"earner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"earnerTokenRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}]},{\"name\":\"tokenIndices\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"},{\"name\":\"tokenTreeProofs\",\"type\":\"bytes[]\",\"internalType\":\"bytes[]\"},{\"name\":\"tokenLeaves\",\"type\":\"tuple[]\",\"internalType\":\"structIRewardsCoordinatorTypes.TokenTreeMerkleLeaf[]\",\"components\":[{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"cumulativeEarnings\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]}]},{\"name\":\"recipient\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"rewardsUpdater\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"setActivationDelay\",\"inputs\":[{\"name\":\"_activationDelay\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setClaimerFor\",\"inputs\":[{\"name\":\"claimer\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setClaimerFor\",\"inputs\":[{\"name\":\"earner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"claimer\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setDefaultOperatorSplit\",\"inputs\":[{\"name\":\"split\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setOperatorAVSSplit\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"split\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setOperatorPISplit\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"split\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setRewardsForAllSubmitter\",\"inputs\":[{\"name\":\"_submitter\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_newValue\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setRewardsUpdater\",\"inputs\":[{\"name\":\"_rewardsUpdater\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"strategyManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategyManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"submissionNonce\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"submitRoot\",\"inputs\":[{\"name\":\"root\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"rewardsCalculationEndTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"AVSRewardsSubmissionCreated\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"submissionNonce\",\"type\":\"uint256\",\"indexed\":true,\"internalType\":\"uint256\"},{\"name\":\"rewardsSubmissionHash\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"},{\"name\":\"rewardsSubmission\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structIRewardsCoordinatorTypes.RewardsSubmission\",\"components\":[{\"name\":\"strategiesAndMultipliers\",\"type\":\"tuple[]\",\"internalType\":\"structIRewardsCoordinatorTypes.StrategyAndMultiplier[]\",\"components\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"multiplier\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"duration\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"ActivationDelaySet\",\"inputs\":[{\"name\":\"oldActivationDelay\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"},{\"name\":\"newActivationDelay\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"ClaimerForSet\",\"inputs\":[{\"name\":\"earner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"oldClaimer\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"claimer\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"DefaultOperatorSplitBipsSet\",\"inputs\":[{\"name\":\"oldDefaultOperatorSplitBips\",\"type\":\"uint16\",\"indexed\":false,\"internalType\":\"uint16\"},{\"name\":\"newDefaultOperatorSplitBips\",\"type\":\"uint16\",\"indexed\":false,\"internalType\":\"uint16\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"DistributionRootDisabled\",\"inputs\":[{\"name\":\"rootIndex\",\"type\":\"uint32\",\"indexed\":true,\"internalType\":\"uint32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"DistributionRootSubmitted\",\"inputs\":[{\"name\":\"rootIndex\",\"type\":\"uint32\",\"indexed\":true,\"internalType\":\"uint32\"},{\"name\":\"root\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"},{\"name\":\"rewardsCalculationEndTimestamp\",\"type\":\"uint32\",\"indexed\":true,\"internalType\":\"uint32\"},{\"name\":\"activatedAt\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorAVSSplitBipsSet\",\"inputs\":[{\"name\":\"caller\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"activatedAt\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"},{\"name\":\"oldOperatorAVSSplitBips\",\"type\":\"uint16\",\"indexed\":false,\"internalType\":\"uint16\"},{\"name\":\"newOperatorAVSSplitBips\",\"type\":\"uint16\",\"indexed\":false,\"internalType\":\"uint16\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorDirectedAVSRewardsSubmissionCreated\",\"inputs\":[{\"name\":\"caller\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operatorDirectedRewardsSubmissionHash\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"},{\"name\":\"submissionNonce\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"operatorDirectedRewardsSubmission\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structIRewardsCoordinatorTypes.OperatorDirectedRewardsSubmission\",\"components\":[{\"name\":\"strategiesAndMultipliers\",\"type\":\"tuple[]\",\"internalType\":\"structIRewardsCoordinatorTypes.StrategyAndMultiplier[]\",\"components\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"multiplier\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"operatorRewards\",\"type\":\"tuple[]\",\"internalType\":\"structIRewardsCoordinatorTypes.OperatorReward[]\",\"components\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"startTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"duration\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"description\",\"type\":\"string\",\"internalType\":\"string\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorPISplitBipsSet\",\"inputs\":[{\"name\":\"caller\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"activatedAt\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"},{\"name\":\"oldOperatorPISplitBips\",\"type\":\"uint16\",\"indexed\":false,\"internalType\":\"uint16\"},{\"name\":\"newOperatorPISplitBips\",\"type\":\"uint16\",\"indexed\":false,\"internalType\":\"uint16\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"RewardsClaimed\",\"inputs\":[{\"name\":\"root\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"},{\"name\":\"earner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"claimer\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"recipient\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"token\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIERC20\"},{\"name\":\"claimedAmount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"RewardsForAllSubmitterSet\",\"inputs\":[{\"name\":\"rewardsForAllSubmitter\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"oldValue\",\"type\":\"bool\",\"indexed\":true,\"internalType\":\"bool\"},{\"name\":\"newValue\",\"type\":\"bool\",\"indexed\":true,\"internalType\":\"bool\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"RewardsSubmissionForAllCreated\",\"inputs\":[{\"name\":\"submitter\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"submissionNonce\",\"type\":\"uint256\",\"indexed\":true,\"internalType\":\"uint256\"},{\"name\":\"rewardsSubmissionHash\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"},{\"name\":\"rewardsSubmission\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structIRewardsCoordinatorTypes.RewardsSubmission\",\"components\":[{\"name\":\"strategiesAndMultipliers\",\"type\":\"tuple[]\",\"internalType\":\"structIRewardsCoordinatorTypes.StrategyAndMultiplier[]\",\"components\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"multiplier\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"duration\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"RewardsSubmissionForAllEarnersCreated\",\"inputs\":[{\"name\":\"tokenHopper\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"submissionNonce\",\"type\":\"uint256\",\"indexed\":true,\"internalType\":\"uint256\"},{\"name\":\"rewardsSubmissionHash\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"},{\"name\":\"rewardsSubmission\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structIRewardsCoordinatorTypes.RewardsSubmission\",\"components\":[{\"name\":\"strategiesAndMultipliers\",\"type\":\"tuple[]\",\"internalType\":\"structIRewardsCoordinatorTypes.StrategyAndMultiplier[]\",\"components\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"multiplier\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"duration\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"RewardsUpdaterSet\",\"inputs\":[{\"name\":\"oldRewardsUpdater\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newRewardsUpdater\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"AmountExceedsMax\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"AmountIsZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CurrentlyPaused\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"DurationExceedsMax\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"EarningsNotGreaterThanClaimed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputArrayLengthMismatch\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputArrayLengthZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidCalculationIntervalSecondsRemainder\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidClaimProof\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidDurationRemainder\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidEarner\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidEarnerLeafIndex\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidGenesisRewardsTimestampRemainder\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidNewPausedStatus\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidPermissions\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidProofLength\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidRoot\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidRootIndex\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidStartTimestampRemainder\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidTokenLeafIndex\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NewRootMustBeForNewCalculatedPeriod\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyPauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyUnpauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorsNotInAscendingOrder\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"PreviousSplitPending\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"RewardsEndTimestampNotElapsed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"RootAlreadyActivated\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"RootDisabled\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"RootNotActivated\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SplitExceedsMax\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StartTimestampTooFarInFuture\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StartTimestampTooFarInPast\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategiesNotInAscendingOrder\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategyNotWhitelisted\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SubmissionNotRetroactive\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"UnauthorizedCaller\",\"inputs\":[]}]", - Bin: "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", + Bin: "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", } // RewardsCoordinatorABI is the input ABI used to generate the binding from. diff --git a/pkg/bindings/SlashingLib/binding.go b/pkg/bindings/SlashingLib/binding.go index 32b0744054..7d63923c31 100644 --- a/pkg/bindings/SlashingLib/binding.go +++ b/pkg/bindings/SlashingLib/binding.go @@ -32,7 +32,7 @@ var ( // SlashingLibMetaData contains all meta data concerning the SlashingLib contract. var SlashingLibMetaData = &bind.MetaData{ ABI: "[]", - Bin: "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea2646970667358221220031531159115e859f21eed5ce5e4aaa5ca9fd89d5ab9cee05fde16361a4e53a664736f6c634300081b0033", + Bin: "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea264697066735822122079d8acd82faee8c5e28651bbc1515549e1c13cf6bb3869d1f31aa11a796fa9f664736f6c634300081b0033", } // SlashingLibABI is the input ABI used to generate the binding from. diff --git a/pkg/bindings/Snapshots/binding.go b/pkg/bindings/Snapshots/binding.go index 351dab3266..2a6027eebf 100644 --- a/pkg/bindings/Snapshots/binding.go +++ b/pkg/bindings/Snapshots/binding.go @@ -32,7 +32,7 @@ var ( // SnapshotsMetaData contains all meta data concerning the Snapshots contract. var SnapshotsMetaData = &bind.MetaData{ ABI: "[{\"type\":\"error\",\"name\":\"InvalidSnapshotOrdering\",\"inputs\":[]}]", - Bin: "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea26469706673582212202269455111f3a63331a42edaf90ec124683e8dcd2c97e7d0cc1d0f6a66af373f64736f6c634300081b0033", + Bin: "0x60556032600b8282823980515f1a607314602657634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe730000000000000000000000000000000000000000301460806040525f5ffdfea264697066735822122044bb5b18319bff57ed60efd0467beb2f05208fa5189c267bfd18f0a7f7417aa964736f6c634300081b0033", } // SnapshotsABI is the input ABI used to generate the binding from. diff --git a/pkg/bindings/StrategyBase/binding.go b/pkg/bindings/StrategyBase/binding.go index 381b87939d..ac35ee68e7 100644 --- a/pkg/bindings/StrategyBase/binding.go +++ b/pkg/bindings/StrategyBase/binding.go @@ -32,7 +32,7 @@ var ( // StrategyBaseMetaData contains all meta data concerning the StrategyBase contract. var StrategyBaseMetaData = &bind.MetaData{ ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_strategyManager\",\"type\":\"address\",\"internalType\":\"contractIStrategyManager\"},{\"name\":\"_pauserRegistry\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"deposit\",\"inputs\":[{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"newShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"explanation\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"_underlyingToken\",\"type\":\"address\",\"internalType\":\"contractIERC20\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"pauseAll\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[{\"name\":\"index\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pauserRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"shares\",\"inputs\":[{\"name\":\"user\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"sharesToUnderlying\",\"inputs\":[{\"name\":\"amountShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"sharesToUnderlyingView\",\"inputs\":[{\"name\":\"amountShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"strategyManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategyManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"totalShares\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"underlyingToShares\",\"inputs\":[{\"name\":\"amountUnderlying\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"underlyingToSharesView\",\"inputs\":[{\"name\":\"amountUnderlying\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"underlyingToken\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIERC20\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"userUnderlying\",\"inputs\":[{\"name\":\"user\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"userUnderlyingView\",\"inputs\":[{\"name\":\"user\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"withdraw\",\"inputs\":[{\"name\":\"recipient\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amountShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"ExchangeRateEmitted\",\"inputs\":[{\"name\":\"rate\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyTokenSet\",\"inputs\":[{\"name\":\"token\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIERC20\"},{\"name\":\"decimals\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"BalanceExceedsMaxTotalDeposits\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CurrentlyPaused\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidNewPausedStatus\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"MaxPerDepositExceedsMax\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NewSharesZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyPauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyStrategyManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyUnderlyingToken\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyUnpauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"TotalSharesExceedsMax\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"WithdrawalAmountExceedsTotalDeposits\",\"inputs\":[]}]", - Bin: "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", + Bin: "0x60c060405234801561000f575f5ffd5b506040516113a63803806113a683398101604081905261002e9161014b565b806001600160a01b038116610056576040516339b190bb60e11b815260040160405180910390fd5b6001600160a01b03908116608052821660a052610071610078565b5050610183565b5f54610100900460ff16156100e35760405162461bcd60e51b815260206004820152602760248201527f496e697469616c697a61626c653a20636f6e747261637420697320696e697469604482015266616c697a696e6760c81b606482015260840160405180910390fd5b5f5460ff90811614610132575f805460ff191660ff9081179091556040519081527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15b565b6001600160a01b0381168114610148575f5ffd5b50565b5f5f6040838503121561015c575f5ffd5b825161016781610134565b602084015190925061017881610134565b809150509250929050565b60805160a0516111d86101ce5f395f81816101750152818161040201528181610796015261083301525f818161022b0152818161030f01528181610543015261096101526111d85ff3fe608060405234801561000f575f5ffd5b5060043610610127575f3560e01c8063886f1195116100a9578063ce7c2ac21161006e578063ce7c2ac21461029b578063d9caed12146102ae578063e3dae51c146102c1578063f3e73875146102d4578063fabc1cbc146102e7575f5ffd5b8063886f1195146102265780638c8710191461024d5780638f6a624014610260578063ab5921e114610273578063c4d66de814610288575f5ffd5b8063553ca5f8116100ef578063553ca5f8146101c1578063595c6a67146101d45780635ac86ab7146101dc5780635c975abb1461020b5780637a8b263714610213575f5ffd5b8063136439dd1461012b5780632495a5991461014057806339b70e38146101705780633a98ef391461019757806347e7ef24146101ae575b5f5ffd5b61013e610139366004610f4d565b6102fa565b005b603254610153906001600160a01b031681565b6040516001600160a01b0390911681526020015b60405180910390f35b6101537f000000000000000000000000000000000000000000000000000000000000000081565b6101a060335481565b604051908152602001610167565b6101a06101bc366004610f7b565b6103cf565b6101a06101cf366004610fa5565b61051b565b61013e61052e565b6101fb6101ea366004610fd5565b6001805460ff9092161b9081161490565b6040519015158152602001610167565b6001546101a0565b6101a0610221366004610f4d565b6105dd565b6101537f000000000000000000000000000000000000000000000000000000000000000081565b6101a061025b366004610f4d565b610626565b6101a061026e366004610fa5565b610630565b61027b61063d565b6040516101679190610ff0565b61013e610296366004610fa5565b61065d565b6101a06102a9366004610fa5565b61076f565b61013e6102bc366004611025565b610801565b6101a06102cf366004610f4d565b61091e565b6101a06102e2366004610f4d565b610955565b61013e6102f5366004610f4d565b61095f565b60405163237dfb4760e11b81523360048201527f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316906346fbf68e90602401602060405180830381865afa15801561035c573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906103809190611063565b61039d57604051631d77d47760e21b815260040160405180910390fd5b60015481811681146103c25760405163c61dca5d60e01b815260040160405180910390fd5b6103cb82610a75565b5050565b600180545f9182918116036103f75760405163840a48d560e01b815260040160405180910390fd5b336001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001614610440576040516348da714f60e01b815260040160405180910390fd5b61044a8484610ab2565b6033545f61045a6103e883611096565b90505f6103e8610468610ae0565b6104729190611096565b90505f61047f87836110a9565b90508061048c84896110bc565b61049691906110d3565b9550855f036104b857604051630c392ed360e11b815260040160405180910390fd5b6104c28685611096565b60338190556f4b3b4ca85a86c47a098a223fffffffff10156104f757604051632f14e8a360e11b815260040160405180910390fd5b610510826103e860335461050b9190611096565b610b4f565b505050505092915050565b5f6105286102218361076f565b92915050565b60405163237dfb4760e11b81523360048201527f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316906346fbf68e90602401602060405180830381865afa158015610590573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906105b49190611063565b6105d157604051631d77d47760e21b815260040160405180910390fd5b6105db5f19610a75565b565b5f5f6103e86033546105ef9190611096565b90505f6103e86105fd610ae0565b6106079190611096565b90508161061485836110bc565b61061e91906110d3565b949350505050565b5f6105288261091e565b5f6105286102e28361076f565b60606040518060800160405280604d8152602001611156604d9139905090565b5f54610100900460ff161580801561067b57505f54600160ff909116105b806106945750303b15801561069457505f5460ff166001145b6106fc5760405162461bcd60e51b815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201526d191e481a5b9a5d1a585b1a5e995960921b60648201526084015b60405180910390fd5b5f805460ff19166001179055801561071d575f805461ff0019166101001790555b61072682610b9b565b80156103cb575f805461ff0019169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498906020015b60405180910390a15050565b60405163fe243a1760e01b81526001600160a01b0382811660048301523060248301525f917f00000000000000000000000000000000000000000000000000000000000000009091169063fe243a1790604401602060405180830381865afa1580156107dd573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061052891906110f2565b600180546002908116036108285760405163840a48d560e01b815260040160405180910390fd5b336001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001614610871576040516348da714f60e01b815260040160405180910390fd5b61087c848484610ce6565b603354808311156108a057604051630b469df360e41b815260040160405180910390fd5b5f6108ad6103e883611096565b90505f6103e86108bb610ae0565b6108c59190611096565b90505f826108d387846110bc565b6108dd91906110d3565b90506108e986856110a9565b6033556109096108f982846110a9565b6103e860335461050b9190611096565b610914888883610d19565b5050505050505050565b5f5f6103e86033546109309190611096565b90505f6103e861093e610ae0565b6109489190611096565b90508061061483866110bc565b5f610528826105dd565b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031663eab66d7a6040518163ffffffff1660e01b8152600401602060405180830381865afa1580156109bb573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906109df9190611109565b6001600160a01b0316336001600160a01b031614610a105760405163794821ff60e01b815260040160405180910390fd5b60015480198219811614610a375760405163c61dca5d60e01b815260040160405180910390fd5b600182905560405182815233907f3582d1828e26bf56bd801502bc021ac0bc8afb57c826e4986b45593c8fad389c9060200160405180910390a25050565b600181905560405181815233907fab40a374bc51de372200a8bc981af8c9ecdc08dfdaef0bb6e09f88f3c616ef3d9060200160405180910390a250565b6032546001600160a01b038381169116146103cb57604051630312abdd60e61b815260040160405180910390fd5b6032546040516370a0823160e01b81523060048201525f916001600160a01b0316906370a0823190602401602060405180830381865afa158015610b26573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610b4a91906110f2565b905090565b7fd2494f3479e5da49d386657c292c610b5b01df313d07c62eb0cfa49924a31be881610b8384670de0b6b3a76400006110bc565b610b8d91906110d3565b604051908152602001610763565b5f54610100900460ff16610c055760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201526a6e697469616c697a696e6760a81b60648201526084016106f3565b603280546001600160a01b0319166001600160a01b038316179055610c295f610a75565b7f1c540707b00eb5427b6b774fc799d756516a54aee108b64b327acc55af55750760325f9054906101000a90046001600160a01b0316826001600160a01b031663313ce5676040518163ffffffff1660e01b8152600401602060405180830381865afa158015610c9b573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610cbf9190611124565b604080516001600160a01b03909316835260ff90911660208301520160405180910390a150565b6032546001600160a01b03838116911614610d1457604051630312abdd60e61b815260040160405180910390fd5b505050565b604080516001600160a01b03858116602483015260448083018590528351808403909101815260649092018352602080830180516001600160e01b031663a9059cbb60e01b17905283518085019094528084527f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c656490840152610d1492908516918691859185918591905f90610db19084908490610e30565b905080515f1480610dd1575080806020019051810190610dd19190611063565b610d145760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6044820152691bdd081cdd58d8d9595960b21b60648201526084016106f3565b606061061e84845f85855f5f866001600160a01b03168587604051610e55919061113f565b5f6040518083038185875af1925050503d805f8114610e8f576040519150601f19603f3d011682016040523d82523d5f602084013e610e94565b606091505b5091509150610ea587838387610eb0565b979650505050505050565b60608315610f1e5782515f03610f17576001600160a01b0385163b610f175760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e747261637400000060448201526064016106f3565b508161061e565b61061e8383815115610f335781518083602001fd5b8060405162461bcd60e51b81526004016106f39190610ff0565b5f60208284031215610f5d575f5ffd5b5035919050565b6001600160a01b0381168114610f78575f5ffd5b50565b5f5f60408385031215610f8c575f5ffd5b8235610f9781610f64565b946020939093013593505050565b5f60208284031215610fb5575f5ffd5b8135610fc081610f64565b9392505050565b60ff81168114610f78575f5ffd5b5f60208284031215610fe5575f5ffd5b8135610fc081610fc7565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f83011684010191505092915050565b5f5f5f60608486031215611037575f5ffd5b833561104281610f64565b9250602084013561105281610f64565b929592945050506040919091013590565b5f60208284031215611073575f5ffd5b81518015158114610fc0575f5ffd5b634e487b7160e01b5f52601160045260245ffd5b8082018082111561052857610528611082565b8181038181111561052857610528611082565b808202811582820484141761052857610528611082565b5f826110ed57634e487b7160e01b5f52601260045260245ffd5b500490565b5f60208284031215611102575f5ffd5b5051919050565b5f60208284031215611119575f5ffd5b8151610fc081610f64565b5f60208284031215611134575f5ffd5b8151610fc081610fc7565b5f82518060208501845e5f92019182525091905056fe4261736520537472617465677920696d706c656d656e746174696f6e20746f20696e68657269742066726f6d20666f72206d6f726520636f6d706c657820696d706c656d656e746174696f6e73a2646970667358221220601b35d308a21bc556eb3a47693a37c1997871cb19c44ae4188b093a82e9065f64736f6c634300081b0033", } // StrategyBaseABI is the input ABI used to generate the binding from. diff --git a/pkg/bindings/StrategyBaseTVLLimits/binding.go b/pkg/bindings/StrategyBaseTVLLimits/binding.go index 1987d88d69..fa4679dba3 100644 --- a/pkg/bindings/StrategyBaseTVLLimits/binding.go +++ b/pkg/bindings/StrategyBaseTVLLimits/binding.go @@ -32,7 +32,7 @@ var ( // StrategyBaseTVLLimitsMetaData contains all meta data concerning the StrategyBaseTVLLimits contract. var StrategyBaseTVLLimitsMetaData = &bind.MetaData{ ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_strategyManager\",\"type\":\"address\",\"internalType\":\"contractIStrategyManager\"},{\"name\":\"_pauserRegistry\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"deposit\",\"inputs\":[{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"newShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"explanation\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"getTVLLimits\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"_maxPerDeposit\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_maxTotalDeposits\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_underlyingToken\",\"type\":\"address\",\"internalType\":\"contractIERC20\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"_underlyingToken\",\"type\":\"address\",\"internalType\":\"contractIERC20\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"maxPerDeposit\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"maxTotalDeposits\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"pauseAll\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[{\"name\":\"index\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pauserRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"setTVLLimits\",\"inputs\":[{\"name\":\"newMaxPerDeposit\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"newMaxTotalDeposits\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"shares\",\"inputs\":[{\"name\":\"user\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"sharesToUnderlying\",\"inputs\":[{\"name\":\"amountShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"sharesToUnderlyingView\",\"inputs\":[{\"name\":\"amountShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"strategyManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategyManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"totalShares\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"underlyingToShares\",\"inputs\":[{\"name\":\"amountUnderlying\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"underlyingToSharesView\",\"inputs\":[{\"name\":\"amountUnderlying\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"underlyingToken\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIERC20\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"userUnderlying\",\"inputs\":[{\"name\":\"user\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"userUnderlyingView\",\"inputs\":[{\"name\":\"user\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"withdraw\",\"inputs\":[{\"name\":\"recipient\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amountShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"ExchangeRateEmitted\",\"inputs\":[{\"name\":\"rate\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"MaxPerDepositUpdated\",\"inputs\":[{\"name\":\"previousValue\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"newValue\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"MaxTotalDepositsUpdated\",\"inputs\":[{\"name\":\"previousValue\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"newValue\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyTokenSet\",\"inputs\":[{\"name\":\"token\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIERC20\"},{\"name\":\"decimals\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"BalanceExceedsMaxTotalDeposits\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CurrentlyPaused\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidNewPausedStatus\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"MaxPerDepositExceedsMax\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NewSharesZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyPauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyStrategyManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyUnderlyingToken\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyUnpauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"TotalSharesExceedsMax\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"WithdrawalAmountExceedsTotalDeposits\",\"inputs\":[]}]", - Bin: "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", + Bin: "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", } // StrategyBaseTVLLimitsABI is the input ABI used to generate the binding from. diff --git a/pkg/bindings/StrategyFactory/binding.go b/pkg/bindings/StrategyFactory/binding.go index ea68cdebb4..97185cc669 100644 --- a/pkg/bindings/StrategyFactory/binding.go +++ b/pkg/bindings/StrategyFactory/binding.go @@ -32,7 +32,7 @@ var ( // StrategyFactoryMetaData contains all meta data concerning the StrategyFactory contract. var StrategyFactoryMetaData = &bind.MetaData{ ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_strategyManager\",\"type\":\"address\",\"internalType\":\"contractIStrategyManager\"},{\"name\":\"_pauserRegistry\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"blacklistTokens\",\"inputs\":[{\"name\":\"tokens\",\"type\":\"address[]\",\"internalType\":\"contractIERC20[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"deployNewStrategy\",\"inputs\":[{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"}],\"outputs\":[{\"name\":\"newStrategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"deployedStrategies\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIERC20\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"_initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_strategyBeacon\",\"type\":\"address\",\"internalType\":\"contractIBeacon\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"isBlacklisted\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIERC20\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"pauseAll\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[{\"name\":\"index\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pauserRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"removeStrategiesFromWhitelist\",\"inputs\":[{\"name\":\"strategiesToRemoveFromWhitelist\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"strategyBeacon\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIBeacon\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"strategyManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategyManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"whitelistStrategies\",\"inputs\":[{\"name\":\"strategiesToWhitelist\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyBeaconModified\",\"inputs\":[{\"name\":\"previousBeacon\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIBeacon\"},{\"name\":\"newBeacon\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIBeacon\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategySetForToken\",\"inputs\":[{\"name\":\"token\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIERC20\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"TokenBlacklisted\",\"inputs\":[{\"name\":\"token\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIERC20\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"AlreadyBlacklisted\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BlacklistedToken\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CurrentlyPaused\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidNewPausedStatus\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyPauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyUnpauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategyAlreadyExists\",\"inputs\":[]}]", - Bin: "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", + Bin: "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", } // StrategyFactoryABI is the input ABI used to generate the binding from. diff --git a/pkg/bindings/StrategyManager/binding.go b/pkg/bindings/StrategyManager/binding.go index 1dfed8ba9d..a11b22ffac 100644 --- a/pkg/bindings/StrategyManager/binding.go +++ b/pkg/bindings/StrategyManager/binding.go @@ -31,8 +31,8 @@ var ( // StrategyManagerMetaData contains all meta data concerning the StrategyManager contract. var StrategyManagerMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_delegation\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"},{\"name\":\"_pauserRegistry\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"DEFAULT_BURN_ADDRESS\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"DEPOSIT_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"addShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"addStrategiesToDepositWhitelist\",\"inputs\":[{\"name\":\"strategiesToWhitelist\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"burnShares\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"sharesToBurn\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"calculateStrategyDepositDigestHash\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"delegation\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"depositIntoStrategy\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"depositedShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"depositIntoStrategyWithSignature\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[{\"name\":\"depositedShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"domainSeparator\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getDeposits\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStakerStrategyList\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialStrategyWhitelister\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"nonces\",\"inputs\":[{\"name\":\"signer\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"pauseAll\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[{\"name\":\"index\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pauserRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"removeDepositShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"depositSharesToRemove\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"removeStrategiesFromDepositWhitelist\",\"inputs\":[{\"name\":\"strategiesToRemoveFromWhitelist\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setStrategyWhitelister\",\"inputs\":[{\"name\":\"newStrategyWhitelister\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"stakerDepositShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"stakerStrategyList\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"strategies\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"stakerStrategyListLength\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"strategyIsWhitelistedForDeposit\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"whitelisted\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"strategyWhitelister\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"withdrawSharesAsTokens\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"Deposit\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"token\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIERC20\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyAddedToDepositWhitelist\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyRemovedFromDepositWhitelist\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyWhitelisterChanged\",\"inputs\":[{\"name\":\"previousAddress\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"newAddress\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"CurrentlyPaused\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidNewPausedStatus\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidSignature\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"MaxStrategiesExceeded\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyDelegationManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyPauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyStrategyWhitelister\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyUnpauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SharesAmountTooHigh\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SharesAmountZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SignatureExpired\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StakerAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategyNotFound\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategyNotWhitelisted\",\"inputs\":[]}]", - Bin: "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", + ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_delegation\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"},{\"name\":\"_pauserRegistry\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"DEFAULT_BURN_ADDRESS\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"DEPOSIT_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"addShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"addStrategiesToDepositWhitelist\",\"inputs\":[{\"name\":\"strategiesToWhitelist\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"burnShares\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"calculateStrategyDepositDigestHash\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"delegation\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"depositIntoStrategy\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"depositShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"depositIntoStrategyWithSignature\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[{\"name\":\"depositShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"domainSeparator\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getBurnableShares\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getDeposits\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStakerStrategyList\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStrategiesWithBurnableShares\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"increaseBurnableShares\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"addedSharesToBurn\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialStrategyWhitelister\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"nonces\",\"inputs\":[{\"name\":\"signer\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"pauseAll\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[{\"name\":\"index\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pauserRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"removeDepositShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"depositSharesToRemove\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"removeStrategiesFromDepositWhitelist\",\"inputs\":[{\"name\":\"strategiesToRemoveFromWhitelist\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setStrategyWhitelister\",\"inputs\":[{\"name\":\"newStrategyWhitelister\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"stakerDepositShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"stakerStrategyList\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"strategies\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"stakerStrategyListLength\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"strategyIsWhitelistedForDeposit\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"whitelisted\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"strategyWhitelister\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"withdrawSharesAsTokens\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"BurnableSharesDecreased\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"BurnableSharesIncreased\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Deposit\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyAddedToDepositWhitelist\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyRemovedFromDepositWhitelist\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyWhitelisterChanged\",\"inputs\":[{\"name\":\"previousAddress\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"newAddress\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"CurrentlyPaused\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidNewPausedStatus\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidSignature\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"MaxStrategiesExceeded\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyDelegationManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyPauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyStrategyWhitelister\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyUnpauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SharesAmountTooHigh\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SharesAmountZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SignatureExpired\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StakerAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategyNotFound\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategyNotWhitelisted\",\"inputs\":[]}]", + Bin: "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", } // StrategyManagerABI is the input ABI used to generate the binding from. @@ -357,6 +357,37 @@ func (_StrategyManager *StrategyManagerCallerSession) DomainSeparator() ([32]byt return _StrategyManager.Contract.DomainSeparator(&_StrategyManager.CallOpts) } +// GetBurnableShares is a free data retrieval call binding the contract method 0xfd980423. +// +// Solidity: function getBurnableShares(address strategy) view returns(uint256) +func (_StrategyManager *StrategyManagerCaller) GetBurnableShares(opts *bind.CallOpts, strategy common.Address) (*big.Int, error) { + var out []interface{} + err := _StrategyManager.contract.Call(opts, &out, "getBurnableShares", strategy) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetBurnableShares is a free data retrieval call binding the contract method 0xfd980423. +// +// Solidity: function getBurnableShares(address strategy) view returns(uint256) +func (_StrategyManager *StrategyManagerSession) GetBurnableShares(strategy common.Address) (*big.Int, error) { + return _StrategyManager.Contract.GetBurnableShares(&_StrategyManager.CallOpts, strategy) +} + +// GetBurnableShares is a free data retrieval call binding the contract method 0xfd980423. +// +// Solidity: function getBurnableShares(address strategy) view returns(uint256) +func (_StrategyManager *StrategyManagerCallerSession) GetBurnableShares(strategy common.Address) (*big.Int, error) { + return _StrategyManager.Contract.GetBurnableShares(&_StrategyManager.CallOpts, strategy) +} + // GetDeposits is a free data retrieval call binding the contract method 0x94f649dd. // // Solidity: function getDeposits(address staker) view returns(address[], uint256[]) @@ -420,6 +451,38 @@ func (_StrategyManager *StrategyManagerCallerSession) GetStakerStrategyList(stak return _StrategyManager.Contract.GetStakerStrategyList(&_StrategyManager.CallOpts, staker) } +// GetStrategiesWithBurnableShares is a free data retrieval call binding the contract method 0x36a8c500. +// +// Solidity: function getStrategiesWithBurnableShares() view returns(address[], uint256[]) +func (_StrategyManager *StrategyManagerCaller) GetStrategiesWithBurnableShares(opts *bind.CallOpts) ([]common.Address, []*big.Int, error) { + var out []interface{} + err := _StrategyManager.contract.Call(opts, &out, "getStrategiesWithBurnableShares") + + if err != nil { + return *new([]common.Address), *new([]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + out1 := *abi.ConvertType(out[1], new([]*big.Int)).(*[]*big.Int) + + return out0, out1, err + +} + +// GetStrategiesWithBurnableShares is a free data retrieval call binding the contract method 0x36a8c500. +// +// Solidity: function getStrategiesWithBurnableShares() view returns(address[], uint256[]) +func (_StrategyManager *StrategyManagerSession) GetStrategiesWithBurnableShares() ([]common.Address, []*big.Int, error) { + return _StrategyManager.Contract.GetStrategiesWithBurnableShares(&_StrategyManager.CallOpts) +} + +// GetStrategiesWithBurnableShares is a free data retrieval call binding the contract method 0x36a8c500. +// +// Solidity: function getStrategiesWithBurnableShares() view returns(address[], uint256[]) +func (_StrategyManager *StrategyManagerCallerSession) GetStrategiesWithBurnableShares() ([]common.Address, []*big.Int, error) { + return _StrategyManager.Contract.GetStrategiesWithBurnableShares(&_StrategyManager.CallOpts) +} + // Nonces is a free data retrieval call binding the contract method 0x7ecebe00. // // Solidity: function nonces(address signer) view returns(uint256 nonce) @@ -730,25 +793,25 @@ func (_StrategyManager *StrategyManagerCallerSession) StrategyWhitelister() (com return _StrategyManager.Contract.StrategyWhitelister(&_StrategyManager.CallOpts) } -// AddShares is a paid mutator transaction binding the contract method 0xc4623ea1. +// AddShares is a paid mutator transaction binding the contract method 0x50ff7225. // -// Solidity: function addShares(address staker, address strategy, address token, uint256 shares) returns(uint256, uint256) -func (_StrategyManager *StrategyManagerTransactor) AddShares(opts *bind.TransactOpts, staker common.Address, strategy common.Address, token common.Address, shares *big.Int) (*types.Transaction, error) { - return _StrategyManager.contract.Transact(opts, "addShares", staker, strategy, token, shares) +// Solidity: function addShares(address staker, address strategy, uint256 shares) returns(uint256, uint256) +func (_StrategyManager *StrategyManagerTransactor) AddShares(opts *bind.TransactOpts, staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { + return _StrategyManager.contract.Transact(opts, "addShares", staker, strategy, shares) } -// AddShares is a paid mutator transaction binding the contract method 0xc4623ea1. +// AddShares is a paid mutator transaction binding the contract method 0x50ff7225. // -// Solidity: function addShares(address staker, address strategy, address token, uint256 shares) returns(uint256, uint256) -func (_StrategyManager *StrategyManagerSession) AddShares(staker common.Address, strategy common.Address, token common.Address, shares *big.Int) (*types.Transaction, error) { - return _StrategyManager.Contract.AddShares(&_StrategyManager.TransactOpts, staker, strategy, token, shares) +// Solidity: function addShares(address staker, address strategy, uint256 shares) returns(uint256, uint256) +func (_StrategyManager *StrategyManagerSession) AddShares(staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { + return _StrategyManager.Contract.AddShares(&_StrategyManager.TransactOpts, staker, strategy, shares) } -// AddShares is a paid mutator transaction binding the contract method 0xc4623ea1. +// AddShares is a paid mutator transaction binding the contract method 0x50ff7225. // -// Solidity: function addShares(address staker, address strategy, address token, uint256 shares) returns(uint256, uint256) -func (_StrategyManager *StrategyManagerTransactorSession) AddShares(staker common.Address, strategy common.Address, token common.Address, shares *big.Int) (*types.Transaction, error) { - return _StrategyManager.Contract.AddShares(&_StrategyManager.TransactOpts, staker, strategy, token, shares) +// Solidity: function addShares(address staker, address strategy, uint256 shares) returns(uint256, uint256) +func (_StrategyManager *StrategyManagerTransactorSession) AddShares(staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { + return _StrategyManager.Contract.AddShares(&_StrategyManager.TransactOpts, staker, strategy, shares) } // AddStrategiesToDepositWhitelist is a paid mutator transaction binding the contract method 0x5de08ff2. @@ -772,69 +835,90 @@ func (_StrategyManager *StrategyManagerTransactorSession) AddStrategiesToDeposit return _StrategyManager.Contract.AddStrategiesToDepositWhitelist(&_StrategyManager.TransactOpts, strategiesToWhitelist) } -// BurnShares is a paid mutator transaction binding the contract method 0xee7a7c04. +// BurnShares is a paid mutator transaction binding the contract method 0x4b6d5d6e. // -// Solidity: function burnShares(address strategy, uint256 sharesToBurn) returns() -func (_StrategyManager *StrategyManagerTransactor) BurnShares(opts *bind.TransactOpts, strategy common.Address, sharesToBurn *big.Int) (*types.Transaction, error) { - return _StrategyManager.contract.Transact(opts, "burnShares", strategy, sharesToBurn) +// Solidity: function burnShares(address strategy) returns() +func (_StrategyManager *StrategyManagerTransactor) BurnShares(opts *bind.TransactOpts, strategy common.Address) (*types.Transaction, error) { + return _StrategyManager.contract.Transact(opts, "burnShares", strategy) } -// BurnShares is a paid mutator transaction binding the contract method 0xee7a7c04. +// BurnShares is a paid mutator transaction binding the contract method 0x4b6d5d6e. // -// Solidity: function burnShares(address strategy, uint256 sharesToBurn) returns() -func (_StrategyManager *StrategyManagerSession) BurnShares(strategy common.Address, sharesToBurn *big.Int) (*types.Transaction, error) { - return _StrategyManager.Contract.BurnShares(&_StrategyManager.TransactOpts, strategy, sharesToBurn) +// Solidity: function burnShares(address strategy) returns() +func (_StrategyManager *StrategyManagerSession) BurnShares(strategy common.Address) (*types.Transaction, error) { + return _StrategyManager.Contract.BurnShares(&_StrategyManager.TransactOpts, strategy) } -// BurnShares is a paid mutator transaction binding the contract method 0xee7a7c04. +// BurnShares is a paid mutator transaction binding the contract method 0x4b6d5d6e. // -// Solidity: function burnShares(address strategy, uint256 sharesToBurn) returns() -func (_StrategyManager *StrategyManagerTransactorSession) BurnShares(strategy common.Address, sharesToBurn *big.Int) (*types.Transaction, error) { - return _StrategyManager.Contract.BurnShares(&_StrategyManager.TransactOpts, strategy, sharesToBurn) +// Solidity: function burnShares(address strategy) returns() +func (_StrategyManager *StrategyManagerTransactorSession) BurnShares(strategy common.Address) (*types.Transaction, error) { + return _StrategyManager.Contract.BurnShares(&_StrategyManager.TransactOpts, strategy) } // DepositIntoStrategy is a paid mutator transaction binding the contract method 0xe7a050aa. // -// Solidity: function depositIntoStrategy(address strategy, address token, uint256 amount) returns(uint256 depositedShares) +// Solidity: function depositIntoStrategy(address strategy, address token, uint256 amount) returns(uint256 depositShares) func (_StrategyManager *StrategyManagerTransactor) DepositIntoStrategy(opts *bind.TransactOpts, strategy common.Address, token common.Address, amount *big.Int) (*types.Transaction, error) { return _StrategyManager.contract.Transact(opts, "depositIntoStrategy", strategy, token, amount) } // DepositIntoStrategy is a paid mutator transaction binding the contract method 0xe7a050aa. // -// Solidity: function depositIntoStrategy(address strategy, address token, uint256 amount) returns(uint256 depositedShares) +// Solidity: function depositIntoStrategy(address strategy, address token, uint256 amount) returns(uint256 depositShares) func (_StrategyManager *StrategyManagerSession) DepositIntoStrategy(strategy common.Address, token common.Address, amount *big.Int) (*types.Transaction, error) { return _StrategyManager.Contract.DepositIntoStrategy(&_StrategyManager.TransactOpts, strategy, token, amount) } // DepositIntoStrategy is a paid mutator transaction binding the contract method 0xe7a050aa. // -// Solidity: function depositIntoStrategy(address strategy, address token, uint256 amount) returns(uint256 depositedShares) +// Solidity: function depositIntoStrategy(address strategy, address token, uint256 amount) returns(uint256 depositShares) func (_StrategyManager *StrategyManagerTransactorSession) DepositIntoStrategy(strategy common.Address, token common.Address, amount *big.Int) (*types.Transaction, error) { return _StrategyManager.Contract.DepositIntoStrategy(&_StrategyManager.TransactOpts, strategy, token, amount) } // DepositIntoStrategyWithSignature is a paid mutator transaction binding the contract method 0x32e89ace. // -// Solidity: function depositIntoStrategyWithSignature(address strategy, address token, uint256 amount, address staker, uint256 expiry, bytes signature) returns(uint256 depositedShares) +// Solidity: function depositIntoStrategyWithSignature(address strategy, address token, uint256 amount, address staker, uint256 expiry, bytes signature) returns(uint256 depositShares) func (_StrategyManager *StrategyManagerTransactor) DepositIntoStrategyWithSignature(opts *bind.TransactOpts, strategy common.Address, token common.Address, amount *big.Int, staker common.Address, expiry *big.Int, signature []byte) (*types.Transaction, error) { return _StrategyManager.contract.Transact(opts, "depositIntoStrategyWithSignature", strategy, token, amount, staker, expiry, signature) } // DepositIntoStrategyWithSignature is a paid mutator transaction binding the contract method 0x32e89ace. // -// Solidity: function depositIntoStrategyWithSignature(address strategy, address token, uint256 amount, address staker, uint256 expiry, bytes signature) returns(uint256 depositedShares) +// Solidity: function depositIntoStrategyWithSignature(address strategy, address token, uint256 amount, address staker, uint256 expiry, bytes signature) returns(uint256 depositShares) func (_StrategyManager *StrategyManagerSession) DepositIntoStrategyWithSignature(strategy common.Address, token common.Address, amount *big.Int, staker common.Address, expiry *big.Int, signature []byte) (*types.Transaction, error) { return _StrategyManager.Contract.DepositIntoStrategyWithSignature(&_StrategyManager.TransactOpts, strategy, token, amount, staker, expiry, signature) } // DepositIntoStrategyWithSignature is a paid mutator transaction binding the contract method 0x32e89ace. // -// Solidity: function depositIntoStrategyWithSignature(address strategy, address token, uint256 amount, address staker, uint256 expiry, bytes signature) returns(uint256 depositedShares) +// Solidity: function depositIntoStrategyWithSignature(address strategy, address token, uint256 amount, address staker, uint256 expiry, bytes signature) returns(uint256 depositShares) func (_StrategyManager *StrategyManagerTransactorSession) DepositIntoStrategyWithSignature(strategy common.Address, token common.Address, amount *big.Int, staker common.Address, expiry *big.Int, signature []byte) (*types.Transaction, error) { return _StrategyManager.Contract.DepositIntoStrategyWithSignature(&_StrategyManager.TransactOpts, strategy, token, amount, staker, expiry, signature) } +// IncreaseBurnableShares is a paid mutator transaction binding the contract method 0xdebe1eab. +// +// Solidity: function increaseBurnableShares(address strategy, uint256 addedSharesToBurn) returns() +func (_StrategyManager *StrategyManagerTransactor) IncreaseBurnableShares(opts *bind.TransactOpts, strategy common.Address, addedSharesToBurn *big.Int) (*types.Transaction, error) { + return _StrategyManager.contract.Transact(opts, "increaseBurnableShares", strategy, addedSharesToBurn) +} + +// IncreaseBurnableShares is a paid mutator transaction binding the contract method 0xdebe1eab. +// +// Solidity: function increaseBurnableShares(address strategy, uint256 addedSharesToBurn) returns() +func (_StrategyManager *StrategyManagerSession) IncreaseBurnableShares(strategy common.Address, addedSharesToBurn *big.Int) (*types.Transaction, error) { + return _StrategyManager.Contract.IncreaseBurnableShares(&_StrategyManager.TransactOpts, strategy, addedSharesToBurn) +} + +// IncreaseBurnableShares is a paid mutator transaction binding the contract method 0xdebe1eab. +// +// Solidity: function increaseBurnableShares(address strategy, uint256 addedSharesToBurn) returns() +func (_StrategyManager *StrategyManagerTransactorSession) IncreaseBurnableShares(strategy common.Address, addedSharesToBurn *big.Int) (*types.Transaction, error) { + return _StrategyManager.Contract.IncreaseBurnableShares(&_StrategyManager.TransactOpts, strategy, addedSharesToBurn) +} + // Initialize is a paid mutator transaction binding the contract method 0x1794bb3c. // // Solidity: function initialize(address initialOwner, address initialStrategyWhitelister, uint256 initialPausedStatus) returns() @@ -1045,6 +1129,276 @@ func (_StrategyManager *StrategyManagerTransactorSession) WithdrawSharesAsTokens return _StrategyManager.Contract.WithdrawSharesAsTokens(&_StrategyManager.TransactOpts, staker, strategy, token, shares) } +// StrategyManagerBurnableSharesDecreasedIterator is returned from FilterBurnableSharesDecreased and is used to iterate over the raw logs and unpacked data for BurnableSharesDecreased events raised by the StrategyManager contract. +type StrategyManagerBurnableSharesDecreasedIterator struct { + Event *StrategyManagerBurnableSharesDecreased // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StrategyManagerBurnableSharesDecreasedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StrategyManagerBurnableSharesDecreased) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StrategyManagerBurnableSharesDecreased) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StrategyManagerBurnableSharesDecreasedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StrategyManagerBurnableSharesDecreasedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StrategyManagerBurnableSharesDecreased represents a BurnableSharesDecreased event raised by the StrategyManager contract. +type StrategyManagerBurnableSharesDecreased struct { + Strategy common.Address + Shares *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterBurnableSharesDecreased is a free log retrieval operation binding the contract event 0xd9d082c3ec4f3a3ffa55c324939a06407f5fbcb87d5e0ce3b9508c92c84ed839. +// +// Solidity: event BurnableSharesDecreased(address strategy, uint256 shares) +func (_StrategyManager *StrategyManagerFilterer) FilterBurnableSharesDecreased(opts *bind.FilterOpts) (*StrategyManagerBurnableSharesDecreasedIterator, error) { + + logs, sub, err := _StrategyManager.contract.FilterLogs(opts, "BurnableSharesDecreased") + if err != nil { + return nil, err + } + return &StrategyManagerBurnableSharesDecreasedIterator{contract: _StrategyManager.contract, event: "BurnableSharesDecreased", logs: logs, sub: sub}, nil +} + +// WatchBurnableSharesDecreased is a free log subscription operation binding the contract event 0xd9d082c3ec4f3a3ffa55c324939a06407f5fbcb87d5e0ce3b9508c92c84ed839. +// +// Solidity: event BurnableSharesDecreased(address strategy, uint256 shares) +func (_StrategyManager *StrategyManagerFilterer) WatchBurnableSharesDecreased(opts *bind.WatchOpts, sink chan<- *StrategyManagerBurnableSharesDecreased) (event.Subscription, error) { + + logs, sub, err := _StrategyManager.contract.WatchLogs(opts, "BurnableSharesDecreased") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StrategyManagerBurnableSharesDecreased) + if err := _StrategyManager.contract.UnpackLog(event, "BurnableSharesDecreased", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseBurnableSharesDecreased is a log parse operation binding the contract event 0xd9d082c3ec4f3a3ffa55c324939a06407f5fbcb87d5e0ce3b9508c92c84ed839. +// +// Solidity: event BurnableSharesDecreased(address strategy, uint256 shares) +func (_StrategyManager *StrategyManagerFilterer) ParseBurnableSharesDecreased(log types.Log) (*StrategyManagerBurnableSharesDecreased, error) { + event := new(StrategyManagerBurnableSharesDecreased) + if err := _StrategyManager.contract.UnpackLog(event, "BurnableSharesDecreased", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// StrategyManagerBurnableSharesIncreasedIterator is returned from FilterBurnableSharesIncreased and is used to iterate over the raw logs and unpacked data for BurnableSharesIncreased events raised by the StrategyManager contract. +type StrategyManagerBurnableSharesIncreasedIterator struct { + Event *StrategyManagerBurnableSharesIncreased // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StrategyManagerBurnableSharesIncreasedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StrategyManagerBurnableSharesIncreased) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StrategyManagerBurnableSharesIncreased) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StrategyManagerBurnableSharesIncreasedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StrategyManagerBurnableSharesIncreasedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StrategyManagerBurnableSharesIncreased represents a BurnableSharesIncreased event raised by the StrategyManager contract. +type StrategyManagerBurnableSharesIncreased struct { + Strategy common.Address + Shares *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterBurnableSharesIncreased is a free log retrieval operation binding the contract event 0xca3e02a4ab7ad3c47a8e36e5a624c30170791726ab720f1babfef21046d953ff. +// +// Solidity: event BurnableSharesIncreased(address strategy, uint256 shares) +func (_StrategyManager *StrategyManagerFilterer) FilterBurnableSharesIncreased(opts *bind.FilterOpts) (*StrategyManagerBurnableSharesIncreasedIterator, error) { + + logs, sub, err := _StrategyManager.contract.FilterLogs(opts, "BurnableSharesIncreased") + if err != nil { + return nil, err + } + return &StrategyManagerBurnableSharesIncreasedIterator{contract: _StrategyManager.contract, event: "BurnableSharesIncreased", logs: logs, sub: sub}, nil +} + +// WatchBurnableSharesIncreased is a free log subscription operation binding the contract event 0xca3e02a4ab7ad3c47a8e36e5a624c30170791726ab720f1babfef21046d953ff. +// +// Solidity: event BurnableSharesIncreased(address strategy, uint256 shares) +func (_StrategyManager *StrategyManagerFilterer) WatchBurnableSharesIncreased(opts *bind.WatchOpts, sink chan<- *StrategyManagerBurnableSharesIncreased) (event.Subscription, error) { + + logs, sub, err := _StrategyManager.contract.WatchLogs(opts, "BurnableSharesIncreased") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StrategyManagerBurnableSharesIncreased) + if err := _StrategyManager.contract.UnpackLog(event, "BurnableSharesIncreased", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseBurnableSharesIncreased is a log parse operation binding the contract event 0xca3e02a4ab7ad3c47a8e36e5a624c30170791726ab720f1babfef21046d953ff. +// +// Solidity: event BurnableSharesIncreased(address strategy, uint256 shares) +func (_StrategyManager *StrategyManagerFilterer) ParseBurnableSharesIncreased(log types.Log) (*StrategyManagerBurnableSharesIncreased, error) { + event := new(StrategyManagerBurnableSharesIncreased) + if err := _StrategyManager.contract.UnpackLog(event, "BurnableSharesIncreased", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + // StrategyManagerDepositIterator is returned from FilterDeposit and is used to iterate over the raw logs and unpacked data for Deposit events raised by the StrategyManager contract. type StrategyManagerDepositIterator struct { Event *StrategyManagerDeposit // Event containing the contract specifics and raw log @@ -1115,15 +1469,14 @@ func (it *StrategyManagerDepositIterator) Close() error { // StrategyManagerDeposit represents a Deposit event raised by the StrategyManager contract. type StrategyManagerDeposit struct { Staker common.Address - Token common.Address Strategy common.Address Shares *big.Int Raw types.Log // Blockchain specific contextual infos } -// FilterDeposit is a free log retrieval operation binding the contract event 0x7cfff908a4b583f36430b25d75964c458d8ede8a99bd61be750e97ee1b2f3a96. +// FilterDeposit is a free log retrieval operation binding the contract event 0x5548c837ab068cf56a2c2479df0882a4922fd203edb7517321831d95078c5f62. // -// Solidity: event Deposit(address staker, address token, address strategy, uint256 shares) +// Solidity: event Deposit(address staker, address strategy, uint256 shares) func (_StrategyManager *StrategyManagerFilterer) FilterDeposit(opts *bind.FilterOpts) (*StrategyManagerDepositIterator, error) { logs, sub, err := _StrategyManager.contract.FilterLogs(opts, "Deposit") @@ -1133,9 +1486,9 @@ func (_StrategyManager *StrategyManagerFilterer) FilterDeposit(opts *bind.Filter return &StrategyManagerDepositIterator{contract: _StrategyManager.contract, event: "Deposit", logs: logs, sub: sub}, nil } -// WatchDeposit is a free log subscription operation binding the contract event 0x7cfff908a4b583f36430b25d75964c458d8ede8a99bd61be750e97ee1b2f3a96. +// WatchDeposit is a free log subscription operation binding the contract event 0x5548c837ab068cf56a2c2479df0882a4922fd203edb7517321831d95078c5f62. // -// Solidity: event Deposit(address staker, address token, address strategy, uint256 shares) +// Solidity: event Deposit(address staker, address strategy, uint256 shares) func (_StrategyManager *StrategyManagerFilterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *StrategyManagerDeposit) (event.Subscription, error) { logs, sub, err := _StrategyManager.contract.WatchLogs(opts, "Deposit") @@ -1170,9 +1523,9 @@ func (_StrategyManager *StrategyManagerFilterer) WatchDeposit(opts *bind.WatchOp }), nil } -// ParseDeposit is a log parse operation binding the contract event 0x7cfff908a4b583f36430b25d75964c458d8ede8a99bd61be750e97ee1b2f3a96. +// ParseDeposit is a log parse operation binding the contract event 0x5548c837ab068cf56a2c2479df0882a4922fd203edb7517321831d95078c5f62. // -// Solidity: event Deposit(address staker, address token, address strategy, uint256 shares) +// Solidity: event Deposit(address staker, address strategy, uint256 shares) func (_StrategyManager *StrategyManagerFilterer) ParseDeposit(log types.Log) (*StrategyManagerDeposit, error) { event := new(StrategyManagerDeposit) if err := _StrategyManager.contract.UnpackLog(event, "Deposit", log); err != nil { diff --git a/pkg/bindings/StrategyManagerStorage/binding.go b/pkg/bindings/StrategyManagerStorage/binding.go index 49acbe475f..3a3c588a46 100644 --- a/pkg/bindings/StrategyManagerStorage/binding.go +++ b/pkg/bindings/StrategyManagerStorage/binding.go @@ -31,7 +31,7 @@ var ( // StrategyManagerStorageMetaData contains all meta data concerning the StrategyManagerStorage contract. var StrategyManagerStorageMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"function\",\"name\":\"DEFAULT_BURN_ADDRESS\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"DEPOSIT_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"addShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"addStrategiesToDepositWhitelist\",\"inputs\":[{\"name\":\"strategiesToWhitelist\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"burnShares\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"sharesToBurn\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"calculateStrategyDepositDigestHash\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"delegation\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"depositIntoStrategy\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"depositIntoStrategyWithSignature\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"getDeposits\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStakerStrategyList\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialStrategyWhitelister\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"nonces\",\"inputs\":[{\"name\":\"signer\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"removeDepositShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"depositSharesToRemove\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"removeStrategiesFromDepositWhitelist\",\"inputs\":[{\"name\":\"strategiesToRemoveFromWhitelist\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setStrategyWhitelister\",\"inputs\":[{\"name\":\"newStrategyWhitelister\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"stakerDepositShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"stakerStrategyList\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"strategies\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"stakerStrategyListLength\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"strategyIsWhitelistedForDeposit\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"whitelisted\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"strategyWhitelister\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"withdrawSharesAsTokens\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"Deposit\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"token\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIERC20\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyAddedToDepositWhitelist\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyRemovedFromDepositWhitelist\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyWhitelisterChanged\",\"inputs\":[{\"name\":\"previousAddress\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"newAddress\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"MaxStrategiesExceeded\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyDelegationManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyStrategyWhitelister\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SharesAmountTooHigh\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SharesAmountZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StakerAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategyNotFound\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategyNotWhitelisted\",\"inputs\":[]}]", + ABI: "[{\"type\":\"function\",\"name\":\"DEFAULT_BURN_ADDRESS\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"DEPOSIT_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"addShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"addStrategiesToDepositWhitelist\",\"inputs\":[{\"name\":\"strategiesToWhitelist\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"burnShares\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"calculateStrategyDepositDigestHash\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"delegation\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"depositIntoStrategy\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"depositShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"depositIntoStrategyWithSignature\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[{\"name\":\"depositShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"getBurnableShares\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getDeposits\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStakerStrategyList\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStrategiesWithBurnableShares\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"increaseBurnableShares\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"addedSharesToBurn\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialStrategyWhitelister\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"nonces\",\"inputs\":[{\"name\":\"signer\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"removeDepositShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"depositSharesToRemove\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"removeStrategiesFromDepositWhitelist\",\"inputs\":[{\"name\":\"strategiesToRemoveFromWhitelist\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setStrategyWhitelister\",\"inputs\":[{\"name\":\"newStrategyWhitelister\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"stakerDepositShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"stakerStrategyList\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"strategies\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"stakerStrategyListLength\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"strategyIsWhitelistedForDeposit\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"whitelisted\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"strategyWhitelister\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"withdrawSharesAsTokens\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"BurnableSharesDecreased\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"BurnableSharesIncreased\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Deposit\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyAddedToDepositWhitelist\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyRemovedFromDepositWhitelist\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyWhitelisterChanged\",\"inputs\":[{\"name\":\"previousAddress\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"newAddress\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"MaxStrategiesExceeded\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyDelegationManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyStrategyWhitelister\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SharesAmountTooHigh\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SharesAmountZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StakerAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategyNotFound\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StrategyNotWhitelisted\",\"inputs\":[]}]", } // StrategyManagerStorageABI is the input ABI used to generate the binding from. @@ -304,6 +304,37 @@ func (_StrategyManagerStorage *StrategyManagerStorageCallerSession) Delegation() return _StrategyManagerStorage.Contract.Delegation(&_StrategyManagerStorage.CallOpts) } +// GetBurnableShares is a free data retrieval call binding the contract method 0xfd980423. +// +// Solidity: function getBurnableShares(address strategy) view returns(uint256) +func (_StrategyManagerStorage *StrategyManagerStorageCaller) GetBurnableShares(opts *bind.CallOpts, strategy common.Address) (*big.Int, error) { + var out []interface{} + err := _StrategyManagerStorage.contract.Call(opts, &out, "getBurnableShares", strategy) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetBurnableShares is a free data retrieval call binding the contract method 0xfd980423. +// +// Solidity: function getBurnableShares(address strategy) view returns(uint256) +func (_StrategyManagerStorage *StrategyManagerStorageSession) GetBurnableShares(strategy common.Address) (*big.Int, error) { + return _StrategyManagerStorage.Contract.GetBurnableShares(&_StrategyManagerStorage.CallOpts, strategy) +} + +// GetBurnableShares is a free data retrieval call binding the contract method 0xfd980423. +// +// Solidity: function getBurnableShares(address strategy) view returns(uint256) +func (_StrategyManagerStorage *StrategyManagerStorageCallerSession) GetBurnableShares(strategy common.Address) (*big.Int, error) { + return _StrategyManagerStorage.Contract.GetBurnableShares(&_StrategyManagerStorage.CallOpts, strategy) +} + // GetDeposits is a free data retrieval call binding the contract method 0x94f649dd. // // Solidity: function getDeposits(address staker) view returns(address[], uint256[]) @@ -367,6 +398,38 @@ func (_StrategyManagerStorage *StrategyManagerStorageCallerSession) GetStakerStr return _StrategyManagerStorage.Contract.GetStakerStrategyList(&_StrategyManagerStorage.CallOpts, staker) } +// GetStrategiesWithBurnableShares is a free data retrieval call binding the contract method 0x36a8c500. +// +// Solidity: function getStrategiesWithBurnableShares() view returns(address[], uint256[]) +func (_StrategyManagerStorage *StrategyManagerStorageCaller) GetStrategiesWithBurnableShares(opts *bind.CallOpts) ([]common.Address, []*big.Int, error) { + var out []interface{} + err := _StrategyManagerStorage.contract.Call(opts, &out, "getStrategiesWithBurnableShares") + + if err != nil { + return *new([]common.Address), *new([]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + out1 := *abi.ConvertType(out[1], new([]*big.Int)).(*[]*big.Int) + + return out0, out1, err + +} + +// GetStrategiesWithBurnableShares is a free data retrieval call binding the contract method 0x36a8c500. +// +// Solidity: function getStrategiesWithBurnableShares() view returns(address[], uint256[]) +func (_StrategyManagerStorage *StrategyManagerStorageSession) GetStrategiesWithBurnableShares() ([]common.Address, []*big.Int, error) { + return _StrategyManagerStorage.Contract.GetStrategiesWithBurnableShares(&_StrategyManagerStorage.CallOpts) +} + +// GetStrategiesWithBurnableShares is a free data retrieval call binding the contract method 0x36a8c500. +// +// Solidity: function getStrategiesWithBurnableShares() view returns(address[], uint256[]) +func (_StrategyManagerStorage *StrategyManagerStorageCallerSession) GetStrategiesWithBurnableShares() ([]common.Address, []*big.Int, error) { + return _StrategyManagerStorage.Contract.GetStrategiesWithBurnableShares(&_StrategyManagerStorage.CallOpts) +} + // Nonces is a free data retrieval call binding the contract method 0x7ecebe00. // // Solidity: function nonces(address signer) view returns(uint256 nonce) @@ -553,25 +616,25 @@ func (_StrategyManagerStorage *StrategyManagerStorageCallerSession) StrategyWhit return _StrategyManagerStorage.Contract.StrategyWhitelister(&_StrategyManagerStorage.CallOpts) } -// AddShares is a paid mutator transaction binding the contract method 0xc4623ea1. +// AddShares is a paid mutator transaction binding the contract method 0x50ff7225. // -// Solidity: function addShares(address staker, address strategy, address token, uint256 shares) returns(uint256, uint256) -func (_StrategyManagerStorage *StrategyManagerStorageTransactor) AddShares(opts *bind.TransactOpts, staker common.Address, strategy common.Address, token common.Address, shares *big.Int) (*types.Transaction, error) { - return _StrategyManagerStorage.contract.Transact(opts, "addShares", staker, strategy, token, shares) +// Solidity: function addShares(address staker, address strategy, uint256 shares) returns(uint256, uint256) +func (_StrategyManagerStorage *StrategyManagerStorageTransactor) AddShares(opts *bind.TransactOpts, staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { + return _StrategyManagerStorage.contract.Transact(opts, "addShares", staker, strategy, shares) } -// AddShares is a paid mutator transaction binding the contract method 0xc4623ea1. +// AddShares is a paid mutator transaction binding the contract method 0x50ff7225. // -// Solidity: function addShares(address staker, address strategy, address token, uint256 shares) returns(uint256, uint256) -func (_StrategyManagerStorage *StrategyManagerStorageSession) AddShares(staker common.Address, strategy common.Address, token common.Address, shares *big.Int) (*types.Transaction, error) { - return _StrategyManagerStorage.Contract.AddShares(&_StrategyManagerStorage.TransactOpts, staker, strategy, token, shares) +// Solidity: function addShares(address staker, address strategy, uint256 shares) returns(uint256, uint256) +func (_StrategyManagerStorage *StrategyManagerStorageSession) AddShares(staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { + return _StrategyManagerStorage.Contract.AddShares(&_StrategyManagerStorage.TransactOpts, staker, strategy, shares) } -// AddShares is a paid mutator transaction binding the contract method 0xc4623ea1. +// AddShares is a paid mutator transaction binding the contract method 0x50ff7225. // -// Solidity: function addShares(address staker, address strategy, address token, uint256 shares) returns(uint256, uint256) -func (_StrategyManagerStorage *StrategyManagerStorageTransactorSession) AddShares(staker common.Address, strategy common.Address, token common.Address, shares *big.Int) (*types.Transaction, error) { - return _StrategyManagerStorage.Contract.AddShares(&_StrategyManagerStorage.TransactOpts, staker, strategy, token, shares) +// Solidity: function addShares(address staker, address strategy, uint256 shares) returns(uint256, uint256) +func (_StrategyManagerStorage *StrategyManagerStorageTransactorSession) AddShares(staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { + return _StrategyManagerStorage.Contract.AddShares(&_StrategyManagerStorage.TransactOpts, staker, strategy, shares) } // AddStrategiesToDepositWhitelist is a paid mutator transaction binding the contract method 0x5de08ff2. @@ -595,69 +658,90 @@ func (_StrategyManagerStorage *StrategyManagerStorageTransactorSession) AddStrat return _StrategyManagerStorage.Contract.AddStrategiesToDepositWhitelist(&_StrategyManagerStorage.TransactOpts, strategiesToWhitelist) } -// BurnShares is a paid mutator transaction binding the contract method 0xee7a7c04. +// BurnShares is a paid mutator transaction binding the contract method 0x4b6d5d6e. // -// Solidity: function burnShares(address strategy, uint256 sharesToBurn) returns() -func (_StrategyManagerStorage *StrategyManagerStorageTransactor) BurnShares(opts *bind.TransactOpts, strategy common.Address, sharesToBurn *big.Int) (*types.Transaction, error) { - return _StrategyManagerStorage.contract.Transact(opts, "burnShares", strategy, sharesToBurn) +// Solidity: function burnShares(address strategy) returns() +func (_StrategyManagerStorage *StrategyManagerStorageTransactor) BurnShares(opts *bind.TransactOpts, strategy common.Address) (*types.Transaction, error) { + return _StrategyManagerStorage.contract.Transact(opts, "burnShares", strategy) } -// BurnShares is a paid mutator transaction binding the contract method 0xee7a7c04. +// BurnShares is a paid mutator transaction binding the contract method 0x4b6d5d6e. // -// Solidity: function burnShares(address strategy, uint256 sharesToBurn) returns() -func (_StrategyManagerStorage *StrategyManagerStorageSession) BurnShares(strategy common.Address, sharesToBurn *big.Int) (*types.Transaction, error) { - return _StrategyManagerStorage.Contract.BurnShares(&_StrategyManagerStorage.TransactOpts, strategy, sharesToBurn) +// Solidity: function burnShares(address strategy) returns() +func (_StrategyManagerStorage *StrategyManagerStorageSession) BurnShares(strategy common.Address) (*types.Transaction, error) { + return _StrategyManagerStorage.Contract.BurnShares(&_StrategyManagerStorage.TransactOpts, strategy) } -// BurnShares is a paid mutator transaction binding the contract method 0xee7a7c04. +// BurnShares is a paid mutator transaction binding the contract method 0x4b6d5d6e. // -// Solidity: function burnShares(address strategy, uint256 sharesToBurn) returns() -func (_StrategyManagerStorage *StrategyManagerStorageTransactorSession) BurnShares(strategy common.Address, sharesToBurn *big.Int) (*types.Transaction, error) { - return _StrategyManagerStorage.Contract.BurnShares(&_StrategyManagerStorage.TransactOpts, strategy, sharesToBurn) +// Solidity: function burnShares(address strategy) returns() +func (_StrategyManagerStorage *StrategyManagerStorageTransactorSession) BurnShares(strategy common.Address) (*types.Transaction, error) { + return _StrategyManagerStorage.Contract.BurnShares(&_StrategyManagerStorage.TransactOpts, strategy) } // DepositIntoStrategy is a paid mutator transaction binding the contract method 0xe7a050aa. // -// Solidity: function depositIntoStrategy(address strategy, address token, uint256 amount) returns(uint256 shares) +// Solidity: function depositIntoStrategy(address strategy, address token, uint256 amount) returns(uint256 depositShares) func (_StrategyManagerStorage *StrategyManagerStorageTransactor) DepositIntoStrategy(opts *bind.TransactOpts, strategy common.Address, token common.Address, amount *big.Int) (*types.Transaction, error) { return _StrategyManagerStorage.contract.Transact(opts, "depositIntoStrategy", strategy, token, amount) } // DepositIntoStrategy is a paid mutator transaction binding the contract method 0xe7a050aa. // -// Solidity: function depositIntoStrategy(address strategy, address token, uint256 amount) returns(uint256 shares) +// Solidity: function depositIntoStrategy(address strategy, address token, uint256 amount) returns(uint256 depositShares) func (_StrategyManagerStorage *StrategyManagerStorageSession) DepositIntoStrategy(strategy common.Address, token common.Address, amount *big.Int) (*types.Transaction, error) { return _StrategyManagerStorage.Contract.DepositIntoStrategy(&_StrategyManagerStorage.TransactOpts, strategy, token, amount) } // DepositIntoStrategy is a paid mutator transaction binding the contract method 0xe7a050aa. // -// Solidity: function depositIntoStrategy(address strategy, address token, uint256 amount) returns(uint256 shares) +// Solidity: function depositIntoStrategy(address strategy, address token, uint256 amount) returns(uint256 depositShares) func (_StrategyManagerStorage *StrategyManagerStorageTransactorSession) DepositIntoStrategy(strategy common.Address, token common.Address, amount *big.Int) (*types.Transaction, error) { return _StrategyManagerStorage.Contract.DepositIntoStrategy(&_StrategyManagerStorage.TransactOpts, strategy, token, amount) } // DepositIntoStrategyWithSignature is a paid mutator transaction binding the contract method 0x32e89ace. // -// Solidity: function depositIntoStrategyWithSignature(address strategy, address token, uint256 amount, address staker, uint256 expiry, bytes signature) returns(uint256 shares) +// Solidity: function depositIntoStrategyWithSignature(address strategy, address token, uint256 amount, address staker, uint256 expiry, bytes signature) returns(uint256 depositShares) func (_StrategyManagerStorage *StrategyManagerStorageTransactor) DepositIntoStrategyWithSignature(opts *bind.TransactOpts, strategy common.Address, token common.Address, amount *big.Int, staker common.Address, expiry *big.Int, signature []byte) (*types.Transaction, error) { return _StrategyManagerStorage.contract.Transact(opts, "depositIntoStrategyWithSignature", strategy, token, amount, staker, expiry, signature) } // DepositIntoStrategyWithSignature is a paid mutator transaction binding the contract method 0x32e89ace. // -// Solidity: function depositIntoStrategyWithSignature(address strategy, address token, uint256 amount, address staker, uint256 expiry, bytes signature) returns(uint256 shares) +// Solidity: function depositIntoStrategyWithSignature(address strategy, address token, uint256 amount, address staker, uint256 expiry, bytes signature) returns(uint256 depositShares) func (_StrategyManagerStorage *StrategyManagerStorageSession) DepositIntoStrategyWithSignature(strategy common.Address, token common.Address, amount *big.Int, staker common.Address, expiry *big.Int, signature []byte) (*types.Transaction, error) { return _StrategyManagerStorage.Contract.DepositIntoStrategyWithSignature(&_StrategyManagerStorage.TransactOpts, strategy, token, amount, staker, expiry, signature) } // DepositIntoStrategyWithSignature is a paid mutator transaction binding the contract method 0x32e89ace. // -// Solidity: function depositIntoStrategyWithSignature(address strategy, address token, uint256 amount, address staker, uint256 expiry, bytes signature) returns(uint256 shares) +// Solidity: function depositIntoStrategyWithSignature(address strategy, address token, uint256 amount, address staker, uint256 expiry, bytes signature) returns(uint256 depositShares) func (_StrategyManagerStorage *StrategyManagerStorageTransactorSession) DepositIntoStrategyWithSignature(strategy common.Address, token common.Address, amount *big.Int, staker common.Address, expiry *big.Int, signature []byte) (*types.Transaction, error) { return _StrategyManagerStorage.Contract.DepositIntoStrategyWithSignature(&_StrategyManagerStorage.TransactOpts, strategy, token, amount, staker, expiry, signature) } +// IncreaseBurnableShares is a paid mutator transaction binding the contract method 0xdebe1eab. +// +// Solidity: function increaseBurnableShares(address strategy, uint256 addedSharesToBurn) returns() +func (_StrategyManagerStorage *StrategyManagerStorageTransactor) IncreaseBurnableShares(opts *bind.TransactOpts, strategy common.Address, addedSharesToBurn *big.Int) (*types.Transaction, error) { + return _StrategyManagerStorage.contract.Transact(opts, "increaseBurnableShares", strategy, addedSharesToBurn) +} + +// IncreaseBurnableShares is a paid mutator transaction binding the contract method 0xdebe1eab. +// +// Solidity: function increaseBurnableShares(address strategy, uint256 addedSharesToBurn) returns() +func (_StrategyManagerStorage *StrategyManagerStorageSession) IncreaseBurnableShares(strategy common.Address, addedSharesToBurn *big.Int) (*types.Transaction, error) { + return _StrategyManagerStorage.Contract.IncreaseBurnableShares(&_StrategyManagerStorage.TransactOpts, strategy, addedSharesToBurn) +} + +// IncreaseBurnableShares is a paid mutator transaction binding the contract method 0xdebe1eab. +// +// Solidity: function increaseBurnableShares(address strategy, uint256 addedSharesToBurn) returns() +func (_StrategyManagerStorage *StrategyManagerStorageTransactorSession) IncreaseBurnableShares(strategy common.Address, addedSharesToBurn *big.Int) (*types.Transaction, error) { + return _StrategyManagerStorage.Contract.IncreaseBurnableShares(&_StrategyManagerStorage.TransactOpts, strategy, addedSharesToBurn) +} + // Initialize is a paid mutator transaction binding the contract method 0x1794bb3c. // // Solidity: function initialize(address initialOwner, address initialStrategyWhitelister, uint256 initialPausedStatus) returns() @@ -763,6 +847,276 @@ func (_StrategyManagerStorage *StrategyManagerStorageTransactorSession) Withdraw return _StrategyManagerStorage.Contract.WithdrawSharesAsTokens(&_StrategyManagerStorage.TransactOpts, staker, strategy, token, shares) } +// StrategyManagerStorageBurnableSharesDecreasedIterator is returned from FilterBurnableSharesDecreased and is used to iterate over the raw logs and unpacked data for BurnableSharesDecreased events raised by the StrategyManagerStorage contract. +type StrategyManagerStorageBurnableSharesDecreasedIterator struct { + Event *StrategyManagerStorageBurnableSharesDecreased // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StrategyManagerStorageBurnableSharesDecreasedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StrategyManagerStorageBurnableSharesDecreased) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StrategyManagerStorageBurnableSharesDecreased) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StrategyManagerStorageBurnableSharesDecreasedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StrategyManagerStorageBurnableSharesDecreasedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StrategyManagerStorageBurnableSharesDecreased represents a BurnableSharesDecreased event raised by the StrategyManagerStorage contract. +type StrategyManagerStorageBurnableSharesDecreased struct { + Strategy common.Address + Shares *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterBurnableSharesDecreased is a free log retrieval operation binding the contract event 0xd9d082c3ec4f3a3ffa55c324939a06407f5fbcb87d5e0ce3b9508c92c84ed839. +// +// Solidity: event BurnableSharesDecreased(address strategy, uint256 shares) +func (_StrategyManagerStorage *StrategyManagerStorageFilterer) FilterBurnableSharesDecreased(opts *bind.FilterOpts) (*StrategyManagerStorageBurnableSharesDecreasedIterator, error) { + + logs, sub, err := _StrategyManagerStorage.contract.FilterLogs(opts, "BurnableSharesDecreased") + if err != nil { + return nil, err + } + return &StrategyManagerStorageBurnableSharesDecreasedIterator{contract: _StrategyManagerStorage.contract, event: "BurnableSharesDecreased", logs: logs, sub: sub}, nil +} + +// WatchBurnableSharesDecreased is a free log subscription operation binding the contract event 0xd9d082c3ec4f3a3ffa55c324939a06407f5fbcb87d5e0ce3b9508c92c84ed839. +// +// Solidity: event BurnableSharesDecreased(address strategy, uint256 shares) +func (_StrategyManagerStorage *StrategyManagerStorageFilterer) WatchBurnableSharesDecreased(opts *bind.WatchOpts, sink chan<- *StrategyManagerStorageBurnableSharesDecreased) (event.Subscription, error) { + + logs, sub, err := _StrategyManagerStorage.contract.WatchLogs(opts, "BurnableSharesDecreased") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StrategyManagerStorageBurnableSharesDecreased) + if err := _StrategyManagerStorage.contract.UnpackLog(event, "BurnableSharesDecreased", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseBurnableSharesDecreased is a log parse operation binding the contract event 0xd9d082c3ec4f3a3ffa55c324939a06407f5fbcb87d5e0ce3b9508c92c84ed839. +// +// Solidity: event BurnableSharesDecreased(address strategy, uint256 shares) +func (_StrategyManagerStorage *StrategyManagerStorageFilterer) ParseBurnableSharesDecreased(log types.Log) (*StrategyManagerStorageBurnableSharesDecreased, error) { + event := new(StrategyManagerStorageBurnableSharesDecreased) + if err := _StrategyManagerStorage.contract.UnpackLog(event, "BurnableSharesDecreased", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// StrategyManagerStorageBurnableSharesIncreasedIterator is returned from FilterBurnableSharesIncreased and is used to iterate over the raw logs and unpacked data for BurnableSharesIncreased events raised by the StrategyManagerStorage contract. +type StrategyManagerStorageBurnableSharesIncreasedIterator struct { + Event *StrategyManagerStorageBurnableSharesIncreased // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StrategyManagerStorageBurnableSharesIncreasedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StrategyManagerStorageBurnableSharesIncreased) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StrategyManagerStorageBurnableSharesIncreased) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StrategyManagerStorageBurnableSharesIncreasedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StrategyManagerStorageBurnableSharesIncreasedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StrategyManagerStorageBurnableSharesIncreased represents a BurnableSharesIncreased event raised by the StrategyManagerStorage contract. +type StrategyManagerStorageBurnableSharesIncreased struct { + Strategy common.Address + Shares *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterBurnableSharesIncreased is a free log retrieval operation binding the contract event 0xca3e02a4ab7ad3c47a8e36e5a624c30170791726ab720f1babfef21046d953ff. +// +// Solidity: event BurnableSharesIncreased(address strategy, uint256 shares) +func (_StrategyManagerStorage *StrategyManagerStorageFilterer) FilterBurnableSharesIncreased(opts *bind.FilterOpts) (*StrategyManagerStorageBurnableSharesIncreasedIterator, error) { + + logs, sub, err := _StrategyManagerStorage.contract.FilterLogs(opts, "BurnableSharesIncreased") + if err != nil { + return nil, err + } + return &StrategyManagerStorageBurnableSharesIncreasedIterator{contract: _StrategyManagerStorage.contract, event: "BurnableSharesIncreased", logs: logs, sub: sub}, nil +} + +// WatchBurnableSharesIncreased is a free log subscription operation binding the contract event 0xca3e02a4ab7ad3c47a8e36e5a624c30170791726ab720f1babfef21046d953ff. +// +// Solidity: event BurnableSharesIncreased(address strategy, uint256 shares) +func (_StrategyManagerStorage *StrategyManagerStorageFilterer) WatchBurnableSharesIncreased(opts *bind.WatchOpts, sink chan<- *StrategyManagerStorageBurnableSharesIncreased) (event.Subscription, error) { + + logs, sub, err := _StrategyManagerStorage.contract.WatchLogs(opts, "BurnableSharesIncreased") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StrategyManagerStorageBurnableSharesIncreased) + if err := _StrategyManagerStorage.contract.UnpackLog(event, "BurnableSharesIncreased", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseBurnableSharesIncreased is a log parse operation binding the contract event 0xca3e02a4ab7ad3c47a8e36e5a624c30170791726ab720f1babfef21046d953ff. +// +// Solidity: event BurnableSharesIncreased(address strategy, uint256 shares) +func (_StrategyManagerStorage *StrategyManagerStorageFilterer) ParseBurnableSharesIncreased(log types.Log) (*StrategyManagerStorageBurnableSharesIncreased, error) { + event := new(StrategyManagerStorageBurnableSharesIncreased) + if err := _StrategyManagerStorage.contract.UnpackLog(event, "BurnableSharesIncreased", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + // StrategyManagerStorageDepositIterator is returned from FilterDeposit and is used to iterate over the raw logs and unpacked data for Deposit events raised by the StrategyManagerStorage contract. type StrategyManagerStorageDepositIterator struct { Event *StrategyManagerStorageDeposit // Event containing the contract specifics and raw log @@ -833,15 +1187,14 @@ func (it *StrategyManagerStorageDepositIterator) Close() error { // StrategyManagerStorageDeposit represents a Deposit event raised by the StrategyManagerStorage contract. type StrategyManagerStorageDeposit struct { Staker common.Address - Token common.Address Strategy common.Address Shares *big.Int Raw types.Log // Blockchain specific contextual infos } -// FilterDeposit is a free log retrieval operation binding the contract event 0x7cfff908a4b583f36430b25d75964c458d8ede8a99bd61be750e97ee1b2f3a96. +// FilterDeposit is a free log retrieval operation binding the contract event 0x5548c837ab068cf56a2c2479df0882a4922fd203edb7517321831d95078c5f62. // -// Solidity: event Deposit(address staker, address token, address strategy, uint256 shares) +// Solidity: event Deposit(address staker, address strategy, uint256 shares) func (_StrategyManagerStorage *StrategyManagerStorageFilterer) FilterDeposit(opts *bind.FilterOpts) (*StrategyManagerStorageDepositIterator, error) { logs, sub, err := _StrategyManagerStorage.contract.FilterLogs(opts, "Deposit") @@ -851,9 +1204,9 @@ func (_StrategyManagerStorage *StrategyManagerStorageFilterer) FilterDeposit(opt return &StrategyManagerStorageDepositIterator{contract: _StrategyManagerStorage.contract, event: "Deposit", logs: logs, sub: sub}, nil } -// WatchDeposit is a free log subscription operation binding the contract event 0x7cfff908a4b583f36430b25d75964c458d8ede8a99bd61be750e97ee1b2f3a96. +// WatchDeposit is a free log subscription operation binding the contract event 0x5548c837ab068cf56a2c2479df0882a4922fd203edb7517321831d95078c5f62. // -// Solidity: event Deposit(address staker, address token, address strategy, uint256 shares) +// Solidity: event Deposit(address staker, address strategy, uint256 shares) func (_StrategyManagerStorage *StrategyManagerStorageFilterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *StrategyManagerStorageDeposit) (event.Subscription, error) { logs, sub, err := _StrategyManagerStorage.contract.WatchLogs(opts, "Deposit") @@ -888,9 +1241,9 @@ func (_StrategyManagerStorage *StrategyManagerStorageFilterer) WatchDeposit(opts }), nil } -// ParseDeposit is a log parse operation binding the contract event 0x7cfff908a4b583f36430b25d75964c458d8ede8a99bd61be750e97ee1b2f3a96. +// ParseDeposit is a log parse operation binding the contract event 0x5548c837ab068cf56a2c2479df0882a4922fd203edb7517321831d95078c5f62. // -// Solidity: event Deposit(address staker, address token, address strategy, uint256 shares) +// Solidity: event Deposit(address staker, address strategy, uint256 shares) func (_StrategyManagerStorage *StrategyManagerStorageFilterer) ParseDeposit(log types.Log) (*StrategyManagerStorageDeposit, error) { event := new(StrategyManagerStorageDeposit) if err := _StrategyManagerStorage.contract.UnpackLog(event, "Deposit", log); err != nil { diff --git a/script/configs/devnet/deploy_from_scratch.anvil.config.json b/script/configs/devnet/deploy_from_scratch.anvil.config.json index 96df127e1f..6d8b5fef76 100644 --- a/script/configs/devnet/deploy_from_scratch.anvil.config.json +++ b/script/configs/devnet/deploy_from_scratch.anvil.config.json @@ -51,5 +51,6 @@ "OPERATOR_SET_GENESIS_REWARDS_TIMESTAMP": 1720656000, "OPERATOR_SET_MAX_RETROACTIVE_LENGTH": 2592000 }, - "ethPOSDepositAddress": "0x00000000219ab540356cBB839Cbe05303d7705Fa" + "ethPOSDepositAddress": "0x00000000219ab540356cBB839Cbe05303d7705Fa", + "semver": "v1.0.3" } \ No newline at end of file diff --git a/script/configs/devnet/deploy_from_scratch.holesky.config.json b/script/configs/devnet/deploy_from_scratch.holesky.config.json index 3dc1f204d5..054a432868 100644 --- a/script/configs/devnet/deploy_from_scratch.holesky.config.json +++ b/script/configs/devnet/deploy_from_scratch.holesky.config.json @@ -51,5 +51,6 @@ "OPERATOR_SET_GENESIS_REWARDS_TIMESTAMP": 1720656000, "OPERATOR_SET_MAX_RETROACTIVE_LENGTH": 2592000 }, - "ethPOSDepositAddress": "0x00000000219ab540356cBB839Cbe05303d7705Fa" -} \ No newline at end of file + "ethPOSDepositAddress": "0x00000000219ab540356cBB839Cbe05303d7705Fa", + "semver": "v0.0.0" +} diff --git a/script/configs/devnet/deploy_from_scratch.holesky.slashing.config.json b/script/configs/devnet/deploy_from_scratch.holesky.slashing.config.json index bcd808f715..99d3c54cbe 100644 --- a/script/configs/devnet/deploy_from_scratch.holesky.slashing.config.json +++ b/script/configs/devnet/deploy_from_scratch.holesky.slashing.config.json @@ -43,5 +43,6 @@ "DEALLOCATION_DELAY": 86400, "ALLOCATION_CONFIGURATION_DELAY": 600 }, - "ethPOSDepositAddress": "0x4242424242424242424242424242424242424242" + "ethPOSDepositAddress": "0x4242424242424242424242424242424242424242", + "semver": "v0.0.0" } \ No newline at end of file diff --git a/script/configs/local/deploy_from_scratch.anvil.config.json b/script/configs/local/deploy_from_scratch.anvil.config.json index f8b15599d4..3b516c4547 100644 --- a/script/configs/local/deploy_from_scratch.anvil.config.json +++ b/script/configs/local/deploy_from_scratch.anvil.config.json @@ -57,5 +57,6 @@ "DEALLOCATION_DELAY": 900, "ALLOCATION_CONFIGURATION_DELAY": 1200 }, - "ethPOSDepositAddress": "0x00000000219ab540356cBB839Cbe05303d7705Fa" + "ethPOSDepositAddress": "0x00000000219ab540356cBB839Cbe05303d7705Fa", + "semver": "v0.0.0" } \ No newline at end of file diff --git a/script/configs/local/deploy_from_scratch.slashing.anvil.config.json b/script/configs/local/deploy_from_scratch.slashing.anvil.config.json index 313bd1827a..af310692d5 100644 --- a/script/configs/local/deploy_from_scratch.slashing.anvil.config.json +++ b/script/configs/local/deploy_from_scratch.slashing.anvil.config.json @@ -57,5 +57,6 @@ "OPERATOR_SET_GENESIS_REWARDS_TIMESTAMP": 1720656000, "OPERATOR_SET_MAX_RETROACTIVE_LENGTH": 2592000 }, - "ethPOSDepositAddress": "0x00000000219ab540356cBB839Cbe05303d7705Fa" + "ethPOSDepositAddress": "0x00000000219ab540356cBB839Cbe05303d7705Fa", + "semver": "v0.0.0" } \ No newline at end of file diff --git a/script/configs/mainnet/mainnet-addresses.config.json b/script/configs/mainnet/mainnet-addresses.config.json index f47b5d9497..c33d7e8380 100644 --- a/script/configs/mainnet/mainnet-addresses.config.json +++ b/script/configs/mainnet/mainnet-addresses.config.json @@ -75,6 +75,7 @@ "executorMultisig": "0x369e6F597e22EaB55fFb173C6d9cD234BD699111", "operationsMultisig": "0xBE1685C81aA44FF9FB319dD389addd9374383e90", "pauserMultisig": "0x5050389572f2d220ad927CcbeA0D406831012390", - "timelock": "0xA6Db1A8C5a981d1536266D2a393c5F8dDb210EAF" + "timelock": "0xA6Db1A8C5a981d1536266D2a393c5F8dDb210EAF", + "semver": "v0.5.4" } } \ No newline at end of file diff --git a/script/deploy/devnet/deploy_from_scratch.s.sol b/script/deploy/devnet/deploy_from_scratch.s.sol index 5c2f888f55..dd07a6e0aa 100644 --- a/script/deploy/devnet/deploy_from_scratch.s.sol +++ b/script/deploy/devnet/deploy_from_scratch.s.sol @@ -76,6 +76,8 @@ contract DeployFromScratch is Script, Test { // strategies deployed StrategyBaseTVLLimits[] public deployedStrategyArray; + string SEMVER; + // IMMUTABLES TO SET uint64 GOERLI_GENESIS_TIME = 1616508000; @@ -121,6 +123,8 @@ contract DeployFromScratch is Script, Test { string memory config_data = vm.readFile(deployConfigPath); // bytes memory parsedData = vm.parseJson(config_data); + SEMVER = stdJson.readString(config_data, ".semver"); + STRATEGY_MANAGER_INIT_PAUSED_STATUS = stdJson.readUint(config_data, ".strategyManager.init_paused_status"); DELEGATION_INIT_PAUSED_STATUS = stdJson.readUint(config_data, ".delegation.init_paused_status"); DELEGATION_WITHDRAWAL_DELAY_BLOCKS = stdJson.readUint(config_data, ".delegation.init_withdrawal_delay_blocks"); @@ -227,37 +231,58 @@ contract DeployFromScratch is Script, Test { eigenPodImplementation = new EigenPod( ethPOSDeposit, eigenPodManager, - GOERLI_GENESIS_TIME + GOERLI_GENESIS_TIME, + SEMVER ); eigenPodBeacon = new UpgradeableBeacon(address(eigenPodImplementation)); // Second, deploy the *implementation* contracts, using the *proxy contracts* as inputs - delegationImplementation = new DelegationManager(strategyManager, eigenPodManager, allocationManager, eigenLayerPauserReg, permissionController, MIN_WITHDRAWAL_DELAY); - strategyManagerImplementation = new StrategyManager(delegation, eigenLayerPauserReg); - avsDirectoryImplementation = new AVSDirectory(delegation, eigenLayerPauserReg); + delegationImplementation = new DelegationManager( + strategyManager, + eigenPodManager, + allocationManager, + eigenLayerPauserReg, + permissionController, + MIN_WITHDRAWAL_DELAY, + SEMVER + ); + + strategyManagerImplementation = new StrategyManager(delegation, eigenLayerPauserReg, SEMVER); + avsDirectoryImplementation = new AVSDirectory(delegation, eigenLayerPauserReg, SEMVER); eigenPodManagerImplementation = new EigenPodManager( ethPOSDeposit, eigenPodBeacon, delegation, - eigenLayerPauserReg + eigenLayerPauserReg, + SEMVER ); rewardsCoordinatorImplementation = new RewardsCoordinator( - delegation, - strategyManager, - allocationManager, - eigenLayerPauserReg, - permissionController, - REWARDS_COORDINATOR_CALCULATION_INTERVAL_SECONDS, - REWARDS_COORDINATOR_MAX_REWARDS_DURATION, - REWARDS_COORDINATOR_MAX_RETROACTIVE_LENGTH, - REWARDS_COORDINATOR_MAX_FUTURE_LENGTH, - REWARDS_COORDINATOR_GENESIS_REWARDS_TIMESTAMP + IRewardsCoordinatorTypes.RewardsCoordinatorConstructorParams( + delegation, + strategyManager, + allocationManager, + eigenLayerPauserReg, + permissionController, + REWARDS_COORDINATOR_CALCULATION_INTERVAL_SECONDS, + REWARDS_COORDINATOR_MAX_REWARDS_DURATION, + REWARDS_COORDINATOR_MAX_RETROACTIVE_LENGTH, + REWARDS_COORDINATOR_MAX_FUTURE_LENGTH, + REWARDS_COORDINATOR_GENESIS_REWARDS_TIMESTAMP, + SEMVER + ) + ); + allocationManagerImplementation = new AllocationManager( + delegation, + eigenLayerPauserReg, + permissionController, + DEALLOCATION_DELAY, + ALLOCATION_CONFIGURATION_DELAY, + SEMVER ); - allocationManagerImplementation = new AllocationManager(delegation, eigenLayerPauserReg, permissionController, DEALLOCATION_DELAY, ALLOCATION_CONFIGURATION_DELAY); - permissionControllerImplementation = new PermissionController(); - strategyFactoryImplementation = new StrategyFactory(strategyManager, eigenLayerPauserReg); + permissionControllerImplementation = new PermissionController(SEMVER); + strategyFactoryImplementation = new StrategyFactory(strategyManager, eigenLayerPauserReg, SEMVER); // Third, upgrade the proxy contracts to use the correct implementation contracts and initialize them. { @@ -325,7 +350,7 @@ contract DeployFromScratch is Script, Test { // Deploy strategyFactory & base // Create base strategy implementation - baseStrategyImplementation = new StrategyBase(strategyManager, eigenLayerPauserReg); + baseStrategyImplementation = new StrategyBase(strategyManager, eigenLayerPauserReg, SEMVER); // Create a proxy beacon for base strategy implementation strategyBeacon = new UpgradeableBeacon(address(baseStrategyImplementation)); diff --git a/script/deploy/local/Deploy_From_Scratch.s.sol b/script/deploy/local/Deploy_From_Scratch.s.sol index 8987c680e4..6201cd55a4 100644 --- a/script/deploy/local/Deploy_From_Scratch.s.sol +++ b/script/deploy/local/Deploy_From_Scratch.s.sol @@ -79,6 +79,8 @@ contract DeployFromScratch is Script, Test { // strategies deployed StrategyBaseTVLLimits[] public deployedStrategyArray; + string SEMVER; + // IMMUTABLES TO SET uint64 GOERLI_GENESIS_TIME = 1616508000; @@ -124,6 +126,8 @@ contract DeployFromScratch is Script, Test { string memory config_data = vm.readFile(deployConfigPath); // bytes memory parsedData = vm.parseJson(config_data); + SEMVER = stdJson.readString(config_data, ".semver"); + STRATEGY_MANAGER_INIT_PAUSED_STATUS = stdJson.readUint(config_data, ".strategyManager.init_paused_status"); DELEGATION_INIT_PAUSED_STATUS = stdJson.readUint(config_data, ".delegation.init_paused_status"); DELEGATION_WITHDRAWAL_DELAY_BLOCKS = stdJson.readUint(config_data, ".delegation.init_withdrawal_delay_blocks"); @@ -240,35 +244,54 @@ contract DeployFromScratch is Script, Test { } else { ethPOSDeposit = IETHPOSDeposit(stdJson.readAddress(config_data, ".ethPOSDepositAddress")); } - eigenPodImplementation = new EigenPod(ethPOSDeposit, eigenPodManager, GOERLI_GENESIS_TIME); + eigenPodImplementation = new EigenPod(ethPOSDeposit, eigenPodManager, GOERLI_GENESIS_TIME, SEMVER); eigenPodBeacon = new UpgradeableBeacon(address(eigenPodImplementation)); // Second, deploy the *implementation* contracts, using the *proxy contracts* as inputs - delegationImplementation = new DelegationManager(strategyManager, eigenPodManager, allocationManager, eigenLayerPauserReg, permissionController, MIN_WITHDRAWAL_DELAY); - strategyManagerImplementation = new StrategyManager(delegation, eigenLayerPauserReg); - avsDirectoryImplementation = new AVSDirectory(delegation, eigenLayerPauserReg); + delegationImplementation = new DelegationManager( + strategyManager, + eigenPodManager, + allocationManager, + eigenLayerPauserReg, + permissionController, + MIN_WITHDRAWAL_DELAY, + SEMVER + ); + strategyManagerImplementation = new StrategyManager(delegation, eigenLayerPauserReg, SEMVER); + avsDirectoryImplementation = new AVSDirectory(delegation, eigenLayerPauserReg, SEMVER); eigenPodManagerImplementation = new EigenPodManager( ethPOSDeposit, eigenPodBeacon, delegation, - eigenLayerPauserReg + eigenLayerPauserReg, + SEMVER ); rewardsCoordinatorImplementation = new RewardsCoordinator( - delegation, - strategyManager, - allocationManager, - eigenLayerPauserReg, - permissionController, - REWARDS_COORDINATOR_CALCULATION_INTERVAL_SECONDS, - REWARDS_COORDINATOR_MAX_REWARDS_DURATION, - REWARDS_COORDINATOR_MAX_RETROACTIVE_LENGTH, - REWARDS_COORDINATOR_MAX_FUTURE_LENGTH, - REWARDS_COORDINATOR_GENESIS_REWARDS_TIMESTAMP + IRewardsCoordinatorTypes.RewardsCoordinatorConstructorParams( + delegation, + strategyManager, + allocationManager, + eigenLayerPauserReg, + permissionController, + REWARDS_COORDINATOR_CALCULATION_INTERVAL_SECONDS, + REWARDS_COORDINATOR_MAX_REWARDS_DURATION, + REWARDS_COORDINATOR_MAX_RETROACTIVE_LENGTH, + REWARDS_COORDINATOR_MAX_FUTURE_LENGTH, + REWARDS_COORDINATOR_GENESIS_REWARDS_TIMESTAMP, + SEMVER + ) + ); + allocationManagerImplementation = new AllocationManager( + delegation, + eigenLayerPauserReg, + permissionController, + DEALLOCATION_DELAY, + ALLOCATION_CONFIGURATION_DELAY, + SEMVER ); - allocationManagerImplementation = new AllocationManager(delegation, eigenLayerPauserReg, permissionController, DEALLOCATION_DELAY, ALLOCATION_CONFIGURATION_DELAY); - permissionControllerImplementation = new PermissionController(); + permissionControllerImplementation = new PermissionController(SEMVER); // Third, upgrade the proxy contracts to use the correct implementation contracts and initialize them. { @@ -340,7 +363,7 @@ contract DeployFromScratch is Script, Test { ); // deploy StrategyBaseTVLLimits contract implementation - baseStrategyImplementation = new StrategyBaseTVLLimits(strategyManager, eigenLayerPauserReg); + baseStrategyImplementation = new StrategyBaseTVLLimits(strategyManager, eigenLayerPauserReg, SEMVER); // create upgradeable proxies that each point to the implementation and initialize them for (uint256 i = 0; i < strategyConfigs.length; ++i) { if (strategyConfigs[i].tokenAddress == address(0)) { diff --git a/script/deploy/local/deploy_from_scratch.slashing.s.sol b/script/deploy/local/deploy_from_scratch.slashing.s.sol index 38ba01b7de..bf07af1d0a 100644 --- a/script/deploy/local/deploy_from_scratch.slashing.s.sol +++ b/script/deploy/local/deploy_from_scratch.slashing.s.sol @@ -73,6 +73,8 @@ contract DeployFromScratch is Script, Test { address operationsMultisig; address pauserMultisig; + string SEMVER; + // the ETH2 deposit contract -- if not on mainnet, we deploy a mock as stand-in IETHPOSDeposit public ethPOSDeposit; @@ -124,6 +126,8 @@ contract DeployFromScratch is Script, Test { string memory config_data = vm.readFile(deployConfigPath); // bytes memory parsedData = vm.parseJson(config_data); + SEMVER = stdJson.readString(config_data, ".semver"); + MIN_WITHDRAWAL_DELAY = uint32(stdJson.readUint(config_data, ".delegation.withdrawal_delay_blocks")); STRATEGY_MANAGER_INIT_PAUSED_STATUS = stdJson.readUint(config_data, ".strategyManager.init_paused_status"); DELEGATION_INIT_PAUSED_STATUS = stdJson.readUint(config_data, ".delegation.init_paused_status"); @@ -234,36 +238,56 @@ contract DeployFromScratch is Script, Test { eigenPodImplementation = new EigenPod( ethPOSDeposit, eigenPodManager, - GOERLI_GENESIS_TIME + GOERLI_GENESIS_TIME, + SEMVER ); eigenPodBeacon = new UpgradeableBeacon(address(eigenPodImplementation)); // Second, deploy the *implementation* contracts, using the *proxy contracts* as inputs - delegationImplementation = new DelegationManager(strategyManager, eigenPodManager, allocationManager, eigenLayerPauserReg, permissionController, MIN_WITHDRAWAL_DELAY); - strategyManagerImplementation = new StrategyManager(delegation, eigenLayerPauserReg); - avsDirectoryImplementation = new AVSDirectory(delegation, eigenLayerPauserReg); + delegationImplementation = new DelegationManager( + strategyManager, + eigenPodManager, + allocationManager, + eigenLayerPauserReg, + permissionController, + MIN_WITHDRAWAL_DELAY, + SEMVER + ); + strategyManagerImplementation = new StrategyManager(delegation, eigenLayerPauserReg, SEMVER); + avsDirectoryImplementation = new AVSDirectory(delegation, eigenLayerPauserReg, SEMVER); eigenPodManagerImplementation = new EigenPodManager( ethPOSDeposit, eigenPodBeacon, delegation, - eigenLayerPauserReg + eigenLayerPauserReg, + SEMVER ); rewardsCoordinatorImplementation = new RewardsCoordinator( - delegation, - strategyManager, - allocationManager, - eigenLayerPauserReg, - permissionController, - REWARDS_COORDINATOR_CALCULATION_INTERVAL_SECONDS, - REWARDS_COORDINATOR_MAX_REWARDS_DURATION, - REWARDS_COORDINATOR_MAX_RETROACTIVE_LENGTH, - REWARDS_COORDINATOR_MAX_FUTURE_LENGTH, - REWARDS_COORDINATOR_GENESIS_REWARDS_TIMESTAMP + IRewardsCoordinatorTypes.RewardsCoordinatorConstructorParams( + delegation, + strategyManager, + allocationManager, + eigenLayerPauserReg, + permissionController, + REWARDS_COORDINATOR_CALCULATION_INTERVAL_SECONDS, + REWARDS_COORDINATOR_MAX_REWARDS_DURATION, + REWARDS_COORDINATOR_MAX_RETROACTIVE_LENGTH, + REWARDS_COORDINATOR_MAX_FUTURE_LENGTH, + REWARDS_COORDINATOR_GENESIS_REWARDS_TIMESTAMP, + SEMVER + ) + ); + allocationManagerImplementation = new AllocationManager( + delegation, + eigenLayerPauserReg, + permissionController, + DEALLOCATION_DELAY, + ALLOCATION_CONFIGURATION_DELAY, + SEMVER ); - allocationManagerImplementation = new AllocationManager(delegation, eigenLayerPauserReg, permissionController, DEALLOCATION_DELAY, ALLOCATION_CONFIGURATION_DELAY); - permissionControllerImplementation = new PermissionController(); + permissionControllerImplementation = new PermissionController(SEMVER); // Third, upgrade the proxy contracts to use the correct implementation contracts and initialize them. { @@ -335,7 +359,7 @@ contract DeployFromScratch is Script, Test { ); // deploy StrategyBaseTVLLimits contract implementation - baseStrategyImplementation = new StrategyBaseTVLLimits(strategyManager, eigenLayerPauserReg); + baseStrategyImplementation = new StrategyBaseTVLLimits(strategyManager, eigenLayerPauserReg, SEMVER); // create upgradeable proxies that each point to the implementation and initialize them for (uint256 i = 0; i < strategyConfigs.length; ++i) { if (strategyConfigs[i].tokenAddress == address(0)) { diff --git a/script/releases/v1.0.0-slashing/1-deployContracts.s.sol b/script/releases/v1.0.0-slashing/1-deployContracts.s.sol deleted file mode 100644 index 6c5828600a..0000000000 --- a/script/releases/v1.0.0-slashing/1-deployContracts.s.sol +++ /dev/null @@ -1,528 +0,0 @@ -// SPDX-License-Identifier: BUSL-1.1 -pragma solidity ^0.8.12; - -import {EOADeployer} from "zeus-templates/templates/EOADeployer.sol"; -import "../Env.sol"; - -import "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol"; -import "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol"; -import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; -import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol"; - -/** - * Purpose: use an EOA to deploy all of the new contracts for this upgrade. - */ -contract Deploy is EOADeployer { - using Env for *; - - function _runAsEOA() internal override { - vm.startBroadcast(); - - /// permissions/ - - address[] memory pausers = new address[](3); - pausers[0] = Env.pauserMultisig(); - pausers[1] = Env.opsMultisig(); - pausers[2] = Env.executorMultisig(); - - deployImpl({ - name: type(PauserRegistry).name, - deployedTo: address(new PauserRegistry({ - _pausers: pausers, - _unpauser: Env.executorMultisig() - })) - }); - - deployImpl({ - name: type(PermissionController).name, - deployedTo: address(new PermissionController()) - }); - - deployProxy({ - name: type(PermissionController).name, - deployedTo: address(new TransparentUpgradeableProxy({ - _logic: address(Env.impl.permissionController()), - admin_: Env.proxyAdmin(), - _data: "" - })) - }); - - /// core/ - - deployImpl({ - name: type(AllocationManager).name, - deployedTo: address(new AllocationManager({ - _delegation: Env.proxy.delegationManager(), - _pauserRegistry: Env.impl.pauserRegistry(), - _permissionController: Env.proxy.permissionController(), - _DEALLOCATION_DELAY: Env.MIN_WITHDRAWAL_DELAY(), - _ALLOCATION_CONFIGURATION_DELAY: Env.ALLOCATION_CONFIGURATION_DELAY() - })) - }); - - deployProxy({ - name: type(AllocationManager).name, - deployedTo: address(new TransparentUpgradeableProxy({ - _logic: address(Env.impl.allocationManager()), - admin_: Env.proxyAdmin(), - _data: abi.encodeCall( - AllocationManager.initialize, - ( - Env.executorMultisig(), // initialOwner - 0 // initialPausedStatus - ) - ) - })) - }); - - deployImpl({ - name: type(AVSDirectory).name, - deployedTo: address(new AVSDirectory({ - _delegation: Env.proxy.delegationManager(), - _pauserRegistry: Env.impl.pauserRegistry() - })) - }); - - deployImpl({ - name: type(DelegationManager).name, - deployedTo: address(new DelegationManager({ - _strategyManager: Env.proxy.strategyManager(), - _eigenPodManager: Env.proxy.eigenPodManager(), - _allocationManager: Env.proxy.allocationManager(), - _pauserRegistry: Env.impl.pauserRegistry(), - _permissionController: Env.proxy.permissionController(), - _MIN_WITHDRAWAL_DELAY: Env.MIN_WITHDRAWAL_DELAY() - })) - }); - - deployImpl({ - name: type(RewardsCoordinator).name, - deployedTo: address(new RewardsCoordinator({ - _delegationManager: Env.proxy.delegationManager(), - _strategyManager: Env.proxy.strategyManager(), - _allocationManager: Env.proxy.allocationManager(), - _pauserRegistry: Env.impl.pauserRegistry(), - _permissionController: Env.proxy.permissionController(), - _CALCULATION_INTERVAL_SECONDS: Env.CALCULATION_INTERVAL_SECONDS(), - _MAX_REWARDS_DURATION: Env.MAX_REWARDS_DURATION(), - _MAX_RETROACTIVE_LENGTH: Env.MAX_RETROACTIVE_LENGTH(), - _MAX_FUTURE_LENGTH: Env.MAX_FUTURE_LENGTH(), - _GENESIS_REWARDS_TIMESTAMP: Env.GENESIS_REWARDS_TIMESTAMP() - })) - }); - - deployImpl({ - name: type(StrategyManager).name, - deployedTo: address(new StrategyManager({ - _delegation: Env.proxy.delegationManager(), - _pauserRegistry: Env.impl.pauserRegistry() - })) - }); - - /// pods/ - - deployImpl({ - name: type(EigenPodManager).name, - deployedTo: address(new EigenPodManager({ - _ethPOS: Env.ethPOS(), - _eigenPodBeacon: Env.beacon.eigenPod(), - _delegationManager: Env.proxy.delegationManager(), - _pauserRegistry: Env.impl.pauserRegistry() - })) - }); - - deployImpl({ - name: type(EigenPod).name, - deployedTo: address(new EigenPod({ - _ethPOS: Env.ethPOS(), - _eigenPodManager: Env.proxy.eigenPodManager(), - _GENESIS_TIME: Env.EIGENPOD_GENESIS_TIME() - })) - }); - - /// strategies/ - - deployImpl({ - name: type(StrategyBaseTVLLimits).name, - deployedTo: address(new StrategyBaseTVLLimits({ - _strategyManager: Env.proxy.strategyManager(), - _pauserRegistry: Env.impl.pauserRegistry() - })) - }); - - deployImpl({ - name: type(EigenStrategy).name, - deployedTo: address(new EigenStrategy({ - _strategyManager: Env.proxy.strategyManager(), - _pauserRegistry: Env.impl.pauserRegistry() - })) - }); - - deployImpl({ - name: type(StrategyFactory).name, - deployedTo: address(new StrategyFactory({ - _strategyManager: Env.proxy.strategyManager(), - _pauserRegistry: Env.impl.pauserRegistry() - })) - }); - - // for strategies deployed via factory - deployImpl({ - name: type(StrategyBase).name, - deployedTo: address(new StrategyBase({ - _strategyManager: Env.proxy.strategyManager(), - _pauserRegistry: Env.impl.pauserRegistry() - })) - }); - - vm.stopBroadcast(); - } - - function testScript() public virtual { - _runAsEOA(); - - _validateNewImplAddresses({ areMatching: false }); - _validateProxyAdmins(); - _validateImplConstructors(); - _validateImplsInitialized(); - _validateStrategiesAreWhitelisted(); - } - - /// @dev Validate that the `Env.impl` addresses are updated to be distinct from what the proxy - /// admin reports as the current implementation address. - /// - /// Note: The upgrade script can call this with `areMatching == true` to check that these impl - /// addresses _are_ matches. - function _validateNewImplAddresses(bool areMatching) internal view { - /// core/ -- can't check AllocationManager as it didn't exist before this deploy - - function (address, address, string memory) internal pure assertion = - areMatching ? _assertMatch : _assertNotMatch; - - assertion( - _getProxyImpl(address(Env.proxy.avsDirectory())), - address(Env.impl.avsDirectory()), - "avsDirectory impl failed" - ); - - assertion( - _getProxyImpl(address(Env.proxy.delegationManager())), - address(Env.impl.delegationManager()), - "delegationManager impl failed" - ); - - assertion( - _getProxyImpl(address(Env.proxy.rewardsCoordinator())), - address(Env.impl.rewardsCoordinator()), - "rewardsCoordinator impl failed" - ); - - assertion( - _getProxyImpl(address(Env.proxy.strategyManager())), - address(Env.impl.strategyManager()), - "strategyManager impl failed" - ); - - /// permissions/ -- can't check these because PauserRegistry has no proxy, and - /// PermissionController proxy didn't exist before this deploy - - /// pods/ - - assertion( - Env.beacon.eigenPod().implementation(), - address(Env.impl.eigenPod()), - "eigenPod impl failed" - ); - - assertion( - _getProxyImpl(address(Env.proxy.eigenPodManager())), - address(Env.impl.eigenPodManager()), - "eigenPodManager impl failed" - ); - - /// strategies/ - - assertion( - _getProxyImpl(address(Env.proxy.eigenStrategy())), - address(Env.impl.eigenStrategy()), - "eigenStrategy impl failed" - ); - - assertion( - Env.beacon.strategyBase().implementation(), - address(Env.impl.strategyBase()), - "strategyBase impl failed" - ); - - uint count = Env.instance.strategyBaseTVLLimits_Count(); - for (uint i = 0; i < count; i++) { - assertion( - _getProxyImpl(address(Env.instance.strategyBaseTVLLimits(i))), - address(Env.impl.strategyBaseTVLLimits()), - "strategyBaseTVLLimits impl failed" - ); - } - - assertion( - _getProxyImpl(address(Env.proxy.strategyFactory())), - address(Env.impl.strategyFactory()), - "strategyFactory impl failed" - ); - } - - /// @dev Ensure each deployed TUP/beacon is owned by the proxyAdmin/executorMultisig - function _validateProxyAdmins() internal view { - address pa = Env.proxyAdmin(); - - assertTrue( - _getProxyAdmin(address(Env.proxy.allocationManager())) == pa, - "allocationManager proxyAdmin incorrect" - ); - - assertTrue( - _getProxyAdmin(address(Env.proxy.avsDirectory())) == pa, - "avsDirectory proxyAdmin incorrect" - ); - - assertTrue( - _getProxyAdmin(address(Env.proxy.delegationManager())) == pa, - "delegationManager proxyAdmin incorrect" - ); - - assertTrue( - _getProxyAdmin(address(Env.proxy.rewardsCoordinator())) == pa, - "rewardsCoordinator proxyAdmin incorrect" - ); - - assertTrue( - _getProxyAdmin(address(Env.proxy.strategyManager())) == pa, - "strategyManager proxyAdmin incorrect" - ); - - /// permissions/ -- can't check these because PauserRegistry has no proxy, and - /// PermissionController proxy didn't exist before this deploy - - /// pods/ - - assertTrue( - Env.beacon.eigenPod().owner() == Env.executorMultisig(), - "eigenPod beacon owner incorrect" - ); - - assertTrue( - _getProxyAdmin(address(Env.proxy.eigenPodManager())) == pa, - "eigenPodManager proxyAdmin incorrect" - ); - - /// strategies/ - - assertTrue( - _getProxyAdmin(address(Env.proxy.eigenStrategy())) == pa, - "eigenStrategy proxyAdmin incorrect" - ); - - assertTrue( - Env.beacon.strategyBase().owner() == Env.executorMultisig(), - "strategyBase beacon owner incorrect" - ); - - uint count = Env.instance.strategyBaseTVLLimits_Count(); - for (uint i = 0; i < count; i++) { - assertTrue( - _getProxyAdmin(address(Env.instance.strategyBaseTVLLimits(i))) == pa, - "strategyBaseTVLLimits proxyAdmin incorrect" - ); - } - - assertTrue( - _getProxyAdmin(address(Env.proxy.strategyFactory())) == pa, - "strategyFactory proxyAdmin incorrect" - ); - } - - /// @dev Validate the immutables set in the new implementation constructors - function _validateImplConstructors() internal view { - { - /// permissions/ - - PauserRegistry registry = Env.impl.pauserRegistry(); - assertTrue(registry.isPauser(Env.pauserMultisig()), "pauser multisig should be pauser"); - assertTrue(registry.isPauser(Env.opsMultisig()), "ops multisig should be pauser"); - assertTrue(registry.isPauser(Env.executorMultisig()), "executor multisig should be pauser"); - assertTrue(registry.unpauser() == Env.executorMultisig(), "executor multisig should be unpauser"); - - /// PermissionController has no initial storage - } - - { - /// core/ - - AllocationManager allocationManager = Env.impl.allocationManager(); - assertTrue(allocationManager.delegation() == Env.proxy.delegationManager(), "alm.dm invalid"); - assertTrue(allocationManager.pauserRegistry() == Env.impl.pauserRegistry(), "alm.pR invalid"); - assertTrue(allocationManager.permissionController() == Env.proxy.permissionController(), "alm.pc invalid"); - assertTrue(allocationManager.DEALLOCATION_DELAY() == Env.MIN_WITHDRAWAL_DELAY(), "alm.deallocDelay invalid"); - assertTrue(allocationManager.ALLOCATION_CONFIGURATION_DELAY() == Env.ALLOCATION_CONFIGURATION_DELAY(), "alm.configDelay invalid"); - - AVSDirectory avsDirectory = Env.impl.avsDirectory(); - assertTrue(avsDirectory.delegation() == Env.proxy.delegationManager(), "avsD.dm invalid"); - assertTrue(avsDirectory.pauserRegistry() == Env.impl.pauserRegistry(), "avsD.pR invalid"); - - DelegationManager delegation = Env.impl.delegationManager(); - assertTrue(delegation.strategyManager() == Env.proxy.strategyManager(), "dm.sm invalid"); - assertTrue(delegation.eigenPodManager() == Env.proxy.eigenPodManager(), "dm.epm invalid"); - assertTrue(delegation.allocationManager() == Env.proxy.allocationManager(), "dm.alm invalid"); - assertTrue(delegation.pauserRegistry() == Env.impl.pauserRegistry(), "dm.pR invalid"); - assertTrue(delegation.permissionController() == Env.proxy.permissionController(), "dm.pc invalid"); - assertTrue(delegation.minWithdrawalDelayBlocks() == Env.MIN_WITHDRAWAL_DELAY(), "dm.withdrawalDelay invalid"); - - RewardsCoordinator rewards = Env.impl.rewardsCoordinator(); - assertTrue(rewards.delegationManager() == Env.proxy.delegationManager(), "rc.dm invalid"); - assertTrue(rewards.strategyManager() == Env.proxy.strategyManager(), "rc.sm invalid"); - assertTrue(rewards.allocationManager() == Env.proxy.allocationManager(), "rc.alm invalid"); - assertTrue(rewards.pauserRegistry() == Env.impl.pauserRegistry(), "rc.pR invalid"); - assertTrue(rewards.permissionController() == Env.proxy.permissionController(), "rc.pc invalid"); - assertTrue(rewards.CALCULATION_INTERVAL_SECONDS() == Env.CALCULATION_INTERVAL_SECONDS(), "rc.calcInterval invalid"); - assertTrue(rewards.MAX_REWARDS_DURATION() == Env.MAX_REWARDS_DURATION(), "rc.rewardsDuration invalid"); - assertTrue(rewards.MAX_RETROACTIVE_LENGTH() == Env.MAX_RETROACTIVE_LENGTH(), "rc.retroLength invalid"); - assertTrue(rewards.MAX_FUTURE_LENGTH() == Env.MAX_FUTURE_LENGTH(), "rc.futureLength invalid"); - assertTrue(rewards.GENESIS_REWARDS_TIMESTAMP() == Env.GENESIS_REWARDS_TIMESTAMP(), "rc.genesis invalid"); - - StrategyManager strategyManager = Env.impl.strategyManager(); - assertTrue(strategyManager.delegation() == Env.proxy.delegationManager(), "sm.dm invalid"); - assertTrue(strategyManager.pauserRegistry() == Env.impl.pauserRegistry(), "sm.pR invalid"); - } - - { - /// pods/ - EigenPod eigenPod = Env.impl.eigenPod(); - assertTrue(eigenPod.ethPOS() == Env.ethPOS(), "ep.ethPOS invalid"); - assertTrue(eigenPod.eigenPodManager() == Env.proxy.eigenPodManager(), "ep.epm invalid"); - assertTrue(eigenPod.GENESIS_TIME() == Env.EIGENPOD_GENESIS_TIME(), "ep.genesis invalid"); - - EigenPodManager eigenPodManager = Env.impl.eigenPodManager(); - assertTrue(eigenPodManager.ethPOS() == Env.ethPOS(), "epm.ethPOS invalid"); - assertTrue(eigenPodManager.eigenPodBeacon() == Env.beacon.eigenPod(), "epm.epBeacon invalid"); - assertTrue(eigenPodManager.delegationManager() == Env.proxy.delegationManager(), "epm.dm invalid"); - assertTrue(eigenPodManager.pauserRegistry() == Env.impl.pauserRegistry(), "epm.pR invalid"); - } - - { - /// strategies/ - EigenStrategy eigenStrategy = Env.impl.eigenStrategy(); - assertTrue(eigenStrategy.strategyManager() == Env.proxy.strategyManager(), "eigStrat.sm invalid"); - assertTrue(eigenStrategy.pauserRegistry() == Env.impl.pauserRegistry(), "eigStrat.pR invalid"); - - StrategyBase strategyBase = Env.impl.strategyBase(); - assertTrue(strategyBase.strategyManager() == Env.proxy.strategyManager(), "stratBase.sm invalid"); - assertTrue(strategyBase.pauserRegistry() == Env.impl.pauserRegistry(), "stratBase.pR invalid"); - - StrategyBaseTVLLimits strategyBaseTVLLimits = Env.impl.strategyBaseTVLLimits(); - assertTrue(strategyBaseTVLLimits.strategyManager() == Env.proxy.strategyManager(), "stratBaseTVL.sm invalid"); - assertTrue(strategyBaseTVLLimits.pauserRegistry() == Env.impl.pauserRegistry(), "stratBaseTVL.pR invalid"); - - StrategyFactory strategyFactory = Env.impl.strategyFactory(); - assertTrue(strategyFactory.strategyManager() == Env.proxy.strategyManager(), "sFact.sm invalid"); - assertTrue(strategyFactory.pauserRegistry() == Env.impl.pauserRegistry(), "sFact.pR invalid"); - } - } - - /// @dev Call initialize on all deployed implementations to ensure initializers are disabled - function _validateImplsInitialized() internal { - bytes memory errInit = "Initializable: contract is already initialized"; - - /// permissions/ - // PermissionController is initializable, but does not expose the `initialize` method - - { - /// core/ - - AllocationManager allocationManager = Env.impl.allocationManager(); - vm.expectRevert(errInit); - allocationManager.initialize(address(0), 0); - - AVSDirectory avsDirectory = Env.impl.avsDirectory(); - vm.expectRevert(errInit); - avsDirectory.initialize(address(0), 0); - - DelegationManager delegation = Env.impl.delegationManager(); - vm.expectRevert(errInit); - delegation.initialize(address(0), 0); - - RewardsCoordinator rewards = Env.impl.rewardsCoordinator(); - vm.expectRevert(errInit); - rewards.initialize(address(0), 0, address(0), 0, 0); - - StrategyManager strategyManager = Env.impl.strategyManager(); - vm.expectRevert(errInit); - strategyManager.initialize(address(0), address(0), 0); - } - - { - /// pods/ - EigenPod eigenPod = Env.impl.eigenPod(); - vm.expectRevert(errInit); - eigenPod.initialize(address(0)); - - EigenPodManager eigenPodManager = Env.impl.eigenPodManager(); - vm.expectRevert(errInit); - eigenPodManager.initialize(address(0), 0); - } - - { - /// strategies/ - EigenStrategy eigenStrategy = Env.impl.eigenStrategy(); - vm.expectRevert(errInit); - eigenStrategy.initialize(IEigen(address(0)), IBackingEigen(address(0))); - - StrategyBase strategyBase = Env.impl.strategyBase(); - vm.expectRevert(errInit); - strategyBase.initialize(IERC20(address(0))); - - StrategyBaseTVLLimits strategyBaseTVLLimits = Env.impl.strategyBaseTVLLimits(); - vm.expectRevert(errInit); - strategyBaseTVLLimits.initialize(0, 0, IERC20(address(0))); - - StrategyFactory strategyFactory = Env.impl.strategyFactory(); - vm.expectRevert(errInit); - strategyFactory.initialize(address(0), 0, UpgradeableBeacon(address(0))); - } - } - - /// @dev Iterate over StrategyBaseTVLLimits instances and validate that each is - /// whitelisted for deposit - function _validateStrategiesAreWhitelisted() internal view { - uint count = Env.instance.strategyBaseTVLLimits_Count(); - for (uint i = 0; i < count; i++) { - StrategyBaseTVLLimits strategy = Env.instance.strategyBaseTVLLimits(i); - - // emit log_named_uint("strategy", i); - // IERC20Metadata underlying = IERC20Metadata(address(strategy.underlyingToken())); - // emit log_named_string("- name", underlying.name()); - // emit log_named_string("- symbol", underlying.symbol()); - // emit log_named_uint("- totalShares", strategy.totalShares()); - - bool isWhitelisted = Env.proxy.strategyManager().strategyIsWhitelistedForDeposit(strategy); - // emit log_named_string("- is whitelisted", isWhitelisted ? "true" : "false"); - assertTrue(isWhitelisted, "not whitelisted!!"); - } - } - - /// @dev Query and return `proxyAdmin.getProxyImplementation(proxy)` - function _getProxyImpl(address proxy) internal view returns (address) { - return ProxyAdmin(Env.proxyAdmin()).getProxyImplementation(ITransparentUpgradeableProxy(proxy)); - } - - /// @dev Query and return `proxyAdmin.getProxyAdmin(proxy)` - function _getProxyAdmin(address proxy) internal view returns (address) { - return ProxyAdmin(Env.proxyAdmin()).getProxyAdmin(ITransparentUpgradeableProxy(proxy)); - } - - function _assertMatch(address a, address b, string memory err) private pure { - assertEq(a, b, err); - } - - function _assertNotMatch(address a, address b, string memory err) private pure { - assertNotEq(a, b, err); - } -} diff --git a/script/releases/v1.0.0-slashing/2-queueUpgradeAndUnpause.s.sol b/script/releases/v1.0.0-slashing/2-queueUpgradeAndUnpause.s.sol deleted file mode 100644 index 6d8915d97d..0000000000 --- a/script/releases/v1.0.0-slashing/2-queueUpgradeAndUnpause.s.sol +++ /dev/null @@ -1,156 +0,0 @@ -// SPDX-License-Identifier: BUSL-1.1 -pragma solidity ^0.8.12; - -import {Deploy} from "./1-deployContracts.s.sol"; -import "../Env.sol"; - -import {MultisigBuilder} from "zeus-templates/templates/MultisigBuilder.sol"; -import "zeus-templates/utils/Encode.sol"; - -import {TimelockController} from "@openzeppelin/contracts/governance/TimelockController.sol"; - -/** - * Purpose: - * * enqueue a multisig transaction which; - * - upgrades all the relevant contracts, and - * - unpauses the system. - * This should be run via the protocol council multisig. - */ -contract QueueAndUnpause is MultisigBuilder, Deploy { - using Env for *; - using Encode for *; - - function _runAsMultisig() prank(Env.opsMultisig()) internal virtual override { - bytes memory calldata_to_executor = _getCalldataToExecutor(); - - TimelockController timelock = Env.timelockController(); - timelock.schedule({ - target: Env.executorMultisig(), - value: 0, - data: calldata_to_executor, - predecessor: 0, - salt: 0, - delay: timelock.getMinDelay() - }); - } - - /// @dev Get the calldata to be sent from the timelock to the executor - function _getCalldataToExecutor() internal returns (bytes memory) { - MultisigCall[] storage executorCalls = Encode.newMultisigCalls() - /// core/ - .append({ - to: Env.proxyAdmin(), - data: Encode.proxyAdmin.upgrade({ - proxy: address(Env.proxy.avsDirectory()), - impl: address(Env.impl.avsDirectory()) - }) - }) - .append({ - to: Env.proxyAdmin(), - data: Encode.proxyAdmin.upgrade({ - proxy: address(Env.proxy.delegationManager()), - impl: address(Env.impl.delegationManager()) - }) - }) - .append({ - to: Env.proxyAdmin(), - data: Encode.proxyAdmin.upgrade({ - proxy: address(Env.proxy.rewardsCoordinator()), - impl: address(Env.impl.rewardsCoordinator()) - }) - }) - .append({ - to: Env.proxyAdmin(), - data: Encode.proxyAdmin.upgrade({ - proxy: address(Env.proxy.strategyManager()), - impl: address(Env.impl.strategyManager()) - }) - }) - /// pods/ - .append({ - to: address(Env.beacon.eigenPod()), - data: Encode.upgradeableBeacon.upgradeTo({ - newImpl: address(Env.impl.eigenPod()) - }) - }) - .append({ - to: Env.proxyAdmin(), - data: Encode.proxyAdmin.upgrade({ - proxy: address(Env.proxy.eigenPodManager()), - impl: address(Env.impl.eigenPodManager()) - }) - }) - /// strategies/ - .append({ - to: Env.proxyAdmin(), - data: Encode.proxyAdmin.upgrade({ - proxy: address(Env.proxy.eigenStrategy()), - impl: address(Env.impl.eigenStrategy()) - }) - }) - .append({ - to: address(Env.beacon.strategyBase()), - data: Encode.upgradeableBeacon.upgradeTo({ - newImpl: address(Env.impl.strategyBase()) - }) - }) - .append({ - to: Env.proxyAdmin(), - data: Encode.proxyAdmin.upgrade({ - proxy: address(Env.proxy.strategyFactory()), - impl: address(Env.impl.strategyFactory()) - }) - }); - - /// Add call to upgrade each pre-longtail strategy instance - uint count = Env.instance.strategyBaseTVLLimits_Count(); - for (uint i = 0; i < count; i++) { - address proxyInstance = address(Env.instance.strategyBaseTVLLimits(i)); - - executorCalls.append({ - to: Env.proxyAdmin(), - data: Encode.proxyAdmin.upgrade({ - proxy: proxyInstance, - impl: address(Env.impl.strategyBaseTVLLimits()) - }) - }); - } - - // /// Finally, add a call unpausing the EigenPodManager - // /// We will end up pausing it in step 3, so the unpause will - // /// go through as part of execution (step 5) - executorCalls.append({ - to: address(Env.proxy.eigenPodManager()), - data: abi.encodeCall(Pausable.unpause, 0) - }); - - return Encode.gnosisSafe.execTransaction({ - from: address(Env.timelockController()), - to: Env.multiSendCallOnly(), - op: Encode.Operation.DelegateCall, - data: Encode.multiSend(executorCalls) - }); - } - - function testScript() public virtual override { - runAsEOA(); - - TimelockController timelock = Env.timelockController(); - bytes memory calldata_to_executor = _getCalldataToExecutor(); - bytes32 txHash = timelock.hashOperation({ - target: Env.executorMultisig(), - value: 0, - data: calldata_to_executor, - predecessor: 0, - salt: 0 - }); - - // Check that the upgrade does not exist in the timelock - assertFalse(timelock.isOperationPending(txHash), "Transaction should NOT be queued."); - - execute(); - - // Check that the upgrade has been added to the timelock - assertTrue(timelock.isOperationPending(txHash), "Transaction should be queued."); - } -} diff --git a/script/releases/v1.0.0-slashing/3-pause.s.sol b/script/releases/v1.0.0-slashing/3-pause.s.sol deleted file mode 100644 index 030949d05d..0000000000 --- a/script/releases/v1.0.0-slashing/3-pause.s.sol +++ /dev/null @@ -1,32 +0,0 @@ -// SPDX-License-Identifier: BUSL-1.1 -pragma solidity ^0.8.12; - -import "../Env.sol"; - -import {MultisigBuilder} from "zeus-templates/templates/MultisigBuilder.sol"; - -/** - * Purpose: Enqueue a transaction which immediately sets `EigenPodManager.PAUSED_START_CHECKPOINT=true` - */ -contract Pause is MultisigBuilder, EigenPodPausingConstants { - using Env for *; - - function _runAsMultisig() prank(Env.pauserMultisig()) internal virtual override { - uint mask = 1 << PAUSED_START_CHECKPOINT; - - Env.proxy.eigenPodManager().pause(mask); - } - - function testScript() public virtual { - execute(); - - assertTrue(Env.proxy.eigenPodManager().paused(PAUSED_START_CHECKPOINT), "Not paused!"); - - // Create a new pod and try to start a checkpoint - EigenPod pod = EigenPod(payable(Env.proxy.eigenPodManager().createPod())); - - // At this point in the upgrade process, we're not using error types yet - vm.expectRevert("EigenPod.onlyWhenNotPaused: index is paused in EigenPodManager"); - pod.startCheckpoint(false); - } -} diff --git a/script/releases/v1.0.0-slashing/4-podCleanup.sh b/script/releases/v1.0.0-slashing/4-podCleanup.sh deleted file mode 100644 index f467ceb02b..0000000000 --- a/script/releases/v1.0.0-slashing/4-podCleanup.sh +++ /dev/null @@ -1 +0,0 @@ -# TODO(justin): run a binary which completes all checkpoints on the network. \ No newline at end of file diff --git a/script/releases/v1.0.0-slashing/5-executeUpgradeAndUnpause.s.sol b/script/releases/v1.0.0-slashing/5-executeUpgradeAndUnpause.s.sol deleted file mode 100644 index f237c41a1e..0000000000 --- a/script/releases/v1.0.0-slashing/5-executeUpgradeAndUnpause.s.sol +++ /dev/null @@ -1,267 +0,0 @@ -// SPDX-License-Identifier: BUSL-1.1 -pragma solidity ^0.8.12; - -import "../Env.sol"; -import {QueueAndUnpause} from "./2-queueUpgradeAndUnpause.s.sol"; -import {Pause} from "./3-pause.s.sol"; - -import "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol"; -import "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol"; - -contract Execute is QueueAndUnpause, Pause { - using Env for *; - - function _runAsMultisig() prank(Env.protocolCouncilMultisig()) internal override(Pause, QueueAndUnpause) { - bytes memory calldata_to_executor = _getCalldataToExecutor(); - - TimelockController timelock = Env.timelockController(); - timelock.execute({ - target: Env.executorMultisig(), - value: 0, - payload: calldata_to_executor, - predecessor: 0, - salt: 0 - }); - } - - function testScript() public virtual override(Pause, QueueAndUnpause) { - runAsEOA(); - - TimelockController timelock = Env.timelockController(); - bytes memory calldata_to_executor = _getCalldataToExecutor(); - bytes32 txHash = timelock.hashOperation({ - target: Env.executorMultisig(), - value: 0, - data: calldata_to_executor, - predecessor: 0, - salt: 0 - }); - - assertFalse(timelock.isOperationPending(txHash), "Transaction should NOT be queued."); - - // 1- run queueing logic - QueueAndUnpause._runAsMultisig(); - _unsafeResetHasPranked(); // reset hasPranked so we can use it again - - assertTrue(timelock.isOperationPending(txHash), "Transaction should be queued."); - assertFalse(timelock.isOperationReady(txHash), "Transaction should NOT be ready for execution."); - assertFalse(timelock.isOperationDone(txHash), "Transaction should NOT be complete."); - - // 2- run pausing logic - Pause._runAsMultisig(); - _unsafeResetHasPranked(); // reset hasPranked so we can use it again - - assertTrue(Env.proxy.eigenPodManager().paused(PAUSED_START_CHECKPOINT), "EPM is not paused!"); - - // 2- warp past delay - vm.warp(block.timestamp + timelock.getMinDelay()); // 1 tick after ETA - assertEq(timelock.isOperationReady(txHash), true, "Transaction should be executable."); - - // 3- execute - execute(); - - assertTrue(timelock.isOperationDone(txHash), "Transaction should be complete."); - - _validateNewImplAddresses({ areMatching: true }); - _validateStrategiesAreWhitelisted(); - _validateProxyAdmins(); - _validateProxyConstructors(); - _validateProxiesInitialized(); - } - - function _validateNewProxyImplsMatch() internal view { - ProxyAdmin pa = ProxyAdmin(Env.proxyAdmin()); - - assertTrue( - pa.getProxyImplementation(ITransparentUpgradeableProxy(address(Env.proxy.allocationManager()))) == - address(Env.impl.allocationManager()), - "allocationManager impl failed" - ); - - assertTrue( - pa.getProxyImplementation(ITransparentUpgradeableProxy(address(Env.proxy.permissionController()))) == - address(Env.impl.permissionController()), - "permissionController impl failed" - ); - } - - /// @dev Mirrors the checks done in 1-deployContracts, but now we check each contract's - /// proxy, as the upgrade should mean that each proxy can see these methods/immutables - function _validateProxyConstructors() internal view { - { - /// permissions/ - - // exception: PauserRegistry doesn't have a proxy! - PauserRegistry registry = Env.impl.pauserRegistry(); - assertTrue(registry.isPauser(Env.pauserMultisig()), "pauser multisig should be pauser"); - assertTrue(registry.isPauser(Env.opsMultisig()), "ops multisig should be pauser"); - assertTrue(registry.isPauser(Env.executorMultisig()), "executor multisig should be pauser"); - assertTrue(registry.unpauser() == Env.executorMultisig(), "executor multisig should be unpauser"); - - /// PermissionController has no initial storage - } - - { - /// core/ - - AllocationManager allocationManager = Env.proxy.allocationManager(); - assertTrue(allocationManager.delegation() == Env.proxy.delegationManager(), "alm.dm invalid"); - assertTrue(allocationManager.pauserRegistry() == Env.impl.pauserRegistry(), "alm.pR invalid"); - assertTrue(allocationManager.permissionController() == Env.proxy.permissionController(), "alm.pc invalid"); - assertTrue(allocationManager.DEALLOCATION_DELAY() == Env.MIN_WITHDRAWAL_DELAY(), "alm.deallocDelay invalid"); - assertTrue(allocationManager.ALLOCATION_CONFIGURATION_DELAY() == Env.ALLOCATION_CONFIGURATION_DELAY(), "alm.configDelay invalid"); - - AVSDirectory avsDirectory = Env.proxy.avsDirectory(); - assertTrue(avsDirectory.delegation() == Env.proxy.delegationManager(), "avsD.dm invalid"); - assertTrue(avsDirectory.pauserRegistry() == Env.impl.pauserRegistry(), "avsD.pR invalid"); - - DelegationManager delegation = Env.proxy.delegationManager(); - assertTrue(delegation.strategyManager() == Env.proxy.strategyManager(), "dm.sm invalid"); - assertTrue(delegation.eigenPodManager() == Env.proxy.eigenPodManager(), "dm.epm invalid"); - assertTrue(delegation.allocationManager() == Env.proxy.allocationManager(), "dm.alm invalid"); - assertTrue(delegation.pauserRegistry() == Env.impl.pauserRegistry(), "dm.pR invalid"); - assertTrue(delegation.permissionController() == Env.proxy.permissionController(), "dm.pc invalid"); - assertTrue(delegation.minWithdrawalDelayBlocks() == Env.MIN_WITHDRAWAL_DELAY(), "dm.withdrawalDelay invalid"); - - RewardsCoordinator rewards = Env.proxy.rewardsCoordinator(); - assertTrue(rewards.delegationManager() == Env.proxy.delegationManager(), "rc.dm invalid"); - assertTrue(rewards.strategyManager() == Env.proxy.strategyManager(), "rc.sm invalid"); - assertTrue(rewards.allocationManager() == Env.proxy.allocationManager(), "rc.alm invalid"); - assertTrue(rewards.pauserRegistry() == Env.impl.pauserRegistry(), "rc.pR invalid"); - assertTrue(rewards.permissionController() == Env.proxy.permissionController(), "rc.pc invalid"); - assertTrue(rewards.CALCULATION_INTERVAL_SECONDS() == Env.CALCULATION_INTERVAL_SECONDS(), "rc.calcInterval invalid"); - assertTrue(rewards.MAX_REWARDS_DURATION() == Env.MAX_REWARDS_DURATION(), "rc.rewardsDuration invalid"); - assertTrue(rewards.MAX_RETROACTIVE_LENGTH() == Env.MAX_RETROACTIVE_LENGTH(), "rc.retroLength invalid"); - assertTrue(rewards.MAX_FUTURE_LENGTH() == Env.MAX_FUTURE_LENGTH(), "rc.futureLength invalid"); - assertTrue(rewards.GENESIS_REWARDS_TIMESTAMP() == Env.GENESIS_REWARDS_TIMESTAMP(), "rc.genesis invalid"); - - StrategyManager strategyManager = Env.proxy.strategyManager(); - assertTrue(strategyManager.delegation() == Env.proxy.delegationManager(), "sm.dm invalid"); - assertTrue(strategyManager.pauserRegistry() == Env.impl.pauserRegistry(), "sm.pR invalid"); - } - - { - /// pods/ - UpgradeableBeacon eigenPodBeacon = Env.beacon.eigenPod(); - assertTrue(eigenPodBeacon.implementation() == address(Env.impl.eigenPod()), "eigenPodBeacon.impl invalid"); - - EigenPodManager eigenPodManager = Env.proxy.eigenPodManager(); - assertTrue(eigenPodManager.ethPOS() == Env.ethPOS(), "epm.ethPOS invalid"); - assertTrue(eigenPodManager.eigenPodBeacon() == Env.beacon.eigenPod(), "epm.epBeacon invalid"); - assertTrue(eigenPodManager.delegationManager() == Env.proxy.delegationManager(), "epm.dm invalid"); - assertTrue(eigenPodManager.pauserRegistry() == Env.impl.pauserRegistry(), "epm.pR invalid"); - } - - { - /// strategies/ - EigenStrategy eigenStrategy = Env.proxy.eigenStrategy(); - assertTrue(eigenStrategy.strategyManager() == Env.proxy.strategyManager(), "eigStrat.sm invalid"); - assertTrue(eigenStrategy.pauserRegistry() == Env.impl.pauserRegistry(), "eigStrat.pR invalid"); - - UpgradeableBeacon strategyBeacon = Env.beacon.strategyBase(); - assertTrue(strategyBeacon.implementation() == address(Env.impl.strategyBase()), "strategyBeacon.impl invalid"); - - uint count = Env.instance.strategyBaseTVLLimits_Count(); - for (uint i = 0; i < count; i++) { - StrategyBaseTVLLimits strategy = Env.instance.strategyBaseTVLLimits(i); - - assertTrue(strategy.strategyManager() == Env.proxy.strategyManager(), "sFact.sm invalid"); - assertTrue(strategy.pauserRegistry() == Env.impl.pauserRegistry(), "sFact.pR invalid"); - } - - StrategyFactory strategyFactory = Env.proxy.strategyFactory(); - assertTrue(strategyFactory.strategyManager() == Env.proxy.strategyManager(), "sFact.sm invalid"); - assertTrue(strategyFactory.pauserRegistry() == Env.impl.pauserRegistry(), "sFact.pR invalid"); - } - } - - /// @dev Call initialize on all proxies to ensure they are initialized - /// Additionally, validate initialization variables - function _validateProxiesInitialized() internal { - bytes memory errInit = "Initializable: contract is already initialized"; - - /// permissions/ - // PermissionController is initializable, but does not expose the `initialize` method - - { - /// core/ - - AllocationManager allocationManager = Env.proxy.allocationManager(); - vm.expectRevert(errInit); - allocationManager.initialize(address(0), 0); - assertTrue(allocationManager.owner() == Env.executorMultisig(), "alm.owner invalid"); - assertTrue(allocationManager.paused() == 0, "alm.paused invalid"); - - AVSDirectory avsDirectory = Env.proxy.avsDirectory(); - vm.expectRevert(errInit); - avsDirectory.initialize(address(0), 0); - assertTrue(avsDirectory.owner() == Env.executorMultisig(), "avsD.owner invalid"); - assertTrue(avsDirectory.paused() == 0, "avsD.paused invalid"); - - DelegationManager delegation = Env.proxy.delegationManager(); - vm.expectRevert(errInit); - delegation.initialize(address(0), 0); - assertTrue(delegation.owner() == Env.executorMultisig(), "dm.owner invalid"); - assertTrue(delegation.paused() == 0, "dm.paused invalid"); - - RewardsCoordinator rewards = Env.proxy.rewardsCoordinator(); - vm.expectRevert(errInit); - rewards.initialize(address(0), 0, address(0), 0, 0); - assertTrue(rewards.owner() == Env.opsMultisig(), "rc.owner invalid"); - assertTrue(rewards.paused() == Env.REWARDS_PAUSE_STATUS(), "rc.paused invalid"); - assertTrue(rewards.rewardsUpdater() == Env.REWARDS_UPDATER(), "rc.updater invalid"); - assertTrue(rewards.activationDelay() == Env.ACTIVATION_DELAY(), "rc.activationDelay invalid"); - assertTrue(rewards.defaultOperatorSplitBips() == Env.DEFAULT_SPLIT_BIPS(), "rc.splitBips invalid"); - - StrategyManager strategyManager = Env.proxy.strategyManager(); - vm.expectRevert(errInit); - strategyManager.initialize(address(0), address(0), 0); - assertTrue(strategyManager.owner() == Env.executorMultisig(), "sm.owner invalid"); - assertTrue(strategyManager.paused() == 0, "sm.paused invalid"); - assertTrue(strategyManager.strategyWhitelister() == address(Env.proxy.strategyFactory()), "sm.whitelister invalid"); - } - - { - /// pods/ - // EigenPod proxies are initialized by individual users - - EigenPodManager eigenPodManager = Env.proxy.eigenPodManager(); - vm.expectRevert(errInit); - eigenPodManager.initialize(address(0), 0); - assertTrue(eigenPodManager.owner() == Env.executorMultisig(), "epm.owner invalid"); - assertTrue(eigenPodManager.paused() == 0, "epm.paused invalid"); - } - - { - /// strategies/ - - EigenStrategy eigenStrategy = Env.proxy.eigenStrategy(); - vm.expectRevert(errInit); - eigenStrategy.initialize(IEigen(address(0)), IBackingEigen(address(0))); - assertTrue(eigenStrategy.paused() == 0, "eigenStrat.paused invalid"); - assertTrue(eigenStrategy.EIGEN() == Env.proxy.eigen(), "eigenStrat.EIGEN invalid"); - assertTrue(eigenStrategy.underlyingToken() == Env.proxy.beigen(), "eigenStrat.underlying invalid"); - - // StrategyBase proxies are initialized when deployed by factory - - uint count = Env.instance.strategyBaseTVLLimits_Count(); - for (uint i = 0; i < count; i++) { - StrategyBaseTVLLimits strategy = Env.instance.strategyBaseTVLLimits(i); - - emit log_named_address("strat", address(strategy)); - - vm.expectRevert(errInit); - strategy.initialize(0, 0, IERC20(address(0))); - assertTrue(strategy.maxPerDeposit() == type(uint).max, "stratTVLLim.maxPerDeposit invalid"); - assertTrue(strategy.maxTotalDeposits() == type(uint).max, "stratTVLLim.maxPerDeposit invalid"); - } - - StrategyFactory strategyFactory = Env.proxy.strategyFactory(); - vm.expectRevert(errInit); - strategyFactory.initialize(address(0), 0, UpgradeableBeacon(address(0))); - assertTrue(strategyFactory.owner() == Env.opsMultisig(), "sFact.owner invalid"); - assertTrue(strategyFactory.paused() == 0, "sFact.paused invalid"); - assertTrue(strategyFactory.strategyBeacon() == Env.beacon.strategyBase(), "sFact.beacon invalid"); - } - } -} diff --git a/script/releases/v1.0.0-slashing/cleanup/EigenPod.abi.json b/script/releases/v1.0.0-slashing/cleanup/EigenPod.abi.json deleted file mode 100644 index eea17671d4..0000000000 --- a/script/releases/v1.0.0-slashing/cleanup/EigenPod.abi.json +++ /dev/null @@ -1 +0,0 @@ -[{"type":"constructor","inputs":[{"name":"_ethPOS","type":"address","internalType":"contract IETHPOSDeposit"},{"name":"_eigenPodManager","type":"address","internalType":"contract IEigenPodManager"},{"name":"_GENESIS_TIME","type":"uint64","internalType":"uint64"}],"stateMutability":"nonpayable"},{"type":"receive","stateMutability":"payable"},{"type":"function","name":"GENESIS_TIME","inputs":[],"outputs":[{"name":"","type":"uint64","internalType":"uint64"}],"stateMutability":"view"},{"type":"function","name":"activeValidatorCount","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"checkpointBalanceExitedGwei","inputs":[{"name":"","type":"uint64","internalType":"uint64"}],"outputs":[{"name":"","type":"uint64","internalType":"uint64"}],"stateMutability":"view"},{"type":"function","name":"currentCheckpoint","inputs":[],"outputs":[{"name":"","type":"tuple","internalType":"struct IEigenPodTypes.Checkpoint","components":[{"name":"beaconBlockRoot","type":"bytes32","internalType":"bytes32"},{"name":"proofsRemaining","type":"uint24","internalType":"uint24"},{"name":"podBalanceGwei","type":"uint64","internalType":"uint64"},{"name":"balanceDeltasGwei","type":"int64","internalType":"int64"},{"name":"prevBeaconBalanceGwei","type":"uint64","internalType":"uint64"}]}],"stateMutability":"view"},{"type":"function","name":"currentCheckpointTimestamp","inputs":[],"outputs":[{"name":"","type":"uint64","internalType":"uint64"}],"stateMutability":"view"},{"type":"function","name":"eigenPodManager","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IEigenPodManager"}],"stateMutability":"view"},{"type":"function","name":"ethPOS","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IETHPOSDeposit"}],"stateMutability":"view"},{"type":"function","name":"getParentBlockRoot","inputs":[{"name":"timestamp","type":"uint64","internalType":"uint64"}],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"type":"function","name":"initialize","inputs":[{"name":"_podOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"lastCheckpointTimestamp","inputs":[],"outputs":[{"name":"","type":"uint64","internalType":"uint64"}],"stateMutability":"view"},{"type":"function","name":"podOwner","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"proofSubmitter","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"recoverTokens","inputs":[{"name":"tokenList","type":"address[]","internalType":"contract IERC20[]"},{"name":"amountsToWithdraw","type":"uint256[]","internalType":"uint256[]"},{"name":"recipient","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"setProofSubmitter","inputs":[{"name":"newProofSubmitter","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"stake","inputs":[{"name":"pubkey","type":"bytes","internalType":"bytes"},{"name":"signature","type":"bytes","internalType":"bytes"},{"name":"depositDataRoot","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"payable"},{"type":"function","name":"startCheckpoint","inputs":[{"name":"revertIfNoBalance","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"validatorPubkeyHashToInfo","inputs":[{"name":"validatorPubkeyHash","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"tuple","internalType":"struct IEigenPodTypes.ValidatorInfo","components":[{"name":"validatorIndex","type":"uint64","internalType":"uint64"},{"name":"restakedBalanceGwei","type":"uint64","internalType":"uint64"},{"name":"lastCheckpointedAt","type":"uint64","internalType":"uint64"},{"name":"status","type":"uint8","internalType":"enum IEigenPodTypes.VALIDATOR_STATUS"}]}],"stateMutability":"view"},{"type":"function","name":"validatorPubkeyToInfo","inputs":[{"name":"validatorPubkey","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"","type":"tuple","internalType":"struct IEigenPodTypes.ValidatorInfo","components":[{"name":"validatorIndex","type":"uint64","internalType":"uint64"},{"name":"restakedBalanceGwei","type":"uint64","internalType":"uint64"},{"name":"lastCheckpointedAt","type":"uint64","internalType":"uint64"},{"name":"status","type":"uint8","internalType":"enum IEigenPodTypes.VALIDATOR_STATUS"}]}],"stateMutability":"view"},{"type":"function","name":"validatorStatus","inputs":[{"name":"validatorPubkey","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"","type":"uint8","internalType":"enum IEigenPodTypes.VALIDATOR_STATUS"}],"stateMutability":"view"},{"type":"function","name":"validatorStatus","inputs":[{"name":"pubkeyHash","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"uint8","internalType":"enum IEigenPodTypes.VALIDATOR_STATUS"}],"stateMutability":"view"},{"type":"function","name":"verifyCheckpointProofs","inputs":[{"name":"balanceContainerProof","type":"tuple","internalType":"struct BeaconChainProofs.BalanceContainerProof","components":[{"name":"balanceContainerRoot","type":"bytes32","internalType":"bytes32"},{"name":"proof","type":"bytes","internalType":"bytes"}]},{"name":"proofs","type":"tuple[]","internalType":"struct BeaconChainProofs.BalanceProof[]","components":[{"name":"pubkeyHash","type":"bytes32","internalType":"bytes32"},{"name":"balanceRoot","type":"bytes32","internalType":"bytes32"},{"name":"proof","type":"bytes","internalType":"bytes"}]}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"verifyStaleBalance","inputs":[{"name":"beaconTimestamp","type":"uint64","internalType":"uint64"},{"name":"stateRootProof","type":"tuple","internalType":"struct BeaconChainProofs.StateRootProof","components":[{"name":"beaconStateRoot","type":"bytes32","internalType":"bytes32"},{"name":"proof","type":"bytes","internalType":"bytes"}]},{"name":"proof","type":"tuple","internalType":"struct BeaconChainProofs.ValidatorProof","components":[{"name":"validatorFields","type":"bytes32[]","internalType":"bytes32[]"},{"name":"proof","type":"bytes","internalType":"bytes"}]}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"verifyWithdrawalCredentials","inputs":[{"name":"beaconTimestamp","type":"uint64","internalType":"uint64"},{"name":"stateRootProof","type":"tuple","internalType":"struct BeaconChainProofs.StateRootProof","components":[{"name":"beaconStateRoot","type":"bytes32","internalType":"bytes32"},{"name":"proof","type":"bytes","internalType":"bytes"}]},{"name":"validatorIndices","type":"uint40[]","internalType":"uint40[]"},{"name":"validatorFieldsProofs","type":"bytes[]","internalType":"bytes[]"},{"name":"validatorFields","type":"bytes32[][]","internalType":"bytes32[][]"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"withdrawRestakedBeaconChainETH","inputs":[{"name":"recipient","type":"address","internalType":"address"},{"name":"amountWei","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"withdrawableRestakedExecutionLayerGwei","inputs":[],"outputs":[{"name":"","type":"uint64","internalType":"uint64"}],"stateMutability":"view"},{"type":"event","name":"CheckpointCreated","inputs":[{"name":"checkpointTimestamp","type":"uint64","indexed":true,"internalType":"uint64"},{"name":"beaconBlockRoot","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"validatorCount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"type":"event","name":"CheckpointFinalized","inputs":[{"name":"checkpointTimestamp","type":"uint64","indexed":true,"internalType":"uint64"},{"name":"totalShareDeltaWei","type":"int256","indexed":false,"internalType":"int256"}],"anonymous":false},{"type":"event","name":"EigenPodStaked","inputs":[{"name":"pubkey","type":"bytes","indexed":false,"internalType":"bytes"}],"anonymous":false},{"type":"event","name":"Initialized","inputs":[{"name":"version","type":"uint8","indexed":false,"internalType":"uint8"}],"anonymous":false},{"type":"event","name":"NonBeaconChainETHReceived","inputs":[{"name":"amountReceived","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"type":"event","name":"ProofSubmitterUpdated","inputs":[{"name":"prevProofSubmitter","type":"address","indexed":false,"internalType":"address"},{"name":"newProofSubmitter","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"type":"event","name":"RestakedBeaconChainETHWithdrawn","inputs":[{"name":"recipient","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"type":"event","name":"ValidatorBalanceUpdated","inputs":[{"name":"validatorIndex","type":"uint40","indexed":false,"internalType":"uint40"},{"name":"balanceTimestamp","type":"uint64","indexed":false,"internalType":"uint64"},{"name":"newValidatorBalanceGwei","type":"uint64","indexed":false,"internalType":"uint64"}],"anonymous":false},{"type":"event","name":"ValidatorCheckpointed","inputs":[{"name":"checkpointTimestamp","type":"uint64","indexed":true,"internalType":"uint64"},{"name":"validatorIndex","type":"uint40","indexed":true,"internalType":"uint40"}],"anonymous":false},{"type":"event","name":"ValidatorRestaked","inputs":[{"name":"validatorIndex","type":"uint40","indexed":false,"internalType":"uint40"}],"anonymous":false},{"type":"event","name":"ValidatorWithdrawn","inputs":[{"name":"checkpointTimestamp","type":"uint64","indexed":true,"internalType":"uint64"},{"name":"validatorIndex","type":"uint40","indexed":true,"internalType":"uint40"}],"anonymous":false},{"type":"error","name":"AmountMustBeMultipleOfGwei","inputs":[]},{"type":"error","name":"BeaconTimestampTooFarInPast","inputs":[]},{"type":"error","name":"CannotCheckpointTwiceInSingleBlock","inputs":[]},{"type":"error","name":"CheckpointAlreadyActive","inputs":[]},{"type":"error","name":"CredentialsAlreadyVerified","inputs":[]},{"type":"error","name":"CurrentlyPaused","inputs":[]},{"type":"error","name":"InputAddressZero","inputs":[]},{"type":"error","name":"InputArrayLengthMismatch","inputs":[]},{"type":"error","name":"InsufficientWithdrawableBalance","inputs":[]},{"type":"error","name":"InvalidEIP4788Response","inputs":[]},{"type":"error","name":"InvalidProof","inputs":[]},{"type":"error","name":"InvalidProofLength","inputs":[]},{"type":"error","name":"InvalidProofLength","inputs":[]},{"type":"error","name":"InvalidPubKeyLength","inputs":[]},{"type":"error","name":"InvalidValidatorFieldsLength","inputs":[]},{"type":"error","name":"MsgValueNot32ETH","inputs":[]},{"type":"error","name":"NoActiveCheckpoint","inputs":[]},{"type":"error","name":"NoBalanceToCheckpoint","inputs":[]},{"type":"error","name":"OnlyEigenPodManager","inputs":[]},{"type":"error","name":"OnlyEigenPodOwner","inputs":[]},{"type":"error","name":"OnlyEigenPodOwnerOrProofSubmitter","inputs":[]},{"type":"error","name":"TimestampOutOfRange","inputs":[]},{"type":"error","name":"ValidatorInactiveOnBeaconChain","inputs":[]},{"type":"error","name":"ValidatorIsExitingBeaconChain","inputs":[]},{"type":"error","name":"ValidatorNotActiveInPod","inputs":[]},{"type":"error","name":"ValidatorNotSlashedOnBeaconChain","inputs":[]},{"type":"error","name":"WithdrawalCredentialsNotForEigenPod","inputs":[]}] \ No newline at end of file diff --git a/script/releases/v1.0.0-slashing/cleanup/EigenPodManager.abi.json b/script/releases/v1.0.0-slashing/cleanup/EigenPodManager.abi.json deleted file mode 100644 index eca82221bb..0000000000 --- a/script/releases/v1.0.0-slashing/cleanup/EigenPodManager.abi.json +++ /dev/null @@ -1 +0,0 @@ -[{"type":"constructor","inputs":[{"name":"_ethPOS","type":"address","internalType":"contract IETHPOSDeposit"},{"name":"_eigenPodBeacon","type":"address","internalType":"contract IBeacon"},{"name":"_strategyManager","type":"address","internalType":"contract IStrategyManager"},{"name":"_delegationManager","type":"address","internalType":"contract IDelegationManager"},{"name":"_pauserRegistry","type":"address","internalType":"contract IPauserRegistry"}],"stateMutability":"nonpayable"},{"type":"function","name":"addShares","inputs":[{"name":"staker","type":"address","internalType":"address"},{"name":"strategy","type":"address","internalType":"contract IStrategy"},{"name":"","type":"address","internalType":"contract IERC20"},{"name":"shares","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"},{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"nonpayable"},{"type":"function","name":"beaconChainETHStrategy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IStrategy"}],"stateMutability":"view"},{"type":"function","name":"beaconChainSlashingFactor","inputs":[{"name":"podOwner","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint64","internalType":"uint64"}],"stateMutability":"view"},{"type":"function","name":"createPod","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"type":"function","name":"delegationManager","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IDelegationManager"}],"stateMutability":"view"},{"type":"function","name":"eigenPodBeacon","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IBeacon"}],"stateMutability":"view"},{"type":"function","name":"ethPOS","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IETHPOSDeposit"}],"stateMutability":"view"},{"type":"function","name":"getPod","inputs":[{"name":"podOwner","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"address","internalType":"contract IEigenPod"}],"stateMutability":"view"},{"type":"function","name":"hasPod","inputs":[{"name":"podOwner","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"type":"function","name":"initialize","inputs":[{"name":"initialOwner","type":"address","internalType":"address"},{"name":"_initPausedStatus","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"numPods","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"owner","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"ownerToPod","inputs":[{"name":"podOwner","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"address","internalType":"contract IEigenPod"}],"stateMutability":"view"},{"type":"function","name":"pause","inputs":[{"name":"newPausedStatus","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"pauseAll","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"paused","inputs":[{"name":"index","type":"uint8","internalType":"uint8"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"type":"function","name":"paused","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"pauserRegistry","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IPauserRegistry"}],"stateMutability":"view"},{"type":"function","name":"podOwnerDepositShares","inputs":[{"name":"podOwner","type":"address","internalType":"address"}],"outputs":[{"name":"shares","type":"int256","internalType":"int256"}],"stateMutability":"view"},{"type":"function","name":"recordBeaconChainETHBalanceUpdate","inputs":[{"name":"podOwner","type":"address","internalType":"address"},{"name":"prevRestakedBalanceWei","type":"uint256","internalType":"uint256"},{"name":"balanceDeltaWei","type":"int256","internalType":"int256"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"removeDepositShares","inputs":[{"name":"staker","type":"address","internalType":"address"},{"name":"strategy","type":"address","internalType":"contract IStrategy"},{"name":"depositSharesToRemove","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"renounceOwnership","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"stake","inputs":[{"name":"pubkey","type":"bytes","internalType":"bytes"},{"name":"signature","type":"bytes","internalType":"bytes"},{"name":"depositDataRoot","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"payable"},{"type":"function","name":"stakerDepositShares","inputs":[{"name":"user","type":"address","internalType":"address"},{"name":"strategy","type":"address","internalType":"contract IStrategy"}],"outputs":[{"name":"depositShares","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"strategyManager","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IStrategyManager"}],"stateMutability":"view"},{"type":"function","name":"transferOwnership","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"unpause","inputs":[{"name":"newPausedStatus","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"withdrawSharesAsTokens","inputs":[{"name":"staker","type":"address","internalType":"address"},{"name":"strategy","type":"address","internalType":"contract IStrategy"},{"name":"","type":"address","internalType":"contract IERC20"},{"name":"shares","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"event","name":"BeaconChainETHDeposited","inputs":[{"name":"podOwner","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"type":"event","name":"BeaconChainETHWithdrawalCompleted","inputs":[{"name":"podOwner","type":"address","indexed":true,"internalType":"address"},{"name":"shares","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"nonce","type":"uint96","indexed":false,"internalType":"uint96"},{"name":"delegatedAddress","type":"address","indexed":false,"internalType":"address"},{"name":"withdrawer","type":"address","indexed":false,"internalType":"address"},{"name":"withdrawalRoot","type":"bytes32","indexed":false,"internalType":"bytes32"}],"anonymous":false},{"type":"event","name":"BeaconChainSlashingFactorDecreased","inputs":[{"name":"staker","type":"address","indexed":false,"internalType":"address"},{"name":"wadSlashed","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"newBeaconChainSlashingFactor","type":"uint64","indexed":false,"internalType":"uint64"}],"anonymous":false},{"type":"event","name":"Initialized","inputs":[{"name":"version","type":"uint8","indexed":false,"internalType":"uint8"}],"anonymous":false},{"type":"event","name":"NewTotalShares","inputs":[{"name":"podOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newTotalShares","type":"int256","indexed":false,"internalType":"int256"}],"anonymous":false},{"type":"event","name":"OwnershipTransferred","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"type":"event","name":"Paused","inputs":[{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"newPausedStatus","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"type":"event","name":"PodDeployed","inputs":[{"name":"eigenPod","type":"address","indexed":true,"internalType":"address"},{"name":"podOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"type":"event","name":"PodSharesUpdated","inputs":[{"name":"podOwner","type":"address","indexed":true,"internalType":"address"},{"name":"sharesDelta","type":"int256","indexed":false,"internalType":"int256"}],"anonymous":false},{"type":"event","name":"Unpaused","inputs":[{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"newPausedStatus","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"type":"error","name":"CurrentlyPaused","inputs":[]},{"type":"error","name":"EigenPodAlreadyExists","inputs":[]},{"type":"error","name":"InputAddressZero","inputs":[]},{"type":"error","name":"InvalidNewPausedStatus","inputs":[]},{"type":"error","name":"InvalidStrategy","inputs":[]},{"type":"error","name":"LegacyWithdrawalsNotCompleted","inputs":[]},{"type":"error","name":"OnlyDelegationManager","inputs":[]},{"type":"error","name":"OnlyEigenPod","inputs":[]},{"type":"error","name":"OnlyPauser","inputs":[]},{"type":"error","name":"OnlyUnpauser","inputs":[]},{"type":"error","name":"SharesNegative","inputs":[]},{"type":"error","name":"SharesNotMultipleOfGwei","inputs":[]}] \ No newline at end of file diff --git a/script/releases/v1.0.0-slashing/cleanup/go.mod b/script/releases/v1.0.0-slashing/cleanup/go.mod deleted file mode 100644 index 54879f94b6..0000000000 --- a/script/releases/v1.0.0-slashing/cleanup/go.mod +++ /dev/null @@ -1,74 +0,0 @@ -module main - -go 1.22.4 - -require ( - github.com/Layr-Labs/eigenpod-proofs-generation v0.1.0-pepe-testnet.0.20240925202841-f6492b1cc9fc - github.com/attestantio/go-eth2-client v0.21.11 - github.com/ethereum/go-ethereum v1.14.9 - github.com/jbrower95/multicall-go v0.0.0-20241012224745-7e9c19976cb5 - github.com/samber/lo v1.47.0 -) - -require ( - github.com/Microsoft/go-winio v0.6.2 // indirect - github.com/StackExchange/wmi v1.2.1 // indirect - github.com/beorn7/perks v1.0.1 // indirect - github.com/bits-and-blooms/bitset v1.13.0 // indirect - github.com/btcsuite/btcd/btcec/v2 v2.3.4 // indirect - github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/consensys/bavard v0.1.13 // indirect - github.com/consensys/gnark-crypto v0.12.1 // indirect - github.com/crate-crypto/go-ipa v0.0.0-20240223125850-b1e8a79f509c // indirect - github.com/crate-crypto/go-kzg-4844 v1.0.0 // indirect - github.com/deckarep/golang-set/v2 v2.6.0 // indirect - github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 // indirect - github.com/ethereum/c-kzg-4844 v1.0.0 // indirect - github.com/ethereum/go-verkle v0.1.1-0.20240829091221-dffa7562dbe9 // indirect - github.com/fatih/color v1.16.0 // indirect - github.com/ferranbt/fastssz v0.1.3 // indirect - github.com/fsnotify/fsnotify v1.6.0 // indirect - github.com/go-logr/logr v1.2.4 // indirect - github.com/go-logr/stdr v1.2.2 // indirect - github.com/go-ole/go-ole v1.3.0 // indirect - github.com/goccy/go-yaml v1.9.2 // indirect - github.com/google/uuid v1.6.0 // indirect - github.com/gorilla/websocket v1.4.2 // indirect - github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect - github.com/holiman/uint256 v1.3.1 // indirect - github.com/huandu/go-clone v1.6.0 // indirect - github.com/klauspost/cpuid/v2 v2.2.7 // indirect - github.com/mattn/go-colorable v0.1.13 // indirect - github.com/mattn/go-isatty v0.0.20 // indirect - github.com/minio/sha256-simd v1.0.1 // indirect - github.com/mitchellh/mapstructure v1.5.0 // indirect - github.com/mmcloughlin/addchain v0.4.0 // indirect - github.com/pk910/dynamic-ssz v0.0.3 // indirect - github.com/pkg/errors v0.9.1 // indirect - github.com/prometheus/client_golang v1.19.0 // indirect - github.com/prometheus/client_model v0.5.0 // indirect - github.com/prometheus/common v0.48.0 // indirect - github.com/prometheus/procfs v0.12.0 // indirect - github.com/prysmaticlabs/go-bitfield v0.0.0-20240328144219-a1caa50c3a1e // indirect - github.com/r3labs/sse/v2 v2.10.0 // indirect - github.com/rs/zerolog v1.32.0 // indirect - github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible // indirect - github.com/supranational/blst v0.3.11 // indirect - github.com/tklauser/go-sysconf v0.3.12 // indirect - github.com/tklauser/numcpus v0.6.1 // indirect - go.opentelemetry.io/otel v1.16.0 // indirect - go.opentelemetry.io/otel/metric v1.16.0 // indirect - go.opentelemetry.io/otel/trace v1.16.0 // indirect - golang.org/x/crypto v0.23.0 // indirect - golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa // indirect - golang.org/x/net v0.24.0 // indirect - golang.org/x/sync v0.7.0 // indirect - golang.org/x/sys v0.22.0 // indirect - golang.org/x/text v0.16.0 // indirect - golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 // indirect - google.golang.org/protobuf v1.34.2 // indirect - gopkg.in/Knetic/govaluate.v3 v3.0.0 // indirect - gopkg.in/cenkalti/backoff.v1 v1.1.0 // indirect - gopkg.in/yaml.v2 v2.4.0 // indirect - rsc.io/tmplfunc v0.0.3 // indirect -) diff --git a/script/releases/v1.0.0-slashing/cleanup/go.sum b/script/releases/v1.0.0-slashing/cleanup/go.sum deleted file mode 100644 index f100d52de7..0000000000 --- a/script/releases/v1.0.0-slashing/cleanup/go.sum +++ /dev/null @@ -1,283 +0,0 @@ -github.com/DataDog/zstd v1.4.5 h1:EndNeuB0l9syBZhut0wns3gV1hL8zX8LIu6ZiVHWLIQ= -github.com/DataDog/zstd v1.4.5/go.mod h1:1jcaCB/ufaK+sKp1NBhlGmpz41jOoPQ35bpF36t7BBo= -github.com/Layr-Labs/eigenpod-proofs-generation v0.1.0-pepe-testnet.0.20240925202841-f6492b1cc9fc h1:xOvrJ2NHD7ykcikuqqvUVXZR6PNUomd05eO/vYQ2+g8= -github.com/Layr-Labs/eigenpod-proofs-generation v0.1.0-pepe-testnet.0.20240925202841-f6492b1cc9fc/go.mod h1:T7tYN8bTdca2pkMnz9G2+ZwXYWw5gWqQUIu4KLgC/vM= -github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= -github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= -github.com/StackExchange/wmi v1.2.1 h1:VIkavFPXSjcnS+O8yTq7NI32k0R5Aj+v39y29VYDOSA= -github.com/StackExchange/wmi v1.2.1/go.mod h1:rcmrprowKIVzvc+NUiLncP2uuArMWLCbu9SBzvHz7e8= -github.com/VictoriaMetrics/fastcache v1.12.2 h1:N0y9ASrJ0F6h0QaC3o6uJb3NIZ9VKLjCM7NQbSmF7WI= -github.com/VictoriaMetrics/fastcache v1.12.2/go.mod h1:AmC+Nzz1+3G2eCPapF6UcsnkThDcMsQicp4xDukwJYI= -github.com/attestantio/go-eth2-client v0.21.11 h1:0ZYP69O8rJz41055WOf3n1C1NA4jNh2iME/NuTVfgmQ= -github.com/attestantio/go-eth2-client v0.21.11/go.mod h1:d7ZPNrMX8jLfIgML5u7QZxFo2AukLM+5m08iMaLdqb8= -github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= -github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= -github.com/bits-and-blooms/bitset v1.13.0 h1:bAQ9OPNFYbGHV6Nez0tmNI0RiEu7/hxlYJRUA0wFAVE= -github.com/bits-and-blooms/bitset v1.13.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= -github.com/btcsuite/btcd/btcec/v2 v2.3.4 h1:3EJjcN70HCu/mwqlUsGK8GcNVyLVxFDlWurTXGPFfiQ= -github.com/btcsuite/btcd/btcec/v2 v2.3.4/go.mod h1:zYzJ8etWJQIv1Ogk7OzpWjowwOdXY1W/17j2MW85J04= -github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1 h1:q0rUy8C/TYNBQS1+CGKw68tLOFYSNEs0TFnxxnS9+4U= -github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc= -github.com/cespare/cp v0.1.0 h1:SE+dxFebS7Iik5LK0tsi1k9ZCxEaFX4AjQmoyA+1dJk= -github.com/cespare/cp v0.1.0/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s= -github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= -github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/cockroachdb/errors v1.11.3 h1:5bA+k2Y6r+oz/6Z/RFlNeVCesGARKuC6YymtcDrbC/I= -github.com/cockroachdb/errors v1.11.3/go.mod h1:m4UIW4CDjx+R5cybPsNrRbreomiFqt8o1h1wUVazSd8= -github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce h1:giXvy4KSc/6g/esnpM7Geqxka4WSqI1SZc7sMJFd3y4= -github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce/go.mod h1:9/y3cnZ5GKakj/H4y9r9GTjCvAFta7KLgSHPJJYc52M= -github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b h1:r6VH0faHjZeQy818SGhaone5OnYfxFR/+AzdY3sf5aE= -github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b/go.mod h1:Vz9DsVWQQhf3vs21MhPMZpMGSht7O/2vFW2xusFUVOs= -github.com/cockroachdb/pebble v1.1.2 h1:CUh2IPtR4swHlEj48Rhfzw6l/d0qA31fItcIszQVIsA= -github.com/cockroachdb/pebble v1.1.2/go.mod h1:4exszw1r40423ZsmkG/09AFEG83I0uDgfujJdbL6kYU= -github.com/cockroachdb/redact v1.1.5 h1:u1PMllDkdFfPWaNGMyLD1+so+aq3uUItthCFqzwPJ30= -github.com/cockroachdb/redact v1.1.5/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg= -github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 h1:zuQyyAKVxetITBuuhv3BI9cMrmStnpT18zmgmTxunpo= -github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ= -github.com/consensys/bavard v0.1.13 h1:oLhMLOFGTLdlda/kma4VOJazblc7IM5y5QPd2A/YjhQ= -github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI= -github.com/consensys/gnark-crypto v0.12.1 h1:lHH39WuuFgVHONRl3J0LRBtuYdQTumFSDtJF7HpyG8M= -github.com/consensys/gnark-crypto v0.12.1/go.mod h1:v2Gy7L/4ZRosZ7Ivs+9SfUDr0f5UlG+EM5t7MPHiLuY= -github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= -github.com/cpuguy83/go-md2man/v2 v2.0.2 h1:p1EgwI/C7NhT0JmVkwCD2ZBK8j4aeHQX2pMHHBfMQ6w= -github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= -github.com/crate-crypto/go-ipa v0.0.0-20240223125850-b1e8a79f509c h1:uQYC5Z1mdLRPrZhHjHxufI8+2UG/i25QG92j0Er9p6I= -github.com/crate-crypto/go-ipa v0.0.0-20240223125850-b1e8a79f509c/go.mod h1:geZJZH3SzKCqnz5VT0q/DyIG/tvu/dZk+VIfXicupJs= -github.com/crate-crypto/go-kzg-4844 v1.0.0 h1:TsSgHwrkTKecKJ4kadtHi4b3xHW5dCFUDFnUp1TsawI= -github.com/crate-crypto/go-kzg-4844 v1.0.0/go.mod h1:1kMhvPgI0Ky3yIa+9lFySEBUBXkYxeOi8ZF1sYioxhc= -github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= -github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/deckarep/golang-set/v2 v2.6.0 h1:XfcQbWM1LlMB8BsJ8N9vW5ehnnPVIw0je80NsVHagjM= -github.com/deckarep/golang-set/v2 v2.6.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4= -github.com/decred/dcrd/crypto/blake256 v1.0.0 h1:/8DMNYp9SGi5f0w7uCm6d6M4OU2rGFK09Y2A4Xv7EE0= -github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc= -github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 h1:YLtO71vCjJRCBcrPMtQ9nqBsqpA1m5sE92cU+pd5Mcc= -github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1/go.mod h1:hyedUtir6IdtD/7lIxGeCxkaw7y45JueMRL4DIyJDKs= -github.com/ethereum/c-kzg-4844 v1.0.0 h1:0X1LBXxaEtYD9xsyj9B9ctQEZIpnvVDeoBx8aHEwTNA= -github.com/ethereum/c-kzg-4844 v1.0.0/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0= -github.com/ethereum/go-ethereum v1.14.9 h1:J7iwXDrtUyE9FUjUYbd4c9tyzwMh6dTJsKzo9i6SrwA= -github.com/ethereum/go-ethereum v1.14.9/go.mod h1:QeW+MtTpRdBEm2pUFoonByee8zfHv7kGp0wK0odvU1I= -github.com/ethereum/go-verkle v0.1.1-0.20240829091221-dffa7562dbe9 h1:8NfxH2iXvJ60YRB8ChToFTUzl8awsc3cJ8CbLjGIl/A= -github.com/ethereum/go-verkle v0.1.1-0.20240829091221-dffa7562dbe9/go.mod h1:M3b90YRnzqKyyzBEWJGqj8Qff4IDeXnzFw0P9bFw3uk= -github.com/fatih/color v1.10.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM= -github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM= -github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE= -github.com/ferranbt/fastssz v0.1.3 h1:ZI+z3JH05h4kgmFXdHuR1aWYsgrg7o+Fw7/NCzM16Mo= -github.com/ferranbt/fastssz v0.1.3/go.mod h1:0Y9TEd/9XuFlh7mskMPfXiI2Dkw4Ddg9EyXt1W7MRvE= -github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY= -github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw= -github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI= -github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww= -github.com/getsentry/sentry-go v0.27.0 h1:Pv98CIbtB3LkMWmXi4Joa5OOcwbmnX88sF5qbK3r3Ps= -github.com/getsentry/sentry-go v0.27.0/go.mod h1:lc76E2QywIyW8WuBnwl8Lc4bkmQH4+w1gwTf25trprY= -github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.2.4 h1:g01GSCwiDw2xSZfjJ2/T9M+S6pFdcNtFYsp+Y43HYDQ= -github.com/go-logr/logr v1.2.4/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= -github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= -github.com/go-ole/go-ole v1.2.5/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= -github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= -github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= -github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4= -github.com/go-playground/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8ceBS/t7Q= -github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8= -github.com/go-playground/universal-translator v0.17.0 h1:icxd5fm+REJzpZx7ZfpaD876Lmtgy7VtROAbHHXk8no= -github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA= -github.com/go-playground/validator/v10 v10.4.1 h1:pH2c5ADXtd66mxoE0Zm9SUhxE20r7aM3F26W0hOn+GE= -github.com/go-playground/validator/v10 v10.4.1/go.mod h1:nlOn6nFhuKACm19sB/8EGNn9GlaMV7XkbRSipzJ0Ii4= -github.com/goccy/go-yaml v1.9.2 h1:2Njwzw+0+pjU2gb805ZC1B/uBuAs2VcZ3K+ZgHwDs7w= -github.com/goccy/go-yaml v1.9.2/go.mod h1:U/jl18uSupI5rdI2jmuCswEA2htH9eXfferR3KfscvA= -github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= -github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw= -github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU= -github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= -github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= -github.com/golang-jwt/jwt/v4 v4.5.0 h1:7cYmW1XlMY7h7ii7UhUyChSgS5wUJEnm9uZVTGqOWzg= -github.com/golang-jwt/jwt/v4 v4.5.0/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= -github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb h1:PBC98N2aIaM3XXiurYmW7fx4GZkL8feAMVq7nEjURHk= -github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= -github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= -github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= -github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= -github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= -github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk= -github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= -github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc= -github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= -github.com/hashicorp/go-bexpr v0.1.10 h1:9kuI5PFotCboP3dkDYFr/wi0gg0QVbSNz5oFRpxn4uE= -github.com/hashicorp/go-bexpr v0.1.10/go.mod h1:oxlubA2vC/gFVfX1A6JGp7ls7uCDlfJn732ehYYg+g0= -github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k= -github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= -github.com/holiman/billy v0.0.0-20240216141850-2abb0c79d3c4 h1:X4egAf/gcS1zATw6wn4Ej8vjuVGxeHdan+bRb2ebyv4= -github.com/holiman/billy v0.0.0-20240216141850-2abb0c79d3c4/go.mod h1:5GuXa7vkL8u9FkFuWdVvfR5ix8hRB7DbOAaYULamFpc= -github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao= -github.com/holiman/bloomfilter/v2 v2.0.3/go.mod h1:zpoh+gs7qcpqrHr3dB55AMiJwo0iURXE7ZOP9L9hSkA= -github.com/holiman/uint256 v1.3.1 h1:JfTzmih28bittyHM8z360dCjIA9dbPIBlcTI6lmctQs= -github.com/holiman/uint256 v1.3.1/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E= -github.com/huandu/go-assert v1.1.5 h1:fjemmA7sSfYHJD7CUqs9qTwwfdNAx7/j2/ZlHXzNB3c= -github.com/huandu/go-assert v1.1.5/go.mod h1:yOLvuqZwmcHIC5rIzrBhT7D3Q9c3GFnd0JrPVhn/06U= -github.com/huandu/go-clone v1.6.0 h1:HMo5uvg4wgfiy5FoGOqlFLQED/VGRm2D9Pi8g1FXPGc= -github.com/huandu/go-clone v1.6.0/go.mod h1:ReGivhG6op3GYr+UY3lS6mxjKp7MIGTknuU5TbTVaXE= -github.com/huandu/go-clone/generic v1.6.0 h1:Wgmt/fUZ28r16F2Y3APotFD59sHk1p78K0XLdbUYN5U= -github.com/huandu/go-clone/generic v1.6.0/go.mod h1:xgd9ZebcMsBWWcBx5mVMCoqMX24gLWr5lQicr+nVXNs= -github.com/huin/goupnp v1.3.0 h1:UvLUlWDNpoUdYzb2TCn+MuTWtcjXKSza2n6CBdQ0xXc= -github.com/huin/goupnp v1.3.0/go.mod h1:gnGPsThkYa7bFi/KWmEysQRf48l2dvR5bxr2OFckNX8= -github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7BdWus= -github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc= -github.com/jbrower95/multicall-go v0.0.0-20241012224745-7e9c19976cb5 h1:MbF9mcEhOK8A1lphvcfh5Tg7Y2p4iUAtw2+yz3jUa94= -github.com/jbrower95/multicall-go v0.0.0-20241012224745-7e9c19976cb5/go.mod h1:cl6hJrk69g0EyKPgNySQbJE1nj29t2q7Pu0as27uC04= -github.com/klauspost/compress v1.16.0 h1:iULayQNOReoYUe+1qtKOqw9CwJv3aNQu8ivo7lw1HU4= -github.com/klauspost/compress v1.16.0/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE= -github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM= -github.com/klauspost/cpuid/v2 v2.2.7/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= -github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= -github.com/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c= -github.com/leanovate/gopter v0.2.9/go.mod h1:U2L/78B+KVFIx2VmW6onHJQzXtFb+p5y3y2Sh+Jxxv8= -github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y= -github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII= -github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= -github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= -github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= -github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= -github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= -github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= -github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= -github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= -github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU= -github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= -github.com/minio/sha256-simd v1.0.1 h1:6kaan5IFmwTNynnKKpDHe6FWHohJOHhCPchzK49dzMM= -github.com/minio/sha256-simd v1.0.1/go.mod h1:Pz6AKMiUdngCLpeTL/RJY1M9rUuPMYujV5xJjtbRSN8= -github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= -github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= -github.com/mitchellh/pointerstructure v1.2.0 h1:O+i9nHnXS3l/9Wu7r4NrEdwA2VFTicjUEN1uBnDo34A= -github.com/mitchellh/pointerstructure v1.2.0/go.mod h1:BRAsLI5zgXmw97Lf6s25bs8ohIXc3tViBH44KcwB2g4= -github.com/mmcloughlin/addchain v0.4.0 h1:SobOdjm2xLj1KkXN5/n0xTIWyZA2+s99UCY1iPfkHRY= -github.com/mmcloughlin/addchain v0.4.0/go.mod h1:A86O+tHqZLMNO4w6ZZ4FlVQEadcoqkyU72HC5wJ4RlU= -github.com/mmcloughlin/profile v0.1.1/go.mod h1:IhHD7q1ooxgwTgjxQYkACGA77oFTDdFVejUS1/tS/qU= -github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec= -github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= -github.com/pk910/dynamic-ssz v0.0.3 h1:fCWzFowq9P6SYCc7NtJMkZcIHk+r5hSVD+32zVi6Aio= -github.com/pk910/dynamic-ssz v0.0.3/go.mod h1:b6CrLaB2X7pYA+OSEEbkgXDEcRnjLOZIxZTsMuO/Y9c= -github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= -github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= -github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/prometheus/client_golang v1.19.0 h1:ygXvpU1AoN1MhdzckN+PyD9QJOSD4x7kmXYlnfbA6JU= -github.com/prometheus/client_golang v1.19.0/go.mod h1:ZRM9uEAypZakd+q/x7+gmsvXdURP+DABIEIjnmDdp+k= -github.com/prometheus/client_model v0.5.0 h1:VQw1hfvPvk3Uv6Qf29VrPF32JB6rtbgI6cYPYQjL0Qw= -github.com/prometheus/client_model v0.5.0/go.mod h1:dTiFglRmd66nLR9Pv9f0mZi7B7fk5Pm3gvsjB5tr+kI= -github.com/prometheus/common v0.48.0 h1:QO8U2CdOzSn1BBsmXJXduaaW+dY/5QLjfB8svtSzKKE= -github.com/prometheus/common v0.48.0/go.mod h1:0/KsvlIEfPQCQ5I2iNSAWKPZziNCvRs5EC6ILDTlAPc= -github.com/prometheus/procfs v0.12.0 h1:jluTpSng7V9hY0O2R9DzzJHYb2xULk9VTR1V1R/k6Bo= -github.com/prometheus/procfs v0.12.0/go.mod h1:pcuDEFsWDnvcgNzo4EEweacyhjeA9Zk3cnaOZAZEfOo= -github.com/prysmaticlabs/go-bitfield v0.0.0-20240328144219-a1caa50c3a1e h1:ATgOe+abbzfx9kCPeXIW4fiWyDdxlwHw07j8UGhdTd4= -github.com/prysmaticlabs/go-bitfield v0.0.0-20240328144219-a1caa50c3a1e/go.mod h1:wmuf/mdK4VMD+jA9ThwcUKjg3a2XWM9cVfFYjDyY4j4= -github.com/r3labs/sse/v2 v2.10.0 h1:hFEkLLFY4LDifoHdiCN/LlGBAdVJYsANaLqNYa1l/v0= -github.com/r3labs/sse/v2 v2.10.0/go.mod h1:Igau6Whc+F17QUgML1fYe1VPZzTV6EMCnYktEmkNJ7I= -github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY= -github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= -github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M= -github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA= -github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik= -github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU= -github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg= -github.com/rs/zerolog v1.32.0 h1:keLypqrlIjaFsbmJOBdB/qvyF8KEtCWHwobLp5l/mQ0= -github.com/rs/zerolog v1.32.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss= -github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk= -github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= -github.com/samber/lo v1.47.0 h1:z7RynLwP5nbyRscyvcD043DWYoOcYRv3mV8lBeqOCLc= -github.com/samber/lo v1.47.0/go.mod h1:RmDH9Ct32Qy3gduHQuKJ3gW1fMHAnE/fAzQuf6He5cU= -github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible h1:Bn1aCHHRnjv4Bl16T8rcaFjYSrGrIZvpiGO6P3Q4GpU= -github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA= -github.com/status-im/keycard-go v0.2.0 h1:QDLFswOQu1r5jsycloeQh3bVU8n/NatHHaZobtDnDzA= -github.com/status-im/keycard-go v0.2.0/go.mod h1:wlp8ZLbsmrF6g6WjugPAx+IzoLrkdf9+mHxBEeo3Hbg= -github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= -github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= -github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= -github.com/supranational/blst v0.3.11 h1:LyU6FolezeWAhvQk0k6O/d49jqgO52MSDDfYgbeoEm4= -github.com/supranational/blst v0.3.11/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw= -github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY= -github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc= -github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFAEVmqU= -github.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI= -github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk= -github.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY= -github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8= -github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U= -github.com/umbracle/gohashtree v0.0.2-alpha.0.20230207094856-5b775a815c10 h1:CQh33pStIp/E30b7TxDlXfM0145bn2e8boI30IxAhTg= -github.com/umbracle/gohashtree v0.0.2-alpha.0.20230207094856-5b775a815c10/go.mod h1:x/Pa0FF5Te9kdrlZKJK82YmAkvL8+f989USgz6Jiw7M= -github.com/urfave/cli/v2 v2.27.1 h1:8xSQ6szndafKVRmfyeUMxkNUJQMjL1F2zmsZ+qHpfho= -github.com/urfave/cli/v2 v2.27.1/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ= -github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU= -github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8= -go.opentelemetry.io/otel v1.16.0 h1:Z7GVAX/UkAXPKsy94IU+i6thsQS4nb7LviLpnaNeW8s= -go.opentelemetry.io/otel v1.16.0/go.mod h1:vl0h9NUa1D5s1nv3A5vZOYWn8av4K8Ml6JDeHrT/bx4= -go.opentelemetry.io/otel/metric v1.16.0 h1:RbrpwVG1Hfv85LgnZ7+txXioPDoh6EdbZHo26Q3hqOo= -go.opentelemetry.io/otel/metric v1.16.0/go.mod h1:QE47cpOmkwipPiefDwo2wDzwJrlfxxNYodqc4xnGCo4= -go.opentelemetry.io/otel/trace v1.16.0 h1:8JRpaObFoW0pxuVPapkgH8UhHQj+bJW8jJsCZEu5MQs= -go.opentelemetry.io/otel/trace v1.16.0/go.mod h1:Yt9vYq1SdNz3xdjZZK7wcXv1qv2pwLkqr2QVwea0ef0= -golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI= -golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8= -golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa h1:FRnLl4eNAQl8hwxVVC17teOw8kdjVDVAiFMtgUdTSRQ= -golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa/go.mod h1:zk2irFbV9DP96SEBUUAy67IdHUaZuSnrz1n472HUCLE= -golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20191116160921-f9c825593386/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.24.0 h1:1PcaxkF854Fu3+lvBIx5SYn9wRlBzzcnHZSiaFFAb0w= -golang.org/x/net v0.24.0/go.mod h1:2Q7sJY5mzlzWjKtYUEXSlBWCdyaioyXzRB2RtU8KVE8= -golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M= -golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= -golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI= -golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= -golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4= -golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI= -golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk= -golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= -golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 h1:+cNy6SZtPcJQH3LJVLOSmiC7MMxXNOb3PU/VUEz+EhU= -golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90= -google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg= -google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw= -gopkg.in/Knetic/govaluate.v3 v3.0.0 h1:18mUyIt4ZlRlFZAAfVetz4/rzlJs9yhN+U02F4u1AOc= -gopkg.in/Knetic/govaluate.v3 v3.0.0/go.mod h1:csKLBORsPbafmSCGTEh3U7Ozmsuq8ZSIlKk1bcqph0E= -gopkg.in/cenkalti/backoff.v1 v1.1.0 h1:Arh75ttbsvlpVA7WtVpH4u9h6Zl46xuptxqLxPiSo4Y= -gopkg.in/cenkalti/backoff.v1 v1.1.0/go.mod h1:J6Vskwqd+OMVJl8C33mmtxTBs2gyzfv7UDAkHu8BrjI= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/natefinch/lumberjack.v2 v2.2.1 h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc= -gopkg.in/natefinch/lumberjack.v2 v2.2.1/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc= -gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= -gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= -gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -rsc.io/tmplfunc v0.0.3 h1:53XFQh69AfOa8Tw0Jm7t+GV7KZhOi6jzsCzTtKbMvzU= -rsc.io/tmplfunc v0.0.3/go.mod h1:AG3sTPzElb1Io3Yg4voV9AGZJuleGAwaVRxL9M49PhA= diff --git a/script/releases/v1.0.0-slashing/cleanup/script.go b/script/releases/v1.0.0-slashing/cleanup/script.go deleted file mode 100644 index bbc3da4da1..0000000000 --- a/script/releases/v1.0.0-slashing/cleanup/script.go +++ /dev/null @@ -1,328 +0,0 @@ -package main - -import ( - "context" - _ "embed" - "encoding/json" - "fmt" - "math/big" - "os" - "sort" - "strings" - "time" - - proofgen "github.com/Layr-Labs/eigenpod-proofs-generation/cli/core" - eth2client "github.com/attestantio/go-eth2-client" - "github.com/attestantio/go-eth2-client/api" - v1 "github.com/attestantio/go-eth2-client/api/v1" - attestantio "github.com/attestantio/go-eth2-client/http" - "github.com/attestantio/go-eth2-client/spec/phase0" - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/ethclient" - multicall "github.com/jbrower95/multicall-go" - "github.com/samber/lo" -) - -type EigenpodInfo struct { - Address string `json:"address"` - CurrentCheckpointTimestamp uint64 `json:"currentCheckpointTimestamp"` -} - -type TQueryAllEigenpodsOnNetworkArgs struct { - Ctx context.Context - AllValidators []ValidatorWithIndex - Eth *ethclient.Client - EigenpodAbi abi.ABI - PodManagerAbi abi.ABI - PodManagerAddress string - Mc *multicall.MulticallClient -} - -//go:embed EigenPod.abi.json -var EigenPodAbi string - -//go:embed EigenPodManager.abi.json -var EigenPodManagerAbi string - -type ValidatorWithIndex struct { - Validator *v1.Validator - Index phase0.ValidatorIndex -} - -type TArgs struct { - Node string - BeaconNode string - Sender string -} - -func main() { - err := runScript(TArgs{ - Node: os.Getenv("RPC_URL"), - BeaconNode: os.Getenv("BEACON_URL"), - Sender: os.Getenv("SENDER_PK"), - }) - if err != nil { - fmt.Printf("Error: %v\n", err) - os.Exit(1) - } -} - -func panicOnError(msg string, err error) { - if err != nil { - fmt.Printf("Error: %s", msg) - panic(err) - } -} - -func runScript(args TArgs) error { - ctx := context.Background() - - if args.Sender[:2] == "0x" { - args.Sender = args.Sender[2:] - } - fmt.Printf("Sender: %s\n", args.Sender) - - eigenpodAbi, err := abi.JSON(strings.NewReader(EigenPodAbi)) - panicOnError("failed to load eigenpod abi", err) - - podManagerAbi, err := abi.JSON(strings.NewReader(EigenPodManagerAbi)) - panicOnError("failed to load eigenpod manager abi", err) - - eth, err := ethclient.Dial(args.Node) - panicOnError("failed to reach eth node", err) - - chainId, err := eth.ChainID(ctx) - panicOnError("failed to read chainId", err) - - beaconClient, err := attestantio.New(ctx, - attestantio.WithAddress(args.BeaconNode), - ) - panicOnError("failed to reach beacon node", err) - - panicOnError("failed to reach ethereum clients", err) - - mc, err := multicall.NewMulticallClient(ctx, eth, &multicall.TMulticallClientOptions{ - MaxBatchSizeBytes: 8192, - }) - panicOnError("error initializing mc", err) - - podManagerAddress := os.Getenv("ZEUS_DEPLOYED_EigenPodManager_Proxy") - - // fetch latest beacon state. - _validators := (func() *map[phase0.ValidatorIndex]*v1.Validator { - if provider, isProvider := beaconClient.(eth2client.ValidatorsProvider); isProvider { - validators, err := provider.Validators(ctx, &api.ValidatorsOpts{ - State: "head", - Common: api.CommonOpts{ - Timeout: 60 * time.Second, - }, - }) - panicOnError("failed to load validator set", err) - return &validators.Data - } - return nil - })() - if _validators == nil { - panic("failed to load validators") - } - validators := *_validators - - fmt.Printf("Found %d validators\n", len(validators)) - - panicOnError("failed to load beacon state", err) - - panicOnError("failed to fetch validators", err) - allValidators := lo.Map(lo.Keys(validators), func(idx phase0.ValidatorIndex, i int) ValidatorWithIndex { - return ValidatorWithIndex{ - Validator: validators[idx], - Index: idx, - } - }) - - allEigenpods, err := queryAllEigenpodsOnNetwork(ctx, allValidators, eth, &eigenpodAbi, &podManagerAbi, podManagerAddress, mc) - panicOnError("queryAllEigenpodsOnNetwork", err) - - enc := json.NewEncoder(os.Stdout) - enc.SetIndent("", " ") - - fmt.Printf("Discovered %d eigenpods on the network.\n", len(allEigenpods)) - - pods := lo.Map(allEigenpods, func(pod string, i int) string { - return fmt.Sprintf("0x%s", pod) - }) - sort.Strings(pods) - fmt.Printf("%s\n", enc.Encode(pods)) - - // Now for each eigenpod, we want to fetch currentCheckpointTimestamp. - // We'll do a multicall to get currentCheckpointTimestamp from each eigenpod. - checkpointTimestamps, err := fetchCurrentCheckpointTimestamps(allEigenpods, &eigenpodAbi, mc) - panicOnError("failed to fetch currentCheckpointTimestamps", err) - - results := []EigenpodInfo{} - - for i, ep := range allEigenpods { - if checkpointTimestamps[i] > 0 { - results = append(results, EigenpodInfo{ - Address: fmt.Sprintf("0x%s", ep), - CurrentCheckpointTimestamp: checkpointTimestamps[i], - }) - } - } - - if len(results) == 0 { - fmt.Printf("No eigenpods had active checkpoints. OK.") - return nil - } - - fmt.Printf("%d EigenPods had active checkpoints\n\n", len(results)) - fmt.Printf("%s\n", enc.Encode(results)) - - fmt.Printf("Completing %d checkpoints....", len(results)) - coreBeaconClient, _, err := proofgen.NewBeaconClient(args.BeaconNode, true /* verbose */) - panicOnError("failed to instantiate beaconClient", err) - - for i := 0; i < len(results); i++ { - fmt.Printf("Completing [%d/%d]...", i+1, len(results)) - fmt.Printf("NOTE: this is expensive, and may take several minutes.") - completeCheckpointForEigenpod(ctx, results[i].Address, eth, chainId, coreBeaconClient, args.Sender) - } - - checkpointTimestamps, err = fetchCurrentCheckpointTimestamps(allEigenpods, &eigenpodAbi, mc) - panicOnError("failed to fetch currentCheckpointTimestamps", err) - - // require that all eigenpods have a checkpoint timestamp of 0 - for i, timestamp := range checkpointTimestamps { - if timestamp != 0 { - panic(fmt.Sprintf("expected all eigenpods to have a checkpoint timestamp of 0, but found %d on %s", timestamp, allEigenpods[i])) - } - } - - return nil -} - -func completeCheckpointForEigenpod(ctx context.Context, eigenpodAddress string, eth *ethclient.Client, chainId *big.Int, coreBeaconClient proofgen.BeaconClient, sender string) { - res, err := proofgen.GenerateCheckpointProof(ctx, eigenpodAddress, eth, chainId, coreBeaconClient, true) - panicOnError(fmt.Sprintf("failed to generate checkpoint proof for eigenpod:%s", eigenpodAddress), err) - - txns, err := proofgen.SubmitCheckpointProof(ctx, sender, eigenpodAddress, chainId, res, eth, 80 /* ideal checkpoint proof batch size */, true /* noPrompt */, false /* noSend */, true /* verbose */) - panicOnError(fmt.Sprintf("failed to submit checkpoint proof for eigenpod:%s", eigenpodAddress), err) - if txns == nil { - panic("submitting checkpoint proof generated no transactions. this is a bug.") - } - - for i, txn := range txns { - fmt.Printf("[%d/%d] %s\n", i+1, len(txns), txn.Hash()) - } -} - -// This is a simplified version of the queryAllEigenpodsOnNetwork function inline. -// It uses the logic from the provided code snippet in the commands package. -func queryAllEigenpodsOnNetwork( - ctx context.Context, - allValidators []ValidatorWithIndex, - eth *ethclient.Client, - eigenpodAbi, podManagerAbi *abi.ABI, - podManagerAddress string, - mc *multicall.MulticallClient, -) ([]string, error) { - args := TQueryAllEigenpodsOnNetworkArgs{ - Ctx: ctx, - AllValidators: allValidators, - Eth: eth, - EigenpodAbi: *eigenpodAbi, - PodManagerAbi: *podManagerAbi, - PodManagerAddress: podManagerAddress, - Mc: mc, - } - return internalQueryAllEigenpodsOnNetwork(args) -} - -// internalQueryAllEigenpodsOnNetwork is lifted from the provided snippet. -func internalQueryAllEigenpodsOnNetwork(args TQueryAllEigenpodsOnNetworkArgs) ([]string, error) { - // Filter out validators that are withdrawing to execution layer addresses - executionLayerWithdrawalCredentialValidators := lo.Filter(args.AllValidators, func(validator ValidatorWithIndex, i int) bool { - return validator.Validator.Validator.WithdrawalCredentials[0] == 1 - }) - - interestingWithdrawalAddresses := lo.Keys(lo.Reduce(executionLayerWithdrawalCredentialValidators, func(accum map[string]int, next ValidatorWithIndex, index int) map[string]int { - accum[common.Bytes2Hex(next.Validator.Validator.WithdrawalCredentials[12:])] = 1 - return accum - }, map[string]int{})) - - fmt.Printf("Querying %d beacon-chain withdrawal addresses to see if they may be eigenpods\n", len(interestingWithdrawalAddresses)) - - podOwners, err := multicall.DoManyAllowFailures[common.Address](args.Mc, lo.Map(interestingWithdrawalAddresses, func(address string, index int) *multicall.MultiCallMetaData[common.Address] { - callMeta, err := multicall.Describe[common.Address]( - common.HexToAddress(address), - args.EigenpodAbi, - "podOwner", - ) - panicOnError("failed to form mc", err) - return callMeta - })...) - - if podOwners == nil || err != nil || len(*podOwners) == 0 { - panicOnError("failed to fetch podOwners", err) - panic("loaded no pod owners") - } - - podToPodOwner := map[string]*common.Address{} - addressesWithPodOwners := lo.Filter(interestingWithdrawalAddresses, func(address string, i int) bool { - success := (*podOwners)[i].Success - if success { - podToPodOwner[address] = (*podOwners)[i].Value - } - return success - }) - - fmt.Printf("Querying %d addresses on (EigenPodManager=%s) to see if it knows about these eigenpods\n", len(addressesWithPodOwners), args.PodManagerAddress) - - eigenpodForOwner, err := multicall.DoMany( - args.Mc, - lo.Map(addressesWithPodOwners, func(address string, i int) *multicall.MultiCallMetaData[common.Address] { - claimedOwner := *podToPodOwner[address] - call, err := multicall.Describe[common.Address]( - common.HexToAddress(args.PodManagerAddress), - args.PodManagerAbi, - "ownerToPod", - claimedOwner, - ) - panicOnError("failed to form multicall", err) - return call - })..., - ) - panicOnError("failed to query", err) - - // now, see which are properly eigenpods - return lo.Filter(addressesWithPodOwners, func(address string, i int) bool { - return (*eigenpodForOwner)[i].Cmp(common.HexToAddress(addressesWithPodOwners[i])) == 0 - }), nil -} - -func fetchCurrentCheckpointTimestamps( - allEigenpods []string, - eigenpodAbi *abi.ABI, - mc *multicall.MulticallClient, -) ([]uint64, error) { - calls := lo.Map(allEigenpods, func(eigenpod string, i int) *multicall.MultiCallMetaData[uint64] { - call, err := multicall.Describe[uint64]( - common.HexToAddress(eigenpod), - *eigenpodAbi, - "currentCheckpointTimestamp", - ) - panicOnError("failed to form multicall", err) - return call - }) - - results, err := multicall.DoMany(mc, calls...) - if err != nil { - return nil, err - } - - out := make([]uint64, len(*results)) - for i, r := range *results { - out[i] = *r - } - return out, nil -} diff --git a/script/releases/v1.0.0-slashing/cleanup/start.sh b/script/releases/v1.0.0-slashing/cleanup/start.sh deleted file mode 100755 index e75139d25b..0000000000 --- a/script/releases/v1.0.0-slashing/cleanup/start.sh +++ /dev/null @@ -1,3 +0,0 @@ -#!/usr/bin/env bash -cd script/releases/v1.0.0-slashing/cleanup -go run script.go \ No newline at end of file diff --git a/script/releases/v1.0.0-slashing/upgrade.json b/script/releases/v1.0.0-slashing/upgrade.json deleted file mode 100644 index 3ee10a2ca6..0000000000 --- a/script/releases/v1.0.0-slashing/upgrade.json +++ /dev/null @@ -1,32 +0,0 @@ -{ - "name": "slashing", - "from": "~0.5.3", - "to": "1.0.0", - "phases": [ - { - "type": "eoa", - "filename": "1-deployContracts.s.sol" - }, - { - "type": "multisig", - "filename": "2-queueUpgradeAndUnpause.s.sol" - }, - { - "type": "multisig", - "filename": "3-pause.s.sol" - }, - { - "type": "script", - "filename": "cleanup/start.sh", - "arguments": [ - {"type": "url", "passBy": "env", "inputType": "text", "name": "RPC_URL", "prompt": "Enter an ETH RPC URL"}, - {"type": "url", "passBy": "env", "inputType": "text", "name": "BEACON_URL", "prompt": "Enter an ETH2 Beacon RPC URL"}, - {"type": "privateKey", "passBy": "env", "inputType": "password", "name": "SENDER_PK", "prompt": "Enter an ETH wallet private key to complete checkpoints from:"} - ] - }, - { - "type": "multisig", - "filename": "5-executeUpgradeAndUnpause.s.sol" - } - ] -} \ No newline at end of file diff --git a/script/releases/v1.0.1-slashing/1-eoa.s.sol b/script/releases/v1.0.1-slashing/1-eoa.s.sol deleted file mode 100644 index 82481da8c2..0000000000 --- a/script/releases/v1.0.1-slashing/1-eoa.s.sol +++ /dev/null @@ -1,123 +0,0 @@ -// SPDX-License-Identifier: BUSL-1.1 -pragma solidity ^0.8.12; - -import {EOADeployer} from "zeus-templates/templates/EOADeployer.sol"; -import "../Env.sol"; - -import "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol"; -import "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol"; -import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; -import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol"; - -contract Deploy is EOADeployer { - using Env for *; - - function _runAsEOA() internal override { - vm.startBroadcast(); - deployImpl({ - name: type(AllocationManager).name, - deployedTo: address(new AllocationManager({ - _delegation: Env.proxy.delegationManager(), - _pauserRegistry: Env.impl.pauserRegistry(), - _permissionController: Env.proxy.permissionController(), - _DEALLOCATION_DELAY: Env.MIN_WITHDRAWAL_DELAY(), - _ALLOCATION_CONFIGURATION_DELAY: Env.ALLOCATION_CONFIGURATION_DELAY() - })) - }); - - deployImpl({ - name: type(DelegationManager).name, - deployedTo: address(new DelegationManager({ - _strategyManager: Env.proxy.strategyManager(), - _eigenPodManager: Env.proxy.eigenPodManager(), - _allocationManager: Env.proxy.allocationManager(), - _pauserRegistry: Env.impl.pauserRegistry(), - _permissionController: Env.proxy.permissionController(), - _MIN_WITHDRAWAL_DELAY: Env.MIN_WITHDRAWAL_DELAY() - })) - }); - - vm.stopBroadcast(); - } - - function testDeploy() public virtual { - _runAsEOA(); - _validateNewImplAddresses(false); - _validateImplConstructors(); - _validateImplsInitialized(); - } - - - /// @dev Validate that the `Env.impl` addresses are updated to be distinct from what the proxy - /// admin reports as the current implementation address. - /// - /// Note: The upgrade script can call this with `areMatching == true` to check that these impl - /// addresses _are_ matches. - function _validateNewImplAddresses(bool areMatching) internal view { - function (address, address, string memory) internal pure assertion = - areMatching ? _assertMatch : _assertNotMatch; - - - assertion( - _getProxyImpl(address(Env.proxy.delegationManager())), - address(Env.impl.delegationManager()), - "delegationManager impl failed" - ); - - assertion( - _getProxyImpl(address(Env.proxy.allocationManager())), - address(Env.impl.allocationManager()), - "allocationManager impl failed" - ); - } - - /// @dev Validate the immutables set in the new implementation constructors - function _validateImplConstructors() internal view { - AllocationManager allocationManager = Env.impl.allocationManager(); - assertTrue(allocationManager.delegation() == Env.proxy.delegationManager(), "alm.dm invalid"); - assertTrue(allocationManager.pauserRegistry() == Env.impl.pauserRegistry(), "alm.pR invalid"); - assertTrue(allocationManager.permissionController() == Env.proxy.permissionController(), "alm.pc invalid"); - assertTrue(allocationManager.DEALLOCATION_DELAY() == Env.MIN_WITHDRAWAL_DELAY(), "alm.deallocDelay invalid"); - assertTrue(allocationManager.ALLOCATION_CONFIGURATION_DELAY() == Env.ALLOCATION_CONFIGURATION_DELAY(), "alm.configDelay invalid"); - - - DelegationManager delegation = Env.impl.delegationManager(); - assertTrue(delegation.strategyManager() == Env.proxy.strategyManager(), "dm.sm invalid"); - assertTrue(delegation.eigenPodManager() == Env.proxy.eigenPodManager(), "dm.epm invalid"); - assertTrue(delegation.allocationManager() == Env.proxy.allocationManager(), "dm.alm invalid"); - assertTrue(delegation.pauserRegistry() == Env.impl.pauserRegistry(), "dm.pR invalid"); - assertTrue(delegation.permissionController() == Env.proxy.permissionController(), "dm.pc invalid"); - assertTrue(delegation.minWithdrawalDelayBlocks() == Env.MIN_WITHDRAWAL_DELAY(), "dm.withdrawalDelay invalid"); - } - - /// @dev Call initialize on all deployed implementations to ensure initializers are disabled - function _validateImplsInitialized() internal { - bytes memory errInit = "Initializable: contract is already initialized"; - - AllocationManager allocationManager = Env.impl.allocationManager(); - vm.expectRevert(errInit); - allocationManager.initialize(address(0), 0); - - DelegationManager delegation = Env.impl.delegationManager(); - vm.expectRevert(errInit); - delegation.initialize(address(0), 0); - } - - /// @dev Query and return `proxyAdmin.getProxyImplementation(proxy)` - function _getProxyImpl(address proxy) internal view returns (address) { - return ProxyAdmin(Env.proxyAdmin()).getProxyImplementation(ITransparentUpgradeableProxy(proxy)); - } - - /// @dev Query and return `proxyAdmin.getProxyAdmin(proxy)` - function _getProxyAdmin(address proxy) internal view returns (address) { - return ProxyAdmin(Env.proxyAdmin()).getProxyAdmin(ITransparentUpgradeableProxy(proxy)); - } - - function _assertMatch(address a, address b, string memory err) private pure { - assertEq(a, b, err); - } - - function _assertNotMatch(address a, address b, string memory err) private pure { - assertNotEq(a, b, err); - } -} \ No newline at end of file diff --git a/script/releases/v1.0.1-slashing/2-multisig.s.sol b/script/releases/v1.0.1-slashing/2-multisig.s.sol deleted file mode 100644 index 143679ab86..0000000000 --- a/script/releases/v1.0.1-slashing/2-multisig.s.sol +++ /dev/null @@ -1,78 +0,0 @@ -// SPDX-License-Identifier: BUSL-1.1 -pragma solidity ^0.8.12; - -import {Deploy} from "./1-eoa.s.sol"; -import "../Env.sol"; - -import {MultisigBuilder} from "zeus-templates/templates/MultisigBuilder.sol"; -import "zeus-templates/utils/Encode.sol"; - -import {TimelockController} from "@openzeppelin/contracts/governance/TimelockController.sol"; - -contract Queue is MultisigBuilder, Deploy { - using Env for *; - using Encode for *; - - function _runAsMultisig() prank(Env.opsMultisig()) internal virtual override { - bytes memory calldata_to_executor = _getCalldataToExecutor(); - - TimelockController timelock = Env.timelockController(); - timelock.schedule({ - target: Env.executorMultisig(), - value: 0, - data: calldata_to_executor, - predecessor: 0, - salt: 0, - delay: timelock.getMinDelay() - }); - } - - /// @dev Get the calldata to be sent from the timelock to the executor - function _getCalldataToExecutor() internal returns (bytes memory) { - MultisigCall[] storage executorCalls = Encode.newMultisigCalls() - /// core/ - .append({ - to: Env.proxyAdmin(), - data: Encode.proxyAdmin.upgrade({ - proxy: address(Env.proxy.allocationManager()), - impl: address(Env.impl.allocationManager()) - }) - }) - .append({ - to: Env.proxyAdmin(), - data: Encode.proxyAdmin.upgrade({ - proxy: address(Env.proxy.delegationManager()), - impl: address(Env.impl.delegationManager()) - }) - }); - - return Encode.gnosisSafe.execTransaction({ - from: address(Env.timelockController()), - to: address(Env.multiSendCallOnly()), - op: Encode.Operation.DelegateCall, - data: Encode.multiSend(executorCalls) - }); - } - - function testScript() public virtual { - runAsEOA(); - - TimelockController timelock = Env.timelockController(); - bytes memory calldata_to_executor = _getCalldataToExecutor(); - bytes32 txHash = timelock.hashOperation({ - target: Env.executorMultisig(), - value: 0, - data: calldata_to_executor, - predecessor: 0, - salt: 0 - }); - - // Check that the upgrade does not exist in the timelock - assertFalse(timelock.isOperationPending(txHash), "Transaction should NOT be queued."); - - execute(); - - // Check that the upgrade has been added to the timelock - assertTrue(timelock.isOperationPending(txHash), "Transaction should be queued."); - } -} \ No newline at end of file diff --git a/script/releases/v1.0.1-slashing/3-execute.s.sol b/script/releases/v1.0.1-slashing/3-execute.s.sol deleted file mode 100644 index d495094872..0000000000 --- a/script/releases/v1.0.1-slashing/3-execute.s.sol +++ /dev/null @@ -1,75 +0,0 @@ -// SPDX-License-Identifier: BUSL-1.1 -pragma solidity ^0.8.12; - -import "../Env.sol"; -import {Queue} from "./2-multisig.s.sol"; - -import "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol"; -import "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol"; - -contract Execute is Queue { - using Env for *; - - function _runAsMultisig() prank(Env.protocolCouncilMultisig()) internal override(Queue) { - bytes memory calldata_to_executor = _getCalldataToExecutor(); - - TimelockController timelock = Env.timelockController(); - timelock.execute({ - target: Env.executorMultisig(), - value: 0, - payload: calldata_to_executor, - predecessor: 0, - salt: 0 - }); - } - - function testScript() public virtual override(Queue){ - // 0. Deploy Impls - runAsEOA(); - - TimelockController timelock = Env.timelockController(); - bytes memory calldata_to_executor = _getCalldataToExecutor(); - bytes32 txHash = timelock.hashOperation({ - target: Env.executorMultisig(), - value: 0, - data: calldata_to_executor, - predecessor: 0, - salt: 0 - }); - assertFalse(timelock.isOperationPending(txHash), "Transaction should NOT be queued."); - - // 1. Queue Upgrade - Queue._runAsMultisig(); - _unsafeResetHasPranked(); // reset hasPranked so we can use it again - - // 2. Warp past delay - vm.warp(block.timestamp + timelock.getMinDelay()); // 1 tick after ETA - assertEq(timelock.isOperationReady(txHash), true, "Transaction should be executable."); - - // 3- execute - execute(); - - assertTrue(timelock.isOperationDone(txHash), "Transaction should be complete."); - - // 4. Validate - _validateNewImplAddresses(true); - _validateProxyConstructors(); - } - - function _validateProxyConstructors() internal view { - AllocationManager allocationManager = Env.proxy.allocationManager(); - assertTrue(allocationManager.delegation() == Env.proxy.delegationManager(), "alm.dm invalid"); - assertTrue(allocationManager.pauserRegistry() == Env.impl.pauserRegistry(), "alm.pR invalid"); - assertTrue(allocationManager.permissionController() == Env.proxy.permissionController(), "alm.pc invalid"); - assertTrue(allocationManager.DEALLOCATION_DELAY() == Env.MIN_WITHDRAWAL_DELAY(), "alm.deallocDelay invalid"); - assertTrue(allocationManager.ALLOCATION_CONFIGURATION_DELAY() == Env.ALLOCATION_CONFIGURATION_DELAY(), "alm.configDelay invalid"); - - DelegationManager delegation = Env.proxy.delegationManager(); - assertTrue(delegation.strategyManager() == Env.proxy.strategyManager(), "dm.sm invalid"); - assertTrue(delegation.eigenPodManager() == Env.proxy.eigenPodManager(), "dm.epm invalid"); - assertTrue(delegation.allocationManager() == Env.proxy.allocationManager(), "dm.alm invalid"); - assertTrue(delegation.pauserRegistry() == Env.impl.pauserRegistry(), "dm.pR invalid"); - assertTrue(delegation.permissionController() == Env.proxy.permissionController(), "dm.pc invalid"); - assertTrue(delegation.minWithdrawalDelayBlocks() == Env.MIN_WITHDRAWAL_DELAY(), "dm.withdrawalDelay invalid"); - } -} \ No newline at end of file diff --git a/script/releases/v1.0.1-slashing/upgrade.json b/script/releases/v1.0.1-slashing/upgrade.json deleted file mode 100644 index 884e8dade3..0000000000 --- a/script/releases/v1.0.1-slashing/upgrade.json +++ /dev/null @@ -1,19 +0,0 @@ -{ - "name": "slashing-patch", - "from": "1.0.0", - "to": "1.0.1", - "phases": [ - { - "type": "eoa", - "filename": "1-eoa.s.sol" - }, - { - "type": "multisig", - "filename": "2-multisig.s.sol" - }, - { - "type": "multisig", - "filename": "3-execute.s.sol" - } - ] -} \ No newline at end of file diff --git a/script/releases/v1.0.2-slashing-consolidated/1-deployContracts.s.sol b/script/releases/v1.0.2-slashing-consolidated/1-deployContracts.s.sol deleted file mode 100644 index 6c5828600a..0000000000 --- a/script/releases/v1.0.2-slashing-consolidated/1-deployContracts.s.sol +++ /dev/null @@ -1,528 +0,0 @@ -// SPDX-License-Identifier: BUSL-1.1 -pragma solidity ^0.8.12; - -import {EOADeployer} from "zeus-templates/templates/EOADeployer.sol"; -import "../Env.sol"; - -import "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol"; -import "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol"; -import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; -import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol"; - -/** - * Purpose: use an EOA to deploy all of the new contracts for this upgrade. - */ -contract Deploy is EOADeployer { - using Env for *; - - function _runAsEOA() internal override { - vm.startBroadcast(); - - /// permissions/ - - address[] memory pausers = new address[](3); - pausers[0] = Env.pauserMultisig(); - pausers[1] = Env.opsMultisig(); - pausers[2] = Env.executorMultisig(); - - deployImpl({ - name: type(PauserRegistry).name, - deployedTo: address(new PauserRegistry({ - _pausers: pausers, - _unpauser: Env.executorMultisig() - })) - }); - - deployImpl({ - name: type(PermissionController).name, - deployedTo: address(new PermissionController()) - }); - - deployProxy({ - name: type(PermissionController).name, - deployedTo: address(new TransparentUpgradeableProxy({ - _logic: address(Env.impl.permissionController()), - admin_: Env.proxyAdmin(), - _data: "" - })) - }); - - /// core/ - - deployImpl({ - name: type(AllocationManager).name, - deployedTo: address(new AllocationManager({ - _delegation: Env.proxy.delegationManager(), - _pauserRegistry: Env.impl.pauserRegistry(), - _permissionController: Env.proxy.permissionController(), - _DEALLOCATION_DELAY: Env.MIN_WITHDRAWAL_DELAY(), - _ALLOCATION_CONFIGURATION_DELAY: Env.ALLOCATION_CONFIGURATION_DELAY() - })) - }); - - deployProxy({ - name: type(AllocationManager).name, - deployedTo: address(new TransparentUpgradeableProxy({ - _logic: address(Env.impl.allocationManager()), - admin_: Env.proxyAdmin(), - _data: abi.encodeCall( - AllocationManager.initialize, - ( - Env.executorMultisig(), // initialOwner - 0 // initialPausedStatus - ) - ) - })) - }); - - deployImpl({ - name: type(AVSDirectory).name, - deployedTo: address(new AVSDirectory({ - _delegation: Env.proxy.delegationManager(), - _pauserRegistry: Env.impl.pauserRegistry() - })) - }); - - deployImpl({ - name: type(DelegationManager).name, - deployedTo: address(new DelegationManager({ - _strategyManager: Env.proxy.strategyManager(), - _eigenPodManager: Env.proxy.eigenPodManager(), - _allocationManager: Env.proxy.allocationManager(), - _pauserRegistry: Env.impl.pauserRegistry(), - _permissionController: Env.proxy.permissionController(), - _MIN_WITHDRAWAL_DELAY: Env.MIN_WITHDRAWAL_DELAY() - })) - }); - - deployImpl({ - name: type(RewardsCoordinator).name, - deployedTo: address(new RewardsCoordinator({ - _delegationManager: Env.proxy.delegationManager(), - _strategyManager: Env.proxy.strategyManager(), - _allocationManager: Env.proxy.allocationManager(), - _pauserRegistry: Env.impl.pauserRegistry(), - _permissionController: Env.proxy.permissionController(), - _CALCULATION_INTERVAL_SECONDS: Env.CALCULATION_INTERVAL_SECONDS(), - _MAX_REWARDS_DURATION: Env.MAX_REWARDS_DURATION(), - _MAX_RETROACTIVE_LENGTH: Env.MAX_RETROACTIVE_LENGTH(), - _MAX_FUTURE_LENGTH: Env.MAX_FUTURE_LENGTH(), - _GENESIS_REWARDS_TIMESTAMP: Env.GENESIS_REWARDS_TIMESTAMP() - })) - }); - - deployImpl({ - name: type(StrategyManager).name, - deployedTo: address(new StrategyManager({ - _delegation: Env.proxy.delegationManager(), - _pauserRegistry: Env.impl.pauserRegistry() - })) - }); - - /// pods/ - - deployImpl({ - name: type(EigenPodManager).name, - deployedTo: address(new EigenPodManager({ - _ethPOS: Env.ethPOS(), - _eigenPodBeacon: Env.beacon.eigenPod(), - _delegationManager: Env.proxy.delegationManager(), - _pauserRegistry: Env.impl.pauserRegistry() - })) - }); - - deployImpl({ - name: type(EigenPod).name, - deployedTo: address(new EigenPod({ - _ethPOS: Env.ethPOS(), - _eigenPodManager: Env.proxy.eigenPodManager(), - _GENESIS_TIME: Env.EIGENPOD_GENESIS_TIME() - })) - }); - - /// strategies/ - - deployImpl({ - name: type(StrategyBaseTVLLimits).name, - deployedTo: address(new StrategyBaseTVLLimits({ - _strategyManager: Env.proxy.strategyManager(), - _pauserRegistry: Env.impl.pauserRegistry() - })) - }); - - deployImpl({ - name: type(EigenStrategy).name, - deployedTo: address(new EigenStrategy({ - _strategyManager: Env.proxy.strategyManager(), - _pauserRegistry: Env.impl.pauserRegistry() - })) - }); - - deployImpl({ - name: type(StrategyFactory).name, - deployedTo: address(new StrategyFactory({ - _strategyManager: Env.proxy.strategyManager(), - _pauserRegistry: Env.impl.pauserRegistry() - })) - }); - - // for strategies deployed via factory - deployImpl({ - name: type(StrategyBase).name, - deployedTo: address(new StrategyBase({ - _strategyManager: Env.proxy.strategyManager(), - _pauserRegistry: Env.impl.pauserRegistry() - })) - }); - - vm.stopBroadcast(); - } - - function testScript() public virtual { - _runAsEOA(); - - _validateNewImplAddresses({ areMatching: false }); - _validateProxyAdmins(); - _validateImplConstructors(); - _validateImplsInitialized(); - _validateStrategiesAreWhitelisted(); - } - - /// @dev Validate that the `Env.impl` addresses are updated to be distinct from what the proxy - /// admin reports as the current implementation address. - /// - /// Note: The upgrade script can call this with `areMatching == true` to check that these impl - /// addresses _are_ matches. - function _validateNewImplAddresses(bool areMatching) internal view { - /// core/ -- can't check AllocationManager as it didn't exist before this deploy - - function (address, address, string memory) internal pure assertion = - areMatching ? _assertMatch : _assertNotMatch; - - assertion( - _getProxyImpl(address(Env.proxy.avsDirectory())), - address(Env.impl.avsDirectory()), - "avsDirectory impl failed" - ); - - assertion( - _getProxyImpl(address(Env.proxy.delegationManager())), - address(Env.impl.delegationManager()), - "delegationManager impl failed" - ); - - assertion( - _getProxyImpl(address(Env.proxy.rewardsCoordinator())), - address(Env.impl.rewardsCoordinator()), - "rewardsCoordinator impl failed" - ); - - assertion( - _getProxyImpl(address(Env.proxy.strategyManager())), - address(Env.impl.strategyManager()), - "strategyManager impl failed" - ); - - /// permissions/ -- can't check these because PauserRegistry has no proxy, and - /// PermissionController proxy didn't exist before this deploy - - /// pods/ - - assertion( - Env.beacon.eigenPod().implementation(), - address(Env.impl.eigenPod()), - "eigenPod impl failed" - ); - - assertion( - _getProxyImpl(address(Env.proxy.eigenPodManager())), - address(Env.impl.eigenPodManager()), - "eigenPodManager impl failed" - ); - - /// strategies/ - - assertion( - _getProxyImpl(address(Env.proxy.eigenStrategy())), - address(Env.impl.eigenStrategy()), - "eigenStrategy impl failed" - ); - - assertion( - Env.beacon.strategyBase().implementation(), - address(Env.impl.strategyBase()), - "strategyBase impl failed" - ); - - uint count = Env.instance.strategyBaseTVLLimits_Count(); - for (uint i = 0; i < count; i++) { - assertion( - _getProxyImpl(address(Env.instance.strategyBaseTVLLimits(i))), - address(Env.impl.strategyBaseTVLLimits()), - "strategyBaseTVLLimits impl failed" - ); - } - - assertion( - _getProxyImpl(address(Env.proxy.strategyFactory())), - address(Env.impl.strategyFactory()), - "strategyFactory impl failed" - ); - } - - /// @dev Ensure each deployed TUP/beacon is owned by the proxyAdmin/executorMultisig - function _validateProxyAdmins() internal view { - address pa = Env.proxyAdmin(); - - assertTrue( - _getProxyAdmin(address(Env.proxy.allocationManager())) == pa, - "allocationManager proxyAdmin incorrect" - ); - - assertTrue( - _getProxyAdmin(address(Env.proxy.avsDirectory())) == pa, - "avsDirectory proxyAdmin incorrect" - ); - - assertTrue( - _getProxyAdmin(address(Env.proxy.delegationManager())) == pa, - "delegationManager proxyAdmin incorrect" - ); - - assertTrue( - _getProxyAdmin(address(Env.proxy.rewardsCoordinator())) == pa, - "rewardsCoordinator proxyAdmin incorrect" - ); - - assertTrue( - _getProxyAdmin(address(Env.proxy.strategyManager())) == pa, - "strategyManager proxyAdmin incorrect" - ); - - /// permissions/ -- can't check these because PauserRegistry has no proxy, and - /// PermissionController proxy didn't exist before this deploy - - /// pods/ - - assertTrue( - Env.beacon.eigenPod().owner() == Env.executorMultisig(), - "eigenPod beacon owner incorrect" - ); - - assertTrue( - _getProxyAdmin(address(Env.proxy.eigenPodManager())) == pa, - "eigenPodManager proxyAdmin incorrect" - ); - - /// strategies/ - - assertTrue( - _getProxyAdmin(address(Env.proxy.eigenStrategy())) == pa, - "eigenStrategy proxyAdmin incorrect" - ); - - assertTrue( - Env.beacon.strategyBase().owner() == Env.executorMultisig(), - "strategyBase beacon owner incorrect" - ); - - uint count = Env.instance.strategyBaseTVLLimits_Count(); - for (uint i = 0; i < count; i++) { - assertTrue( - _getProxyAdmin(address(Env.instance.strategyBaseTVLLimits(i))) == pa, - "strategyBaseTVLLimits proxyAdmin incorrect" - ); - } - - assertTrue( - _getProxyAdmin(address(Env.proxy.strategyFactory())) == pa, - "strategyFactory proxyAdmin incorrect" - ); - } - - /// @dev Validate the immutables set in the new implementation constructors - function _validateImplConstructors() internal view { - { - /// permissions/ - - PauserRegistry registry = Env.impl.pauserRegistry(); - assertTrue(registry.isPauser(Env.pauserMultisig()), "pauser multisig should be pauser"); - assertTrue(registry.isPauser(Env.opsMultisig()), "ops multisig should be pauser"); - assertTrue(registry.isPauser(Env.executorMultisig()), "executor multisig should be pauser"); - assertTrue(registry.unpauser() == Env.executorMultisig(), "executor multisig should be unpauser"); - - /// PermissionController has no initial storage - } - - { - /// core/ - - AllocationManager allocationManager = Env.impl.allocationManager(); - assertTrue(allocationManager.delegation() == Env.proxy.delegationManager(), "alm.dm invalid"); - assertTrue(allocationManager.pauserRegistry() == Env.impl.pauserRegistry(), "alm.pR invalid"); - assertTrue(allocationManager.permissionController() == Env.proxy.permissionController(), "alm.pc invalid"); - assertTrue(allocationManager.DEALLOCATION_DELAY() == Env.MIN_WITHDRAWAL_DELAY(), "alm.deallocDelay invalid"); - assertTrue(allocationManager.ALLOCATION_CONFIGURATION_DELAY() == Env.ALLOCATION_CONFIGURATION_DELAY(), "alm.configDelay invalid"); - - AVSDirectory avsDirectory = Env.impl.avsDirectory(); - assertTrue(avsDirectory.delegation() == Env.proxy.delegationManager(), "avsD.dm invalid"); - assertTrue(avsDirectory.pauserRegistry() == Env.impl.pauserRegistry(), "avsD.pR invalid"); - - DelegationManager delegation = Env.impl.delegationManager(); - assertTrue(delegation.strategyManager() == Env.proxy.strategyManager(), "dm.sm invalid"); - assertTrue(delegation.eigenPodManager() == Env.proxy.eigenPodManager(), "dm.epm invalid"); - assertTrue(delegation.allocationManager() == Env.proxy.allocationManager(), "dm.alm invalid"); - assertTrue(delegation.pauserRegistry() == Env.impl.pauserRegistry(), "dm.pR invalid"); - assertTrue(delegation.permissionController() == Env.proxy.permissionController(), "dm.pc invalid"); - assertTrue(delegation.minWithdrawalDelayBlocks() == Env.MIN_WITHDRAWAL_DELAY(), "dm.withdrawalDelay invalid"); - - RewardsCoordinator rewards = Env.impl.rewardsCoordinator(); - assertTrue(rewards.delegationManager() == Env.proxy.delegationManager(), "rc.dm invalid"); - assertTrue(rewards.strategyManager() == Env.proxy.strategyManager(), "rc.sm invalid"); - assertTrue(rewards.allocationManager() == Env.proxy.allocationManager(), "rc.alm invalid"); - assertTrue(rewards.pauserRegistry() == Env.impl.pauserRegistry(), "rc.pR invalid"); - assertTrue(rewards.permissionController() == Env.proxy.permissionController(), "rc.pc invalid"); - assertTrue(rewards.CALCULATION_INTERVAL_SECONDS() == Env.CALCULATION_INTERVAL_SECONDS(), "rc.calcInterval invalid"); - assertTrue(rewards.MAX_REWARDS_DURATION() == Env.MAX_REWARDS_DURATION(), "rc.rewardsDuration invalid"); - assertTrue(rewards.MAX_RETROACTIVE_LENGTH() == Env.MAX_RETROACTIVE_LENGTH(), "rc.retroLength invalid"); - assertTrue(rewards.MAX_FUTURE_LENGTH() == Env.MAX_FUTURE_LENGTH(), "rc.futureLength invalid"); - assertTrue(rewards.GENESIS_REWARDS_TIMESTAMP() == Env.GENESIS_REWARDS_TIMESTAMP(), "rc.genesis invalid"); - - StrategyManager strategyManager = Env.impl.strategyManager(); - assertTrue(strategyManager.delegation() == Env.proxy.delegationManager(), "sm.dm invalid"); - assertTrue(strategyManager.pauserRegistry() == Env.impl.pauserRegistry(), "sm.pR invalid"); - } - - { - /// pods/ - EigenPod eigenPod = Env.impl.eigenPod(); - assertTrue(eigenPod.ethPOS() == Env.ethPOS(), "ep.ethPOS invalid"); - assertTrue(eigenPod.eigenPodManager() == Env.proxy.eigenPodManager(), "ep.epm invalid"); - assertTrue(eigenPod.GENESIS_TIME() == Env.EIGENPOD_GENESIS_TIME(), "ep.genesis invalid"); - - EigenPodManager eigenPodManager = Env.impl.eigenPodManager(); - assertTrue(eigenPodManager.ethPOS() == Env.ethPOS(), "epm.ethPOS invalid"); - assertTrue(eigenPodManager.eigenPodBeacon() == Env.beacon.eigenPod(), "epm.epBeacon invalid"); - assertTrue(eigenPodManager.delegationManager() == Env.proxy.delegationManager(), "epm.dm invalid"); - assertTrue(eigenPodManager.pauserRegistry() == Env.impl.pauserRegistry(), "epm.pR invalid"); - } - - { - /// strategies/ - EigenStrategy eigenStrategy = Env.impl.eigenStrategy(); - assertTrue(eigenStrategy.strategyManager() == Env.proxy.strategyManager(), "eigStrat.sm invalid"); - assertTrue(eigenStrategy.pauserRegistry() == Env.impl.pauserRegistry(), "eigStrat.pR invalid"); - - StrategyBase strategyBase = Env.impl.strategyBase(); - assertTrue(strategyBase.strategyManager() == Env.proxy.strategyManager(), "stratBase.sm invalid"); - assertTrue(strategyBase.pauserRegistry() == Env.impl.pauserRegistry(), "stratBase.pR invalid"); - - StrategyBaseTVLLimits strategyBaseTVLLimits = Env.impl.strategyBaseTVLLimits(); - assertTrue(strategyBaseTVLLimits.strategyManager() == Env.proxy.strategyManager(), "stratBaseTVL.sm invalid"); - assertTrue(strategyBaseTVLLimits.pauserRegistry() == Env.impl.pauserRegistry(), "stratBaseTVL.pR invalid"); - - StrategyFactory strategyFactory = Env.impl.strategyFactory(); - assertTrue(strategyFactory.strategyManager() == Env.proxy.strategyManager(), "sFact.sm invalid"); - assertTrue(strategyFactory.pauserRegistry() == Env.impl.pauserRegistry(), "sFact.pR invalid"); - } - } - - /// @dev Call initialize on all deployed implementations to ensure initializers are disabled - function _validateImplsInitialized() internal { - bytes memory errInit = "Initializable: contract is already initialized"; - - /// permissions/ - // PermissionController is initializable, but does not expose the `initialize` method - - { - /// core/ - - AllocationManager allocationManager = Env.impl.allocationManager(); - vm.expectRevert(errInit); - allocationManager.initialize(address(0), 0); - - AVSDirectory avsDirectory = Env.impl.avsDirectory(); - vm.expectRevert(errInit); - avsDirectory.initialize(address(0), 0); - - DelegationManager delegation = Env.impl.delegationManager(); - vm.expectRevert(errInit); - delegation.initialize(address(0), 0); - - RewardsCoordinator rewards = Env.impl.rewardsCoordinator(); - vm.expectRevert(errInit); - rewards.initialize(address(0), 0, address(0), 0, 0); - - StrategyManager strategyManager = Env.impl.strategyManager(); - vm.expectRevert(errInit); - strategyManager.initialize(address(0), address(0), 0); - } - - { - /// pods/ - EigenPod eigenPod = Env.impl.eigenPod(); - vm.expectRevert(errInit); - eigenPod.initialize(address(0)); - - EigenPodManager eigenPodManager = Env.impl.eigenPodManager(); - vm.expectRevert(errInit); - eigenPodManager.initialize(address(0), 0); - } - - { - /// strategies/ - EigenStrategy eigenStrategy = Env.impl.eigenStrategy(); - vm.expectRevert(errInit); - eigenStrategy.initialize(IEigen(address(0)), IBackingEigen(address(0))); - - StrategyBase strategyBase = Env.impl.strategyBase(); - vm.expectRevert(errInit); - strategyBase.initialize(IERC20(address(0))); - - StrategyBaseTVLLimits strategyBaseTVLLimits = Env.impl.strategyBaseTVLLimits(); - vm.expectRevert(errInit); - strategyBaseTVLLimits.initialize(0, 0, IERC20(address(0))); - - StrategyFactory strategyFactory = Env.impl.strategyFactory(); - vm.expectRevert(errInit); - strategyFactory.initialize(address(0), 0, UpgradeableBeacon(address(0))); - } - } - - /// @dev Iterate over StrategyBaseTVLLimits instances and validate that each is - /// whitelisted for deposit - function _validateStrategiesAreWhitelisted() internal view { - uint count = Env.instance.strategyBaseTVLLimits_Count(); - for (uint i = 0; i < count; i++) { - StrategyBaseTVLLimits strategy = Env.instance.strategyBaseTVLLimits(i); - - // emit log_named_uint("strategy", i); - // IERC20Metadata underlying = IERC20Metadata(address(strategy.underlyingToken())); - // emit log_named_string("- name", underlying.name()); - // emit log_named_string("- symbol", underlying.symbol()); - // emit log_named_uint("- totalShares", strategy.totalShares()); - - bool isWhitelisted = Env.proxy.strategyManager().strategyIsWhitelistedForDeposit(strategy); - // emit log_named_string("- is whitelisted", isWhitelisted ? "true" : "false"); - assertTrue(isWhitelisted, "not whitelisted!!"); - } - } - - /// @dev Query and return `proxyAdmin.getProxyImplementation(proxy)` - function _getProxyImpl(address proxy) internal view returns (address) { - return ProxyAdmin(Env.proxyAdmin()).getProxyImplementation(ITransparentUpgradeableProxy(proxy)); - } - - /// @dev Query and return `proxyAdmin.getProxyAdmin(proxy)` - function _getProxyAdmin(address proxy) internal view returns (address) { - return ProxyAdmin(Env.proxyAdmin()).getProxyAdmin(ITransparentUpgradeableProxy(proxy)); - } - - function _assertMatch(address a, address b, string memory err) private pure { - assertEq(a, b, err); - } - - function _assertNotMatch(address a, address b, string memory err) private pure { - assertNotEq(a, b, err); - } -} diff --git a/script/releases/v1.0.2-slashing-consolidated/2-queueUpgradeAndUnpause.s.sol b/script/releases/v1.0.2-slashing-consolidated/2-queueUpgradeAndUnpause.s.sol deleted file mode 100644 index 6d8915d97d..0000000000 --- a/script/releases/v1.0.2-slashing-consolidated/2-queueUpgradeAndUnpause.s.sol +++ /dev/null @@ -1,156 +0,0 @@ -// SPDX-License-Identifier: BUSL-1.1 -pragma solidity ^0.8.12; - -import {Deploy} from "./1-deployContracts.s.sol"; -import "../Env.sol"; - -import {MultisigBuilder} from "zeus-templates/templates/MultisigBuilder.sol"; -import "zeus-templates/utils/Encode.sol"; - -import {TimelockController} from "@openzeppelin/contracts/governance/TimelockController.sol"; - -/** - * Purpose: - * * enqueue a multisig transaction which; - * - upgrades all the relevant contracts, and - * - unpauses the system. - * This should be run via the protocol council multisig. - */ -contract QueueAndUnpause is MultisigBuilder, Deploy { - using Env for *; - using Encode for *; - - function _runAsMultisig() prank(Env.opsMultisig()) internal virtual override { - bytes memory calldata_to_executor = _getCalldataToExecutor(); - - TimelockController timelock = Env.timelockController(); - timelock.schedule({ - target: Env.executorMultisig(), - value: 0, - data: calldata_to_executor, - predecessor: 0, - salt: 0, - delay: timelock.getMinDelay() - }); - } - - /// @dev Get the calldata to be sent from the timelock to the executor - function _getCalldataToExecutor() internal returns (bytes memory) { - MultisigCall[] storage executorCalls = Encode.newMultisigCalls() - /// core/ - .append({ - to: Env.proxyAdmin(), - data: Encode.proxyAdmin.upgrade({ - proxy: address(Env.proxy.avsDirectory()), - impl: address(Env.impl.avsDirectory()) - }) - }) - .append({ - to: Env.proxyAdmin(), - data: Encode.proxyAdmin.upgrade({ - proxy: address(Env.proxy.delegationManager()), - impl: address(Env.impl.delegationManager()) - }) - }) - .append({ - to: Env.proxyAdmin(), - data: Encode.proxyAdmin.upgrade({ - proxy: address(Env.proxy.rewardsCoordinator()), - impl: address(Env.impl.rewardsCoordinator()) - }) - }) - .append({ - to: Env.proxyAdmin(), - data: Encode.proxyAdmin.upgrade({ - proxy: address(Env.proxy.strategyManager()), - impl: address(Env.impl.strategyManager()) - }) - }) - /// pods/ - .append({ - to: address(Env.beacon.eigenPod()), - data: Encode.upgradeableBeacon.upgradeTo({ - newImpl: address(Env.impl.eigenPod()) - }) - }) - .append({ - to: Env.proxyAdmin(), - data: Encode.proxyAdmin.upgrade({ - proxy: address(Env.proxy.eigenPodManager()), - impl: address(Env.impl.eigenPodManager()) - }) - }) - /// strategies/ - .append({ - to: Env.proxyAdmin(), - data: Encode.proxyAdmin.upgrade({ - proxy: address(Env.proxy.eigenStrategy()), - impl: address(Env.impl.eigenStrategy()) - }) - }) - .append({ - to: address(Env.beacon.strategyBase()), - data: Encode.upgradeableBeacon.upgradeTo({ - newImpl: address(Env.impl.strategyBase()) - }) - }) - .append({ - to: Env.proxyAdmin(), - data: Encode.proxyAdmin.upgrade({ - proxy: address(Env.proxy.strategyFactory()), - impl: address(Env.impl.strategyFactory()) - }) - }); - - /// Add call to upgrade each pre-longtail strategy instance - uint count = Env.instance.strategyBaseTVLLimits_Count(); - for (uint i = 0; i < count; i++) { - address proxyInstance = address(Env.instance.strategyBaseTVLLimits(i)); - - executorCalls.append({ - to: Env.proxyAdmin(), - data: Encode.proxyAdmin.upgrade({ - proxy: proxyInstance, - impl: address(Env.impl.strategyBaseTVLLimits()) - }) - }); - } - - // /// Finally, add a call unpausing the EigenPodManager - // /// We will end up pausing it in step 3, so the unpause will - // /// go through as part of execution (step 5) - executorCalls.append({ - to: address(Env.proxy.eigenPodManager()), - data: abi.encodeCall(Pausable.unpause, 0) - }); - - return Encode.gnosisSafe.execTransaction({ - from: address(Env.timelockController()), - to: Env.multiSendCallOnly(), - op: Encode.Operation.DelegateCall, - data: Encode.multiSend(executorCalls) - }); - } - - function testScript() public virtual override { - runAsEOA(); - - TimelockController timelock = Env.timelockController(); - bytes memory calldata_to_executor = _getCalldataToExecutor(); - bytes32 txHash = timelock.hashOperation({ - target: Env.executorMultisig(), - value: 0, - data: calldata_to_executor, - predecessor: 0, - salt: 0 - }); - - // Check that the upgrade does not exist in the timelock - assertFalse(timelock.isOperationPending(txHash), "Transaction should NOT be queued."); - - execute(); - - // Check that the upgrade has been added to the timelock - assertTrue(timelock.isOperationPending(txHash), "Transaction should be queued."); - } -} diff --git a/script/releases/v1.0.2-slashing-consolidated/3-pause.s.sol b/script/releases/v1.0.2-slashing-consolidated/3-pause.s.sol deleted file mode 100644 index 030949d05d..0000000000 --- a/script/releases/v1.0.2-slashing-consolidated/3-pause.s.sol +++ /dev/null @@ -1,32 +0,0 @@ -// SPDX-License-Identifier: BUSL-1.1 -pragma solidity ^0.8.12; - -import "../Env.sol"; - -import {MultisigBuilder} from "zeus-templates/templates/MultisigBuilder.sol"; - -/** - * Purpose: Enqueue a transaction which immediately sets `EigenPodManager.PAUSED_START_CHECKPOINT=true` - */ -contract Pause is MultisigBuilder, EigenPodPausingConstants { - using Env for *; - - function _runAsMultisig() prank(Env.pauserMultisig()) internal virtual override { - uint mask = 1 << PAUSED_START_CHECKPOINT; - - Env.proxy.eigenPodManager().pause(mask); - } - - function testScript() public virtual { - execute(); - - assertTrue(Env.proxy.eigenPodManager().paused(PAUSED_START_CHECKPOINT), "Not paused!"); - - // Create a new pod and try to start a checkpoint - EigenPod pod = EigenPod(payable(Env.proxy.eigenPodManager().createPod())); - - // At this point in the upgrade process, we're not using error types yet - vm.expectRevert("EigenPod.onlyWhenNotPaused: index is paused in EigenPodManager"); - pod.startCheckpoint(false); - } -} diff --git a/script/releases/v1.0.2-slashing-consolidated/4-podCleanup.sh b/script/releases/v1.0.2-slashing-consolidated/4-podCleanup.sh deleted file mode 100644 index f467ceb02b..0000000000 --- a/script/releases/v1.0.2-slashing-consolidated/4-podCleanup.sh +++ /dev/null @@ -1 +0,0 @@ -# TODO(justin): run a binary which completes all checkpoints on the network. \ No newline at end of file diff --git a/script/releases/v1.0.2-slashing-consolidated/5-executeUpgradeAndUnpause.s.sol b/script/releases/v1.0.2-slashing-consolidated/5-executeUpgradeAndUnpause.s.sol deleted file mode 100644 index f237c41a1e..0000000000 --- a/script/releases/v1.0.2-slashing-consolidated/5-executeUpgradeAndUnpause.s.sol +++ /dev/null @@ -1,267 +0,0 @@ -// SPDX-License-Identifier: BUSL-1.1 -pragma solidity ^0.8.12; - -import "../Env.sol"; -import {QueueAndUnpause} from "./2-queueUpgradeAndUnpause.s.sol"; -import {Pause} from "./3-pause.s.sol"; - -import "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol"; -import "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol"; - -contract Execute is QueueAndUnpause, Pause { - using Env for *; - - function _runAsMultisig() prank(Env.protocolCouncilMultisig()) internal override(Pause, QueueAndUnpause) { - bytes memory calldata_to_executor = _getCalldataToExecutor(); - - TimelockController timelock = Env.timelockController(); - timelock.execute({ - target: Env.executorMultisig(), - value: 0, - payload: calldata_to_executor, - predecessor: 0, - salt: 0 - }); - } - - function testScript() public virtual override(Pause, QueueAndUnpause) { - runAsEOA(); - - TimelockController timelock = Env.timelockController(); - bytes memory calldata_to_executor = _getCalldataToExecutor(); - bytes32 txHash = timelock.hashOperation({ - target: Env.executorMultisig(), - value: 0, - data: calldata_to_executor, - predecessor: 0, - salt: 0 - }); - - assertFalse(timelock.isOperationPending(txHash), "Transaction should NOT be queued."); - - // 1- run queueing logic - QueueAndUnpause._runAsMultisig(); - _unsafeResetHasPranked(); // reset hasPranked so we can use it again - - assertTrue(timelock.isOperationPending(txHash), "Transaction should be queued."); - assertFalse(timelock.isOperationReady(txHash), "Transaction should NOT be ready for execution."); - assertFalse(timelock.isOperationDone(txHash), "Transaction should NOT be complete."); - - // 2- run pausing logic - Pause._runAsMultisig(); - _unsafeResetHasPranked(); // reset hasPranked so we can use it again - - assertTrue(Env.proxy.eigenPodManager().paused(PAUSED_START_CHECKPOINT), "EPM is not paused!"); - - // 2- warp past delay - vm.warp(block.timestamp + timelock.getMinDelay()); // 1 tick after ETA - assertEq(timelock.isOperationReady(txHash), true, "Transaction should be executable."); - - // 3- execute - execute(); - - assertTrue(timelock.isOperationDone(txHash), "Transaction should be complete."); - - _validateNewImplAddresses({ areMatching: true }); - _validateStrategiesAreWhitelisted(); - _validateProxyAdmins(); - _validateProxyConstructors(); - _validateProxiesInitialized(); - } - - function _validateNewProxyImplsMatch() internal view { - ProxyAdmin pa = ProxyAdmin(Env.proxyAdmin()); - - assertTrue( - pa.getProxyImplementation(ITransparentUpgradeableProxy(address(Env.proxy.allocationManager()))) == - address(Env.impl.allocationManager()), - "allocationManager impl failed" - ); - - assertTrue( - pa.getProxyImplementation(ITransparentUpgradeableProxy(address(Env.proxy.permissionController()))) == - address(Env.impl.permissionController()), - "permissionController impl failed" - ); - } - - /// @dev Mirrors the checks done in 1-deployContracts, but now we check each contract's - /// proxy, as the upgrade should mean that each proxy can see these methods/immutables - function _validateProxyConstructors() internal view { - { - /// permissions/ - - // exception: PauserRegistry doesn't have a proxy! - PauserRegistry registry = Env.impl.pauserRegistry(); - assertTrue(registry.isPauser(Env.pauserMultisig()), "pauser multisig should be pauser"); - assertTrue(registry.isPauser(Env.opsMultisig()), "ops multisig should be pauser"); - assertTrue(registry.isPauser(Env.executorMultisig()), "executor multisig should be pauser"); - assertTrue(registry.unpauser() == Env.executorMultisig(), "executor multisig should be unpauser"); - - /// PermissionController has no initial storage - } - - { - /// core/ - - AllocationManager allocationManager = Env.proxy.allocationManager(); - assertTrue(allocationManager.delegation() == Env.proxy.delegationManager(), "alm.dm invalid"); - assertTrue(allocationManager.pauserRegistry() == Env.impl.pauserRegistry(), "alm.pR invalid"); - assertTrue(allocationManager.permissionController() == Env.proxy.permissionController(), "alm.pc invalid"); - assertTrue(allocationManager.DEALLOCATION_DELAY() == Env.MIN_WITHDRAWAL_DELAY(), "alm.deallocDelay invalid"); - assertTrue(allocationManager.ALLOCATION_CONFIGURATION_DELAY() == Env.ALLOCATION_CONFIGURATION_DELAY(), "alm.configDelay invalid"); - - AVSDirectory avsDirectory = Env.proxy.avsDirectory(); - assertTrue(avsDirectory.delegation() == Env.proxy.delegationManager(), "avsD.dm invalid"); - assertTrue(avsDirectory.pauserRegistry() == Env.impl.pauserRegistry(), "avsD.pR invalid"); - - DelegationManager delegation = Env.proxy.delegationManager(); - assertTrue(delegation.strategyManager() == Env.proxy.strategyManager(), "dm.sm invalid"); - assertTrue(delegation.eigenPodManager() == Env.proxy.eigenPodManager(), "dm.epm invalid"); - assertTrue(delegation.allocationManager() == Env.proxy.allocationManager(), "dm.alm invalid"); - assertTrue(delegation.pauserRegistry() == Env.impl.pauserRegistry(), "dm.pR invalid"); - assertTrue(delegation.permissionController() == Env.proxy.permissionController(), "dm.pc invalid"); - assertTrue(delegation.minWithdrawalDelayBlocks() == Env.MIN_WITHDRAWAL_DELAY(), "dm.withdrawalDelay invalid"); - - RewardsCoordinator rewards = Env.proxy.rewardsCoordinator(); - assertTrue(rewards.delegationManager() == Env.proxy.delegationManager(), "rc.dm invalid"); - assertTrue(rewards.strategyManager() == Env.proxy.strategyManager(), "rc.sm invalid"); - assertTrue(rewards.allocationManager() == Env.proxy.allocationManager(), "rc.alm invalid"); - assertTrue(rewards.pauserRegistry() == Env.impl.pauserRegistry(), "rc.pR invalid"); - assertTrue(rewards.permissionController() == Env.proxy.permissionController(), "rc.pc invalid"); - assertTrue(rewards.CALCULATION_INTERVAL_SECONDS() == Env.CALCULATION_INTERVAL_SECONDS(), "rc.calcInterval invalid"); - assertTrue(rewards.MAX_REWARDS_DURATION() == Env.MAX_REWARDS_DURATION(), "rc.rewardsDuration invalid"); - assertTrue(rewards.MAX_RETROACTIVE_LENGTH() == Env.MAX_RETROACTIVE_LENGTH(), "rc.retroLength invalid"); - assertTrue(rewards.MAX_FUTURE_LENGTH() == Env.MAX_FUTURE_LENGTH(), "rc.futureLength invalid"); - assertTrue(rewards.GENESIS_REWARDS_TIMESTAMP() == Env.GENESIS_REWARDS_TIMESTAMP(), "rc.genesis invalid"); - - StrategyManager strategyManager = Env.proxy.strategyManager(); - assertTrue(strategyManager.delegation() == Env.proxy.delegationManager(), "sm.dm invalid"); - assertTrue(strategyManager.pauserRegistry() == Env.impl.pauserRegistry(), "sm.pR invalid"); - } - - { - /// pods/ - UpgradeableBeacon eigenPodBeacon = Env.beacon.eigenPod(); - assertTrue(eigenPodBeacon.implementation() == address(Env.impl.eigenPod()), "eigenPodBeacon.impl invalid"); - - EigenPodManager eigenPodManager = Env.proxy.eigenPodManager(); - assertTrue(eigenPodManager.ethPOS() == Env.ethPOS(), "epm.ethPOS invalid"); - assertTrue(eigenPodManager.eigenPodBeacon() == Env.beacon.eigenPod(), "epm.epBeacon invalid"); - assertTrue(eigenPodManager.delegationManager() == Env.proxy.delegationManager(), "epm.dm invalid"); - assertTrue(eigenPodManager.pauserRegistry() == Env.impl.pauserRegistry(), "epm.pR invalid"); - } - - { - /// strategies/ - EigenStrategy eigenStrategy = Env.proxy.eigenStrategy(); - assertTrue(eigenStrategy.strategyManager() == Env.proxy.strategyManager(), "eigStrat.sm invalid"); - assertTrue(eigenStrategy.pauserRegistry() == Env.impl.pauserRegistry(), "eigStrat.pR invalid"); - - UpgradeableBeacon strategyBeacon = Env.beacon.strategyBase(); - assertTrue(strategyBeacon.implementation() == address(Env.impl.strategyBase()), "strategyBeacon.impl invalid"); - - uint count = Env.instance.strategyBaseTVLLimits_Count(); - for (uint i = 0; i < count; i++) { - StrategyBaseTVLLimits strategy = Env.instance.strategyBaseTVLLimits(i); - - assertTrue(strategy.strategyManager() == Env.proxy.strategyManager(), "sFact.sm invalid"); - assertTrue(strategy.pauserRegistry() == Env.impl.pauserRegistry(), "sFact.pR invalid"); - } - - StrategyFactory strategyFactory = Env.proxy.strategyFactory(); - assertTrue(strategyFactory.strategyManager() == Env.proxy.strategyManager(), "sFact.sm invalid"); - assertTrue(strategyFactory.pauserRegistry() == Env.impl.pauserRegistry(), "sFact.pR invalid"); - } - } - - /// @dev Call initialize on all proxies to ensure they are initialized - /// Additionally, validate initialization variables - function _validateProxiesInitialized() internal { - bytes memory errInit = "Initializable: contract is already initialized"; - - /// permissions/ - // PermissionController is initializable, but does not expose the `initialize` method - - { - /// core/ - - AllocationManager allocationManager = Env.proxy.allocationManager(); - vm.expectRevert(errInit); - allocationManager.initialize(address(0), 0); - assertTrue(allocationManager.owner() == Env.executorMultisig(), "alm.owner invalid"); - assertTrue(allocationManager.paused() == 0, "alm.paused invalid"); - - AVSDirectory avsDirectory = Env.proxy.avsDirectory(); - vm.expectRevert(errInit); - avsDirectory.initialize(address(0), 0); - assertTrue(avsDirectory.owner() == Env.executorMultisig(), "avsD.owner invalid"); - assertTrue(avsDirectory.paused() == 0, "avsD.paused invalid"); - - DelegationManager delegation = Env.proxy.delegationManager(); - vm.expectRevert(errInit); - delegation.initialize(address(0), 0); - assertTrue(delegation.owner() == Env.executorMultisig(), "dm.owner invalid"); - assertTrue(delegation.paused() == 0, "dm.paused invalid"); - - RewardsCoordinator rewards = Env.proxy.rewardsCoordinator(); - vm.expectRevert(errInit); - rewards.initialize(address(0), 0, address(0), 0, 0); - assertTrue(rewards.owner() == Env.opsMultisig(), "rc.owner invalid"); - assertTrue(rewards.paused() == Env.REWARDS_PAUSE_STATUS(), "rc.paused invalid"); - assertTrue(rewards.rewardsUpdater() == Env.REWARDS_UPDATER(), "rc.updater invalid"); - assertTrue(rewards.activationDelay() == Env.ACTIVATION_DELAY(), "rc.activationDelay invalid"); - assertTrue(rewards.defaultOperatorSplitBips() == Env.DEFAULT_SPLIT_BIPS(), "rc.splitBips invalid"); - - StrategyManager strategyManager = Env.proxy.strategyManager(); - vm.expectRevert(errInit); - strategyManager.initialize(address(0), address(0), 0); - assertTrue(strategyManager.owner() == Env.executorMultisig(), "sm.owner invalid"); - assertTrue(strategyManager.paused() == 0, "sm.paused invalid"); - assertTrue(strategyManager.strategyWhitelister() == address(Env.proxy.strategyFactory()), "sm.whitelister invalid"); - } - - { - /// pods/ - // EigenPod proxies are initialized by individual users - - EigenPodManager eigenPodManager = Env.proxy.eigenPodManager(); - vm.expectRevert(errInit); - eigenPodManager.initialize(address(0), 0); - assertTrue(eigenPodManager.owner() == Env.executorMultisig(), "epm.owner invalid"); - assertTrue(eigenPodManager.paused() == 0, "epm.paused invalid"); - } - - { - /// strategies/ - - EigenStrategy eigenStrategy = Env.proxy.eigenStrategy(); - vm.expectRevert(errInit); - eigenStrategy.initialize(IEigen(address(0)), IBackingEigen(address(0))); - assertTrue(eigenStrategy.paused() == 0, "eigenStrat.paused invalid"); - assertTrue(eigenStrategy.EIGEN() == Env.proxy.eigen(), "eigenStrat.EIGEN invalid"); - assertTrue(eigenStrategy.underlyingToken() == Env.proxy.beigen(), "eigenStrat.underlying invalid"); - - // StrategyBase proxies are initialized when deployed by factory - - uint count = Env.instance.strategyBaseTVLLimits_Count(); - for (uint i = 0; i < count; i++) { - StrategyBaseTVLLimits strategy = Env.instance.strategyBaseTVLLimits(i); - - emit log_named_address("strat", address(strategy)); - - vm.expectRevert(errInit); - strategy.initialize(0, 0, IERC20(address(0))); - assertTrue(strategy.maxPerDeposit() == type(uint).max, "stratTVLLim.maxPerDeposit invalid"); - assertTrue(strategy.maxTotalDeposits() == type(uint).max, "stratTVLLim.maxPerDeposit invalid"); - } - - StrategyFactory strategyFactory = Env.proxy.strategyFactory(); - vm.expectRevert(errInit); - strategyFactory.initialize(address(0), 0, UpgradeableBeacon(address(0))); - assertTrue(strategyFactory.owner() == Env.opsMultisig(), "sFact.owner invalid"); - assertTrue(strategyFactory.paused() == 0, "sFact.paused invalid"); - assertTrue(strategyFactory.strategyBeacon() == Env.beacon.strategyBase(), "sFact.beacon invalid"); - } - } -} diff --git a/script/releases/v1.0.2-slashing-consolidated/cleanup/EigenPod.abi.json b/script/releases/v1.0.2-slashing-consolidated/cleanup/EigenPod.abi.json deleted file mode 100644 index eea17671d4..0000000000 --- a/script/releases/v1.0.2-slashing-consolidated/cleanup/EigenPod.abi.json +++ /dev/null @@ -1 +0,0 @@ -[{"type":"constructor","inputs":[{"name":"_ethPOS","type":"address","internalType":"contract IETHPOSDeposit"},{"name":"_eigenPodManager","type":"address","internalType":"contract IEigenPodManager"},{"name":"_GENESIS_TIME","type":"uint64","internalType":"uint64"}],"stateMutability":"nonpayable"},{"type":"receive","stateMutability":"payable"},{"type":"function","name":"GENESIS_TIME","inputs":[],"outputs":[{"name":"","type":"uint64","internalType":"uint64"}],"stateMutability":"view"},{"type":"function","name":"activeValidatorCount","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"checkpointBalanceExitedGwei","inputs":[{"name":"","type":"uint64","internalType":"uint64"}],"outputs":[{"name":"","type":"uint64","internalType":"uint64"}],"stateMutability":"view"},{"type":"function","name":"currentCheckpoint","inputs":[],"outputs":[{"name":"","type":"tuple","internalType":"struct IEigenPodTypes.Checkpoint","components":[{"name":"beaconBlockRoot","type":"bytes32","internalType":"bytes32"},{"name":"proofsRemaining","type":"uint24","internalType":"uint24"},{"name":"podBalanceGwei","type":"uint64","internalType":"uint64"},{"name":"balanceDeltasGwei","type":"int64","internalType":"int64"},{"name":"prevBeaconBalanceGwei","type":"uint64","internalType":"uint64"}]}],"stateMutability":"view"},{"type":"function","name":"currentCheckpointTimestamp","inputs":[],"outputs":[{"name":"","type":"uint64","internalType":"uint64"}],"stateMutability":"view"},{"type":"function","name":"eigenPodManager","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IEigenPodManager"}],"stateMutability":"view"},{"type":"function","name":"ethPOS","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IETHPOSDeposit"}],"stateMutability":"view"},{"type":"function","name":"getParentBlockRoot","inputs":[{"name":"timestamp","type":"uint64","internalType":"uint64"}],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"type":"function","name":"initialize","inputs":[{"name":"_podOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"lastCheckpointTimestamp","inputs":[],"outputs":[{"name":"","type":"uint64","internalType":"uint64"}],"stateMutability":"view"},{"type":"function","name":"podOwner","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"proofSubmitter","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"recoverTokens","inputs":[{"name":"tokenList","type":"address[]","internalType":"contract IERC20[]"},{"name":"amountsToWithdraw","type":"uint256[]","internalType":"uint256[]"},{"name":"recipient","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"setProofSubmitter","inputs":[{"name":"newProofSubmitter","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"stake","inputs":[{"name":"pubkey","type":"bytes","internalType":"bytes"},{"name":"signature","type":"bytes","internalType":"bytes"},{"name":"depositDataRoot","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"payable"},{"type":"function","name":"startCheckpoint","inputs":[{"name":"revertIfNoBalance","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"validatorPubkeyHashToInfo","inputs":[{"name":"validatorPubkeyHash","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"tuple","internalType":"struct IEigenPodTypes.ValidatorInfo","components":[{"name":"validatorIndex","type":"uint64","internalType":"uint64"},{"name":"restakedBalanceGwei","type":"uint64","internalType":"uint64"},{"name":"lastCheckpointedAt","type":"uint64","internalType":"uint64"},{"name":"status","type":"uint8","internalType":"enum IEigenPodTypes.VALIDATOR_STATUS"}]}],"stateMutability":"view"},{"type":"function","name":"validatorPubkeyToInfo","inputs":[{"name":"validatorPubkey","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"","type":"tuple","internalType":"struct IEigenPodTypes.ValidatorInfo","components":[{"name":"validatorIndex","type":"uint64","internalType":"uint64"},{"name":"restakedBalanceGwei","type":"uint64","internalType":"uint64"},{"name":"lastCheckpointedAt","type":"uint64","internalType":"uint64"},{"name":"status","type":"uint8","internalType":"enum IEigenPodTypes.VALIDATOR_STATUS"}]}],"stateMutability":"view"},{"type":"function","name":"validatorStatus","inputs":[{"name":"validatorPubkey","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"","type":"uint8","internalType":"enum IEigenPodTypes.VALIDATOR_STATUS"}],"stateMutability":"view"},{"type":"function","name":"validatorStatus","inputs":[{"name":"pubkeyHash","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"uint8","internalType":"enum IEigenPodTypes.VALIDATOR_STATUS"}],"stateMutability":"view"},{"type":"function","name":"verifyCheckpointProofs","inputs":[{"name":"balanceContainerProof","type":"tuple","internalType":"struct BeaconChainProofs.BalanceContainerProof","components":[{"name":"balanceContainerRoot","type":"bytes32","internalType":"bytes32"},{"name":"proof","type":"bytes","internalType":"bytes"}]},{"name":"proofs","type":"tuple[]","internalType":"struct BeaconChainProofs.BalanceProof[]","components":[{"name":"pubkeyHash","type":"bytes32","internalType":"bytes32"},{"name":"balanceRoot","type":"bytes32","internalType":"bytes32"},{"name":"proof","type":"bytes","internalType":"bytes"}]}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"verifyStaleBalance","inputs":[{"name":"beaconTimestamp","type":"uint64","internalType":"uint64"},{"name":"stateRootProof","type":"tuple","internalType":"struct BeaconChainProofs.StateRootProof","components":[{"name":"beaconStateRoot","type":"bytes32","internalType":"bytes32"},{"name":"proof","type":"bytes","internalType":"bytes"}]},{"name":"proof","type":"tuple","internalType":"struct BeaconChainProofs.ValidatorProof","components":[{"name":"validatorFields","type":"bytes32[]","internalType":"bytes32[]"},{"name":"proof","type":"bytes","internalType":"bytes"}]}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"verifyWithdrawalCredentials","inputs":[{"name":"beaconTimestamp","type":"uint64","internalType":"uint64"},{"name":"stateRootProof","type":"tuple","internalType":"struct BeaconChainProofs.StateRootProof","components":[{"name":"beaconStateRoot","type":"bytes32","internalType":"bytes32"},{"name":"proof","type":"bytes","internalType":"bytes"}]},{"name":"validatorIndices","type":"uint40[]","internalType":"uint40[]"},{"name":"validatorFieldsProofs","type":"bytes[]","internalType":"bytes[]"},{"name":"validatorFields","type":"bytes32[][]","internalType":"bytes32[][]"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"withdrawRestakedBeaconChainETH","inputs":[{"name":"recipient","type":"address","internalType":"address"},{"name":"amountWei","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"withdrawableRestakedExecutionLayerGwei","inputs":[],"outputs":[{"name":"","type":"uint64","internalType":"uint64"}],"stateMutability":"view"},{"type":"event","name":"CheckpointCreated","inputs":[{"name":"checkpointTimestamp","type":"uint64","indexed":true,"internalType":"uint64"},{"name":"beaconBlockRoot","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"validatorCount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"type":"event","name":"CheckpointFinalized","inputs":[{"name":"checkpointTimestamp","type":"uint64","indexed":true,"internalType":"uint64"},{"name":"totalShareDeltaWei","type":"int256","indexed":false,"internalType":"int256"}],"anonymous":false},{"type":"event","name":"EigenPodStaked","inputs":[{"name":"pubkey","type":"bytes","indexed":false,"internalType":"bytes"}],"anonymous":false},{"type":"event","name":"Initialized","inputs":[{"name":"version","type":"uint8","indexed":false,"internalType":"uint8"}],"anonymous":false},{"type":"event","name":"NonBeaconChainETHReceived","inputs":[{"name":"amountReceived","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"type":"event","name":"ProofSubmitterUpdated","inputs":[{"name":"prevProofSubmitter","type":"address","indexed":false,"internalType":"address"},{"name":"newProofSubmitter","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"type":"event","name":"RestakedBeaconChainETHWithdrawn","inputs":[{"name":"recipient","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"type":"event","name":"ValidatorBalanceUpdated","inputs":[{"name":"validatorIndex","type":"uint40","indexed":false,"internalType":"uint40"},{"name":"balanceTimestamp","type":"uint64","indexed":false,"internalType":"uint64"},{"name":"newValidatorBalanceGwei","type":"uint64","indexed":false,"internalType":"uint64"}],"anonymous":false},{"type":"event","name":"ValidatorCheckpointed","inputs":[{"name":"checkpointTimestamp","type":"uint64","indexed":true,"internalType":"uint64"},{"name":"validatorIndex","type":"uint40","indexed":true,"internalType":"uint40"}],"anonymous":false},{"type":"event","name":"ValidatorRestaked","inputs":[{"name":"validatorIndex","type":"uint40","indexed":false,"internalType":"uint40"}],"anonymous":false},{"type":"event","name":"ValidatorWithdrawn","inputs":[{"name":"checkpointTimestamp","type":"uint64","indexed":true,"internalType":"uint64"},{"name":"validatorIndex","type":"uint40","indexed":true,"internalType":"uint40"}],"anonymous":false},{"type":"error","name":"AmountMustBeMultipleOfGwei","inputs":[]},{"type":"error","name":"BeaconTimestampTooFarInPast","inputs":[]},{"type":"error","name":"CannotCheckpointTwiceInSingleBlock","inputs":[]},{"type":"error","name":"CheckpointAlreadyActive","inputs":[]},{"type":"error","name":"CredentialsAlreadyVerified","inputs":[]},{"type":"error","name":"CurrentlyPaused","inputs":[]},{"type":"error","name":"InputAddressZero","inputs":[]},{"type":"error","name":"InputArrayLengthMismatch","inputs":[]},{"type":"error","name":"InsufficientWithdrawableBalance","inputs":[]},{"type":"error","name":"InvalidEIP4788Response","inputs":[]},{"type":"error","name":"InvalidProof","inputs":[]},{"type":"error","name":"InvalidProofLength","inputs":[]},{"type":"error","name":"InvalidProofLength","inputs":[]},{"type":"error","name":"InvalidPubKeyLength","inputs":[]},{"type":"error","name":"InvalidValidatorFieldsLength","inputs":[]},{"type":"error","name":"MsgValueNot32ETH","inputs":[]},{"type":"error","name":"NoActiveCheckpoint","inputs":[]},{"type":"error","name":"NoBalanceToCheckpoint","inputs":[]},{"type":"error","name":"OnlyEigenPodManager","inputs":[]},{"type":"error","name":"OnlyEigenPodOwner","inputs":[]},{"type":"error","name":"OnlyEigenPodOwnerOrProofSubmitter","inputs":[]},{"type":"error","name":"TimestampOutOfRange","inputs":[]},{"type":"error","name":"ValidatorInactiveOnBeaconChain","inputs":[]},{"type":"error","name":"ValidatorIsExitingBeaconChain","inputs":[]},{"type":"error","name":"ValidatorNotActiveInPod","inputs":[]},{"type":"error","name":"ValidatorNotSlashedOnBeaconChain","inputs":[]},{"type":"error","name":"WithdrawalCredentialsNotForEigenPod","inputs":[]}] \ No newline at end of file diff --git a/script/releases/v1.0.2-slashing-consolidated/cleanup/EigenPodManager.abi.json b/script/releases/v1.0.2-slashing-consolidated/cleanup/EigenPodManager.abi.json deleted file mode 100644 index eca82221bb..0000000000 --- a/script/releases/v1.0.2-slashing-consolidated/cleanup/EigenPodManager.abi.json +++ /dev/null @@ -1 +0,0 @@ -[{"type":"constructor","inputs":[{"name":"_ethPOS","type":"address","internalType":"contract IETHPOSDeposit"},{"name":"_eigenPodBeacon","type":"address","internalType":"contract IBeacon"},{"name":"_strategyManager","type":"address","internalType":"contract IStrategyManager"},{"name":"_delegationManager","type":"address","internalType":"contract IDelegationManager"},{"name":"_pauserRegistry","type":"address","internalType":"contract IPauserRegistry"}],"stateMutability":"nonpayable"},{"type":"function","name":"addShares","inputs":[{"name":"staker","type":"address","internalType":"address"},{"name":"strategy","type":"address","internalType":"contract IStrategy"},{"name":"","type":"address","internalType":"contract IERC20"},{"name":"shares","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"},{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"nonpayable"},{"type":"function","name":"beaconChainETHStrategy","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IStrategy"}],"stateMutability":"view"},{"type":"function","name":"beaconChainSlashingFactor","inputs":[{"name":"podOwner","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint64","internalType":"uint64"}],"stateMutability":"view"},{"type":"function","name":"createPod","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"type":"function","name":"delegationManager","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IDelegationManager"}],"stateMutability":"view"},{"type":"function","name":"eigenPodBeacon","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IBeacon"}],"stateMutability":"view"},{"type":"function","name":"ethPOS","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IETHPOSDeposit"}],"stateMutability":"view"},{"type":"function","name":"getPod","inputs":[{"name":"podOwner","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"address","internalType":"contract IEigenPod"}],"stateMutability":"view"},{"type":"function","name":"hasPod","inputs":[{"name":"podOwner","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"type":"function","name":"initialize","inputs":[{"name":"initialOwner","type":"address","internalType":"address"},{"name":"_initPausedStatus","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"numPods","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"owner","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"ownerToPod","inputs":[{"name":"podOwner","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"address","internalType":"contract IEigenPod"}],"stateMutability":"view"},{"type":"function","name":"pause","inputs":[{"name":"newPausedStatus","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"pauseAll","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"paused","inputs":[{"name":"index","type":"uint8","internalType":"uint8"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"type":"function","name":"paused","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"pauserRegistry","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IPauserRegistry"}],"stateMutability":"view"},{"type":"function","name":"podOwnerDepositShares","inputs":[{"name":"podOwner","type":"address","internalType":"address"}],"outputs":[{"name":"shares","type":"int256","internalType":"int256"}],"stateMutability":"view"},{"type":"function","name":"recordBeaconChainETHBalanceUpdate","inputs":[{"name":"podOwner","type":"address","internalType":"address"},{"name":"prevRestakedBalanceWei","type":"uint256","internalType":"uint256"},{"name":"balanceDeltaWei","type":"int256","internalType":"int256"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"removeDepositShares","inputs":[{"name":"staker","type":"address","internalType":"address"},{"name":"strategy","type":"address","internalType":"contract IStrategy"},{"name":"depositSharesToRemove","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"renounceOwnership","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"stake","inputs":[{"name":"pubkey","type":"bytes","internalType":"bytes"},{"name":"signature","type":"bytes","internalType":"bytes"},{"name":"depositDataRoot","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"payable"},{"type":"function","name":"stakerDepositShares","inputs":[{"name":"user","type":"address","internalType":"address"},{"name":"strategy","type":"address","internalType":"contract IStrategy"}],"outputs":[{"name":"depositShares","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"strategyManager","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IStrategyManager"}],"stateMutability":"view"},{"type":"function","name":"transferOwnership","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"unpause","inputs":[{"name":"newPausedStatus","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"withdrawSharesAsTokens","inputs":[{"name":"staker","type":"address","internalType":"address"},{"name":"strategy","type":"address","internalType":"contract IStrategy"},{"name":"","type":"address","internalType":"contract IERC20"},{"name":"shares","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"event","name":"BeaconChainETHDeposited","inputs":[{"name":"podOwner","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"type":"event","name":"BeaconChainETHWithdrawalCompleted","inputs":[{"name":"podOwner","type":"address","indexed":true,"internalType":"address"},{"name":"shares","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"nonce","type":"uint96","indexed":false,"internalType":"uint96"},{"name":"delegatedAddress","type":"address","indexed":false,"internalType":"address"},{"name":"withdrawer","type":"address","indexed":false,"internalType":"address"},{"name":"withdrawalRoot","type":"bytes32","indexed":false,"internalType":"bytes32"}],"anonymous":false},{"type":"event","name":"BeaconChainSlashingFactorDecreased","inputs":[{"name":"staker","type":"address","indexed":false,"internalType":"address"},{"name":"wadSlashed","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"newBeaconChainSlashingFactor","type":"uint64","indexed":false,"internalType":"uint64"}],"anonymous":false},{"type":"event","name":"Initialized","inputs":[{"name":"version","type":"uint8","indexed":false,"internalType":"uint8"}],"anonymous":false},{"type":"event","name":"NewTotalShares","inputs":[{"name":"podOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newTotalShares","type":"int256","indexed":false,"internalType":"int256"}],"anonymous":false},{"type":"event","name":"OwnershipTransferred","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"type":"event","name":"Paused","inputs":[{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"newPausedStatus","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"type":"event","name":"PodDeployed","inputs":[{"name":"eigenPod","type":"address","indexed":true,"internalType":"address"},{"name":"podOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"type":"event","name":"PodSharesUpdated","inputs":[{"name":"podOwner","type":"address","indexed":true,"internalType":"address"},{"name":"sharesDelta","type":"int256","indexed":false,"internalType":"int256"}],"anonymous":false},{"type":"event","name":"Unpaused","inputs":[{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"newPausedStatus","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"type":"error","name":"CurrentlyPaused","inputs":[]},{"type":"error","name":"EigenPodAlreadyExists","inputs":[]},{"type":"error","name":"InputAddressZero","inputs":[]},{"type":"error","name":"InvalidNewPausedStatus","inputs":[]},{"type":"error","name":"InvalidStrategy","inputs":[]},{"type":"error","name":"LegacyWithdrawalsNotCompleted","inputs":[]},{"type":"error","name":"OnlyDelegationManager","inputs":[]},{"type":"error","name":"OnlyEigenPod","inputs":[]},{"type":"error","name":"OnlyPauser","inputs":[]},{"type":"error","name":"OnlyUnpauser","inputs":[]},{"type":"error","name":"SharesNegative","inputs":[]},{"type":"error","name":"SharesNotMultipleOfGwei","inputs":[]}] \ No newline at end of file diff --git a/script/releases/v1.0.2-slashing-consolidated/cleanup/go.mod b/script/releases/v1.0.2-slashing-consolidated/cleanup/go.mod deleted file mode 100644 index 54879f94b6..0000000000 --- a/script/releases/v1.0.2-slashing-consolidated/cleanup/go.mod +++ /dev/null @@ -1,74 +0,0 @@ -module main - -go 1.22.4 - -require ( - github.com/Layr-Labs/eigenpod-proofs-generation v0.1.0-pepe-testnet.0.20240925202841-f6492b1cc9fc - github.com/attestantio/go-eth2-client v0.21.11 - github.com/ethereum/go-ethereum v1.14.9 - github.com/jbrower95/multicall-go v0.0.0-20241012224745-7e9c19976cb5 - github.com/samber/lo v1.47.0 -) - -require ( - github.com/Microsoft/go-winio v0.6.2 // indirect - github.com/StackExchange/wmi v1.2.1 // indirect - github.com/beorn7/perks v1.0.1 // indirect - github.com/bits-and-blooms/bitset v1.13.0 // indirect - github.com/btcsuite/btcd/btcec/v2 v2.3.4 // indirect - github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/consensys/bavard v0.1.13 // indirect - github.com/consensys/gnark-crypto v0.12.1 // indirect - github.com/crate-crypto/go-ipa v0.0.0-20240223125850-b1e8a79f509c // indirect - github.com/crate-crypto/go-kzg-4844 v1.0.0 // indirect - github.com/deckarep/golang-set/v2 v2.6.0 // indirect - github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 // indirect - github.com/ethereum/c-kzg-4844 v1.0.0 // indirect - github.com/ethereum/go-verkle v0.1.1-0.20240829091221-dffa7562dbe9 // indirect - github.com/fatih/color v1.16.0 // indirect - github.com/ferranbt/fastssz v0.1.3 // indirect - github.com/fsnotify/fsnotify v1.6.0 // indirect - github.com/go-logr/logr v1.2.4 // indirect - github.com/go-logr/stdr v1.2.2 // indirect - github.com/go-ole/go-ole v1.3.0 // indirect - github.com/goccy/go-yaml v1.9.2 // indirect - github.com/google/uuid v1.6.0 // indirect - github.com/gorilla/websocket v1.4.2 // indirect - github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect - github.com/holiman/uint256 v1.3.1 // indirect - github.com/huandu/go-clone v1.6.0 // indirect - github.com/klauspost/cpuid/v2 v2.2.7 // indirect - github.com/mattn/go-colorable v0.1.13 // indirect - github.com/mattn/go-isatty v0.0.20 // indirect - github.com/minio/sha256-simd v1.0.1 // indirect - github.com/mitchellh/mapstructure v1.5.0 // indirect - github.com/mmcloughlin/addchain v0.4.0 // indirect - github.com/pk910/dynamic-ssz v0.0.3 // indirect - github.com/pkg/errors v0.9.1 // indirect - github.com/prometheus/client_golang v1.19.0 // indirect - github.com/prometheus/client_model v0.5.0 // indirect - github.com/prometheus/common v0.48.0 // indirect - github.com/prometheus/procfs v0.12.0 // indirect - github.com/prysmaticlabs/go-bitfield v0.0.0-20240328144219-a1caa50c3a1e // indirect - github.com/r3labs/sse/v2 v2.10.0 // indirect - github.com/rs/zerolog v1.32.0 // indirect - github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible // indirect - github.com/supranational/blst v0.3.11 // indirect - github.com/tklauser/go-sysconf v0.3.12 // indirect - github.com/tklauser/numcpus v0.6.1 // indirect - go.opentelemetry.io/otel v1.16.0 // indirect - go.opentelemetry.io/otel/metric v1.16.0 // indirect - go.opentelemetry.io/otel/trace v1.16.0 // indirect - golang.org/x/crypto v0.23.0 // indirect - golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa // indirect - golang.org/x/net v0.24.0 // indirect - golang.org/x/sync v0.7.0 // indirect - golang.org/x/sys v0.22.0 // indirect - golang.org/x/text v0.16.0 // indirect - golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 // indirect - google.golang.org/protobuf v1.34.2 // indirect - gopkg.in/Knetic/govaluate.v3 v3.0.0 // indirect - gopkg.in/cenkalti/backoff.v1 v1.1.0 // indirect - gopkg.in/yaml.v2 v2.4.0 // indirect - rsc.io/tmplfunc v0.0.3 // indirect -) diff --git a/script/releases/v1.0.2-slashing-consolidated/cleanup/go.sum b/script/releases/v1.0.2-slashing-consolidated/cleanup/go.sum deleted file mode 100644 index f100d52de7..0000000000 --- a/script/releases/v1.0.2-slashing-consolidated/cleanup/go.sum +++ /dev/null @@ -1,283 +0,0 @@ -github.com/DataDog/zstd v1.4.5 h1:EndNeuB0l9syBZhut0wns3gV1hL8zX8LIu6ZiVHWLIQ= -github.com/DataDog/zstd v1.4.5/go.mod h1:1jcaCB/ufaK+sKp1NBhlGmpz41jOoPQ35bpF36t7BBo= -github.com/Layr-Labs/eigenpod-proofs-generation v0.1.0-pepe-testnet.0.20240925202841-f6492b1cc9fc h1:xOvrJ2NHD7ykcikuqqvUVXZR6PNUomd05eO/vYQ2+g8= -github.com/Layr-Labs/eigenpod-proofs-generation v0.1.0-pepe-testnet.0.20240925202841-f6492b1cc9fc/go.mod h1:T7tYN8bTdca2pkMnz9G2+ZwXYWw5gWqQUIu4KLgC/vM= -github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= -github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= -github.com/StackExchange/wmi v1.2.1 h1:VIkavFPXSjcnS+O8yTq7NI32k0R5Aj+v39y29VYDOSA= -github.com/StackExchange/wmi v1.2.1/go.mod h1:rcmrprowKIVzvc+NUiLncP2uuArMWLCbu9SBzvHz7e8= -github.com/VictoriaMetrics/fastcache v1.12.2 h1:N0y9ASrJ0F6h0QaC3o6uJb3NIZ9VKLjCM7NQbSmF7WI= -github.com/VictoriaMetrics/fastcache v1.12.2/go.mod h1:AmC+Nzz1+3G2eCPapF6UcsnkThDcMsQicp4xDukwJYI= -github.com/attestantio/go-eth2-client v0.21.11 h1:0ZYP69O8rJz41055WOf3n1C1NA4jNh2iME/NuTVfgmQ= -github.com/attestantio/go-eth2-client v0.21.11/go.mod h1:d7ZPNrMX8jLfIgML5u7QZxFo2AukLM+5m08iMaLdqb8= -github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= -github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= -github.com/bits-and-blooms/bitset v1.13.0 h1:bAQ9OPNFYbGHV6Nez0tmNI0RiEu7/hxlYJRUA0wFAVE= -github.com/bits-and-blooms/bitset v1.13.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= -github.com/btcsuite/btcd/btcec/v2 v2.3.4 h1:3EJjcN70HCu/mwqlUsGK8GcNVyLVxFDlWurTXGPFfiQ= -github.com/btcsuite/btcd/btcec/v2 v2.3.4/go.mod h1:zYzJ8etWJQIv1Ogk7OzpWjowwOdXY1W/17j2MW85J04= -github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1 h1:q0rUy8C/TYNBQS1+CGKw68tLOFYSNEs0TFnxxnS9+4U= -github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc= -github.com/cespare/cp v0.1.0 h1:SE+dxFebS7Iik5LK0tsi1k9ZCxEaFX4AjQmoyA+1dJk= -github.com/cespare/cp v0.1.0/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s= -github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= -github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/cockroachdb/errors v1.11.3 h1:5bA+k2Y6r+oz/6Z/RFlNeVCesGARKuC6YymtcDrbC/I= -github.com/cockroachdb/errors v1.11.3/go.mod h1:m4UIW4CDjx+R5cybPsNrRbreomiFqt8o1h1wUVazSd8= -github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce h1:giXvy4KSc/6g/esnpM7Geqxka4WSqI1SZc7sMJFd3y4= -github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce/go.mod h1:9/y3cnZ5GKakj/H4y9r9GTjCvAFta7KLgSHPJJYc52M= -github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b h1:r6VH0faHjZeQy818SGhaone5OnYfxFR/+AzdY3sf5aE= -github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b/go.mod h1:Vz9DsVWQQhf3vs21MhPMZpMGSht7O/2vFW2xusFUVOs= -github.com/cockroachdb/pebble v1.1.2 h1:CUh2IPtR4swHlEj48Rhfzw6l/d0qA31fItcIszQVIsA= -github.com/cockroachdb/pebble v1.1.2/go.mod h1:4exszw1r40423ZsmkG/09AFEG83I0uDgfujJdbL6kYU= -github.com/cockroachdb/redact v1.1.5 h1:u1PMllDkdFfPWaNGMyLD1+so+aq3uUItthCFqzwPJ30= -github.com/cockroachdb/redact v1.1.5/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg= -github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 h1:zuQyyAKVxetITBuuhv3BI9cMrmStnpT18zmgmTxunpo= -github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ= -github.com/consensys/bavard v0.1.13 h1:oLhMLOFGTLdlda/kma4VOJazblc7IM5y5QPd2A/YjhQ= -github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI= -github.com/consensys/gnark-crypto v0.12.1 h1:lHH39WuuFgVHONRl3J0LRBtuYdQTumFSDtJF7HpyG8M= -github.com/consensys/gnark-crypto v0.12.1/go.mod h1:v2Gy7L/4ZRosZ7Ivs+9SfUDr0f5UlG+EM5t7MPHiLuY= -github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= -github.com/cpuguy83/go-md2man/v2 v2.0.2 h1:p1EgwI/C7NhT0JmVkwCD2ZBK8j4aeHQX2pMHHBfMQ6w= -github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= -github.com/crate-crypto/go-ipa v0.0.0-20240223125850-b1e8a79f509c h1:uQYC5Z1mdLRPrZhHjHxufI8+2UG/i25QG92j0Er9p6I= -github.com/crate-crypto/go-ipa v0.0.0-20240223125850-b1e8a79f509c/go.mod h1:geZJZH3SzKCqnz5VT0q/DyIG/tvu/dZk+VIfXicupJs= -github.com/crate-crypto/go-kzg-4844 v1.0.0 h1:TsSgHwrkTKecKJ4kadtHi4b3xHW5dCFUDFnUp1TsawI= -github.com/crate-crypto/go-kzg-4844 v1.0.0/go.mod h1:1kMhvPgI0Ky3yIa+9lFySEBUBXkYxeOi8ZF1sYioxhc= -github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= -github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/deckarep/golang-set/v2 v2.6.0 h1:XfcQbWM1LlMB8BsJ8N9vW5ehnnPVIw0je80NsVHagjM= -github.com/deckarep/golang-set/v2 v2.6.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4= -github.com/decred/dcrd/crypto/blake256 v1.0.0 h1:/8DMNYp9SGi5f0w7uCm6d6M4OU2rGFK09Y2A4Xv7EE0= -github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc= -github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 h1:YLtO71vCjJRCBcrPMtQ9nqBsqpA1m5sE92cU+pd5Mcc= -github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1/go.mod h1:hyedUtir6IdtD/7lIxGeCxkaw7y45JueMRL4DIyJDKs= -github.com/ethereum/c-kzg-4844 v1.0.0 h1:0X1LBXxaEtYD9xsyj9B9ctQEZIpnvVDeoBx8aHEwTNA= -github.com/ethereum/c-kzg-4844 v1.0.0/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0= -github.com/ethereum/go-ethereum v1.14.9 h1:J7iwXDrtUyE9FUjUYbd4c9tyzwMh6dTJsKzo9i6SrwA= -github.com/ethereum/go-ethereum v1.14.9/go.mod h1:QeW+MtTpRdBEm2pUFoonByee8zfHv7kGp0wK0odvU1I= -github.com/ethereum/go-verkle v0.1.1-0.20240829091221-dffa7562dbe9 h1:8NfxH2iXvJ60YRB8ChToFTUzl8awsc3cJ8CbLjGIl/A= -github.com/ethereum/go-verkle v0.1.1-0.20240829091221-dffa7562dbe9/go.mod h1:M3b90YRnzqKyyzBEWJGqj8Qff4IDeXnzFw0P9bFw3uk= -github.com/fatih/color v1.10.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM= -github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM= -github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE= -github.com/ferranbt/fastssz v0.1.3 h1:ZI+z3JH05h4kgmFXdHuR1aWYsgrg7o+Fw7/NCzM16Mo= -github.com/ferranbt/fastssz v0.1.3/go.mod h1:0Y9TEd/9XuFlh7mskMPfXiI2Dkw4Ddg9EyXt1W7MRvE= -github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY= -github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw= -github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI= -github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww= -github.com/getsentry/sentry-go v0.27.0 h1:Pv98CIbtB3LkMWmXi4Joa5OOcwbmnX88sF5qbK3r3Ps= -github.com/getsentry/sentry-go v0.27.0/go.mod h1:lc76E2QywIyW8WuBnwl8Lc4bkmQH4+w1gwTf25trprY= -github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.2.4 h1:g01GSCwiDw2xSZfjJ2/T9M+S6pFdcNtFYsp+Y43HYDQ= -github.com/go-logr/logr v1.2.4/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= -github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= -github.com/go-ole/go-ole v1.2.5/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= -github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= -github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= -github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4= -github.com/go-playground/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8ceBS/t7Q= -github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8= -github.com/go-playground/universal-translator v0.17.0 h1:icxd5fm+REJzpZx7ZfpaD876Lmtgy7VtROAbHHXk8no= -github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA= -github.com/go-playground/validator/v10 v10.4.1 h1:pH2c5ADXtd66mxoE0Zm9SUhxE20r7aM3F26W0hOn+GE= -github.com/go-playground/validator/v10 v10.4.1/go.mod h1:nlOn6nFhuKACm19sB/8EGNn9GlaMV7XkbRSipzJ0Ii4= -github.com/goccy/go-yaml v1.9.2 h1:2Njwzw+0+pjU2gb805ZC1B/uBuAs2VcZ3K+ZgHwDs7w= -github.com/goccy/go-yaml v1.9.2/go.mod h1:U/jl18uSupI5rdI2jmuCswEA2htH9eXfferR3KfscvA= -github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= -github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw= -github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU= -github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= -github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= -github.com/golang-jwt/jwt/v4 v4.5.0 h1:7cYmW1XlMY7h7ii7UhUyChSgS5wUJEnm9uZVTGqOWzg= -github.com/golang-jwt/jwt/v4 v4.5.0/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= -github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb h1:PBC98N2aIaM3XXiurYmW7fx4GZkL8feAMVq7nEjURHk= -github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= -github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= -github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= -github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= -github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= -github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk= -github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= -github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc= -github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= -github.com/hashicorp/go-bexpr v0.1.10 h1:9kuI5PFotCboP3dkDYFr/wi0gg0QVbSNz5oFRpxn4uE= -github.com/hashicorp/go-bexpr v0.1.10/go.mod h1:oxlubA2vC/gFVfX1A6JGp7ls7uCDlfJn732ehYYg+g0= -github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k= -github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= -github.com/holiman/billy v0.0.0-20240216141850-2abb0c79d3c4 h1:X4egAf/gcS1zATw6wn4Ej8vjuVGxeHdan+bRb2ebyv4= -github.com/holiman/billy v0.0.0-20240216141850-2abb0c79d3c4/go.mod h1:5GuXa7vkL8u9FkFuWdVvfR5ix8hRB7DbOAaYULamFpc= -github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao= -github.com/holiman/bloomfilter/v2 v2.0.3/go.mod h1:zpoh+gs7qcpqrHr3dB55AMiJwo0iURXE7ZOP9L9hSkA= -github.com/holiman/uint256 v1.3.1 h1:JfTzmih28bittyHM8z360dCjIA9dbPIBlcTI6lmctQs= -github.com/holiman/uint256 v1.3.1/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E= -github.com/huandu/go-assert v1.1.5 h1:fjemmA7sSfYHJD7CUqs9qTwwfdNAx7/j2/ZlHXzNB3c= -github.com/huandu/go-assert v1.1.5/go.mod h1:yOLvuqZwmcHIC5rIzrBhT7D3Q9c3GFnd0JrPVhn/06U= -github.com/huandu/go-clone v1.6.0 h1:HMo5uvg4wgfiy5FoGOqlFLQED/VGRm2D9Pi8g1FXPGc= -github.com/huandu/go-clone v1.6.0/go.mod h1:ReGivhG6op3GYr+UY3lS6mxjKp7MIGTknuU5TbTVaXE= -github.com/huandu/go-clone/generic v1.6.0 h1:Wgmt/fUZ28r16F2Y3APotFD59sHk1p78K0XLdbUYN5U= -github.com/huandu/go-clone/generic v1.6.0/go.mod h1:xgd9ZebcMsBWWcBx5mVMCoqMX24gLWr5lQicr+nVXNs= -github.com/huin/goupnp v1.3.0 h1:UvLUlWDNpoUdYzb2TCn+MuTWtcjXKSza2n6CBdQ0xXc= -github.com/huin/goupnp v1.3.0/go.mod h1:gnGPsThkYa7bFi/KWmEysQRf48l2dvR5bxr2OFckNX8= -github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7BdWus= -github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc= -github.com/jbrower95/multicall-go v0.0.0-20241012224745-7e9c19976cb5 h1:MbF9mcEhOK8A1lphvcfh5Tg7Y2p4iUAtw2+yz3jUa94= -github.com/jbrower95/multicall-go v0.0.0-20241012224745-7e9c19976cb5/go.mod h1:cl6hJrk69g0EyKPgNySQbJE1nj29t2q7Pu0as27uC04= -github.com/klauspost/compress v1.16.0 h1:iULayQNOReoYUe+1qtKOqw9CwJv3aNQu8ivo7lw1HU4= -github.com/klauspost/compress v1.16.0/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE= -github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM= -github.com/klauspost/cpuid/v2 v2.2.7/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= -github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= -github.com/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c= -github.com/leanovate/gopter v0.2.9/go.mod h1:U2L/78B+KVFIx2VmW6onHJQzXtFb+p5y3y2Sh+Jxxv8= -github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y= -github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII= -github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= -github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= -github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= -github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= -github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= -github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= -github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= -github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= -github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU= -github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= -github.com/minio/sha256-simd v1.0.1 h1:6kaan5IFmwTNynnKKpDHe6FWHohJOHhCPchzK49dzMM= -github.com/minio/sha256-simd v1.0.1/go.mod h1:Pz6AKMiUdngCLpeTL/RJY1M9rUuPMYujV5xJjtbRSN8= -github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= -github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= -github.com/mitchellh/pointerstructure v1.2.0 h1:O+i9nHnXS3l/9Wu7r4NrEdwA2VFTicjUEN1uBnDo34A= -github.com/mitchellh/pointerstructure v1.2.0/go.mod h1:BRAsLI5zgXmw97Lf6s25bs8ohIXc3tViBH44KcwB2g4= -github.com/mmcloughlin/addchain v0.4.0 h1:SobOdjm2xLj1KkXN5/n0xTIWyZA2+s99UCY1iPfkHRY= -github.com/mmcloughlin/addchain v0.4.0/go.mod h1:A86O+tHqZLMNO4w6ZZ4FlVQEadcoqkyU72HC5wJ4RlU= -github.com/mmcloughlin/profile v0.1.1/go.mod h1:IhHD7q1ooxgwTgjxQYkACGA77oFTDdFVejUS1/tS/qU= -github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec= -github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= -github.com/pk910/dynamic-ssz v0.0.3 h1:fCWzFowq9P6SYCc7NtJMkZcIHk+r5hSVD+32zVi6Aio= -github.com/pk910/dynamic-ssz v0.0.3/go.mod h1:b6CrLaB2X7pYA+OSEEbkgXDEcRnjLOZIxZTsMuO/Y9c= -github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= -github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= -github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/prometheus/client_golang v1.19.0 h1:ygXvpU1AoN1MhdzckN+PyD9QJOSD4x7kmXYlnfbA6JU= -github.com/prometheus/client_golang v1.19.0/go.mod h1:ZRM9uEAypZakd+q/x7+gmsvXdURP+DABIEIjnmDdp+k= -github.com/prometheus/client_model v0.5.0 h1:VQw1hfvPvk3Uv6Qf29VrPF32JB6rtbgI6cYPYQjL0Qw= -github.com/prometheus/client_model v0.5.0/go.mod h1:dTiFglRmd66nLR9Pv9f0mZi7B7fk5Pm3gvsjB5tr+kI= -github.com/prometheus/common v0.48.0 h1:QO8U2CdOzSn1BBsmXJXduaaW+dY/5QLjfB8svtSzKKE= -github.com/prometheus/common v0.48.0/go.mod h1:0/KsvlIEfPQCQ5I2iNSAWKPZziNCvRs5EC6ILDTlAPc= -github.com/prometheus/procfs v0.12.0 h1:jluTpSng7V9hY0O2R9DzzJHYb2xULk9VTR1V1R/k6Bo= -github.com/prometheus/procfs v0.12.0/go.mod h1:pcuDEFsWDnvcgNzo4EEweacyhjeA9Zk3cnaOZAZEfOo= -github.com/prysmaticlabs/go-bitfield v0.0.0-20240328144219-a1caa50c3a1e h1:ATgOe+abbzfx9kCPeXIW4fiWyDdxlwHw07j8UGhdTd4= -github.com/prysmaticlabs/go-bitfield v0.0.0-20240328144219-a1caa50c3a1e/go.mod h1:wmuf/mdK4VMD+jA9ThwcUKjg3a2XWM9cVfFYjDyY4j4= -github.com/r3labs/sse/v2 v2.10.0 h1:hFEkLLFY4LDifoHdiCN/LlGBAdVJYsANaLqNYa1l/v0= -github.com/r3labs/sse/v2 v2.10.0/go.mod h1:Igau6Whc+F17QUgML1fYe1VPZzTV6EMCnYktEmkNJ7I= -github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY= -github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= -github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M= -github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA= -github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik= -github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU= -github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg= -github.com/rs/zerolog v1.32.0 h1:keLypqrlIjaFsbmJOBdB/qvyF8KEtCWHwobLp5l/mQ0= -github.com/rs/zerolog v1.32.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss= -github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk= -github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= -github.com/samber/lo v1.47.0 h1:z7RynLwP5nbyRscyvcD043DWYoOcYRv3mV8lBeqOCLc= -github.com/samber/lo v1.47.0/go.mod h1:RmDH9Ct32Qy3gduHQuKJ3gW1fMHAnE/fAzQuf6He5cU= -github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible h1:Bn1aCHHRnjv4Bl16T8rcaFjYSrGrIZvpiGO6P3Q4GpU= -github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA= -github.com/status-im/keycard-go v0.2.0 h1:QDLFswOQu1r5jsycloeQh3bVU8n/NatHHaZobtDnDzA= -github.com/status-im/keycard-go v0.2.0/go.mod h1:wlp8ZLbsmrF6g6WjugPAx+IzoLrkdf9+mHxBEeo3Hbg= -github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= -github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= -github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= -github.com/supranational/blst v0.3.11 h1:LyU6FolezeWAhvQk0k6O/d49jqgO52MSDDfYgbeoEm4= -github.com/supranational/blst v0.3.11/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw= -github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY= -github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc= -github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFAEVmqU= -github.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI= -github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk= -github.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY= -github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8= -github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U= -github.com/umbracle/gohashtree v0.0.2-alpha.0.20230207094856-5b775a815c10 h1:CQh33pStIp/E30b7TxDlXfM0145bn2e8boI30IxAhTg= -github.com/umbracle/gohashtree v0.0.2-alpha.0.20230207094856-5b775a815c10/go.mod h1:x/Pa0FF5Te9kdrlZKJK82YmAkvL8+f989USgz6Jiw7M= -github.com/urfave/cli/v2 v2.27.1 h1:8xSQ6szndafKVRmfyeUMxkNUJQMjL1F2zmsZ+qHpfho= -github.com/urfave/cli/v2 v2.27.1/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ= -github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU= -github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8= -go.opentelemetry.io/otel v1.16.0 h1:Z7GVAX/UkAXPKsy94IU+i6thsQS4nb7LviLpnaNeW8s= -go.opentelemetry.io/otel v1.16.0/go.mod h1:vl0h9NUa1D5s1nv3A5vZOYWn8av4K8Ml6JDeHrT/bx4= -go.opentelemetry.io/otel/metric v1.16.0 h1:RbrpwVG1Hfv85LgnZ7+txXioPDoh6EdbZHo26Q3hqOo= -go.opentelemetry.io/otel/metric v1.16.0/go.mod h1:QE47cpOmkwipPiefDwo2wDzwJrlfxxNYodqc4xnGCo4= -go.opentelemetry.io/otel/trace v1.16.0 h1:8JRpaObFoW0pxuVPapkgH8UhHQj+bJW8jJsCZEu5MQs= -go.opentelemetry.io/otel/trace v1.16.0/go.mod h1:Yt9vYq1SdNz3xdjZZK7wcXv1qv2pwLkqr2QVwea0ef0= -golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI= -golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8= -golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa h1:FRnLl4eNAQl8hwxVVC17teOw8kdjVDVAiFMtgUdTSRQ= -golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa/go.mod h1:zk2irFbV9DP96SEBUUAy67IdHUaZuSnrz1n472HUCLE= -golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20191116160921-f9c825593386/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.24.0 h1:1PcaxkF854Fu3+lvBIx5SYn9wRlBzzcnHZSiaFFAb0w= -golang.org/x/net v0.24.0/go.mod h1:2Q7sJY5mzlzWjKtYUEXSlBWCdyaioyXzRB2RtU8KVE8= -golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M= -golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= -golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI= -golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= -golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4= -golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI= -golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk= -golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= -golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 h1:+cNy6SZtPcJQH3LJVLOSmiC7MMxXNOb3PU/VUEz+EhU= -golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90= -google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg= -google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw= -gopkg.in/Knetic/govaluate.v3 v3.0.0 h1:18mUyIt4ZlRlFZAAfVetz4/rzlJs9yhN+U02F4u1AOc= -gopkg.in/Knetic/govaluate.v3 v3.0.0/go.mod h1:csKLBORsPbafmSCGTEh3U7Ozmsuq8ZSIlKk1bcqph0E= -gopkg.in/cenkalti/backoff.v1 v1.1.0 h1:Arh75ttbsvlpVA7WtVpH4u9h6Zl46xuptxqLxPiSo4Y= -gopkg.in/cenkalti/backoff.v1 v1.1.0/go.mod h1:J6Vskwqd+OMVJl8C33mmtxTBs2gyzfv7UDAkHu8BrjI= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/natefinch/lumberjack.v2 v2.2.1 h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc= -gopkg.in/natefinch/lumberjack.v2 v2.2.1/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc= -gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= -gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= -gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -rsc.io/tmplfunc v0.0.3 h1:53XFQh69AfOa8Tw0Jm7t+GV7KZhOi6jzsCzTtKbMvzU= -rsc.io/tmplfunc v0.0.3/go.mod h1:AG3sTPzElb1Io3Yg4voV9AGZJuleGAwaVRxL9M49PhA= diff --git a/script/releases/v1.0.2-slashing-consolidated/cleanup/script.go b/script/releases/v1.0.2-slashing-consolidated/cleanup/script.go deleted file mode 100644 index bbc3da4da1..0000000000 --- a/script/releases/v1.0.2-slashing-consolidated/cleanup/script.go +++ /dev/null @@ -1,328 +0,0 @@ -package main - -import ( - "context" - _ "embed" - "encoding/json" - "fmt" - "math/big" - "os" - "sort" - "strings" - "time" - - proofgen "github.com/Layr-Labs/eigenpod-proofs-generation/cli/core" - eth2client "github.com/attestantio/go-eth2-client" - "github.com/attestantio/go-eth2-client/api" - v1 "github.com/attestantio/go-eth2-client/api/v1" - attestantio "github.com/attestantio/go-eth2-client/http" - "github.com/attestantio/go-eth2-client/spec/phase0" - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/ethclient" - multicall "github.com/jbrower95/multicall-go" - "github.com/samber/lo" -) - -type EigenpodInfo struct { - Address string `json:"address"` - CurrentCheckpointTimestamp uint64 `json:"currentCheckpointTimestamp"` -} - -type TQueryAllEigenpodsOnNetworkArgs struct { - Ctx context.Context - AllValidators []ValidatorWithIndex - Eth *ethclient.Client - EigenpodAbi abi.ABI - PodManagerAbi abi.ABI - PodManagerAddress string - Mc *multicall.MulticallClient -} - -//go:embed EigenPod.abi.json -var EigenPodAbi string - -//go:embed EigenPodManager.abi.json -var EigenPodManagerAbi string - -type ValidatorWithIndex struct { - Validator *v1.Validator - Index phase0.ValidatorIndex -} - -type TArgs struct { - Node string - BeaconNode string - Sender string -} - -func main() { - err := runScript(TArgs{ - Node: os.Getenv("RPC_URL"), - BeaconNode: os.Getenv("BEACON_URL"), - Sender: os.Getenv("SENDER_PK"), - }) - if err != nil { - fmt.Printf("Error: %v\n", err) - os.Exit(1) - } -} - -func panicOnError(msg string, err error) { - if err != nil { - fmt.Printf("Error: %s", msg) - panic(err) - } -} - -func runScript(args TArgs) error { - ctx := context.Background() - - if args.Sender[:2] == "0x" { - args.Sender = args.Sender[2:] - } - fmt.Printf("Sender: %s\n", args.Sender) - - eigenpodAbi, err := abi.JSON(strings.NewReader(EigenPodAbi)) - panicOnError("failed to load eigenpod abi", err) - - podManagerAbi, err := abi.JSON(strings.NewReader(EigenPodManagerAbi)) - panicOnError("failed to load eigenpod manager abi", err) - - eth, err := ethclient.Dial(args.Node) - panicOnError("failed to reach eth node", err) - - chainId, err := eth.ChainID(ctx) - panicOnError("failed to read chainId", err) - - beaconClient, err := attestantio.New(ctx, - attestantio.WithAddress(args.BeaconNode), - ) - panicOnError("failed to reach beacon node", err) - - panicOnError("failed to reach ethereum clients", err) - - mc, err := multicall.NewMulticallClient(ctx, eth, &multicall.TMulticallClientOptions{ - MaxBatchSizeBytes: 8192, - }) - panicOnError("error initializing mc", err) - - podManagerAddress := os.Getenv("ZEUS_DEPLOYED_EigenPodManager_Proxy") - - // fetch latest beacon state. - _validators := (func() *map[phase0.ValidatorIndex]*v1.Validator { - if provider, isProvider := beaconClient.(eth2client.ValidatorsProvider); isProvider { - validators, err := provider.Validators(ctx, &api.ValidatorsOpts{ - State: "head", - Common: api.CommonOpts{ - Timeout: 60 * time.Second, - }, - }) - panicOnError("failed to load validator set", err) - return &validators.Data - } - return nil - })() - if _validators == nil { - panic("failed to load validators") - } - validators := *_validators - - fmt.Printf("Found %d validators\n", len(validators)) - - panicOnError("failed to load beacon state", err) - - panicOnError("failed to fetch validators", err) - allValidators := lo.Map(lo.Keys(validators), func(idx phase0.ValidatorIndex, i int) ValidatorWithIndex { - return ValidatorWithIndex{ - Validator: validators[idx], - Index: idx, - } - }) - - allEigenpods, err := queryAllEigenpodsOnNetwork(ctx, allValidators, eth, &eigenpodAbi, &podManagerAbi, podManagerAddress, mc) - panicOnError("queryAllEigenpodsOnNetwork", err) - - enc := json.NewEncoder(os.Stdout) - enc.SetIndent("", " ") - - fmt.Printf("Discovered %d eigenpods on the network.\n", len(allEigenpods)) - - pods := lo.Map(allEigenpods, func(pod string, i int) string { - return fmt.Sprintf("0x%s", pod) - }) - sort.Strings(pods) - fmt.Printf("%s\n", enc.Encode(pods)) - - // Now for each eigenpod, we want to fetch currentCheckpointTimestamp. - // We'll do a multicall to get currentCheckpointTimestamp from each eigenpod. - checkpointTimestamps, err := fetchCurrentCheckpointTimestamps(allEigenpods, &eigenpodAbi, mc) - panicOnError("failed to fetch currentCheckpointTimestamps", err) - - results := []EigenpodInfo{} - - for i, ep := range allEigenpods { - if checkpointTimestamps[i] > 0 { - results = append(results, EigenpodInfo{ - Address: fmt.Sprintf("0x%s", ep), - CurrentCheckpointTimestamp: checkpointTimestamps[i], - }) - } - } - - if len(results) == 0 { - fmt.Printf("No eigenpods had active checkpoints. OK.") - return nil - } - - fmt.Printf("%d EigenPods had active checkpoints\n\n", len(results)) - fmt.Printf("%s\n", enc.Encode(results)) - - fmt.Printf("Completing %d checkpoints....", len(results)) - coreBeaconClient, _, err := proofgen.NewBeaconClient(args.BeaconNode, true /* verbose */) - panicOnError("failed to instantiate beaconClient", err) - - for i := 0; i < len(results); i++ { - fmt.Printf("Completing [%d/%d]...", i+1, len(results)) - fmt.Printf("NOTE: this is expensive, and may take several minutes.") - completeCheckpointForEigenpod(ctx, results[i].Address, eth, chainId, coreBeaconClient, args.Sender) - } - - checkpointTimestamps, err = fetchCurrentCheckpointTimestamps(allEigenpods, &eigenpodAbi, mc) - panicOnError("failed to fetch currentCheckpointTimestamps", err) - - // require that all eigenpods have a checkpoint timestamp of 0 - for i, timestamp := range checkpointTimestamps { - if timestamp != 0 { - panic(fmt.Sprintf("expected all eigenpods to have a checkpoint timestamp of 0, but found %d on %s", timestamp, allEigenpods[i])) - } - } - - return nil -} - -func completeCheckpointForEigenpod(ctx context.Context, eigenpodAddress string, eth *ethclient.Client, chainId *big.Int, coreBeaconClient proofgen.BeaconClient, sender string) { - res, err := proofgen.GenerateCheckpointProof(ctx, eigenpodAddress, eth, chainId, coreBeaconClient, true) - panicOnError(fmt.Sprintf("failed to generate checkpoint proof for eigenpod:%s", eigenpodAddress), err) - - txns, err := proofgen.SubmitCheckpointProof(ctx, sender, eigenpodAddress, chainId, res, eth, 80 /* ideal checkpoint proof batch size */, true /* noPrompt */, false /* noSend */, true /* verbose */) - panicOnError(fmt.Sprintf("failed to submit checkpoint proof for eigenpod:%s", eigenpodAddress), err) - if txns == nil { - panic("submitting checkpoint proof generated no transactions. this is a bug.") - } - - for i, txn := range txns { - fmt.Printf("[%d/%d] %s\n", i+1, len(txns), txn.Hash()) - } -} - -// This is a simplified version of the queryAllEigenpodsOnNetwork function inline. -// It uses the logic from the provided code snippet in the commands package. -func queryAllEigenpodsOnNetwork( - ctx context.Context, - allValidators []ValidatorWithIndex, - eth *ethclient.Client, - eigenpodAbi, podManagerAbi *abi.ABI, - podManagerAddress string, - mc *multicall.MulticallClient, -) ([]string, error) { - args := TQueryAllEigenpodsOnNetworkArgs{ - Ctx: ctx, - AllValidators: allValidators, - Eth: eth, - EigenpodAbi: *eigenpodAbi, - PodManagerAbi: *podManagerAbi, - PodManagerAddress: podManagerAddress, - Mc: mc, - } - return internalQueryAllEigenpodsOnNetwork(args) -} - -// internalQueryAllEigenpodsOnNetwork is lifted from the provided snippet. -func internalQueryAllEigenpodsOnNetwork(args TQueryAllEigenpodsOnNetworkArgs) ([]string, error) { - // Filter out validators that are withdrawing to execution layer addresses - executionLayerWithdrawalCredentialValidators := lo.Filter(args.AllValidators, func(validator ValidatorWithIndex, i int) bool { - return validator.Validator.Validator.WithdrawalCredentials[0] == 1 - }) - - interestingWithdrawalAddresses := lo.Keys(lo.Reduce(executionLayerWithdrawalCredentialValidators, func(accum map[string]int, next ValidatorWithIndex, index int) map[string]int { - accum[common.Bytes2Hex(next.Validator.Validator.WithdrawalCredentials[12:])] = 1 - return accum - }, map[string]int{})) - - fmt.Printf("Querying %d beacon-chain withdrawal addresses to see if they may be eigenpods\n", len(interestingWithdrawalAddresses)) - - podOwners, err := multicall.DoManyAllowFailures[common.Address](args.Mc, lo.Map(interestingWithdrawalAddresses, func(address string, index int) *multicall.MultiCallMetaData[common.Address] { - callMeta, err := multicall.Describe[common.Address]( - common.HexToAddress(address), - args.EigenpodAbi, - "podOwner", - ) - panicOnError("failed to form mc", err) - return callMeta - })...) - - if podOwners == nil || err != nil || len(*podOwners) == 0 { - panicOnError("failed to fetch podOwners", err) - panic("loaded no pod owners") - } - - podToPodOwner := map[string]*common.Address{} - addressesWithPodOwners := lo.Filter(interestingWithdrawalAddresses, func(address string, i int) bool { - success := (*podOwners)[i].Success - if success { - podToPodOwner[address] = (*podOwners)[i].Value - } - return success - }) - - fmt.Printf("Querying %d addresses on (EigenPodManager=%s) to see if it knows about these eigenpods\n", len(addressesWithPodOwners), args.PodManagerAddress) - - eigenpodForOwner, err := multicall.DoMany( - args.Mc, - lo.Map(addressesWithPodOwners, func(address string, i int) *multicall.MultiCallMetaData[common.Address] { - claimedOwner := *podToPodOwner[address] - call, err := multicall.Describe[common.Address]( - common.HexToAddress(args.PodManagerAddress), - args.PodManagerAbi, - "ownerToPod", - claimedOwner, - ) - panicOnError("failed to form multicall", err) - return call - })..., - ) - panicOnError("failed to query", err) - - // now, see which are properly eigenpods - return lo.Filter(addressesWithPodOwners, func(address string, i int) bool { - return (*eigenpodForOwner)[i].Cmp(common.HexToAddress(addressesWithPodOwners[i])) == 0 - }), nil -} - -func fetchCurrentCheckpointTimestamps( - allEigenpods []string, - eigenpodAbi *abi.ABI, - mc *multicall.MulticallClient, -) ([]uint64, error) { - calls := lo.Map(allEigenpods, func(eigenpod string, i int) *multicall.MultiCallMetaData[uint64] { - call, err := multicall.Describe[uint64]( - common.HexToAddress(eigenpod), - *eigenpodAbi, - "currentCheckpointTimestamp", - ) - panicOnError("failed to form multicall", err) - return call - }) - - results, err := multicall.DoMany(mc, calls...) - if err != nil { - return nil, err - } - - out := make([]uint64, len(*results)) - for i, r := range *results { - out[i] = *r - } - return out, nil -} diff --git a/script/releases/v1.0.2-slashing-consolidated/cleanup/start.sh b/script/releases/v1.0.2-slashing-consolidated/cleanup/start.sh deleted file mode 100755 index e75139d25b..0000000000 --- a/script/releases/v1.0.2-slashing-consolidated/cleanup/start.sh +++ /dev/null @@ -1,3 +0,0 @@ -#!/usr/bin/env bash -cd script/releases/v1.0.0-slashing/cleanup -go run script.go \ No newline at end of file diff --git a/script/releases/v1.0.2-slashing-consolidated/upgrade.json b/script/releases/v1.0.2-slashing-consolidated/upgrade.json deleted file mode 100644 index 1d7f57e108..0000000000 --- a/script/releases/v1.0.2-slashing-consolidated/upgrade.json +++ /dev/null @@ -1,32 +0,0 @@ -{ - "name": "slashing-consolidated", - "from": "~0.5.3", - "to": "1.0.2", - "phases": [ - { - "type": "eoa", - "filename": "1-deployContracts.s.sol" - }, - { - "type": "multisig", - "filename": "2-queueUpgradeAndUnpause.s.sol" - }, - { - "type": "multisig", - "filename": "3-pause.s.sol" - }, - { - "type": "script", - "filename": "cleanup/start.sh", - "arguments": [ - {"type": "url", "passBy": "env", "inputType": "text", "name": "RPC_URL", "prompt": "Enter an ETH RPC URL"}, - {"type": "url", "passBy": "env", "inputType": "text", "name": "BEACON_URL", "prompt": "Enter an ETH2 Beacon RPC URL"}, - {"type": "privateKey", "passBy": "env", "inputType": "password", "name": "SENDER_PK", "prompt": "Enter an ETH wallet private key to complete checkpoints from:"} - ] - }, - { - "type": "multisig", - "filename": "5-executeUpgradeAndUnpause.s.sol" - } - ] -} \ No newline at end of file diff --git a/script/releases/v1.0.2-slashing/1-eoa.s.sol b/script/releases/v1.0.2-slashing/1-eoa.s.sol deleted file mode 100644 index 6a740cf9c3..0000000000 --- a/script/releases/v1.0.2-slashing/1-eoa.s.sol +++ /dev/null @@ -1,87 +0,0 @@ -// SPDX-License-Identifier: BUSL-1.1 -pragma solidity ^0.8.12; - -import {EOADeployer} from "zeus-templates/templates/EOADeployer.sol"; -import "../Env.sol"; - -import "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol"; -import "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol"; -import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; -import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol"; - -// Just upgrade StrategyManager -contract Deploy is EOADeployer { - using Env for *; - - function _runAsEOA() internal override { - vm.startBroadcast(); - deployImpl({ - name: type(StrategyManager).name, - deployedTo: address(new StrategyManager({ - _delegation: Env.proxy.delegationManager(), - _pauserRegistry: Env.impl.pauserRegistry() - })) - }); - - vm.stopBroadcast(); - } - - function testDeploy() public virtual { - _runAsEOA(); - _validateNewImplAddresses(false); - _validateImplConstructors(); - _validateImplsInitialized(); - } - - - /// @dev Validate that the `Env.impl` addresses are updated to be distinct from what the proxy - /// admin reports as the current implementation address. - /// - /// Note: The upgrade script can call this with `areMatching == true` to check that these impl - /// addresses _are_ matches. - function _validateNewImplAddresses(bool areMatching) internal view { - function (address, address, string memory) internal pure assertion = - areMatching ? _assertMatch : _assertNotMatch; - - - assertion( - _getProxyImpl(address(Env.proxy.strategyManager())), - address(Env.impl.strategyManager()), - "strategyManager impl failed" - ); - } - - /// @dev Validate the immutables set in the new implementation constructors - function _validateImplConstructors() internal view { - StrategyManager strategyManager = Env.impl.strategyManager(); - assertTrue(strategyManager.delegation() == Env.proxy.delegationManager(), "sm.dm invalid"); - assertTrue(strategyManager.pauserRegistry() == Env.impl.pauserRegistry(), "sm.pR invalid"); - } - - /// @dev Call initialize on all deployed implementations to ensure initializers are disabled - function _validateImplsInitialized() internal { - bytes memory errInit = "Initializable: contract is already initialized"; - - StrategyManager strategyManager = Env.impl.strategyManager(); - vm.expectRevert(errInit); - strategyManager.initialize(address(0), address(0), 0); - } - - /// @dev Query and return `proxyAdmin.getProxyImplementation(proxy)` - function _getProxyImpl(address proxy) internal view returns (address) { - return ProxyAdmin(Env.proxyAdmin()).getProxyImplementation(ITransparentUpgradeableProxy(proxy)); - } - - /// @dev Query and return `proxyAdmin.getProxyAdmin(proxy)` - function _getProxyAdmin(address proxy) internal view returns (address) { - return ProxyAdmin(Env.proxyAdmin()).getProxyAdmin(ITransparentUpgradeableProxy(proxy)); - } - - function _assertMatch(address a, address b, string memory err) private pure { - assertEq(a, b, err); - } - - function _assertNotMatch(address a, address b, string memory err) private pure { - assertNotEq(a, b, err); - } -} \ No newline at end of file diff --git a/script/releases/v1.0.2-slashing/2-multisig.s.sol b/script/releases/v1.0.2-slashing/2-multisig.s.sol deleted file mode 100644 index 7557f94b48..0000000000 --- a/script/releases/v1.0.2-slashing/2-multisig.s.sol +++ /dev/null @@ -1,71 +0,0 @@ -// SPDX-License-Identifier: BUSL-1.1 -pragma solidity ^0.8.12; - -import {Deploy} from "./1-eoa.s.sol"; -import "../Env.sol"; - -import {MultisigBuilder} from "zeus-templates/templates/MultisigBuilder.sol"; -import "zeus-templates/utils/Encode.sol"; - -import {TimelockController} from "@openzeppelin/contracts/governance/TimelockController.sol"; - -contract Queue is MultisigBuilder, Deploy { - using Env for *; - using Encode for *; - - function _runAsMultisig() prank(Env.opsMultisig()) internal virtual override { - bytes memory calldata_to_executor = _getCalldataToExecutor(); - - TimelockController timelock = Env.timelockController(); - timelock.schedule({ - target: Env.executorMultisig(), - value: 0, - data: calldata_to_executor, - predecessor: 0, - salt: 0, - delay: timelock.getMinDelay() - }); - } - - /// @dev Get the calldata to be sent from the timelock to the executor - function _getCalldataToExecutor() internal returns (bytes memory) { - MultisigCall[] storage executorCalls = Encode.newMultisigCalls() - /// core/ - .append({ - to: Env.proxyAdmin(), - data: Encode.proxyAdmin.upgrade({ - proxy: address(Env.proxy.strategyManager()), - impl: address(Env.impl.strategyManager()) - }) - }); - - return Encode.gnosisSafe.execTransaction({ - from: address(Env.timelockController()), - to: address(Env.multiSendCallOnly()), - op: Encode.Operation.DelegateCall, - data: Encode.multiSend(executorCalls) - }); - } - - function testScript() public virtual { - runAsEOA(); - - TimelockController timelock = Env.timelockController(); - bytes memory calldata_to_executor = _getCalldataToExecutor(); - bytes32 txHash = timelock.hashOperation({ - target: Env.executorMultisig(), - value: 0, - data: calldata_to_executor, - predecessor: 0, - salt: 0 - }); - - // Check that the upgrade does not exist in the timelock - assertFalse(timelock.isOperationPending(txHash), "Transaction should NOT be queued."); - - execute(); - - // Check that the upgrade has been added to the timelock - assertTrue(timelock.isOperationPending(txHash), "Transaction should be queued."); - } -} \ No newline at end of file diff --git a/script/releases/v1.0.2-slashing/3-execute.s.sol b/script/releases/v1.0.2-slashing/3-execute.s.sol deleted file mode 100644 index 624bc1a31c..0000000000 --- a/script/releases/v1.0.2-slashing/3-execute.s.sol +++ /dev/null @@ -1,64 +0,0 @@ -// SPDX-License-Identifier: BUSL-1.1 -pragma solidity ^0.8.12; - -import "../Env.sol"; -import {Queue} from "./2-multisig.s.sol"; - -import "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol"; -import "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol"; - -contract Execute is Queue { - using Env for *; - - function _runAsMultisig() prank(Env.protocolCouncilMultisig()) internal override(Queue) { - bytes memory calldata_to_executor = _getCalldataToExecutor(); - - TimelockController timelock = Env.timelockController(); - timelock.execute({ - target: Env.executorMultisig(), - value: 0, - payload: calldata_to_executor, - predecessor: 0, - salt: 0 - }); - } - - function testScript() public virtual override(Queue){ - // 0. Deploy Impls - runAsEOA(); - - TimelockController timelock = Env.timelockController(); - bytes memory calldata_to_executor = _getCalldataToExecutor(); - bytes32 txHash = timelock.hashOperation({ - target: Env.executorMultisig(), - value: 0, - data: calldata_to_executor, - predecessor: 0, - salt: 0 - }); - assertFalse(timelock.isOperationPending(txHash), "Transaction should NOT be queued."); - - // 1. Queue Upgrade - Queue._runAsMultisig(); - _unsafeResetHasPranked(); // reset hasPranked so we can use it again - - // 2. Warp past delay - vm.warp(block.timestamp + timelock.getMinDelay()); // 1 tick after ETA - assertEq(timelock.isOperationReady(txHash), true, "Transaction should be executable."); - - // 3- execute - execute(); - - assertTrue(timelock.isOperationDone(txHash), "Transaction should be complete."); - - // 4. Validate - _validateNewImplAddresses(true); - _validateProxyConstructors(); - } - - function _validateProxyConstructors() internal view { - StrategyManager strategyManager = Env.proxy.strategyManager(); - assertTrue(strategyManager.delegation() == Env.proxy.delegationManager(), "sm.dm invalid"); - assertTrue(strategyManager.pauserRegistry() == Env.impl.pauserRegistry(), "sm.pR invalid"); - } -} \ No newline at end of file diff --git a/script/releases/v1.0.2-slashing/upgrade.json b/script/releases/v1.0.2-slashing/upgrade.json deleted file mode 100644 index e54c2e2253..0000000000 --- a/script/releases/v1.0.2-slashing/upgrade.json +++ /dev/null @@ -1,19 +0,0 @@ -{ - "name": "slashing-patch", - "from": "1.0.1", - "to": "1.0.2", - "phases": [ - { - "type": "eoa", - "filename": "1-eoa.s.sol" - }, - { - "type": "multisig", - "filename": "2-multisig.s.sol" - }, - { - "type": "multisig", - "filename": "3-execute.s.sol" - } - ] -} \ No newline at end of file diff --git a/script/releases/v1.0.3-slashing/1-eoa.s.sol b/script/releases/v1.0.3-slashing/1-eoa.s.sol index d9a5793aa3..d66e7e6918 100644 --- a/script/releases/v1.0.3-slashing/1-eoa.s.sol +++ b/script/releases/v1.0.3-slashing/1-eoa.s.sol @@ -13,6 +13,8 @@ import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol"; contract Deploy is EOADeployer { using Env for *; + string internal constant VERSION = "v1.0.3-slashing"; + function _runAsEOA() internal override { vm.startBroadcast(); @@ -25,7 +27,8 @@ contract Deploy is EOADeployer { _allocationManager: Env.proxy.allocationManager(), _pauserRegistry: Env.impl.pauserRegistry(), _permissionController: Env.proxy.permissionController(), - _MIN_WITHDRAWAL_DELAY: Env.MIN_WITHDRAWAL_DELAY() + _MIN_WITHDRAWAL_DELAY: Env.MIN_WITHDRAWAL_DELAY(), + _version: VERSION })) }); @@ -34,7 +37,8 @@ contract Deploy is EOADeployer { name: type(AVSDirectory).name, deployedTo: address(new AVSDirectory({ _delegation: Env.proxy.delegationManager(), - _pauserRegistry: Env.impl.pauserRegistry() + _pauserRegistry: Env.impl.pauserRegistry(), + _version: VERSION })) }); @@ -43,25 +47,29 @@ contract Deploy is EOADeployer { name: type(StrategyManager).name, deployedTo: address(new StrategyManager({ _delegation: Env.proxy.delegationManager(), - _pauserRegistry: Env.impl.pauserRegistry() + _pauserRegistry: Env.impl.pauserRegistry(), + _version: VERSION })) }); // Deploy RC deployImpl({ name: type(RewardsCoordinator).name, - deployedTo: address(new RewardsCoordinator({ - _delegationManager: Env.proxy.delegationManager(), - _strategyManager: Env.proxy.strategyManager(), - _allocationManager: Env.proxy.allocationManager(), - _pauserRegistry: Env.impl.pauserRegistry(), - _permissionController: Env.proxy.permissionController(), - _CALCULATION_INTERVAL_SECONDS: Env.CALCULATION_INTERVAL_SECONDS(), - _MAX_REWARDS_DURATION: Env.MAX_REWARDS_DURATION(), - _MAX_RETROACTIVE_LENGTH: Env.MAX_RETROACTIVE_LENGTH(), - _MAX_FUTURE_LENGTH: Env.MAX_FUTURE_LENGTH(), - _GENESIS_REWARDS_TIMESTAMP: Env.GENESIS_REWARDS_TIMESTAMP() - })) + deployedTo: address(new RewardsCoordinator( + IRewardsCoordinatorTypes.RewardsCoordinatorConstructorParams({ + delegationManager: Env.proxy.delegationManager(), + strategyManager: Env.proxy.strategyManager(), + allocationManager: Env.proxy.allocationManager(), + pauserRegistry: Env.impl.pauserRegistry(), + permissionController: Env.proxy.permissionController(), + CALCULATION_INTERVAL_SECONDS: Env.CALCULATION_INTERVAL_SECONDS(), + MAX_REWARDS_DURATION: Env.MAX_REWARDS_DURATION(), + MAX_RETROACTIVE_LENGTH: Env.MAX_RETROACTIVE_LENGTH(), + MAX_FUTURE_LENGTH: Env.MAX_FUTURE_LENGTH(), + GENESIS_REWARDS_TIMESTAMP: Env.GENESIS_REWARDS_TIMESTAMP(), + version: VERSION + }) + )) }); vm.stopBroadcast(); diff --git a/script/tasks/register_operator_to_operatorSet.s.sol b/script/tasks/register_operator_to_operatorSet.s.sol index 9ab8dc252a..292102ee64 100644 --- a/script/tasks/register_operator_to_operatorSet.s.sol +++ b/script/tasks/register_operator_to_operatorSet.s.sol @@ -64,7 +64,7 @@ contract RegisterOperatorToOperatorSets is Script, Test { // Register the Operator to the AVS avsDirectory.registerOperatorToAVS( - operator, ISignatureUtils.SignatureWithSaltAndExpiry(abi.encodePacked(r, s, v), bytes32(uint256(0) + 1), expiry) + operator, ISignatureUtilsMixinTypes.SignatureWithSaltAndExpiry(abi.encodePacked(r, s, v), bytes32(uint256(0) + 1), expiry) ); // Deploy and set registrar. diff --git a/script/utils/ExistingDeploymentParser.sol b/script/utils/ExistingDeploymentParser.sol index c80333ac35..56751522d4 100644 --- a/script/utils/ExistingDeploymentParser.sol +++ b/script/utils/ExistingDeploymentParser.sol @@ -50,6 +50,7 @@ contract ExistingDeploymentParser is Script, Logger { /// EigenLayer Contract Parameters /// ----------------------------------------------------------------------- + string public SEMVER; /// @dev AllocationManager uint256 ALLOCATION_MANAGER_INIT_PAUSED_STATUS; uint32 DEALLOCATION_DELAY; @@ -185,7 +186,7 @@ contract ExistingDeploymentParser is Script, Logger { /// @notice use for parsing already deployed EigenLayer contracts function _parseDeployedContracts( string memory existingDeploymentInfoPath - ) internal virtual { + ) internal noTracing virtual { // read and log the chainID uint256 currentChainId = block.chainid; console.log("You are parsing on ChainID", currentChainId); @@ -193,6 +194,8 @@ contract ExistingDeploymentParser is Script, Logger { // READ JSON CONFIG DATA string memory json = cheats.readFile(existingDeploymentInfoPath); + SEMVER = stdJson.readString(json, ".parameters.semver"); + // check that the chainID matches the one in the config uint256 configChainId = json.readUint(".chainInfo.chainId"); assertEq(configChainId, currentChainId, "You are on the wrong chain for this config"); @@ -211,7 +214,7 @@ contract ExistingDeploymentParser is Script, Logger { eigenLayerPauserReg = PauserRegistry(json.readAddress(".addresses.eigenLayerPauserReg")); // FIXME: hotfix - remove later... - permissionControllerImplementation = new PermissionController(); + permissionControllerImplementation = new PermissionController(SEMVER); permissionController = PermissionController( address(new TransparentUpgradeableProxy(address(permissionControllerImplementation), address(eigenLayerProxyAdmin), "")) ); @@ -221,7 +224,8 @@ contract ExistingDeploymentParser is Script, Logger { eigenLayerPauserReg, permissionController, DEALLOCATION_DELAY, - ALLOCATION_CONFIGURATION_DELAY + ALLOCATION_CONFIGURATION_DELAY, + SEMVER ); allocationManager = AllocationManager( address(new TransparentUpgradeableProxy(address(allocationManagerImplementation), address(eigenLayerProxyAdmin), "")) @@ -663,7 +667,7 @@ contract ExistingDeploymentParser is Script, Logger { /// @notice used for parsing parameters used in the integration test upgrade function _parseParamsForIntegrationUpgrade( string memory initialDeploymentParamsPath - ) internal virtual { + ) internal noTracing virtual { // read and log the chainID uint256 currentChainId = block.chainid; console.log("You are parsing on ChainID", currentChainId); diff --git a/src/contracts/core/AVSDirectory.sol b/src/contracts/core/AVSDirectory.sol index 0e9af8741f..86e5c2920d 100644 --- a/src/contracts/core/AVSDirectory.sol +++ b/src/contracts/core/AVSDirectory.sol @@ -5,7 +5,7 @@ import "@openzeppelin-upgrades/contracts/proxy/utils/Initializable.sol"; import "@openzeppelin-upgrades/contracts/access/OwnableUpgradeable.sol"; import "@openzeppelin-upgrades/contracts/security/ReentrancyGuardUpgradeable.sol"; -import "../mixins/SignatureUtils.sol"; +import "../mixins/SignatureUtilsMixin.sol"; import "../permissions/Pausable.sol"; import "./AVSDirectoryStorage.sol"; @@ -15,7 +15,7 @@ contract AVSDirectory is Pausable, AVSDirectoryStorage, ReentrancyGuardUpgradeable, - SignatureUtils + SignatureUtilsMixin { /** * @@ -29,8 +29,9 @@ contract AVSDirectory is */ constructor( IDelegationManager _delegation, - IPauserRegistry _pauserRegistry - ) AVSDirectoryStorage(_delegation) Pausable(_pauserRegistry) { + IPauserRegistry _pauserRegistry, + string memory _version + ) AVSDirectoryStorage(_delegation) Pausable(_pauserRegistry) SignatureUtilsMixin(_version) { _disableInitializers(); } @@ -70,7 +71,7 @@ contract AVSDirectory is /// @inheritdoc IAVSDirectory function registerOperatorToAVS( address operator, - ISignatureUtils.SignatureWithSaltAndExpiry memory operatorSignature + ISignatureUtilsMixinTypes.SignatureWithSaltAndExpiry memory operatorSignature ) external override onlyWhenNotPaused(PAUSED_OPERATOR_REGISTER_DEREGISTER_TO_AVS) { // Assert that the `operator` is not actively registered to the AVS. require( diff --git a/src/contracts/core/AllocationManager.sol b/src/contracts/core/AllocationManager.sol index 2c77cc02b4..6e6ce86301 100644 --- a/src/contracts/core/AllocationManager.sol +++ b/src/contracts/core/AllocationManager.sol @@ -6,6 +6,7 @@ import "@openzeppelin-upgrades/contracts/access/OwnableUpgradeable.sol"; import "@openzeppelin-upgrades/contracts/security/ReentrancyGuardUpgradeable.sol"; import "../mixins/PermissionControllerMixin.sol"; +import "../mixins/SemVerMixin.sol"; import "../permissions/Pausable.sol"; import "../libraries/SlashingLib.sol"; import "../libraries/OperatorSetLib.sol"; @@ -17,10 +18,12 @@ contract AllocationManager is Pausable, AllocationManagerStorage, ReentrancyGuardUpgradeable, - PermissionControllerMixin + PermissionControllerMixin, + SemVerMixin { using DoubleEndedQueue for DoubleEndedQueue.Bytes32Deque; using EnumerableSet for *; + using SafeCast for *; using Snapshots for Snapshots.DefaultWadHistory; using OperatorSetLib for OperatorSet; @@ -40,11 +43,13 @@ contract AllocationManager is IPauserRegistry _pauserRegistry, IPermissionController _permissionController, uint32 _DEALLOCATION_DELAY, - uint32 _ALLOCATION_CONFIGURATION_DELAY + uint32 _ALLOCATION_CONFIGURATION_DELAY, + string memory _version ) AllocationManagerStorage(_delegation, _DEALLOCATION_DELAY, _ALLOCATION_CONFIGURATION_DELAY) Pausable(_pauserRegistry) PermissionControllerMixin(_permissionController) + SemVerMixin(_version) { _disableInitializers(); } @@ -62,10 +67,9 @@ contract AllocationManager is ) external onlyWhenNotPaused(PAUSED_OPERATOR_SLASHING) checkCanCall(avs) { // Check that the operator set exists and the operator is registered to it OperatorSet memory operatorSet = OperatorSet(avs, params.operatorSetId); - bool isOperatorSlashable = _isOperatorSlashable(params.operator, operatorSet); require(params.strategies.length == params.wadsToSlash.length, InputArrayLengthMismatch()); require(_operatorSets[operatorSet.avs].contains(operatorSet.id), InvalidOperatorSet()); - require(isOperatorSlashable, OperatorNotSlashable()); + require(isOperatorSlashable(params.operator, operatorSet), OperatorNotSlashable()); uint256[] memory wadSlashed = new uint256[](params.strategies.length); @@ -172,7 +176,7 @@ contract AllocationManager is OperatorSet memory operatorSet = params[i].operatorSet; require(_operatorSets[operatorSet.avs].contains(operatorSet.id), InvalidOperatorSet()); - bool isOperatorSlashable = _isOperatorSlashable(operator, operatorSet); + bool _isOperatorSlashable = isOperatorSlashable(operator, operatorSet); for (uint256 j = 0; j < params[i].strategies.length; j++) { IStrategy strategy = params[i].strategies[j]; @@ -184,11 +188,11 @@ contract AllocationManager is (StrategyInfo memory info, Allocation memory allocation) = _getUpdatedAllocation(operator, operatorSet.key(), strategy); - require(allocation.pendingDiff == 0, ModificationAlreadyPending()); + require(allocation.effectBlock == 0, ModificationAlreadyPending()); // 2. Check whether the operator's allocation is slashable. If not, we allow instant // deallocation. - bool isSlashable = _isAllocationSlashable(operatorSet, strategy, allocation, isOperatorSlashable); + bool isSlashable = _isAllocationSlashable(operatorSet, strategy, allocation, _isOperatorSlashable); // 3. Calculate the change in magnitude allocation.pendingDiff = _calcDelta(allocation.currentMagnitude, params[i].newMagnitudes[j]); @@ -227,7 +231,7 @@ contract AllocationManager is // 6. Emit an event for the updated allocation emit AllocationUpdated( operator, - OperatorSetLib.decode(operatorSet.key()), + operatorSet, strategy, _addInt128(allocation.currentMagnitude, allocation.pendingDiff), allocation.effectBlock @@ -261,7 +265,7 @@ contract AllocationManager is // Check the operator set exists and the operator is not currently registered to it OperatorSet memory operatorSet = OperatorSet(params.avs, params.operatorSetIds[i]); require(_operatorSets[operatorSet.avs].contains(operatorSet.id), InvalidOperatorSet()); - require(!_isOperatorSlashable(operator, operatorSet), AlreadyMemberOfSet()); + require(!isOperatorSlashable(operator, operatorSet), AlreadyMemberOfSet()); // Add operator to operator set registeredSets[operator].add(operatorSet.key()); @@ -324,11 +328,18 @@ contract AllocationManager is /// @inheritdoc IAllocationManager function updateAVSMetadataURI(address avs, string calldata metadataURI) external checkCanCall(avs) { + if (!_avsRegisteredMetadata[avs]) { + _avsRegisteredMetadata[avs] = true; + } + emit AVSMetadataURIUpdated(avs, metadataURI); } /// @inheritdoc IAllocationManager function createOperatorSets(address avs, CreateSetParams[] calldata params) external checkCanCall(avs) { + // Check that the AVS exists and has registered metadata + require(_avsRegisteredMetadata[avs], NonexistentAVSMetadata()); + for (uint256 i = 0; i < params.length; i++) { OperatorSet memory operatorSet = OperatorSet(avs, params[i].operatorSetId); @@ -438,28 +449,19 @@ contract AllocationManager is emit AllocationDelaySet(operator, delay, info.effectBlock); } - /// @notice returns whether the operator is slashable in the given operator set - function _isOperatorSlashable(address operator, OperatorSet memory operatorSet) internal view returns (bool) { - RegistrationStatus memory status = registrationStatus[operator][operatorSet.key()]; - - // slashableUntil returns the last block the operator is slashable in so we check for - // less than or equal to - return status.registered || block.number <= status.slashableUntil; - } - /// @notice returns whether the operator's allocation is slashable in the given operator set function _isAllocationSlashable( OperatorSet memory operatorSet, IStrategy strategy, Allocation memory allocation, - bool isOperatorSlashable + bool _isOperatorSlashable ) internal view returns (bool) { /// forgefmt: disable-next-item return // If the operator set does not use this strategy, any allocation from it is not slashable _operatorSetStrategies[operatorSet.key()].contains(address(strategy)) && // If the operator is not slashable by the operatorSet, any allocation is not slashable - isOperatorSlashable && + _isOperatorSlashable && // If there is nothing allocated, the allocation is not slashable allocation.currentMagnitude != 0; } @@ -540,6 +542,53 @@ contract AllocationManager is } } + /** + * @dev Returns the minimum allocated stake at the future block. + * @param operatorSet The operator set to get the minimum allocated stake for. + * @param operators The operators to get the minimum allocated stake for. + * @param strategies The strategies to get the minimum allocated stake for. + * @param futureBlock The future block to get the minimum allocated stake for. + */ + function _getMinimumAllocatedStake( + OperatorSet memory operatorSet, + address[] memory operators, + IStrategy[] memory strategies, + uint32 futureBlock + ) internal view returns (uint256[][] memory allocatedStake) { + allocatedStake = new uint256[][](operators.length); + uint256[][] memory delegatedStake = delegation.getOperatorsShares(operators, strategies); + + for (uint256 i = 0; i < operators.length; i++) { + address operator = operators[i]; + + allocatedStake[i] = new uint256[](strategies.length); + + for (uint256 j = 0; j < strategies.length; j++) { + IStrategy strategy = strategies[j]; + + // Fetch the max magnitude and allocation for the operator/strategy. + // Prevent division by 0 if needed. This mirrors the "FullySlashed" checks + // in the DelegationManager + uint64 maxMagnitude = _maxMagnitudeHistory[operator][strategy].latest(); + if (maxMagnitude == 0) { + continue; + } + + Allocation memory alloc = getAllocation(operator, operatorSet, strategy); + + // If the pending change takes effect before `futureBlock`, include it in `currentMagnitude` + // However, ONLY include the pending change if it is a deallocation, since this method + // is supposed to return the minimum slashable stake between now and `futureBlock` + if (alloc.effectBlock <= futureBlock && alloc.pendingDiff < 0) { + alloc.currentMagnitude = _addInt128(alloc.currentMagnitude, alloc.pendingDiff); + } + + uint256 slashableProportion = uint256(alloc.currentMagnitude).divWad(maxMagnitude); + allocatedStake[i][j] = delegatedStake[i][j].mulWad(slashableProportion); + } + } + } + function _updateMaxMagnitude(address operator, IStrategy strategy, uint64 newMaxMagnitude) internal { _maxMagnitudeHistory[operator][strategy].push({key: uint32(block.number), value: newMaxMagnitude}); emit MaxMagnitudeUpdated(operator, strategy, newMaxMagnitude); @@ -549,8 +598,9 @@ contract AllocationManager is return int128(uint128(newMagnitude)) - int128(uint128(currentMagnitude)); } + /// @dev Use safe casting when downcasting to uint64 function _addInt128(uint64 a, int128 b) internal pure returns (uint64) { - return uint64(uint128(int128(uint128(a)) + b)); + return uint256(int256(int128(uint128(a)) + b)).toUint64(); } /** @@ -641,13 +691,30 @@ contract AllocationManager is return (operatorSets, _allocations); } + /// @inheritdoc IAllocationManager + function getEncumberedMagnitude(address operator, IStrategy strategy) external view returns (uint64) { + (uint64 curEncumberedMagnitude,) = _getFreeAndUsedMagnitude(operator, strategy); + return curEncumberedMagnitude; + } + /// @inheritdoc IAllocationManager function getAllocatableMagnitude(address operator, IStrategy strategy) external view returns (uint64) { + (, uint64 curAllocatableMagnitude) = _getFreeAndUsedMagnitude(operator, strategy); + return curAllocatableMagnitude; + } + + /// @dev For an operator, returns up-to-date amounts for current encumbered and available + /// magnitude. Note that these two values will always add up to the operator's max magnitude + /// for the strategy + function _getFreeAndUsedMagnitude( + address operator, + IStrategy strategy + ) internal view returns (uint64 curEncumberedMagnitude, uint64 curAllocatableMagnitude) { // This method needs to simulate clearing any pending deallocations. // This roughly mimics the calculations done in `_clearDeallocationQueue` and // `_getUpdatedAllocation`, while operating on a `curEncumberedMagnitude` // rather than continually reading/updating state. - uint64 curEncumberedMagnitude = encumberedMagnitude[operator][strategy]; + curEncumberedMagnitude = encumberedMagnitude[operator][strategy]; uint256 length = deallocationQueue[operator][strategy].length(); for (uint256 i = 0; i < length; ++i) { @@ -668,7 +735,8 @@ contract AllocationManager is // The difference between the operator's max magnitude and its encumbered magnitude // is the magnitude that can be allocated. - return _maxMagnitudeHistory[operator][strategy].latest() - curEncumberedMagnitude; + curAllocatableMagnitude = _maxMagnitudeHistory[operator][strategy].latest() - curEncumberedMagnitude; + return (curEncumberedMagnitude, curAllocatableMagnitude); } /// @inheritdoc IAllocationManager @@ -804,36 +872,35 @@ contract AllocationManager is IStrategy[] memory strategies, uint32 futureBlock ) external view returns (uint256[][] memory slashableStake) { - slashableStake = new uint256[][](operators.length); - uint256[][] memory delegatedStake = delegation.getOperatorsShares(operators, strategies); + slashableStake = _getMinimumAllocatedStake(operatorSet, operators, strategies, futureBlock); for (uint256 i = 0; i < operators.length; i++) { - address operator = operators[i]; - slashableStake[i] = new uint256[](strategies.length); - - for (uint256 j = 0; j < strategies.length; j++) { - IStrategy strategy = strategies[j]; - - // Fetch the max magnitude and allocation for the operator/strategy. - // Prevent division by 0 if needed. This mirrors the "FullySlashed" checks - // in the DelegationManager - uint64 maxMagnitude = _maxMagnitudeHistory[operator][strategy].latest(); - if (maxMagnitude == 0) { - continue; + // If the operator is not slashable by the opSet, all strategies should have a slashable stake of 0 + if (!isOperatorSlashable(operators[i], operatorSet)) { + for (uint256 j = 0; j < strategies.length; j++) { + slashableStake[i][j] = 0; } + } + } + } - Allocation memory alloc = getAllocation(operator, operatorSet, strategy); + /// @inheritdoc IAllocationManager + function getAllocatedStake( + OperatorSet memory operatorSet, + address[] memory operators, + IStrategy[] memory strategies + ) public view returns (uint256[][] memory) { + /// This helper function returns the minimum allocated stake by taking into account deallocations at some `futureBlock`. + /// We use the block.number, as the `futureBlock`, meaning that no **future** deallocations are considered. + return _getMinimumAllocatedStake(operatorSet, operators, strategies, uint32(block.number)); + } - // If the pending change takes effect before `futureBlock`, include it in `currentMagnitude` - // However, ONLY include the pending change if it is a deallocation, since this method - // is supposed to return the minimum slashable stake between now and `futureBlock` - if (alloc.effectBlock <= futureBlock && alloc.pendingDiff < 0) { - alloc.currentMagnitude = _addInt128(alloc.currentMagnitude, alloc.pendingDiff); - } + /// @inheritdoc IAllocationManager + function isOperatorSlashable(address operator, OperatorSet memory operatorSet) public view returns (bool) { + RegistrationStatus memory status = registrationStatus[operator][operatorSet.key()]; - uint256 slashableProportion = uint256(alloc.currentMagnitude).divWad(maxMagnitude); - slashableStake[i][j] = delegatedStake[i][j].mulWad(slashableProportion); - } - } + // slashableUntil returns the last block the operator is slashable in so we check for + // less than or equal to + return status.registered || block.number <= status.slashableUntil; } } diff --git a/src/contracts/core/AllocationManagerStorage.sol b/src/contracts/core/AllocationManagerStorage.sol index caab8f4195..24bbb8f3e7 100644 --- a/src/contracts/core/AllocationManagerStorage.sol +++ b/src/contracts/core/AllocationManagerStorage.sol @@ -83,14 +83,16 @@ abstract contract AllocationManagerStorage is IAllocationManager { _maxMagnitudeHistory; /// @dev For a strategy, contains the amount of magnitude an operator has allocated to operator sets - /// @dev This value should be read with caution, as deallocations that are completable but not - /// popped off the queue are still included in the encumbered magnitude - mapping(address operator => mapping(IStrategy strategy => uint64)) public encumberedMagnitude; + mapping(address operator => mapping(IStrategy strategy => uint64)) internal encumberedMagnitude; /// @dev For a strategy, keeps an ordered queue of operator sets that have pending deallocations /// These must be completed in order to free up magnitude for future allocation mapping(address operator => mapping(IStrategy strategy => DoubleEndedQueue.Bytes32Deque)) internal deallocationQueue; + /// @dev Lists the AVSs who has registered metadata and claimed itself as an AVS + /// @notice bool is not used and is always true if the avs has registered metadata + mapping(address avs => bool) internal _avsRegisteredMetadata; + // Construction constructor(IDelegationManager _delegation, uint32 _DEALLOCATION_DELAY, uint32 _ALLOCATION_CONFIGURATION_DELAY) { @@ -104,5 +106,5 @@ abstract contract AllocationManagerStorage is IAllocationManager { * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ - uint256[37] private __gap; + uint256[36] private __gap; } diff --git a/src/contracts/core/DelegationManager.sol b/src/contracts/core/DelegationManager.sol index 2d5350b408..13cfb70254 100644 --- a/src/contracts/core/DelegationManager.sol +++ b/src/contracts/core/DelegationManager.sol @@ -5,7 +5,7 @@ import "@openzeppelin-upgrades/contracts/proxy/utils/Initializable.sol"; import "@openzeppelin-upgrades/contracts/access/OwnableUpgradeable.sol"; import "@openzeppelin-upgrades/contracts/security/ReentrancyGuardUpgradeable.sol"; -import "../mixins/SignatureUtils.sol"; +import "../mixins/SignatureUtilsMixin.sol"; import "../mixins/PermissionControllerMixin.sol"; import "../permissions/Pausable.sol"; import "../libraries/SlashingLib.sol"; @@ -28,8 +28,8 @@ contract DelegationManager is Pausable, DelegationManagerStorage, ReentrancyGuardUpgradeable, - SignatureUtils, - PermissionControllerMixin + PermissionControllerMixin, + SignatureUtilsMixin { using SlashingLib for *; using Snapshots for Snapshots.DefaultZeroHistory; @@ -69,11 +69,13 @@ contract DelegationManager is IAllocationManager _allocationManager, IPauserRegistry _pauserRegistry, IPermissionController _permissionController, - uint32 _MIN_WITHDRAWAL_DELAY + uint32 _MIN_WITHDRAWAL_DELAY, + string memory _version ) DelegationManagerStorage(_strategyManager, _eigenPodManager, _allocationManager, _MIN_WITHDRAWAL_DELAY) Pausable(_pauserRegistry) PermissionControllerMixin(_permissionController) + SignatureUtilsMixin(_version) { _disableInitializers(); } @@ -94,7 +96,7 @@ contract DelegationManager is address initDelegationApprover, uint32 allocationDelay, string calldata metadataURI - ) external { + ) external nonReentrant { require(!isDelegated(msg.sender), ActivelyDelegated()); allocationManager.setAllocationDelay(msg.sender, allocationDelay); @@ -108,7 +110,10 @@ contract DelegationManager is } /// @inheritdoc IDelegationManager - function modifyOperatorDetails(address operator, address newDelegationApprover) external checkCanCall(operator) { + function modifyOperatorDetails( + address operator, + address newDelegationApprover + ) external checkCanCall(operator) nonReentrant { require(isOperator(operator), OperatorNotRegistered()); _setDelegationApprover(operator, newDelegationApprover); } @@ -124,7 +129,7 @@ contract DelegationManager is address operator, SignatureWithExpiry memory approverSignatureAndExpiry, bytes32 approverSalt - ) public { + ) public nonReentrant { require(!isDelegated(msg.sender), ActivelyDelegated()); require(isOperator(operator), OperatorNotRegistered()); @@ -143,7 +148,7 @@ contract DelegationManager is /// @inheritdoc IDelegationManager function undelegate( address staker - ) public returns (bytes32[] memory withdrawalRoots) { + ) public nonReentrant returns (bytes32[] memory withdrawalRoots) { // Check that the `staker` can undelegate require(isDelegated(staker), NotActivelyDelegated()); require(!isOperator(staker), OperatorsCannotUndelegate()); @@ -174,7 +179,7 @@ contract DelegationManager is /// @inheritdoc IDelegationManager function queueWithdrawals( QueuedWithdrawalParams[] calldata params - ) external onlyWhenNotPaused(PAUSED_ENTER_WITHDRAWAL_QUEUE) returns (bytes32[] memory) { + ) external onlyWhenNotPaused(PAUSED_ENTER_WITHDRAWAL_QUEUE) nonReentrant returns (bytes32[] memory) { bytes32[] memory withdrawalRoots = new bytes32[](params.length); address operator = delegatedTo[msg.sender]; @@ -226,7 +231,7 @@ contract DelegationManager is IStrategy strategy, uint256 prevDepositShares, uint256 addedShares - ) external onlyStrategyManagerOrEigenPodManager { + ) external onlyStrategyManagerOrEigenPodManager nonReentrant { /// Note: Unlike `decreaseDelegatedShares`, we don't return early if the staker has no operator. /// This is because `_increaseDelegation` updates the staker's deposit scaling factor, which we /// need to do even if not delegated. @@ -250,7 +255,7 @@ contract DelegationManager is address staker, uint256 curDepositShares, uint64 beaconChainSlashingFactorDecrease - ) external onlyEigenPodManager { + ) external onlyEigenPodManager nonReentrant { if (!isDelegated(staker)) { return; } @@ -280,7 +285,7 @@ contract DelegationManager is IStrategy strategy, uint64 prevMaxMagnitude, uint64 newMaxMagnitude - ) external onlyAllocationManager { + ) external onlyAllocationManager nonReentrant { /// forgefmt: disable-next-item uint256 operatorSharesSlashed = SlashingLib.calcSlashedAmount({ operatorShares: operatorShares[operator][strategy], @@ -307,6 +312,9 @@ contract DelegationManager is sharesToDecrease: operatorSharesSlashed }); + // Emit event for operator shares being slashed + emit OperatorSharesSlashed(operator, strategy, totalDepositSharesToBurn); + IShareManager shareManager = _getShareManager(strategy); // NOTE: for beaconChainETHStrategy, increased burnable shares currently have no mechanism for burning shareManager.increaseBurnableShares(strategy, totalDepositSharesToBurn); @@ -340,24 +348,37 @@ contract DelegationManager is * 1) new delegations are not paused (PAUSED_NEW_DELEGATION) */ function _delegate(address staker, address operator) internal onlyWhenNotPaused(PAUSED_NEW_DELEGATION) { - // record the delegation relation between the staker and operator, and emit an event + // When a staker is not delegated to an operator, their deposit shares are equal to their + // withdrawable shares -- except for the beaconChainETH strategy, which is handled below + (IStrategy[] memory strategies, uint256[] memory withdrawableShares) = getDepositedShares(staker); + + // Retrieve the amount of slashing experienced by the operator in each strategy so far. + // When delegating, we "forgive" the staker for this slashing by adjusting their + // deposit scaling factor. + uint256[] memory operatorSlashingFactors = _getSlashingFactors(address(0), operator, strategies); + + // Delegate to the operator delegatedTo[staker] = operator; emit StakerDelegated(staker, operator); - // read staker's deposited shares and strategies to add to operator's shares - // and also update the staker depositScalingFactor for each strategy - (IStrategy[] memory strategies, uint256[] memory depositedShares) = getDepositedShares(staker); - uint256[] memory slashingFactors = _getSlashingFactors(staker, operator, strategies); - for (uint256 i = 0; i < strategies.length; ++i) { + // Special case for beacon chain slashing - ensure the staker's beacon chain slashing is + // reflected in the number of shares they delegate. + if (strategies[i] == beaconChainETHStrategy) { + uint64 stakerBeaconChainSlashing = eigenPodManager.beaconChainSlashingFactor(staker); + + DepositScalingFactor memory dsf = _depositScalingFactor[staker][strategies[i]]; + withdrawableShares[i] = dsf.calcWithdrawable(withdrawableShares[i], stakerBeaconChainSlashing); + } + // forgefmt: disable-next-item _increaseDelegation({ operator: operator, staker: staker, strategy: strategies[i], prevDepositShares: uint256(0), - addedShares: depositedShares[i], - slashingFactor: slashingFactors[i] + addedShares: withdrawableShares[i], + slashingFactor: operatorSlashingFactors[i] }); } } @@ -478,7 +499,11 @@ contract DelegationManager is } // Remove deposit shares from EigenPodManager/StrategyManager - shareManager.removeDepositShares(staker, strategies[i], depositSharesToWithdraw[i]); + uint256 sharesAfter = shareManager.removeDepositShares(staker, strategies[i], depositSharesToWithdraw[i]); + + if (sharesAfter == 0) { + _depositScalingFactor[staker][strategies[i]].reset(); + } } // Create queue entry and increment withdrawal nonce @@ -562,6 +587,11 @@ contract DelegationManager is slashingFactor: prevSlashingFactors[i] }); + //Do nothing if 0 shares to withdraw + if (sharesToWithdraw == 0) { + continue; + } + if (receiveAsTokens) { // Withdraws `shares` in `strategy` to `withdrawer`. If the shares are virtual beaconChainETH shares, // then a call is ultimately forwarded to the `staker`s EigenPod; otherwise a call is ultimately forwarded @@ -577,7 +607,6 @@ contract DelegationManager is (uint256 prevDepositShares, uint256 addedShares) = shareManager.addShares({ staker: withdrawal.staker, strategy: withdrawal.strategies[i], - token: tokens[i], shares: sharesToWithdraw }); @@ -674,7 +703,10 @@ contract DelegationManager is }); } - /// @dev Calculate the amount of slashing to apply to the staker's shares + /// @dev Calculate the amount of slashing to apply to the staker's shares. + /// @dev Be mindful of rounding in `mulWad()`, it's possible for the slashing factor to round down to 0 + /// even when both operatorMaxMagnitude and beaconChainSlashingFactor are non-zero. This is only possible + /// in an edge case where the operator has a very low maxMagnitude. function _getSlashingFactor( address staker, IStrategy strategy, @@ -760,11 +792,43 @@ contract DelegationManager is /// @dev Add to the cumulative withdrawn scaled shares from an operator for a given strategy function _addQueuedSlashableShares(address operator, IStrategy strategy, uint256 scaledShares) internal { - if (strategy != beaconChainETHStrategy) { - uint256 currCumulativeScaledShares = _cumulativeScaledSharesHistory[operator][strategy].latest(); - _cumulativeScaledSharesHistory[operator][strategy].push({ - key: uint32(block.number), - value: currCumulativeScaledShares + scaledShares + uint256 currCumulativeScaledShares = _cumulativeScaledSharesHistory[operator][strategy].latest(); + _cumulativeScaledSharesHistory[operator][strategy].push({ + key: uint32(block.number), + value: currCumulativeScaledShares + scaledShares + }); + } + + /// @dev Get the shares from a queued withdrawal. + function _getSharesByWithdrawalRoot( + bytes32 withdrawalRoot + ) internal view returns (Withdrawal memory withdrawal, uint256[] memory shares) { + withdrawal = queuedWithdrawals[withdrawalRoot]; + shares = new uint256[](withdrawal.strategies.length); + + uint32 slashableUntil = withdrawal.startBlock + MIN_WITHDRAWAL_DELAY_BLOCKS; + + // If the slashableUntil block is in the past, read the slashing factors at that block. + // Otherwise, read the current slashing factors. Note that if the slashableUntil block is the current block + // or in the future, then the slashing factors are still subject to change before the withdrawal is completable, + // which may result in fewer shares being withdrawn. + uint256[] memory slashingFactors = slashableUntil < uint32(block.number) + ? _getSlashingFactorsAtBlock({ + staker: withdrawal.staker, + operator: withdrawal.delegatedTo, + strategies: withdrawal.strategies, + blockNumber: slashableUntil + }) + : _getSlashingFactors({ + staker: withdrawal.staker, + operator: withdrawal.delegatedTo, + strategies: withdrawal.strategies + }); + + for (uint256 j; j < withdrawal.strategies.length; ++j) { + shares[j] = SlashingLib.scaleForCompleteWithdrawal({ + scaledShares: withdrawal.scaledShares[j], + slashingFactor: slashingFactors[j] }); } } @@ -907,6 +971,13 @@ contract DelegationManager is return queuedWithdrawals[withdrawalRoot]; } + /// @inheritdoc IDelegationManager + function getQueuedWithdrawalFromRoot( + bytes32 withdrawalRoot + ) external view returns (Withdrawal memory withdrawal, uint256[] memory shares) { + (withdrawal, shares) = _getSharesByWithdrawalRoot(withdrawalRoot); + } + /// @inheritdoc IDelegationManager function getQueuedWithdrawals( address staker @@ -917,37 +988,8 @@ contract DelegationManager is withdrawals = new Withdrawal[](totalQueued); shares = new uint256[][](totalQueued); - address operator = delegatedTo[staker]; - for (uint256 i; i < totalQueued; ++i) { - withdrawals[i] = queuedWithdrawals[withdrawalRoots[i]]; - shares[i] = new uint256[](withdrawals[i].strategies.length); - - uint32 slashableUntil = withdrawals[i].startBlock + MIN_WITHDRAWAL_DELAY_BLOCKS; - - uint256[] memory slashingFactors; - // If slashableUntil block is in the past, read the slashing factors at that block - // Otherwise read the current slashing factors. Note that if the slashableUntil block is the current block - // or in the future then the slashing factors are still subject to change before the withdrawal is completable - // and the shares withdrawn to be less - if (slashableUntil < uint32(block.number)) { - slashingFactors = _getSlashingFactorsAtBlock({ - staker: staker, - operator: operator, - strategies: withdrawals[i].strategies, - blockNumber: slashableUntil - }); - } else { - slashingFactors = - _getSlashingFactors({staker: staker, operator: operator, strategies: withdrawals[i].strategies}); - } - - for (uint256 j; j < withdrawals[i].strategies.length; ++j) { - shares[i][j] = SlashingLib.scaleForCompleteWithdrawal({ - scaledShares: withdrawals[i].scaledShares[j], - slashingFactor: slashingFactors[j] - }); - } + (withdrawals[i], shares[i]) = _getSharesByWithdrawalRoot(withdrawalRoots[i]); } } diff --git a/src/contracts/core/RewardsCoordinator.sol b/src/contracts/core/RewardsCoordinator.sol index 13e2569d59..24ee4af825 100644 --- a/src/contracts/core/RewardsCoordinator.sol +++ b/src/contracts/core/RewardsCoordinator.sol @@ -10,6 +10,7 @@ import "../libraries/Merkle.sol"; import "../permissions/Pausable.sol"; import "./RewardsCoordinatorStorage.sol"; import "../mixins/PermissionControllerMixin.sol"; +import "../mixins/SemVerMixin.sol"; /** * @title RewardsCoordinator @@ -26,7 +27,8 @@ contract RewardsCoordinator is Pausable, ReentrancyGuardUpgradeable, RewardsCoordinatorStorage, - PermissionControllerMixin + PermissionControllerMixin, + SemVerMixin { using SafeERC20 for IERC20; @@ -42,29 +44,21 @@ contract RewardsCoordinator is /// @dev Sets the immutable variables for the contract constructor( - IDelegationManager _delegationManager, - IStrategyManager _strategyManager, - IAllocationManager _allocationManager, - IPauserRegistry _pauserRegistry, - IPermissionController _permissionController, - uint32 _CALCULATION_INTERVAL_SECONDS, - uint32 _MAX_REWARDS_DURATION, - uint32 _MAX_RETROACTIVE_LENGTH, - uint32 _MAX_FUTURE_LENGTH, - uint32 _GENESIS_REWARDS_TIMESTAMP + RewardsCoordinatorConstructorParams memory params ) RewardsCoordinatorStorage( - _delegationManager, - _strategyManager, - _allocationManager, - _CALCULATION_INTERVAL_SECONDS, - _MAX_REWARDS_DURATION, - _MAX_RETROACTIVE_LENGTH, - _MAX_FUTURE_LENGTH, - _GENESIS_REWARDS_TIMESTAMP + params.delegationManager, + params.strategyManager, + params.allocationManager, + params.CALCULATION_INTERVAL_SECONDS, + params.MAX_REWARDS_DURATION, + params.MAX_RETROACTIVE_LENGTH, + params.MAX_FUTURE_LENGTH, + params.GENESIS_REWARDS_TIMESTAMP ) - Pausable(_pauserRegistry) - PermissionControllerMixin(_permissionController) + Pausable(params.pauserRegistry) + PermissionControllerMixin(params.permissionController) + SemVerMixin(params.version) { _disableInitializers(); } diff --git a/src/contracts/core/RewardsCoordinatorStorage.sol b/src/contracts/core/RewardsCoordinatorStorage.sol index 6c519214f9..31d4b61f1a 100644 --- a/src/contracts/core/RewardsCoordinatorStorage.sol +++ b/src/contracts/core/RewardsCoordinatorStorage.sol @@ -2,9 +2,6 @@ pragma solidity ^0.8.27; import "../interfaces/IRewardsCoordinator.sol"; -import "../interfaces/IDelegationManager.sol"; -import "../interfaces/IStrategyManager.sol"; -import "../interfaces/IAllocationManager.sol"; /** * @title Storage variables for the `RewardsCoordinator` contract. diff --git a/src/contracts/core/StrategyManager.sol b/src/contracts/core/StrategyManager.sol index 3f986fedec..fddf81a06c 100644 --- a/src/contracts/core/StrategyManager.sol +++ b/src/contracts/core/StrategyManager.sol @@ -6,7 +6,7 @@ import "@openzeppelin-upgrades/contracts/access/OwnableUpgradeable.sol"; import "@openzeppelin-upgrades/contracts/security/ReentrancyGuardUpgradeable.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; -import "../mixins/SignatureUtils.sol"; +import "../mixins/SignatureUtilsMixin.sol"; import "../interfaces/IEigenPodManager.sol"; import "../permissions/Pausable.sol"; import "./StrategyManagerStorage.sol"; @@ -26,7 +26,7 @@ contract StrategyManager is ReentrancyGuardUpgradeable, Pausable, StrategyManagerStorage, - SignatureUtils + SignatureUtilsMixin { using SlashingLib for *; using SafeERC20 for IERC20; @@ -53,8 +53,9 @@ contract StrategyManager is */ constructor( IDelegationManager _delegation, - IPauserRegistry _pauserRegistry - ) StrategyManagerStorage(_delegation) Pausable(_pauserRegistry) { + IPauserRegistry _pauserRegistry, + string memory _version + ) StrategyManagerStorage(_delegation) Pausable(_pauserRegistry) SignatureUtilsMixin(_version) { _disableInitializers(); } @@ -81,8 +82,8 @@ contract StrategyManager is IStrategy strategy, IERC20 token, uint256 amount - ) external onlyWhenNotPaused(PAUSED_DEPOSITS) nonReentrant returns (uint256 depositedShares) { - depositedShares = _depositIntoStrategy(msg.sender, strategy, token, amount); + ) external onlyWhenNotPaused(PAUSED_DEPOSITS) nonReentrant returns (uint256 depositShares) { + depositShares = _depositIntoStrategy(msg.sender, strategy, token, amount); } /// @inheritdoc IStrategyManager @@ -93,7 +94,7 @@ contract StrategyManager is address staker, uint256 expiry, bytes memory signature - ) external onlyWhenNotPaused(PAUSED_DEPOSITS) nonReentrant returns (uint256 depositedShares) { + ) external onlyWhenNotPaused(PAUSED_DEPOSITS) nonReentrant returns (uint256 depositShares) { // Cache staker's nonce to avoid sloads. uint256 nonce = nonces[staker]; // Assert that the signature is valid. @@ -108,7 +109,7 @@ contract StrategyManager is nonces[staker] = nonce + 1; } // deposit the tokens (from the `msg.sender`) and credit the new shares to the `staker` - depositedShares = _depositIntoStrategy(staker, strategy, token, amount); + depositShares = _depositIntoStrategy(staker, strategy, token, amount); } /// @inheritdoc IShareManager @@ -116,18 +117,18 @@ contract StrategyManager is address staker, IStrategy strategy, uint256 depositSharesToRemove - ) external onlyDelegationManager { - _removeDepositShares(staker, strategy, depositSharesToRemove); + ) external onlyDelegationManager nonReentrant returns (uint256) { + (, uint256 sharesAfter) = _removeDepositShares(staker, strategy, depositSharesToRemove); + return sharesAfter; } /// @inheritdoc IShareManager function addShares( address staker, IStrategy strategy, - IERC20 token, uint256 shares - ) external onlyDelegationManager returns (uint256, uint256) { - return _addShares(staker, token, strategy, shares); + ) external onlyDelegationManager nonReentrant returns (uint256, uint256) { + return _addShares(staker, strategy, shares); } /// @inheritdoc IShareManager @@ -136,13 +137,17 @@ contract StrategyManager is IStrategy strategy, IERC20 token, uint256 shares - ) external onlyDelegationManager { + ) external onlyDelegationManager nonReentrant { strategy.withdraw(staker, token, shares); } /// @inheritdoc IShareManager - function increaseBurnableShares(IStrategy strategy, uint256 addedSharesToBurn) external onlyDelegationManager { - burnableShares[strategy] += addedSharesToBurn; + function increaseBurnableShares( + IStrategy strategy, + uint256 addedSharesToBurn + ) external onlyDelegationManager nonReentrant { + (, uint256 currentShares) = EnumerableMap.tryGet(burnableShares, address(strategy)); + EnumerableMap.set(burnableShares, address(strategy), currentShares + addedSharesToBurn); emit BurnableSharesIncreased(strategy, addedSharesToBurn); } @@ -150,24 +155,28 @@ contract StrategyManager is function burnShares( IStrategy strategy ) external nonReentrant { - uint256 sharesToBurn = burnableShares[strategy]; - burnableShares[strategy] = 0; + (, uint256 sharesToBurn) = EnumerableMap.tryGet(burnableShares, address(strategy)); + EnumerableMap.remove(burnableShares, address(strategy)); emit BurnableSharesDecreased(strategy, sharesToBurn); - // burning shares is functionally the same as withdrawing but with different destination address - strategy.withdraw(DEFAULT_BURN_ADDRESS, strategy.underlyingToken(), sharesToBurn); + + // Burning acts like withdrawing, except that the destination is to the burn address. + // If we have no shares to burn, we don't need to call the strategy. + if (sharesToBurn != 0) { + strategy.withdraw(DEFAULT_BURN_ADDRESS, strategy.underlyingToken(), sharesToBurn); + } } /// @inheritdoc IStrategyManager function setStrategyWhitelister( address newStrategyWhitelister - ) external onlyOwner { + ) external onlyOwner nonReentrant { _setStrategyWhitelister(newStrategyWhitelister); } /// @inheritdoc IStrategyManager function addStrategiesToDepositWhitelist( IStrategy[] calldata strategiesToWhitelist - ) external onlyStrategyWhitelister { + ) external onlyStrategyWhitelister nonReentrant { uint256 strategiesToWhitelistLength = strategiesToWhitelist.length; for (uint256 i = 0; i < strategiesToWhitelistLength; ++i) { // change storage and emit event only if strategy is not already in whitelist @@ -181,7 +190,7 @@ contract StrategyManager is /// @inheritdoc IStrategyManager function removeStrategiesFromDepositWhitelist( IStrategy[] calldata strategiesToRemoveFromWhitelist - ) external onlyStrategyWhitelister { + ) external onlyStrategyWhitelister nonReentrant { uint256 strategiesToRemoveFromWhitelistLength = strategiesToRemoveFromWhitelist.length; for (uint256 i = 0; i < strategiesToRemoveFromWhitelistLength; ++i) { // change storage and emit event only if strategy is already in whitelist @@ -197,19 +206,13 @@ contract StrategyManager is /** * @notice This function adds `shares` for a given `strategy` to the `staker` and runs through the necessary update logic. * @param staker The address to add shares to - * @param token The token that is being deposited (used for indexing) * @param strategy The Strategy in which the `staker` is receiving shares * @param shares The amount of shares to grant to the `staker` * @dev In particular, this function calls `delegation.increaseDelegatedShares(staker, strategy, shares)` to ensure that all * delegated shares are tracked, increases the stored share amount in `stakerDepositShares[staker][strategy]`, and adds `strategy` * to the `staker`'s list of strategies, if it is not in the list already. */ - function _addShares( - address staker, - IERC20 token, - IStrategy strategy, - uint256 shares - ) internal returns (uint256, uint256) { + function _addShares(address staker, IStrategy strategy, uint256 shares) internal returns (uint256, uint256) { // sanity checks on inputs require(staker != address(0), StakerAddressZero()); require(shares != 0, SharesAmountZero()); @@ -225,7 +228,7 @@ contract StrategyManager is // add the returned depositedShares to their existing shares for this strategy stakerDepositShares[staker][strategy] = prevDepositShares + shares; - emit Deposit(staker, token, strategy, shares); + emit Deposit(staker, strategy, shares); return (prevDepositShares, shares); } @@ -251,7 +254,7 @@ contract StrategyManager is shares = strategy.deposit(token, amount); // add the returned shares to the staker's existing shares for this strategy - (uint256 prevDepositShares, uint256 addedShares) = _addShares(staker, token, strategy, shares); + (uint256 prevDepositShares, uint256 addedShares) = _addShares(staker, strategy, shares); // Increase shares delegated to operator delegation.increaseDelegatedShares({ @@ -271,12 +274,13 @@ contract StrategyManager is * @param depositSharesToRemove The amount of deposit shares to decrement * @dev If the amount of shares represents all of the staker`s shares in said strategy, * then the strategy is removed from stakerStrategyList[staker] and 'true' is returned. Otherwise 'false' is returned. + * Also returns the user's udpated deposit shares after decrement. */ function _removeDepositShares( address staker, IStrategy strategy, uint256 depositSharesToRemove - ) internal returns (bool) { + ) internal returns (bool, uint256) { // sanity checks on inputs require(depositSharesToRemove != 0, SharesAmountZero()); @@ -296,10 +300,10 @@ contract StrategyManager is _removeStrategyFromStakerStrategyList(staker, strategy); // return true in the event that the strategy was removed from stakerStrategyList[staker] - return true; + return (true, userDepositShares); } // return false in the event that the strategy was *not* removed from stakerStrategyList[staker] - return false; + return (false, userDepositShares); } /** @@ -387,4 +391,28 @@ contract StrategyManager is ) ); } + + /// @inheritdoc IStrategyManager + function getBurnableShares( + IStrategy strategy + ) external view returns (uint256) { + (, uint256 shares) = EnumerableMap.tryGet(burnableShares, address(strategy)); + return shares; + } + + /// @inheritdoc IStrategyManager + function getStrategiesWithBurnableShares() external view returns (address[] memory, uint256[] memory) { + uint256 totalEntries = EnumerableMap.length(burnableShares); + + address[] memory strategies = new address[](totalEntries); + uint256[] memory shares = new uint256[](totalEntries); + + for (uint256 i = 0; i < totalEntries; i++) { + (address strategy, uint256 shareAmount) = EnumerableMap.at(burnableShares, i); + strategies[i] = strategy; + shares[i] = shareAmount; + } + + return (strategies, shares); + } } diff --git a/src/contracts/core/StrategyManagerStorage.sol b/src/contracts/core/StrategyManagerStorage.sol index 705dab4a44..61db02e792 100644 --- a/src/contracts/core/StrategyManagerStorage.sol +++ b/src/contracts/core/StrategyManagerStorage.sol @@ -1,6 +1,8 @@ // SPDX-License-Identifier: BUSL-1.1 pragma solidity ^0.8.27; +import "@openzeppelin/contracts/utils/structs/EnumerableMap.sol"; + import "../interfaces/IStrategyManager.sol"; import "../interfaces/IStrategy.sol"; import "../interfaces/IEigenPodManager.sol"; @@ -69,8 +71,8 @@ abstract contract StrategyManagerStorage is IStrategyManager { /// @dev Do not remove, deprecated storage. mapping(IStrategy strategy => bool) private __deprecated_thirdPartyTransfersForbidden; - /// @notice Returns the amount of `shares` that have been slashed on EigenLayer but not burned yet. - mapping(IStrategy strategy => uint256) public burnableShares; + /// @notice Returns the amount of `shares` that have been slashed on EigenLayer but not burned yet. Takes 3 storage slots. + EnumerableMap.AddressToUintMap internal burnableShares; // Construction @@ -88,5 +90,5 @@ abstract contract StrategyManagerStorage is IStrategyManager { * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ - uint256[38] private __gap; + uint256[36] private __gap; } diff --git a/src/contracts/interfaces/IAVSDirectory.sol b/src/contracts/interfaces/IAVSDirectory.sol index 1276682ca1..4d48aa93df 100644 --- a/src/contracts/interfaces/IAVSDirectory.sol +++ b/src/contracts/interfaces/IAVSDirectory.sol @@ -1,7 +1,7 @@ // SPDX-License-Identifier: BUSL-1.1 pragma solidity >=0.5.0; -import "./ISignatureUtils.sol"; +import "./ISignatureUtilsMixin.sol"; import "./IPauserRegistry.sol"; import "./IStrategy.sol"; @@ -53,7 +53,7 @@ interface IAVSDirectoryEvents is IAVSDirectoryTypes { event AVSMetadataURIUpdated(address indexed avs, string metadataURI); } -interface IAVSDirectory is IAVSDirectoryEvents, IAVSDirectoryErrors, ISignatureUtils { +interface IAVSDirectory is IAVSDirectoryEvents, IAVSDirectoryErrors, ISignatureUtilsMixin { /** * * EXTERNAL FUNCTIONS @@ -98,7 +98,7 @@ interface IAVSDirectory is IAVSDirectoryEvents, IAVSDirectoryErrors, ISignatureU */ function registerOperatorToAVS( address operator, - ISignatureUtils.SignatureWithSaltAndExpiry memory operatorSignature + ISignatureUtilsMixinTypes.SignatureWithSaltAndExpiry memory operatorSignature ) external; /** diff --git a/src/contracts/interfaces/IAllocationManager.sol b/src/contracts/interfaces/IAllocationManager.sol index 0033fc736f..c74fcd2266 100644 --- a/src/contracts/interfaces/IAllocationManager.sol +++ b/src/contracts/interfaces/IAllocationManager.sol @@ -5,6 +5,7 @@ import {OperatorSet} from "../libraries/OperatorSetLib.sol"; import "./IPauserRegistry.sol"; import "./IStrategy.sol"; import "./IAVSRegistrar.sol"; +import "./ISemVerMixin.sol"; interface IAllocationManagerErrors { /// Input Validation @@ -23,6 +24,8 @@ interface IAllocationManagerErrors { /// @dev Thrown when an invalid operator is provided. error InvalidOperator(); + /// @dev Thrown when an invalid avs whose metadata is not registered is provided. + error NonexistentAVSMetadata(); /// @dev Thrown when an operator's allocation delay has yet to be set. error UninitializedAllocationDelay(); /// @dev Thrown when attempting to slash an operator when they are not slashable. @@ -210,14 +213,33 @@ interface IAllocationManagerEvents is IAllocationManagerTypes { event StrategyRemovedFromOperatorSet(OperatorSet operatorSet, IStrategy strategy); } -interface IAllocationManager is IAllocationManagerErrors, IAllocationManagerEvents { +interface IAllocationManager is IAllocationManagerErrors, IAllocationManagerEvents, ISemVerMixin { /** * @dev Initializes the initial owner and paused status. */ function initialize(address initialOwner, uint256 initialPausedStatus) external; /** - * @notice Called by an AVS to slash an operator in a given operator set + * @notice Called by an AVS to slash an operator in a given operator set. The operator must be registered + * and have slashable stake allocated to the operator set. + * + * @param avs The AVS address initiating the slash. + * @param params The slashing parameters, containing: + * - operator: The operator to slash. + * - operatorSetId: The ID of the operator set the operator is being slashed from. + * - strategies: Array of strategies to slash allocations from (must be in ascending order). + * - wadsToSlash: Array of proportions to slash from each strategy (must be between 0 and 1e18). + * - description: Description of why the operator was slashed. + * + * @dev For each strategy: + * 1. Reduces the operator's current allocation magnitude by wadToSlash proportion. + * 2. Reduces the strategy's max and encumbered magnitudes proportionally. + * 3. If there is a pending deallocation, reduces it proportionally. + * 4. Updates the operator's shares in the DelegationManager. + * + * @dev Small slashing amounts may not result in actual token burns due to + * rounding, which will result in small amounts of tokens locked in the contract + * rather than fully burning through the burn mechanism. */ function slashOperator(address avs, SlashingParams calldata params) external; @@ -397,6 +419,14 @@ interface IAllocationManager is IAllocationManagerErrors, IAllocationManagerEven IStrategy strategy ) external view returns (OperatorSet[] memory, Allocation[] memory); + /** + * @notice For a strategy, get the amount of magnitude that is allocated across one or more operator sets + * @param operator the operator to query + * @param strategy the strategy to get allocatable magnitude for + * @return currently allocated magnitude + */ + function getEncumberedMagnitude(address operator, IStrategy strategy) external view returns (uint64); + /** * @notice For a strategy, get the amount of magnitude not currently allocated to any operator set * @param operator the operator to query @@ -525,7 +555,8 @@ interface IAllocationManager is IAllocationManagerErrors, IAllocationManagerEven /** * @notice Returns the minimum amount of stake that will be slashable as of some future block, - * according to each operator's allocation from each strategy to the operator set. + * according to each operator's allocation from each strategy to the operator set. Note that this function + * will return 0 for the slashable stake if the operator is not slashable at the time of the call. * @dev This method queries actual delegated stakes in the DelegationManager and applies * each operator's allocation to the stake to produce the slashable stake each allocation * represents. @@ -538,7 +569,6 @@ interface IAllocationManager is IAllocationManagerErrors, IAllocationManagerEven * @param operators the list of operators whose slashable stakes will be returned * @param strategies the strategies that each slashable stake corresponds to * @param futureBlock the block at which to get allocation information. Should be a future block. - * @return slashableStake a list of slashable stakes, indexed by [operator][strategy] */ function getMinimumSlashableStake( OperatorSet memory operatorSet, @@ -546,4 +576,25 @@ interface IAllocationManager is IAllocationManagerErrors, IAllocationManagerEven IStrategy[] memory strategies, uint32 futureBlock ) external view returns (uint256[][] memory slashableStake); + + /** + * @notice Returns the current allocated stake, irrespective of the operator's slashable status for the operatorSet. + * @param operatorSet the operator set to query + * @param operators the operators to query + * @param strategies the strategies to query + */ + function getAllocatedStake( + OperatorSet memory operatorSet, + address[] memory operators, + IStrategy[] memory strategies + ) external view returns (uint256[][] memory slashableStake); + + /** + * @notice Returns whether an operator is slashable by an operator set. + * This returns true if the operator is registered or their slashableUntil block has not passed. + * This is because even when operators are deregistered, they still remain slashable for a period of time. + * @param operator the operator to check slashability for + * @param operatorSet the operator set to check slashability for + */ + function isOperatorSlashable(address operator, OperatorSet memory operatorSet) external view returns (bool); } diff --git a/src/contracts/interfaces/IDelegationManager.sol b/src/contracts/interfaces/IDelegationManager.sol index 4533fffe7b..f8e61a13fe 100644 --- a/src/contracts/interfaces/IDelegationManager.sol +++ b/src/contracts/interfaces/IDelegationManager.sol @@ -3,7 +3,7 @@ pragma solidity >=0.5.0; import "./IStrategy.sol"; import "./IPauserRegistry.sol"; -import "./ISignatureUtils.sol"; +import "./ISignatureUtilsMixin.sol"; import "../libraries/SlashingLib.sol"; interface IDelegationManagerErrors { @@ -170,6 +170,9 @@ interface IDelegationManagerEvents is IDelegationManagerTypes { /// @notice Emitted when a queued withdrawal is completed event SlashingWithdrawalCompleted(bytes32 withdrawalRoot); + + /// @notice Emitted whenever an operator's shares are slashed for a given strategy + event OperatorSharesSlashed(address indexed operator, IStrategy strategy, uint256 totalSlashedShares); } /** @@ -182,7 +185,7 @@ interface IDelegationManagerEvents is IDelegationManagerTypes { * - enabling any staker to delegate its stake to the operator of its choice (a given staker can only delegate to a single operator at a time) * - enabling a staker to undelegate its assets from the operator it is delegated to (performed as part of the withdrawal process, initiated through the StrategyManager) */ -interface IDelegationManager is ISignatureUtils, IDelegationManagerErrors, IDelegationManagerEvents { +interface IDelegationManager is ISignatureUtilsMixin, IDelegationManagerErrors, IDelegationManagerEvents { /** * @dev Initializes the initial owner and paused status. */ @@ -283,15 +286,15 @@ interface IDelegationManager is ISignatureUtils, IDelegationManagerErrors, IDele ) external returns (bytes32[] memory); /** - * @notice Used to complete the lastest queued withdrawal. - * @param withdrawal The withdrawal to complete. + * @notice Used to complete a queued withdrawal + * @param withdrawal The withdrawal to complete * @param tokens Array in which the i-th entry specifies the `token` input to the 'withdraw' function of the i-th Strategy in the `withdrawal.strategies` array. - * @param receiveAsTokens If true, the shares calculated to be withdrawn will be withdrawn from the specified strategies themselves - * and sent to the caller, through calls to `withdrawal.strategies[i].withdraw`. If false, then the shares in the specified strategies - * will simply be transferred to the caller directly. - * @dev beaconChainETHStrategy shares are non-transferrable, so if `receiveAsTokens = false` and `withdrawal.withdrawer != withdrawal.staker`, note that - * any beaconChainETHStrategy shares in the `withdrawal` will be _returned to the staker_, rather than transferred to the withdrawer, unlike shares in - * any other strategies, which will be transferred to the withdrawer. + * @param tokens For each `withdrawal.strategies`, the underlying token of the strategy + * NOTE: if `receiveAsTokens` is false, the `tokens` array is unused and can be filled with default values. However, `tokens.length` MUST still be equal to `withdrawal.strategies.length`. + * NOTE: For the `beaconChainETHStrategy`, the corresponding `tokens` value is ignored (can be 0). + * @param receiveAsTokens If true, withdrawn shares will be converted to tokens and sent to the caller. If false, the caller receives shares that can be delegated to an operator. + * NOTE: if the caller receives shares and is currently delegated to an operator, the received shares are + * automatically delegated to the caller's current operator. */ function completeQueuedWithdrawal( Withdrawal calldata withdrawal, @@ -300,8 +303,7 @@ interface IDelegationManager is ISignatureUtils, IDelegationManagerErrors, IDele ) external; /** - * @notice Used to complete the all queued withdrawals. - * Used to complete the specified `withdrawals`. The function caller must match `withdrawals[...].withdrawer` + * @notice Used to complete multiple queued withdrawals * @param withdrawals Array of Withdrawals to complete. See `completeQueuedWithdrawal` for the usage of a single Withdrawal. * @param tokens Array of tokens for each Withdrawal. See `completeQueuedWithdrawal` for the usage of a single array. * @param receiveAsTokens Whether or not to complete each withdrawal as tokens. See `completeQueuedWithdrawal` for the usage of a single boolean. @@ -314,18 +316,17 @@ interface IDelegationManager is ISignatureUtils, IDelegationManagerErrors, IDele ) external; /** - * @notice Increases a staker's delegated share balance in a strategy. Note that before adding to operator shares, - * the delegated delegatedShares. The staker's depositScalingFactor is updated here. - * @param staker The address to increase the delegated shares for their operator. - * @param strategy The strategy in which to increase the delegated shares. - * @param prevDepositShares The number of deposit shares the staker already had in the strategy. This is the shares amount stored in the - * StrategyManager/EigenPodManager for the staker's shares. - * @param addedShares The number of shares added to the staker's shares in the strategy + * @notice Called by a share manager when a staker's deposit share balance in a strategy increases. + * This method delegates any new shares to an operator (if applicable), and updates the staker's + * deposit scaling factor regardless. + * @param staker The address whose deposit shares have increased + * @param strategy The strategy in which shares have been deposited + * @param prevDepositShares The number of deposit shares the staker had in the strategy prior to the increase + * @param addedShares The number of deposit shares added by the staker * - * @dev *If the staker is actively delegated*, then increases the `staker`'s delegated delegatedShares in `strategy`. - * Otherwise does nothing. - * @dev If the operator was slashed 100% for the strategy (the operator's maxMagnitude = 0), then increasing delegated shares is blocked and will revert. - * @dev Callable only by the StrategyManager or EigenPodManager. + * @dev Note that if the either the staker's current operator has been slashed 100% for `strategy`, OR the + * staker has been slashed 100% on the beacon chain such that the calculated slashing factor is 0, this + * method WILL REVERT. */ function increaseDelegatedShares( address staker, @@ -476,11 +477,28 @@ interface IDelegationManager is ISignatureUtils, IDelegationManagerErrors, IDele bytes32 withdrawalRoot ) external view returns (Withdrawal memory); - /// @notice Returns a list of pending queued withdrawals for a `staker`, and the `shares` to be withdrawn. + /** + * @notice Returns all queued withdrawals and their corresponding shares for a staker. + * @param staker The address of the staker to query withdrawals for. + * @return withdrawals Array of Withdrawal structs containing details about each queued withdrawal. + * @return shares 2D array of shares, where each inner array corresponds to the strategies in the withdrawal. + * @dev The shares are what a user would receive from completing a queued withdrawal, assuming all slashings are applied. + */ function getQueuedWithdrawals( address staker ) external view returns (Withdrawal[] memory withdrawals, uint256[][] memory shares); + /** + * @notice Returns the withdrawal details and corresponding shares for a specific queued withdrawal. + * @param withdrawalRoot The hash identifying the queued withdrawal. + * @return withdrawal The withdrawal details. + * @return shares Array of shares corresponding to each strategy in the withdrawal. + * @dev The shares are what a user would receive from completing a queued withdrawal, assuming all slashings are applied. + */ + function getQueuedWithdrawalFromRoot( + bytes32 withdrawalRoot + ) external view returns (Withdrawal memory withdrawal, uint256[] memory shares); + /// @notice Returns a list of queued withdrawal roots for the `staker`. /// NOTE that this only returns withdrawals queued AFTER the slashing release. function getQueuedWithdrawalRoots( diff --git a/src/contracts/interfaces/IEigenPod.sol b/src/contracts/interfaces/IEigenPod.sol index 5f354e7cd4..83dc8d8211 100644 --- a/src/contracts/interfaces/IEigenPod.sol +++ b/src/contracts/interfaces/IEigenPod.sol @@ -4,6 +4,7 @@ pragma solidity >=0.5.0; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "../libraries/BeaconChainProofs.sol"; +import "./ISemVerMixin.sol"; import "./IEigenPodManager.sol"; interface IEigenPodErrors { @@ -138,7 +139,7 @@ interface IEigenPodEvents is IEigenPodTypes { * @dev Note that all beacon chain balances are stored as gwei within the beacon chain datastructures. We choose * to account balances in terms of gwei in the EigenPod contract and convert to wei when making calls to other contracts */ -interface IEigenPod is IEigenPodErrors, IEigenPodEvents { +interface IEigenPod is IEigenPodErrors, IEigenPodEvents, ISemVerMixin { /// @notice Used to initialize the pointers to contracts crucial to the pod's functionality, in beacon proxy construction from EigenPodManager function initialize( address owner diff --git a/src/contracts/interfaces/IEigenPodManager.sol b/src/contracts/interfaces/IEigenPodManager.sol index b7611b50a4..afb384b744 100644 --- a/src/contracts/interfaces/IEigenPodManager.sol +++ b/src/contracts/interfaces/IEigenPodManager.sol @@ -8,6 +8,7 @@ import "./IEigenPod.sol"; import "./IShareManager.sol"; import "./IPausable.sol"; import "./IStrategy.sol"; +import "./ISemVerMixin.sol"; interface IEigenPodManagerErrors { /// @dev Thrown when caller is not a EigenPod. @@ -85,7 +86,8 @@ interface IEigenPodManager is IEigenPodManagerEvents, IEigenPodManagerTypes, IShareManager, - IPausable + IPausable, + ISemVerMixin { /** * @notice Creates an EigenPod for the sender. @@ -104,10 +106,12 @@ interface IEigenPodManager is function stake(bytes calldata pubkey, bytes calldata signature, bytes32 depositDataRoot) external payable; /** - * @notice Changes the `podOwner`'s shares by `sharesDelta` and performs a call to the DelegationManager - * to ensure that delegated shares are also tracked correctly + * @notice Adds any positive share delta to the pod owner's deposit shares, and delegates them to the pod + * owner's operator (if applicable). A negative share delta does NOT impact the pod owner's deposit shares, + * but will reduce their beacon chain slashing factor and delegated shares accordingly. * @param podOwner is the pod owner whose balance is being updated. - * @param prevRestakedBalanceWei is the total amount restaked through the pod before the balance update + * @param prevRestakedBalanceWei is the total amount restaked through the pod before the balance update, including + * any amount currently in the withdrawal queue. * @param balanceDeltaWei is the amount the balance changed * @dev Callable only by the podOwner's EigenPod contract. * @dev Reverts if `sharesDelta` is not a whole Gwei amount diff --git a/src/contracts/interfaces/IPermissionController.sol b/src/contracts/interfaces/IPermissionController.sol index 5d4be806d6..b8e2153736 100644 --- a/src/contracts/interfaces/IPermissionController.sol +++ b/src/contracts/interfaces/IPermissionController.sol @@ -1,142 +1,157 @@ // SPDX-License-Identifier: BUSL-1.1 pragma solidity ^0.8.27; +import "./ISemVerMixin.sol"; + interface IPermissionControllerErrors { - /// @notice Thrown when the caller is not the admin + /// @notice Thrown when a non-admin caller attempts to perform an admin-only action. error NotAdmin(); - /// @notice Thrown when the admin to remove is not an admin + /// @notice Thrown when attempting to remove an admin that does not exist. error AdminNotSet(); - /// @notice Thrown when an appointee is already set for the account's function + /// @notice Thrown when attempting to set an appointee for a function that already has one. error AppointeeAlreadySet(); - /// @notice Thrown when an appointee is not set for the account's function + /// @notice Thrown when attempting to interact with a non-existent appointee. error AppointeeNotSet(); - /// @notice Thrown when the account attempts to remove the only admin + /// @notice Thrown when attempting to remove the last remaining admin. error CannotHaveZeroAdmins(); - /// @notice Thrown when an admin is already set + /// @notice Thrown when attempting to set an admin that is already registered. error AdminAlreadySet(); - /// @notice Thrown when an admin is not pending + /// @notice Thrown when attempting to interact with an admin that is not in pending status. error AdminNotPending(); - /// @notice Thrown when an admin is already pending + /// @notice Thrown when attempting to add an admin that is already pending. error AdminAlreadyPending(); } interface IPermissionControllerEvents { - /// @notice Emitted when an appointee is set + /// @notice Emitted when an appointee is set for an account to handle specific function calls. event AppointeeSet(address indexed account, address indexed appointee, address target, bytes4 selector); - /// @notice Emitted when an appointee is revoked + /// @notice Emitted when an appointee's permission to handle function calls for an account is revoked. event AppointeeRemoved(address indexed account, address indexed appointee, address target, bytes4 selector); - /// @notice Emitted when an admin is set as pending for an account + /// @notice Emitted when an address is set as a pending admin for an account, requiring acceptance. event PendingAdminAdded(address indexed account, address admin); - /// @notice Emitted when an admin is removed as pending for an account + /// @notice Emitted when a pending admin status is removed for an account before acceptance. event PendingAdminRemoved(address indexed account, address admin); - /// @notice Emitted when an admin is set for a given account + /// @notice Emitted when an address accepts and becomes an active admin for an account. event AdminSet(address indexed account, address admin); - /// @notice Emitted when an admin is removed for a given account + /// @notice Emitted when an admin's permissions are removed from an account. event AdminRemoved(address indexed account, address admin); } -interface IPermissionController is IPermissionControllerErrors, IPermissionControllerEvents { +interface IPermissionController is IPermissionControllerErrors, IPermissionControllerEvents, ISemVerMixin { /** - * @notice Sets a pending admin of an account - * @param account to set pending admin for - * @param admin to set - * @dev Multiple admins can be set for an account + * @notice Sets a pending admin for an account. + * @param account The account to set the pending admin for. + * @param admin The address to set as pending admin. + * @dev The pending admin must accept the role before becoming an active admin. + * @dev Multiple admins can be set for a single account. */ function addPendingAdmin(address account, address admin) external; /** - * @notice Removes a pending admin of an account - * @param account to remove pending admin for - * @param admin to remove - * @dev Only the admin of the account can remove a pending admin + * @notice Removes a pending admin from an account before they have accepted the role. + * @param account The account to remove the pending admin from. + * @param admin The pending admin address to remove. + * @dev Only an existing admin of the account can remove a pending admin. */ function removePendingAdmin(address account, address admin) external; /** - * @notice Accepts the admin role of an account - * @param account to accept admin for - * @dev Only a pending admin for the account can become an admin + * @notice Allows a pending admin to accept their admin role for an account. + * @param account The account to accept the admin role for. + * @dev Only addresses that were previously set as pending admins can accept the role. */ function acceptAdmin( address account ) external; /** - * @notice Remove an admin of an account - * @param account to remove admin for - * @param admin to remove - * @dev Only the admin of the account can remove an admin - * @dev Reverts when an admin is removed such that no admins are remaining + * @notice Removes an active admin from an account. + * @param account The account to remove the admin from. + * @param admin The admin address to remove. + * @dev Only an existing admin of the account can remove another admin. + * @dev Will revert if removing this admin would leave the account with zero admins. */ function removeAdmin(address account, address admin) external; /** - * @notice Set an appointee for a given account - * @param account to set appointee for - * @param appointee to set - * @param target to set appointee for - * @param selector to set appointee for - * @dev Only the admin of the account can set an appointee + * @notice Sets an appointee who can call specific functions on behalf of an account. + * @param account The account to set the appointee for. + * @param appointee The address to be given permission. + * @param target The contract address the appointee can interact with. + * @param selector The function selector the appointee can call. + * @dev Only an admin of the account can set appointees. */ function setAppointee(address account, address appointee, address target, bytes4 selector) external; /** - * Removes an appointee for a given account - * @param account to remove appointee for - * @param appointee to remove - * @param target to remove appointee for - * @param selector to remove appointee for - * @dev Only the admin of the account can remove an appointee + * @notice Removes an appointee's permission to call a specific function. + * @param account The account to remove the appointee from. + * @param appointee The appointee address to remove. + * @param target The contract address to remove permissions for. + * @param selector The function selector to remove permissions for. + * @dev Only an admin of the account can remove appointees. */ function removeAppointee(address account, address appointee, address target, bytes4 selector) external; /** - * @notice Checks if the given caller is an admin of the account - * @dev If the account has no admin, the caller is checked to be the account itself + * @notice Checks if a given address is an admin of an account. + * @param account The account to check admin status for. + * @param caller The address to check. + * @dev If the account has no admins, returns true only if the caller is the account itself. + * @return Returns true if the caller is an admin, false otherwise. */ function isAdmin(address account, address caller) external view returns (bool); /** - * @notice Checks if the `pendingAdmin` is a pending admin of the `account` + * @notice Checks if an address is currently a pending admin for an account. + * @param account The account to check pending admin status for. + * @param pendingAdmin The address to check. + * @return Returns true if the address is a pending admin, false otherwise. */ function isPendingAdmin(address account, address pendingAdmin) external view returns (bool); /** - * @notice Get the admins of an account - * @param account The account to get the admin of - * @dev If the account has no admin, the account itself is returned + * @notice Retrieves all active admins for an account. + * @param account The account to get the admins for. + * @dev If the account has no admins, returns an array containing only the account address. + * @return An array of admin addresses. */ function getAdmins( address account ) external view returns (address[] memory); /** - * @notice Get the pending admins of an account - * @param account The account to get the pending admin of + * @notice Retrieves all pending admins for an account. + * @param account The account to get the pending admins for. + * @return An array of pending admin addresses. */ function getPendingAdmins( address account ) external view returns (address[] memory); /** - * @notice Checks if the given caller has permissions to call the fucntion - * @param account to check - * @param caller to check permission for - * @param target to check permission for - * @param selector to check permission for - * @dev Returns `true` if the admin OR the appointee is the caller + * @notice Checks if a caller has permission to call a specific function. + * @param account The account to check permissions for. + * @param caller The address attempting to make the call. + * @param target The contract address being called. + * @param selector The function selector being called. + * @dev Returns true if the caller is either an admin or an appointed caller. + * @dev Be mindful that upgrades to the contract may invalidate the appointee's permissions. + * This is only possible if a function's selector changes (e.g. if a function's parameters are modified). + * @return Returns true if the caller has permission, false otherwise. */ function canCall(address account, address caller, address target, bytes4 selector) external returns (bool); /** - * @notice Gets the list of permissions of an appointee for a given account - * @param account to get appointee permissions for - * @param appointee to get permissions + * @notice Retrieves all permissions granted to an appointee for a given account. + * @param account The account to check appointee permissions for. + * @param appointee The appointee address to check. + * @return Two arrays: target contract addresses and their corresponding function selectors. */ function getAppointeePermissions( address account, @@ -144,11 +159,12 @@ interface IPermissionController is IPermissionControllerErrors, IPermissionContr ) external returns (address[] memory, bytes4[] memory); /** - * @notice Returns the list of appointees for a given account and function - * @param account to get appointees for - * @param target to get appointees for - * @param selector to get appointees for - * @dev Does NOT include admin as an appointee, even though it can call + * @notice Retrieves all appointees that can call a specific function for an account. + * @param account The account to get appointees for. + * @param target The contract address to check. + * @param selector The function selector to check. + * @dev Does not include admins in the returned list, even though they have calling permission. + * @return An array of appointee addresses. */ function getAppointees(address account, address target, bytes4 selector) external returns (address[] memory); } diff --git a/src/contracts/interfaces/IRewardsCoordinator.sol b/src/contracts/interfaces/IRewardsCoordinator.sol index c019c8efe0..38d310eca7 100644 --- a/src/contracts/interfaces/IRewardsCoordinator.sol +++ b/src/contracts/interfaces/IRewardsCoordinator.sol @@ -2,8 +2,14 @@ pragma solidity ^0.8.27; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; + +import "./IAllocationManager.sol"; +import "./IDelegationManager.sol"; +import "./IStrategyManager.sol"; import "./IPauserRegistry.sol"; +import "./IPermissionController.sol"; import "./IStrategy.sol"; +import "./ISemVerMixin.sol"; interface IRewardsCoordinatorErrors { /// @dev Thrown when msg.sender is not allowed to call a function @@ -234,6 +240,35 @@ interface IRewardsCoordinatorTypes { bytes[] tokenTreeProofs; TokenTreeMerkleLeaf[] tokenLeaves; } + + /** + * @notice Parameters for the RewardsCoordinator constructor + * @param delegationManager The address of the DelegationManager contract + * @param strategyManager The address of the StrategyManager contract + * @param allocationManager The address of the AllocationManager contract + * @param pauserRegistry The address of the PauserRegistry contract + * @param permissionController The address of the PermissionController contract + * @param CALCULATION_INTERVAL_SECONDS The interval at which rewards are calculated + * @param MAX_REWARDS_DURATION The maximum duration of a rewards submission + * @param MAX_RETROACTIVE_LENGTH The maximum retroactive length of a rewards submission + * @param MAX_FUTURE_LENGTH The maximum future length of a rewards submission + * @param GENESIS_REWARDS_TIMESTAMP The timestamp at which rewards are first calculated + * @param version The semantic version of the contract (e.g. "v1.2.3") + * @dev Needed to avoid stack-too-deep errors + */ + struct RewardsCoordinatorConstructorParams { + IDelegationManager delegationManager; + IStrategyManager strategyManager; + IAllocationManager allocationManager; + IPauserRegistry pauserRegistry; + IPermissionController permissionController; + uint32 CALCULATION_INTERVAL_SECONDS; + uint32 MAX_REWARDS_DURATION; + uint32 MAX_RETROACTIVE_LENGTH; + uint32 MAX_FUTURE_LENGTH; + uint32 GENESIS_REWARDS_TIMESTAMP; + string version; + } } interface IRewardsCoordinatorEvents is IRewardsCoordinatorTypes { @@ -353,7 +388,7 @@ interface IRewardsCoordinatorEvents is IRewardsCoordinatorTypes { * Calculations are performed based on the completed RewardsSubmission, with the results posted in * a Merkle root against which Stakers & Operators can make claims. */ -interface IRewardsCoordinator is IRewardsCoordinatorErrors, IRewardsCoordinatorEvents { +interface IRewardsCoordinator is IRewardsCoordinatorErrors, IRewardsCoordinatorEvents, ISemVerMixin { /** * @dev Initializes the addresses of the initial owner, pauser registry, rewardsUpdater and * configures the initial paused status, activationDelay, and defaultOperatorSplitBips. diff --git a/src/contracts/interfaces/ISemVerMixin.sol b/src/contracts/interfaces/ISemVerMixin.sol new file mode 100644 index 0000000000..206cf38d46 --- /dev/null +++ b/src/contracts/interfaces/ISemVerMixin.sol @@ -0,0 +1,11 @@ +// SPDX-License-Identifier: BUSL-1.1 +pragma solidity ^0.8.0; + +/// @title ISemVerMixin +/// @notice A mixin interface that provides semantic versioning functionality. +/// @dev Follows SemVer 2.0.0 specification (https://semver.org/) +interface ISemVerMixin { + /// @notice Returns the semantic version string of the contract. + /// @return The version string in SemVer format (e.g., "v1.1.1") + function version() external view returns (string memory); +} diff --git a/src/contracts/interfaces/IShareManager.sol b/src/contracts/interfaces/IShareManager.sol index 6ee50bc627..4d2d66e9ff 100644 --- a/src/contracts/interfaces/IShareManager.sol +++ b/src/contracts/interfaces/IShareManager.sol @@ -1,9 +1,9 @@ // SPDX-License-Identifier: BUSL-1.1 pragma solidity ^0.8.27; -import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "../libraries/SlashingLib.sol"; import "./IStrategy.sol"; +import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; /** * @title Interface for a `IShareManager` contract. @@ -14,21 +14,20 @@ import "./IStrategy.sol"; interface IShareManager { /// @notice Used by the DelegationManager to remove a Staker's shares from a particular strategy when entering the withdrawal queue /// @dev strategy must be beaconChainETH when talking to the EigenPodManager - function removeDepositShares(address staker, IStrategy strategy, uint256 depositSharesToRemove) external; + /// @return updatedShares the staker's deposit shares after decrement + function removeDepositShares( + address staker, + IStrategy strategy, + uint256 depositSharesToRemove + ) external returns (uint256); /// @notice Used by the DelegationManager to award a Staker some shares that have passed through the withdrawal queue /// @dev strategy must be beaconChainETH when talking to the EigenPodManager - /// @dev token is not validated when talking to the EigenPodManager /// @return existingDepositShares the shares the staker had before any were added /// @return addedShares the new shares added to the staker's balance - function addShares( - address staker, - IStrategy strategy, - IERC20 token, - uint256 shares - ) external returns (uint256, uint256); + function addShares(address staker, IStrategy strategy, uint256 shares) external returns (uint256, uint256); - /// @notice Used by the DelegationManager to convert withdrawn descaled shares to tokens and send them to a staker + /// @notice Used by the DelegationManager to convert deposit shares to tokens and send them to a staker /// @dev strategy must be beaconChainETH when talking to the EigenPodManager /// @dev token is not validated when talking to the EigenPodManager function withdrawSharesAsTokens(address staker, IStrategy strategy, IERC20 token, uint256 shares) external; diff --git a/src/contracts/interfaces/ISignatureUtils.sol b/src/contracts/interfaces/ISignatureUtils.sol deleted file mode 100644 index 9e1ac2b45d..0000000000 --- a/src/contracts/interfaces/ISignatureUtils.sol +++ /dev/null @@ -1,30 +0,0 @@ -// SPDX-License-Identifier: BUSL-1.1 -pragma solidity >=0.5.0; - -/** - * @title The interface for common signature utilities. - * @author Layr Labs, Inc. - * @notice Terms of Service: https://docs.eigenlayer.xyz/overview/terms-of-service - */ -interface ISignatureUtils { - error InvalidSignature(); - error SignatureExpired(); - - // @notice Struct that bundles together a signature and an expiration time for the signature. Used primarily for stack management. - struct SignatureWithExpiry { - // the signature itself, formatted as a single bytes object - bytes signature; - // the expiration timestamp (UTC) of the signature - uint256 expiry; - } - - // @notice Struct that bundles together a signature, a salt for uniqueness, and an expiration time for the signature. Used primarily for stack management. - struct SignatureWithSaltAndExpiry { - // the signature itself, formatted as a single bytes object - bytes signature; - // the salt used to generate the signature - bytes32 salt; - // the expiration timestamp (UTC) of the signature - uint256 expiry; - } -} diff --git a/src/contracts/interfaces/ISignatureUtilsMixin.sol b/src/contracts/interfaces/ISignatureUtilsMixin.sol new file mode 100644 index 0000000000..7b9c8c372f --- /dev/null +++ b/src/contracts/interfaces/ISignatureUtilsMixin.sol @@ -0,0 +1,50 @@ +// SPDX-License-Identifier: BUSL-1.1 +pragma solidity >=0.5.0; + +import "./ISemVerMixin.sol"; + +interface ISignatureUtilsMixinErrors { + /// @notice Thrown when a signature is invalid. + error InvalidSignature(); + /// @notice Thrown when a signature has expired. + error SignatureExpired(); +} + +interface ISignatureUtilsMixinTypes { + /// @notice Struct that bundles together a signature and an expiration time for the signature. + /// @dev Used primarily for stack management. + struct SignatureWithExpiry { + // the signature itself, formatted as a single bytes object + bytes signature; + // the expiration timestamp (UTC) of the signature + uint256 expiry; + } + + /// @notice Struct that bundles together a signature, a salt for uniqueness, and an expiration time for the signature. + /// @dev Used primarily for stack management. + struct SignatureWithSaltAndExpiry { + // the signature itself, formatted as a single bytes object + bytes signature; + // the salt used to generate the signature + bytes32 salt; + // the expiration timestamp (UTC) of the signature + uint256 expiry; + } +} + +/** + * @title The interface for common signature utilities. + * @author Layr Labs, Inc. + * @notice Terms of Service: https://docs.eigenlayer.xyz/overview/terms-of-service + */ +interface ISignatureUtilsMixin is ISignatureUtilsMixinErrors, ISignatureUtilsMixinTypes, ISemVerMixin { + /// @notice Computes the EIP-712 domain separator used for signature validation. + /// @dev The domain separator is computed according to EIP-712 specification, using: + /// - The hardcoded name "EigenLayer" + /// - The contract's version string + /// - The current chain ID + /// - This contract's address + /// @return The 32-byte domain separator hash used in EIP-712 structured data signing. + /// @dev See https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator. + function domainSeparator() external view returns (bytes32); +} diff --git a/src/contracts/interfaces/IStrategy.sol b/src/contracts/interfaces/IStrategy.sol index 3052cba1c4..79e95302ca 100644 --- a/src/contracts/interfaces/IStrategy.sol +++ b/src/contracts/interfaces/IStrategy.sol @@ -3,6 +3,7 @@ pragma solidity >=0.5.0; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "../libraries/SlashingLib.sol"; +import "./ISemVerMixin.sol"; interface IStrategyErrors { /// @dev Thrown when called by an account that is not strategy manager. @@ -47,7 +48,7 @@ interface IStrategyEvents { * @notice Terms of Service: https://docs.eigenlayer.xyz/overview/terms-of-service * @notice Custom `Strategy` implementations may expand extensively on this interface. */ -interface IStrategy is IStrategyErrors, IStrategyEvents { +interface IStrategy is IStrategyErrors, IStrategyEvents, ISemVerMixin { /** * @notice Used to deposit tokens into this Strategy * @param token is the ERC20 token being deposited diff --git a/src/contracts/interfaces/IStrategyFactory.sol b/src/contracts/interfaces/IStrategyFactory.sol index 137659cc34..c019695b4a 100644 --- a/src/contracts/interfaces/IStrategyFactory.sol +++ b/src/contracts/interfaces/IStrategyFactory.sol @@ -4,6 +4,7 @@ pragma solidity ^0.8.27; import "@openzeppelin/contracts/proxy/beacon/IBeacon.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "./IStrategy.sol"; +import "./ISemVerMixin.sol"; /** * @title Interface for the `StrategyFactory` contract. @@ -11,7 +12,7 @@ import "./IStrategy.sol"; * @notice Terms of Service: https://docs.eigenlayer.xyz/overview/terms-of-service * @dev This may not be compatible with non-standard ERC20 tokens. Caution is warranted. */ -interface IStrategyFactory { +interface IStrategyFactory is ISemVerMixin { /// @dev Thrown when attempting to deploy a strategy for a blacklisted token. error BlacklistedToken(); /// @dev Thrown when attempting to deploy a strategy that already exists. diff --git a/src/contracts/interfaces/IStrategyManager.sol b/src/contracts/interfaces/IStrategyManager.sol index 6b31224c72..2af48d4386 100644 --- a/src/contracts/interfaces/IStrategyManager.sol +++ b/src/contracts/interfaces/IStrategyManager.sol @@ -5,6 +5,7 @@ import "./IStrategy.sol"; import "./IShareManager.sol"; import "./IDelegationManager.sol"; import "./IEigenPodManager.sol"; +import "./ISemVerMixin.sol"; interface IStrategyManagerErrors { /// @dev Thrown when total strategies deployed exceeds max. @@ -30,10 +31,9 @@ interface IStrategyManagerEvents { * @notice Emitted when a new deposit occurs on behalf of `staker`. * @param staker Is the staker who is depositing funds into EigenLayer. * @param strategy Is the strategy that `staker` has deposited into. - * @param token Is the token that `staker` deposited. * @param shares Is the number of new shares `staker` has been granted in `strategy`. */ - event Deposit(address staker, IERC20 token, IStrategy strategy, uint256 shares); + event Deposit(address staker, IStrategy strategy, uint256 shares); /// @notice Emitted when the `strategyWhitelister` is changed event StrategyWhitelisterChanged(address previousAddress, address newAddress); @@ -57,7 +57,7 @@ interface IStrategyManagerEvents { * @notice Terms of Service: https://docs.eigenlayer.xyz/overview/terms-of-service * @notice See the `StrategyManager` contract itself for implementation details. */ -interface IStrategyManager is IStrategyManagerErrors, IStrategyManagerEvents, IShareManager { +interface IStrategyManager is IStrategyManagerErrors, IStrategyManagerEvents, IShareManager, ISemVerMixin { /** * @notice Initializes the strategy manager contract. Sets the `pauserRegistry` (currently **not** modifiable after being set), * and transfers contract ownership to the specified `initialOwner`. @@ -72,38 +72,39 @@ interface IStrategyManager is IStrategyManagerErrors, IStrategyManagerEvents, IS ) external; /** - * @notice Deposits `amount` of `token` into the specified `strategy`, with the resultant shares credited to `msg.sender` - * @param strategy is the specified strategy where deposit is to be made, - * @param token is the denomination in which the deposit is to be made, - * @param amount is the amount of token to be deposited in the strategy by the staker - * @return shares The amount of new shares in the `strategy` created as part of the action. - * @dev The `msg.sender` must have previously approved this contract to transfer at least `amount` of `token` on their behalf. - * @dev Cannot be called by an address that is 'frozen' (this function will revert if the `msg.sender` is frozen). + * @notice Deposits `amount` of `token` into the specified `strategy` and credits shares to the caller + * @param strategy the strategy that handles `token` + * @param token the token from which the `amount` will be transferred + * @param amount the number of tokens to deposit + * @return depositShares the number of deposit shares credited to the caller + * @dev The caller must have previously approved this contract to transfer at least `amount` of `token` on their behalf. * - * WARNING: Depositing tokens that allow reentrancy (eg. ERC-777) into a strategy is not recommended. This can lead to attack vectors - * where the token balance and corresponding strategy shares are not in sync upon reentrancy. + * WARNING: Be extremely cautious when depositing tokens that do not strictly adhere to ERC20 standards. + * Tokens that diverge significantly from ERC20 norms can cause unexpected behavior in token balances for + * that strategy, e.g. ERC-777 tokens allowing cross-contract reentrancy. */ - function depositIntoStrategy(IStrategy strategy, IERC20 token, uint256 amount) external returns (uint256 shares); + function depositIntoStrategy( + IStrategy strategy, + IERC20 token, + uint256 amount + ) external returns (uint256 depositShares); /** - * @notice Used for depositing an asset into the specified strategy with the resultant shares credited to `staker`, - * who must sign off on the action. - * Note that the assets are transferred out/from the `msg.sender`, not from the `staker`; this function is explicitly designed - * purely to help one address deposit 'for' another. - * @param strategy is the specified strategy where deposit is to be made, - * @param token is the denomination in which the deposit is to be made, - * @param amount is the amount of token to be deposited in the strategy by the staker + * @notice Deposits `amount` of `token` into the specified `strategy` and credits shares to the `staker` + * Note tokens are transferred from `msg.sender`, NOT from `staker`. This method allows the caller, using a + * signature, to deposit their tokens to another staker's balance. + * @param strategy the strategy that handles `token` + * @param token the token from which the `amount` will be transferred + * @param amount the number of tokens to transfer from the caller to the strategy * @param staker the staker that the deposited assets will be credited to * @param expiry the timestamp at which the signature expires - * @param signature is a valid signature from the `staker`. either an ECDSA signature if the `staker` is an EOA, or data to forward - * following EIP-1271 if the `staker` is a contract - * @return shares The amount of new shares in the `strategy` created as part of the action. - * @dev The `msg.sender` must have previously approved this contract to transfer at least `amount` of `token` on their behalf. - * @dev A signature is required for this function to eliminate the possibility of griefing attacks, specifically those - * targeting stakers who may be attempting to undelegate. + * @param signature a valid ECDSA or EIP-1271 signature from `staker` + * @return depositShares the number of deposit shares credited to `staker` + * @dev The caller must have previously approved this contract to transfer at least `amount` of `token` on their behalf. * - * WARNING: Depositing tokens that allow reentrancy (eg. ERC-777) into a strategy is not recommended. This can lead to attack vectors - * where the token balance and corresponding strategy shares are not in sync upon reentrancy + * WARNING: Be extremely cautious when depositing tokens that do not strictly adhere to ERC20 standards. + * Tokens that diverge significantly from ERC20 norms can cause unexpected behavior in token balances for + * that strategy, e.g. ERC-777 tokens allowing cross-contract reentrancy. */ function depositIntoStrategyWithSignature( IStrategy strategy, @@ -112,7 +113,7 @@ interface IStrategyManager is IStrategyManagerErrors, IStrategyManagerEvents, IS address staker, uint256 expiry, bytes memory signature - ) external returns (uint256 shares); + ) external returns (uint256 depositShares); /** * @notice Burns Strategy shares for the given strategy by calling into the strategy to transfer @@ -178,6 +179,21 @@ interface IStrategyManager is IStrategyManagerErrors, IStrategyManagerEvents, IS /// @notice Returns the address of the `strategyWhitelister` function strategyWhitelister() external view returns (address); + /// @notice Returns the burnable shares of a strategy + function getBurnableShares( + IStrategy strategy + ) external view returns (uint256); + + /** + * @notice Gets every strategy with burnable shares and the amount of burnable shares in each said strategy + * + * WARNING: This operation can copy the entire storage to memory, which can be quite expensive. This is designed + * to mostly be used by view accessors that are queried without any gas fees. Users should keep in mind that + * this function has an unbounded cost, and using it as part of a state-changing function may render the function + * uncallable if the map grows to a point where copying to memory consumes too much gas to fit in a block. + */ + function getStrategiesWithBurnableShares() external view returns (address[] memory, uint256[] memory); + /** * @param staker The address of the staker. * @param strategy The strategy to deposit into. diff --git a/src/contracts/libraries/OperatorSetLib.sol b/src/contracts/libraries/OperatorSetLib.sol index eb761b0b45..0b1ae4808d 100644 --- a/src/contracts/libraries/OperatorSetLib.sol +++ b/src/contracts/libraries/OperatorSetLib.sol @@ -1,6 +1,8 @@ // SPDX-License-Identifier: BUSL-1.1 pragma solidity ^0.8.27; +using OperatorSetLib for OperatorSet global; + /** * @notice An operator set identified by the AVS address and an identifier * @param avs The address of the AVS this operator set belongs to diff --git a/src/contracts/libraries/SlashingLib.sol b/src/contracts/libraries/SlashingLib.sol index b6ce24151c..f608480f08 100644 --- a/src/contracts/libraries/SlashingLib.sol +++ b/src/contracts/libraries/SlashingLib.sol @@ -55,13 +55,6 @@ library SlashingLib { return x.mulDiv(y, WAD, Math.Rounding.Up); } - /** - * @notice Used as part of calculating wadSlashed in the EPM to ensure that we don't overslash - */ - function divWadRoundUp(uint256 x, uint256 y) internal pure returns (uint256) { - return x.mulDiv(WAD, y, Math.Rounding.Up); - } - // GETTERS function scalingFactor( @@ -101,10 +94,11 @@ library SlashingLib { uint256 addedShares, uint256 slashingFactor ) internal { - // If this is the staker's first deposit, set the scaling factor to - // the inverse of slashingFactor if (prevDepositShares == 0) { - dsf._scalingFactor = uint256(WAD).divWad(slashingFactor); + // If this is the staker's first deposit or they are delegating to an operator, + // the slashing factor is inverted and applied to the existing DSF. This has the + // effect of "forgiving" prior slashing for any subsequent deposits. + dsf._scalingFactor = dsf.scalingFactor().divWad(slashingFactor); return; } @@ -143,6 +137,18 @@ library SlashingLib { dsf._scalingFactor = newDepositScalingFactor; } + /// @dev Reset the staker's DSF for a strategy by setting it to 0. This is the same + /// as setting it to WAD (see the `scalingFactor` getter above). + /// + /// A DSF is reset when a staker reduces their deposit shares to 0, either by queueing + /// a withdrawal, or undelegating from their operator. This ensures that subsequent + /// delegations/deposits do not use a stale DSF (e.g. from a prior operator). + function reset( + DepositScalingFactor storage dsf + ) internal { + dsf._scalingFactor = 0; + } + // CONVERSION function calcWithdrawable( diff --git a/src/contracts/mixins/SemVerMixin.sol b/src/contracts/mixins/SemVerMixin.sol new file mode 100644 index 0000000000..c955de4f8b --- /dev/null +++ b/src/contracts/mixins/SemVerMixin.sol @@ -0,0 +1,38 @@ +// SPDX-License-Identifier: BUSL-1.1 +pragma solidity ^0.8.0; + +import "../interfaces/ISemVerMixin.sol"; +import "@openzeppelin-upgrades/contracts/utils/ShortStringsUpgradeable.sol"; + +/// @title SemVerMixin +/// @notice A mixin contract that provides semantic versioning functionality. +/// @dev Follows SemVer 2.0.0 specification (https://semver.org/). +abstract contract SemVerMixin is ISemVerMixin { + using ShortStringsUpgradeable for *; + + /// @notice The semantic version string for this contract, stored as a ShortString for gas efficiency. + /// @dev Follows SemVer 2.0.0 specification (https://semver.org/). Prefixed with 'v' (e.g., "v1.2.3"). + ShortString internal immutable _VERSION; + + /// @notice Initializes the contract with a semantic version string. + /// @param _version The SemVer-formatted version string (e.g., "v1.2.3") + /// @dev Version should follow SemVer 2.0.0 format with 'v' prefix: vMAJOR.MINOR.PATCH + constructor( + string memory _version + ) { + _VERSION = _version.toShortString(); + } + + /// @inheritdoc ISemVerMixin + function version() public view virtual returns (string memory) { + return _VERSION.toString(); + } + + /// @notice Returns the major version of the contract. + /// @dev Supports single digit major versions (e.g., "v1" for version "v1.2.3") + /// @return The major version string (e.g., "v1" for version "v1.2.3") + function _majorVersion() internal view returns (string memory) { + bytes memory v = bytes(_VERSION.toString()); + return string(bytes.concat(v[0], v[1])); + } +} diff --git a/src/contracts/mixins/SignatureUtils.sol b/src/contracts/mixins/SignatureUtils.sol deleted file mode 100644 index 18f9c89844..0000000000 --- a/src/contracts/mixins/SignatureUtils.sol +++ /dev/null @@ -1,85 +0,0 @@ -// SPDX-License-Identifier: BUSL-1.1 -pragma solidity ^0.8.0; - -import "@openzeppelin-upgrades/contracts/utils/cryptography/SignatureCheckerUpgradeable.sol"; - -import "../interfaces/ISignatureUtils.sol"; - -/// @title SignatureUtils -/// @notice A mixin to provide EIP-712 signature validation utilities. -/// @dev Domain name is hardcoded to "EigenLayer". -abstract contract SignatureUtils is ISignatureUtils { - using SignatureCheckerUpgradeable for address; - - /// CONSTANTS - - /// @notice The EIP-712 typehash for the contract's domain. - bytes32 internal constant EIP712_DOMAIN_TYPEHASH = - keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)"); - - /// @dev Returns the original chain ID from the time the contract was deployed. - uint256 internal immutable _INITIAL_CHAIN_ID; - - /// @dev Returns the original domain separator from the time the contract was deployed. - bytes32 internal immutable _INITIAL_DOMAIN_SEPARATOR; - - /// CONSTRUCTION - - constructor() { - _INITIAL_CHAIN_ID = block.chainid; - _INITIAL_DOMAIN_SEPARATOR = _calculateDomainSeparator(); - } - - /// EXTERNAL FUNCTIONS - - /** - * @notice Returns the current EIP-712 domain separator for this contract. - * - * @dev The domain separator will change in the event of a fork that changes the ChainID. - * @dev By introducing a domain separator the DApp developers are guaranteed that there can be no signature collision. - * for more detailed information please read EIP-712. - * @dev Use `_calculateDomainSeparator` rather than using this function. - */ - function domainSeparator() public view virtual returns (bytes32) { - /// forgefmt: disable-next-item - return block.chainid == _INITIAL_CHAIN_ID - // If the chain ID is the same, return the original domain separator. - ? _INITIAL_DOMAIN_SEPARATOR - // If the chain ID is different, return the new domain separator. - : _calculateDomainSeparator(); - } - - /// INTERNAL HELPERS - - /// @dev Helper for calculating the contract's domain separator. - function _calculateDomainSeparator() internal view returns (bytes32) { - /// forgefmt: disable-next-item - return - keccak256( - abi.encode( - EIP712_DOMAIN_TYPEHASH, - keccak256(bytes("EigenLayer")), - block.chainid, - address(this) - ) - ); - } - - /// @dev Helper for creating valid EIP-712 signable digests. - function _calculateSignableDigest( - bytes32 hash - ) internal view returns (bytes32) { - return keccak256(abi.encodePacked("\x19\x01", domainSeparator(), hash)); - } - - /// @dev Helper for checking if a signature is valid, reverts if not valid. - function _checkIsValidSignatureNow( - address signer, - bytes32 signableDigest, - bytes memory signature, - uint256 expiry - ) internal view { - require(expiry >= block.timestamp, SignatureExpired()); - require(signer.isValidSignatureNow(signableDigest, signature), InvalidSignature()); - } -} diff --git a/src/contracts/mixins/SignatureUtilsMixin.sol b/src/contracts/mixins/SignatureUtilsMixin.sol new file mode 100644 index 0000000000..10b33ad61c --- /dev/null +++ b/src/contracts/mixins/SignatureUtilsMixin.sol @@ -0,0 +1,87 @@ +// SPDX-License-Identifier: BUSL-1.1 +pragma solidity ^0.8.0; + +import "@openzeppelin-upgrades/contracts/utils/ShortStringsUpgradeable.sol"; +import "@openzeppelin-upgrades/contracts/utils/cryptography/SignatureCheckerUpgradeable.sol"; + +import "../interfaces/ISignatureUtilsMixin.sol"; +import "./SemVerMixin.sol"; + +/// @dev The EIP-712 domain type hash used for computing the domain separator +/// See https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator +bytes32 constant EIP712_DOMAIN_TYPEHASH = + keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"); + +/// @title SignatureUtilsMixin +/// @notice A mixin contract that provides utilities for validating signatures according to EIP-712 and EIP-1271 standards. +/// @dev The domain name is hardcoded to "EigenLayer". This contract implements signature validation functionality that can be +/// inherited by other contracts. The domain separator uses the major version (e.g., "v1") to maintain EIP-712 +/// signature compatibility across minor and patch version updates. +abstract contract SignatureUtilsMixin is ISignatureUtilsMixin, SemVerMixin { + using SignatureCheckerUpgradeable for address; + + /// @notice Initializes the contract with a semantic version string. + /// @param _version The SemVer-formatted version string (e.g., "v1.1.1") to use for this contract's domain separator. + /// @dev Version should follow SemVer 2.0.0 format with 'v' prefix: vMAJOR.MINOR.PATCH. + /// Only the major version component is used in the domain separator to maintain signature compatibility + /// across minor and patch version updates. + constructor( + string memory _version + ) SemVerMixin(_version) {} + + /// EXTERNAL FUNCTIONS /// + + /// @inheritdoc ISignatureUtilsMixin + function domainSeparator() public view virtual returns (bytes32) { + // forgefmt: disable-next-item + return + keccak256( + abi.encode( + EIP712_DOMAIN_TYPEHASH, + keccak256(bytes("EigenLayer")), + keccak256(bytes(_majorVersion())), + block.chainid, + address(this) + ) + ); + } + + /// INTERNAL HELPERS /// + + /// @notice Creates a digest that can be signed using EIP-712. + /// @dev Prepends the EIP-712 prefix ("\x19\x01") and domain separator to the input hash. + /// This follows the EIP-712 specification for creating structured data hashes. + /// See https://eips.ethereum.org/EIPS/eip-712#specification. + /// @param hash The hash of the typed data to be signed. + /// @return The complete digest that should be signed according to EIP-712. + function _calculateSignableDigest( + bytes32 hash + ) internal view returns (bytes32) { + return keccak256(abi.encodePacked("\x19\x01", domainSeparator(), hash)); + } + + /// @notice Validates a signature against a signer and digest, with an expiry timestamp. + /// @dev Reverts if the signature is invalid or expired. Uses EIP-1271 for smart contract signers. + /// For EOA signers, validates ECDSA signatures directly. + /// For contract signers, calls isValidSignature according to EIP-1271. + /// See https://eips.ethereum.org/EIPS/eip-1271#specification. + /// @param signer The address that should have signed the digest. + /// @param signableDigest The digest that was signed, created via _calculateSignableDigest. + /// @param signature The signature bytes to validate. + /// @param expiry The timestamp after which the signature is no longer valid. + function _checkIsValidSignatureNow( + address signer, + bytes32 signableDigest, + bytes memory signature, + uint256 expiry + ) internal view { + // First, check if the signature has expired by comparing the expiry timestamp + // against the current block timestamp. + require(expiry >= block.timestamp, SignatureExpired()); + + // Next, verify that the signature is valid for the given signer and digest. + // For EOA signers, this performs standard ECDSA signature verification. + // For contract signers, this calls the EIP-1271 isValidSignature method. + require(signer.isValidSignatureNow(signableDigest, signature), InvalidSignature()); + } +} diff --git a/src/contracts/permissions/PermissionController.sol b/src/contracts/permissions/PermissionController.sol index 46bdea5bde..ee367d79d8 100644 --- a/src/contracts/permissions/PermissionController.sol +++ b/src/contracts/permissions/PermissionController.sol @@ -2,9 +2,10 @@ pragma solidity ^0.8.27; import "@openzeppelin-upgrades/contracts/proxy/utils/Initializable.sol"; +import "../mixins/SemVerMixin.sol"; import "./PermissionControllerStorage.sol"; -contract PermissionController is Initializable, PermissionControllerStorage { +contract PermissionController is Initializable, SemVerMixin, PermissionControllerStorage { using EnumerableSet for *; modifier onlyAdmin( @@ -19,7 +20,9 @@ contract PermissionController is Initializable, PermissionControllerStorage { * INITIALIZING FUNCTIONS * */ - constructor() { + constructor( + string memory _version + ) SemVerMixin(_version) { _disableInitializers(); } diff --git a/src/contracts/pods/EigenPod.sol b/src/contracts/pods/EigenPod.sol index 1066b2fbfb..c92bf9191e 100644 --- a/src/contracts/pods/EigenPod.sol +++ b/src/contracts/pods/EigenPod.sol @@ -8,6 +8,8 @@ import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../libraries/BeaconChainProofs.sol"; import "../libraries/BytesLib.sol"; +import "../mixins/SemVerMixin.sol"; + import "../interfaces/IETHPOSDeposit.sol"; import "../interfaces/IEigenPodManager.sol"; import "../interfaces/IPausable.sol"; @@ -23,7 +25,13 @@ import "./EigenPodStorage.sol"; * @dev Note that all beacon chain balances are stored as gwei within the beacon chain datastructures. We choose * to account balances in terms of gwei in the EigenPod contract and convert to wei when making calls to other contracts */ -contract EigenPod is Initializable, ReentrancyGuardUpgradeable, EigenPodPausingConstants, EigenPodStorage { +contract EigenPod is + Initializable, + ReentrancyGuardUpgradeable, + EigenPodPausingConstants, + EigenPodStorage, + SemVerMixin +{ using BytesLib for bytes; using SafeERC20 for IERC20; using BeaconChainProofs for *; @@ -94,7 +102,12 @@ contract EigenPod is Initializable, ReentrancyGuardUpgradeable, EigenPodPausingC * CONSTRUCTOR / INIT * */ - constructor(IETHPOSDeposit _ethPOS, IEigenPodManager _eigenPodManager, uint64 _GENESIS_TIME) { + constructor( + IETHPOSDeposit _ethPOS, + IEigenPodManager _eigenPodManager, + uint64 _GENESIS_TIME, + string memory _version + ) SemVerMixin(_version) { ethPOS = _ethPOS; eigenPodManager = _eigenPodManager; GENESIS_TIME = _GENESIS_TIME; diff --git a/src/contracts/pods/EigenPodManager.sol b/src/contracts/pods/EigenPodManager.sol index c15b60f8fe..921fefba91 100644 --- a/src/contracts/pods/EigenPodManager.sol +++ b/src/contracts/pods/EigenPodManager.sol @@ -7,6 +7,7 @@ import "@openzeppelin-upgrades/contracts/access/OwnableUpgradeable.sol"; import "@openzeppelin-upgrades/contracts/security/ReentrancyGuardUpgradeable.sol"; import "../libraries/SlashingLib.sol"; +import "../mixins/SemVerMixin.sol"; import "../permissions/Pausable.sol"; import "./EigenPodPausingConstants.sol"; import "./EigenPodManagerStorage.sol"; @@ -27,7 +28,8 @@ contract EigenPodManager is Pausable, EigenPodPausingConstants, EigenPodManagerStorage, - ReentrancyGuardUpgradeable + ReentrancyGuardUpgradeable, + SemVerMixin { using SlashingLib for *; using Math for *; @@ -48,8 +50,13 @@ contract EigenPodManager is IETHPOSDeposit _ethPOS, IBeacon _eigenPodBeacon, IDelegationManager _delegationManager, - IPauserRegistry _pauserRegistry - ) EigenPodManagerStorage(_ethPOS, _eigenPodBeacon, _delegationManager) Pausable(_pauserRegistry) { + IPauserRegistry _pauserRegistry, + string memory _version + ) + EigenPodManagerStorage(_ethPOS, _eigenPodBeacon, _delegationManager) + Pausable(_pauserRegistry) + SemVerMixin(_version) + { _disableInitializers(); } @@ -59,7 +66,7 @@ contract EigenPodManager is } /// @inheritdoc IEigenPodManager - function createPod() external onlyWhenNotPaused(PAUSED_NEW_EIGENPODS) returns (address) { + function createPod() external onlyWhenNotPaused(PAUSED_NEW_EIGENPODS) nonReentrant returns (address) { require(!hasPod(msg.sender), EigenPodAlreadyExists()); // deploy a pod if the sender doesn't have one already IEigenPod pod = _deployPod(); @@ -72,7 +79,7 @@ contract EigenPodManager is bytes calldata pubkey, bytes calldata signature, bytes32 depositDataRoot - ) external payable onlyWhenNotPaused(PAUSED_NEW_EIGENPODS) { + ) external payable onlyWhenNotPaused(PAUSED_NEW_EIGENPODS) nonReentrant { IEigenPod pod = ownerToPod[msg.sender]; if (address(pod) == address(0)) { //deploy a pod if the sender doesn't have one already @@ -135,24 +142,25 @@ contract EigenPodManager is * result in the `podOwner` incurring a "share deficit". This behavior prevents a Staker from queuing a withdrawal which improperly removes excessive * shares from the operator to whom the staker is delegated. * @dev The delegation manager validates that the podOwner is not address(0) + * @return updatedShares the staker's deposit shares after decrement */ function removeDepositShares( address staker, IStrategy strategy, uint256 depositSharesToRemove - ) external onlyDelegationManager { + ) external onlyDelegationManager nonReentrant returns (uint256) { require(strategy == beaconChainETHStrategy, InvalidStrategy()); int256 updatedShares = podOwnerDepositShares[staker] - int256(depositSharesToRemove); require(updatedShares >= 0, SharesNegative()); podOwnerDepositShares[staker] = updatedShares; emit NewTotalShares(staker, updatedShares); + return uint256(updatedShares); } /** - * @notice Increases the `podOwner`'s shares by `shares`, paying off deficit if possible. + * @notice Increases the `podOwner`'s shares by `shares`, paying off negative shares if needed. * Used by the DelegationManager to award a pod owner shares on exiting the withdrawal queue - * @dev Reverts if `shares` is not a whole Gwei amount * @return existingDepositShares the pod owner's shares prior to any additions. Returns 0 if negative * @return addedShares the number of shares added to the staker's balance above 0. This means that if, * after shares are added, the staker's balance is non-positive, this will return 0. @@ -160,17 +168,15 @@ contract EigenPodManager is function addShares( address staker, IStrategy strategy, - IERC20, uint256 shares - ) external onlyDelegationManager returns (uint256, uint256) { + ) external onlyDelegationManager nonReentrant returns (uint256, uint256) { require(strategy == beaconChainETHStrategy, InvalidStrategy()); return _addShares(staker, shares); } /** - * @notice Used by the DelegationManager to complete a withdrawal, sending tokens to some destination address + * @notice Used by the DelegationManager to complete a withdrawal, sending tokens to the pod owner * @dev Prioritizes decreasing the podOwner's share deficit, if they have one - * @dev Reverts if `shares` is not a whole Gwei amount * @dev This function assumes that `removeShares` has already been called by the delegationManager, hence why * we do not need to update the podOwnerDepositShares if `currentpodOwnerDepositShares` is positive */ @@ -179,7 +185,7 @@ contract EigenPodManager is IStrategy strategy, IERC20, uint256 shares - ) external onlyDelegationManager { + ) external onlyDelegationManager nonReentrant { require(strategy == beaconChainETHStrategy, InvalidStrategy()); require(staker != address(0), InputAddressZero()); require(int256(shares) > 0, SharesNegative()); @@ -220,7 +226,7 @@ contract EigenPodManager is } /// @inheritdoc IShareManager - function increaseBurnableShares(IStrategy, uint256 addedSharesToBurn) external onlyDelegationManager { + function increaseBurnableShares(IStrategy, uint256 addedSharesToBurn) external onlyDelegationManager nonReentrant { burnableETHShares += addedSharesToBurn; emit BurnableETHSharesIncreased(addedSharesToBurn); } @@ -265,8 +271,14 @@ contract EigenPodManager is if (updatedDepositShares <= 0) { return (0, 0); } - - return (prevDepositShares < 0 ? 0 : uint256(prevDepositShares), shares); + // If we have gone from negative to positive shares, return (0, positive delta) + else if (prevDepositShares < 0) { + return (0, uint256(updatedDepositShares)); + } + // Else, return true previous shares and added shares + else { + return (uint256(prevDepositShares), shares); + } } /// @dev Calculates the proportion a pod owner's restaked balance has decreased, and diff --git a/src/contracts/pods/EigenPodManagerStorage.sol b/src/contracts/pods/EigenPodManagerStorage.sol index dc1281521a..acc676fe43 100644 --- a/src/contracts/pods/EigenPodManagerStorage.sol +++ b/src/contracts/pods/EigenPodManagerStorage.sol @@ -62,20 +62,30 @@ abstract contract EigenPodManagerStorage is IEigenPodManager { // BEGIN STORAGE VARIABLES ADDED AFTER MAINNET DEPLOYMENT -- DO NOT SUGGEST REORDERING TO CONVENTIONAL ORDER /** - * // TODO: Update this comment - * @notice Mapping from Pod owner owner to the number of deposit shares they have in the virtual beacon chain ETH strategy. - * @dev The deposit share amount can become negative. This is necessary to accommodate the fact that a pod owner's virtual beacon chain ETH shares can - * decrease between the pod owner queuing and completing a withdrawal. - * When the pod owner's shares would otherwise increase, this "deficit" is decreased first _instead_. - * Likewise, when a withdrawal is completed, this "deficit" is decreased and the withdrawal amount is decreased; We can think of this - * as the withdrawal "paying off the deficit". + * @notice mapping from pod owner to the deposit shares they have in the virtual beacon chain ETH strategy + * + * @dev When an EigenPod registers a balance increase, deposit shares are increased. When registering a balance + * decrease, however, deposit shares are NOT decreased. Instead, the pod owner's beacon chain slashing factor + * is decreased proportional to the balance decrease. This impacts the number of shares that will be withdrawn + * when the deposit shares are queued for withdrawal in the DelegationManager. + * + * Note that prior to the slashing release, deposit shares were decreased when balance decreases occurred. + * In certain cases, a combination of queueing a withdrawal plus registering a balance decrease could result + * in a staker having negative deposit shares in this mapping. This negative value would be corrected when the + * staker completes a withdrawal (as tokens or as shares). + * + * With the slashing release, negative shares are no longer possible. However, a staker can still have negative + * shares if they met the conditions for them before the slashing release. If this is the case, that staker + * should complete any outstanding queued withdrawal in the DelegationManager ("as shares"). This will correct + * the negative share count and allow the staker to continue using their pod as normal. */ mapping(address podOwner => int256 shares) public podOwnerDepositShares; uint64 internal __deprecated_denebForkTimestamp; /// @notice Returns the slashing factor applied to the `staker` for the `beaconChainETHStrategy` - /// Note: this is specifically updated when the staker's beacon chain balance decreases + /// Note: this value starts at 1 WAD (1e18) for all stakers, and is updated when a staker's pod registers + /// a balance decrease. mapping(address staker => BeaconChainSlashingFactor) internal _beaconChainSlashingFactor; /// @notice Returns the amount of `shares` that have been slashed on EigenLayer but not burned yet. diff --git a/src/contracts/strategies/EigenStrategy.sol b/src/contracts/strategies/EigenStrategy.sol index f73bccf30c..0720568a2e 100644 --- a/src/contracts/strategies/EigenStrategy.sol +++ b/src/contracts/strategies/EigenStrategy.sol @@ -2,6 +2,7 @@ pragma solidity ^0.8.27; // NOTE: Mainnet uses the OpenZeppelin v4.9.0 contracts, but this imports the 4.7.1 version. This will be changed after an upgrade. + import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../interfaces/IStrategyManager.sol"; import "../strategies/StrategyBase.sol"; @@ -37,8 +38,9 @@ contract EigenStrategy is StrategyBase { /// @notice Since this contract is designed to be initializable, the constructor simply sets `strategyManager`, the only immutable variable. constructor( IStrategyManager _strategyManager, - IPauserRegistry _pauserRegistry - ) StrategyBase(_strategyManager, _pauserRegistry) {} + IPauserRegistry _pauserRegistry, + string memory _version + ) StrategyBase(_strategyManager, _pauserRegistry, _version) {} function initialize(IEigen _EIGEN, IERC20 _bEIGEN) public virtual initializer { EIGEN = _EIGEN; diff --git a/src/contracts/strategies/StrategyBase.sol b/src/contracts/strategies/StrategyBase.sol index 555fe6a6e3..b4a9164748 100644 --- a/src/contracts/strategies/StrategyBase.sol +++ b/src/contracts/strategies/StrategyBase.sol @@ -3,6 +3,7 @@ pragma solidity ^0.8.27; import "../interfaces/IStrategyManager.sol"; import "../permissions/Pausable.sol"; +import "../mixins/SemVerMixin.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; @@ -28,7 +29,7 @@ import "@openzeppelin-upgrades/contracts/proxy/utils/Initializable.sol"; * [this thread](https://github.com/OpenZeppelin/openzeppelin-contracts/issues/3706) on the OpenZeppelin repo. * We specifically use a share offset of `SHARES_OFFSET` and a balance offset of `BALANCE_OFFSET`. */ -contract StrategyBase is Initializable, Pausable, IStrategy { +contract StrategyBase is Initializable, Pausable, IStrategy, SemVerMixin { using SafeERC20 for IERC20; uint8 internal constant PAUSED_DEPOSITS = 0; @@ -69,7 +70,11 @@ contract StrategyBase is Initializable, Pausable, IStrategy { } /// @notice Since this contract is designed to be initializable, the constructor simply sets `strategyManager`, the only immutable variable. - constructor(IStrategyManager _strategyManager, IPauserRegistry _pauserRegistry) Pausable(_pauserRegistry) { + constructor( + IStrategyManager _strategyManager, + IPauserRegistry _pauserRegistry, + string memory _version + ) Pausable(_pauserRegistry) SemVerMixin(_version) { strategyManager = _strategyManager; _disableInitializers(); } diff --git a/src/contracts/strategies/StrategyBaseTVLLimits.sol b/src/contracts/strategies/StrategyBaseTVLLimits.sol index ac972822e8..65eca55877 100644 --- a/src/contracts/strategies/StrategyBaseTVLLimits.sol +++ b/src/contracts/strategies/StrategyBaseTVLLimits.sol @@ -26,8 +26,9 @@ contract StrategyBaseTVLLimits is StrategyBase { // solhint-disable-next-line no-empty-blocks constructor( IStrategyManager _strategyManager, - IPauserRegistry _pauserRegistry - ) StrategyBase(_strategyManager, _pauserRegistry) {} + IPauserRegistry _pauserRegistry, + string memory _version + ) StrategyBase(_strategyManager, _pauserRegistry, _version) {} function initialize( uint256 _maxPerDeposit, diff --git a/src/contracts/strategies/StrategyFactory.sol b/src/contracts/strategies/StrategyFactory.sol index f2d35d53fa..385bdcd839 100644 --- a/src/contracts/strategies/StrategyFactory.sol +++ b/src/contracts/strategies/StrategyFactory.sol @@ -3,6 +3,7 @@ pragma solidity ^0.8.27; import "@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol"; import "@openzeppelin-upgrades/contracts/access/OwnableUpgradeable.sol"; +import "../mixins/SemVerMixin.sol"; import "./StrategyFactoryStorage.sol"; import "./StrategyBase.sol"; import "../permissions/Pausable.sol"; @@ -14,14 +15,18 @@ import "../permissions/Pausable.sol"; * @notice Terms of Service: https://docs.eigenlayer.xyz/overview/terms-of-service * @dev This may not be compatible with non-standard ERC20 tokens. Caution is warranted. */ -contract StrategyFactory is StrategyFactoryStorage, OwnableUpgradeable, Pausable { +contract StrategyFactory is StrategyFactoryStorage, OwnableUpgradeable, Pausable, SemVerMixin { uint8 internal constant PAUSED_NEW_STRATEGIES = 0; /// @notice EigenLayer's StrategyManager contract IStrategyManager public immutable strategyManager; /// @notice Since this contract is designed to be initializable, the constructor simply sets the immutable variables. - constructor(IStrategyManager _strategyManager, IPauserRegistry _pauserRegistry) Pausable(_pauserRegistry) { + constructor( + IStrategyManager _strategyManager, + IPauserRegistry _pauserRegistry, + string memory _version + ) Pausable(_pauserRegistry) SemVerMixin(_version) { strategyManager = _strategyManager; _disableInitializers(); } @@ -37,9 +42,9 @@ contract StrategyFactory is StrategyFactoryStorage, OwnableUpgradeable, Pausable } /** - * @notice Deploy a new strategyBeacon contract for the ERC20 token. + * @notice Deploy a new StrategyBase contract for the ERC20 token, using a beacon proxy * @dev A strategy contract must not yet exist for the token. - * $dev Immense caution is warranted for non-standard ERC20 tokens, particularly "reentrant" tokens + * @dev Immense caution is warranted for non-standard ERC20 tokens, particularly "reentrant" tokens * like those that conform to ERC777. */ function deployNewStrategy( diff --git a/src/test/DevnetLifecycle.t.sol b/src/test/DevnetLifecycle.t.sol index 79beb56f99..aeb3cd6752 100644 --- a/src/test/DevnetLifecycle.t.sol +++ b/src/test/DevnetLifecycle.t.sol @@ -119,7 +119,7 @@ contract Devnet_Lifecycle_Test is Test, IAllocationManagerTypes { function _delegateToOperator() internal { // Delegate to operator - ISignatureUtils.SignatureWithExpiry memory signatureWithExpiry; + ISignatureUtilsMixinTypes.SignatureWithExpiry memory signatureWithExpiry; cheats.prank(staker); delegationManager.delegateTo(operator, signatureWithExpiry, bytes32(0)); diff --git a/src/test/harnesses/AllocationManagerHarness.sol b/src/test/harnesses/AllocationManagerHarness.sol new file mode 100644 index 0000000000..98205c0d22 --- /dev/null +++ b/src/test/harnesses/AllocationManagerHarness.sol @@ -0,0 +1,33 @@ +// SPDX-License-Identifier: BUSL-1.1 +pragma solidity ^0.8.27; + +import "../../contracts/core/AllocationManager.sol"; + +contract AllocationManagerHarness is AllocationManager { + using DoubleEndedQueue for DoubleEndedQueue.Bytes32Deque; + + constructor( + IDelegationManager _delegation, + IPauserRegistry _pauserRegistry, + IPermissionController _permissionController, + uint32 _DEALLOCATION_DELAY, + uint32 _ALLOCATION_CONFIGURATION_DELAY + ) + AllocationManager( + _delegation, + _pauserRegistry, + _permissionController, + _DEALLOCATION_DELAY, + _ALLOCATION_CONFIGURATION_DELAY, + "v9.9.9" + ) + {} + + function deallocationQueueAtIndex( + address operator, + IStrategy strategy, + uint256 index + ) external view returns (bytes32) { + return deallocationQueue[operator][strategy].at(index); + } +} diff --git a/src/test/harnesses/DelegationManagerHarness.sol b/src/test/harnesses/DelegationManagerHarness.sol index a88d0fe67b..dcf1bc0229 100644 --- a/src/test/harnesses/DelegationManagerHarness.sol +++ b/src/test/harnesses/DelegationManagerHarness.sol @@ -20,7 +20,8 @@ contract DelegationManagerHarness is DelegationManager { _allocationManager, _pauserRegistry, _permissionController, - _MIN_WITHDRAWAL_DELAY + _MIN_WITHDRAWAL_DELAY, + "v9.9.9" ) {} diff --git a/src/test/harnesses/EigenPodHarness.sol b/src/test/harnesses/EigenPodHarness.sol index 0be5e4a541..29217270bc 100644 --- a/src/test/harnesses/EigenPodHarness.sol +++ b/src/test/harnesses/EigenPodHarness.sol @@ -9,11 +9,13 @@ contract EigenPodHarness is EigenPod { constructor( IETHPOSDeposit _ethPOS, IEigenPodManager _eigenPodManager, - uint64 _GENESIS_TIME + uint64 _GENESIS_TIME, + string memory _version ) EigenPod( _ethPOS, _eigenPodManager, - _GENESIS_TIME + _GENESIS_TIME, + _version ) {} function getActiveValidatorCount() public view returns (uint256) { diff --git a/src/test/harnesses/EigenPodManagerWrapper.sol b/src/test/harnesses/EigenPodManagerWrapper.sol index ffb190a551..5491984548 100644 --- a/src/test/harnesses/EigenPodManagerWrapper.sol +++ b/src/test/harnesses/EigenPodManagerWrapper.sol @@ -9,8 +9,9 @@ contract EigenPodManagerWrapper is EigenPodManager { IETHPOSDeposit _ethPOS, IBeacon _eigenPodBeacon, IDelegationManager _delegationManager, - IPauserRegistry _pauserRegistry - ) EigenPodManager(_ethPOS, _eigenPodBeacon, _delegationManager, _pauserRegistry) {} + IPauserRegistry _pauserRegistry, + string memory _version + ) EigenPodManager(_ethPOS, _eigenPodBeacon, _delegationManager, _pauserRegistry, _version) {} function setPodOwnerShares(address owner, IEigenPod pod) external { ownerToPod[owner] = pod; diff --git a/src/test/integration/IntegrationBase.t.sol b/src/test/integration/IntegrationBase.t.sol index 1df949a05e..0f3d9d1524 100644 --- a/src/test/integration/IntegrationBase.t.sol +++ b/src/test/integration/IntegrationBase.t.sol @@ -9,18 +9,20 @@ import "@openzeppelin/contracts/utils/Strings.sol"; import "src/contracts/libraries/BeaconChainProofs.sol"; import "src/contracts/libraries/SlashingLib.sol"; +import "src/test/integration/TypeImporter.t.sol"; import "src/test/integration/IntegrationDeployer.t.sol"; import "src/test/integration/TimeMachine.t.sol"; import "src/test/integration/users/User.t.sol"; import "src/test/integration/users/User_M1.t.sol"; -abstract contract IntegrationBase is IntegrationDeployer { +abstract contract IntegrationBase is IntegrationDeployer, TypeImporter { using StdStyle for *; using SlashingLib for *; + using Math for uint256; using Strings for *; using print for *; - using ArrayLib for IStrategy[]; + using ArrayLib for *; uint numStakers = 0; uint numOperators = 0; @@ -49,7 +51,7 @@ abstract contract IntegrationBase is IntegrationDeployer { IStrategy[] memory strategies; uint[] memory tokenBalances; - if (forkType == MAINNET && !isUpgraded) { + if (!isUpgraded) { stakerName = string.concat("M2Staker", cheats.toString(numStakers)); (staker, strategies, tokenBalances) = _randUser(stakerName); @@ -67,6 +69,35 @@ abstract contract IntegrationBase is IntegrationDeployer { return (staker, strategies, tokenBalances); } + function _newBasicStaker() internal returns (User, IStrategy[] memory, uint[] memory) { + string memory stakerName; + + User staker; + IStrategy[] memory strategies; + uint[] memory tokenBalances; + + if (!isUpgraded) { + stakerName = string.concat("M2Staker", cheats.toString(numStakers)); + + (staker, strategies, tokenBalances) = _randUser(stakerName); + + stakersToMigrate.push(staker); + } else { + stakerName = string.concat("staker", cheats.toString(numStakers)); + + (staker, strategies, tokenBalances) = _randUser(stakerName); + } + + assert_HasUnderlyingTokenBalances(staker, strategies, tokenBalances, "_newRandomStaker: failed to award token balances"); + + numStakers++; + assembly { // TODO HACK + mstore(strategies, 1) + mstore(tokenBalances, 1) + } + return (staker, strategies, tokenBalances); + } + /** * @dev Create a new operator according to configured random variants. * This user will immediately deposit their randomized assets into eigenlayer. @@ -79,7 +110,7 @@ abstract contract IntegrationBase is IntegrationDeployer { uint[] memory tokenBalances; uint[] memory addedShares; - if (forkType == MAINNET && !isUpgraded) { + if (!isUpgraded) { string memory operatorName = string.concat("M2Operator", numOperators.toString()); // Create an operator for M2. @@ -102,11 +133,12 @@ abstract contract IntegrationBase is IntegrationDeployer { operator.registerAsOperator(); operator.depositIntoEigenlayer(strategies, tokenBalances); - // Roll passed the allocation configuration delay - rollForward({blocks: ALLOCATION_CONFIGURATION_DELAY}); - } + // Roll past the allocation configuration delay + rollForward({blocks: ALLOCATION_CONFIGURATION_DELAY + 1}); - assert_Snap_Added_Staker_DepositShares(operator, strategies, addedShares, "_newRandomOperator: failed to add delegatable shares"); + assert_Snap_Added_Staker_DepositShares(operator, strategies, addedShares, "_newRandomOperator: failed to add delegatable shares"); + } + assert_Snap_Added_OperatorShares(operator, strategies, addedShares, "_newRandomOperator: failed to award shares to operator"); assertTrue(delegationManager.isOperator(address(operator)), "_newRandomOperator: operator should be registered"); @@ -114,9 +146,38 @@ abstract contract IntegrationBase is IntegrationDeployer { return (operator, strategies, tokenBalances); } + /// @dev Creates a new operator with no assets + function _newRandomOperator_NoAssets() internal returns (User) { + User operator; + + if (!isUpgraded) { + string memory operatorName = string.concat("M2Operator", numOperators.toString()); + + // Create an operator for M2. + operator = _randUser_NoAssets(operatorName); + User_M2(payable(operator)).registerAsOperator_M2(); + + operatorsToMigrate.push(operator); + } else { + string memory operatorName = string.concat("operator", numOperators.toString()); + + operator = _randUser_NoAssets(operatorName); + operator.registerAsOperator(); + + // Roll past the allocation configuration delay + rollForward({blocks: ALLOCATION_CONFIGURATION_DELAY + 1}); + } + + assertTrue(delegationManager.isOperator(address(operator)), "_newRandomOperator: operator should be registered"); + + numOperators++; + return operator; + } + function _newRandomAVS() internal returns (AVS avs, OperatorSet[] memory operatorSets) { string memory avsName = string.concat("avs", numAVSs.toString()); avs = _genRandAVS(avsName); + avs.updateAVSMetadataURI("https://example.com"); operatorSets = avs.createOperatorSets(_randomStrategies()); ++numAVSs; } @@ -138,44 +199,16 @@ abstract contract IntegrationBase is IntegrationDeployer { return (gweiSent, remainderSent); } - - /// @dev If we're on mainnet, upgrade contracts to slashing and migrate stakers/operators - function _upgradeEigenLayerContracts() internal { - if (forkType == MAINNET) { - require(!isUpgraded, "_upgradeEigenLayerContracts: already performed slashing upgrade"); - - emit log("_upgradeEigenLayerContracts: upgrading mainnet to slashing"); - _upgradeMainnetContracts(); - - // Bump block.timestamp forward to allow verifyWC proofs for migrated pods - emit log("advancing block time to start of next epoch:"); - - beaconChain.advanceEpoch_NoRewards(); - - emit log("======"); - - isUpgraded = true; - emit log("_upgradeEigenLayerContracts: slashing upgrade complete"); - } else if (forkType == HOLESKY) { - require(!isUpgraded, "_upgradeEigenLayerContracts: already performed slashing upgrade"); - - emit log("_upgradeEigenLayerContracts: upgrading holesky to slashing"); - _upgradeHoleskyContracts(); - - isUpgraded = true; - emit log("_upgradeEigenLayerContracts: slashing upgrade complete"); - } - } - + /// @dev Choose a random subset of validators (selects AT LEAST ONE) function _choose(uint40[] memory validators) internal returns (uint40[] memory) { - uint rand = _randUint({ min: 1, max: validators.length ** 2 }); + uint _rand = _randUint({ min: 1, max: validators.length ** 2 }); uint40[] memory result = new uint40[](validators.length); uint newLen; for (uint i = 0; i < validators.length; i++) { // if bit set, add validator - if (rand >> i & 1 == 1) { + if (_rand >> i & 1 == 1) { result[newLen] = validators[i]; newLen++; } @@ -252,235 +285,922 @@ abstract contract IntegrationBase is IntegrationDeployer { tokenBalance = strat.underlyingToken().balanceOf(address(user)); } - assertApproxEqAbs(expectedBalance, tokenBalance, 1, err); - } - } + assertApproxEqAbs(expectedBalance, tokenBalance, 1, err); + } + } + + function assert_HasNoUnderlyingTokenBalance(User user, IStrategy[] memory strategies, string memory err) internal view { + assert_HasUnderlyingTokenBalances(user, strategies, new uint[](strategies.length), err); + } + + function assert_HasExpectedShares( + User user, + IStrategy[] memory strategies, + uint[] memory expectedShares, + string memory err + ) internal view { + uint[] memory actualShares = _getStakerDepositShares(user, strategies); + for(uint i = 0; i < strategies.length; i++) { + assertApproxEqAbs(expectedShares[i], actualShares[i], 1, err); + } + } + + function assert_HasOperatorShares( + User user, + IStrategy[] memory strategies, + uint[] memory expectedShares, + string memory err + ) internal view { + for (uint i = 0; i < strategies.length; i++) { + uint actualShares = delegationManager.operatorShares(address(user), strategies[i]); + assertEq(expectedShares[i], actualShares, err); + } + } + + /// @dev Asserts that ALL of the `withdrawalRoots` is in `delegationManager.pendingWithdrawals` + function assert_AllWithdrawalsPending(bytes32[] memory withdrawalRoots, string memory err) internal view { + for (uint i = 0; i < withdrawalRoots.length; i++) { + assert_WithdrawalPending(withdrawalRoots[i], err); + } + } + + /// @dev Asserts that NONE of the `withdrawalRoots` is in `delegationManager.pendingWithdrawals` + function assert_NoWithdrawalsPending(bytes32[] memory withdrawalRoots, string memory err) internal view { + for (uint i = 0; i < withdrawalRoots.length; i++) { + assert_WithdrawalNotPending(withdrawalRoots[i], err); + } + } + + /// @dev Asserts that the hash of each withdrawal corresponds to the provided withdrawal root + function assert_WithdrawalPending(bytes32 withdrawalRoot, string memory err) internal view { + assertTrue(delegationManager.pendingWithdrawals(withdrawalRoot), err); + } + + function assert_WithdrawalNotPending(bytes32 withdrawalRoot, string memory err) internal view { + assertFalse(delegationManager.pendingWithdrawals(withdrawalRoot), err); + } + + function assert_ValidWithdrawalHashes( + Withdrawal[] memory withdrawals, + bytes32[] memory withdrawalRoots, + string memory err + ) internal view { + for (uint i = 0; i < withdrawals.length; i++) { + assert_ValidWithdrawalHash(withdrawals[i], withdrawalRoots[i], err); + } + } + + function assert_ValidWithdrawalHash( + Withdrawal memory withdrawal, + bytes32 withdrawalRoot, + string memory err + ) internal view { + assertEq(withdrawalRoot, delegationManager.calculateWithdrawalRoot(withdrawal), err); + } + + function assert_PodBalance_Eq( + User staker, + uint expectedBalance, + string memory err + ) internal view { + EigenPod pod = staker.pod(); + assertEq(address(pod).balance, expectedBalance, err); + } + + function assert_ProofsRemainingEqualsActive( + User staker, + string memory err + ) internal view { + EigenPod pod = staker.pod(); + assertEq(pod.currentCheckpoint().proofsRemaining, pod.activeValidatorCount(), err); + } + + function assert_CheckpointPodBalance( + User staker, + uint64 expectedPodBalanceGwei, + string memory err + ) internal view { + EigenPod pod = staker.pod(); + assertEq(pod.currentCheckpoint().podBalanceGwei, expectedPodBalanceGwei, err); + } + + function assert_MaxEqualsAllocatablePlusEncumbered( + User operator, + string memory err + ) internal view { + Magnitudes[] memory mags = _getMagnitudes(operator, allStrats); + + for (uint i = 0; i < allStrats.length; i++) { + Magnitudes memory m = mags[i]; + assertEq(m.max, m.encumbered + m.allocatable, err); + } + } + + function assert_CurMinSlashableEqualsMinAllocated( + User operator, + OperatorSet memory operatorSet, + IStrategy[] memory strategies, + string memory err + ) internal view { + uint[] memory minSlashableStake = _getMinSlashableStake(operator, operatorSet, strategies); + uint[] memory minAllocatedStake = _getAllocatedStake(operator, operatorSet, strategies); + + for (uint i = 0; i < strategies.length; i++) { + assertEq(minSlashableStake[i], minAllocatedStake[i], err); + } + } + + function assert_MaxMagsEqualMaxMagsAtCurrentBlock( + User operator, + IStrategy[] memory strategies, + string memory err + ) internal view { + uint64[] memory maxMagnitudes = _getMaxMagnitudes(operator, strategies); + uint64[] memory maxAtCurrentBlock = _getMaxMagnitudes(operator, strategies, uint32(block.number)); + + for (uint i = 0; i < strategies.length; i++) { + assertEq(maxMagnitudes[i], maxAtCurrentBlock[i], err); + } + } + + function assert_CurrentMagnitude( + User operator, + AllocateParams memory params, + string memory err + ) internal view { + Allocation[] memory allocations = _getAllocations(operator, params.operatorSet, params.strategies); + + for (uint i = 0; i < allocations.length; i++) { + assertEq(allocations[i].currentMagnitude, params.newMagnitudes[i], err); + } + } + + function assert_NoPendingModification( + User operator, + OperatorSet memory operatorSet, + IStrategy[] memory strategies, + string memory err + ) internal view { + Allocation[] memory allocations = _getAllocations(operator, operatorSet, strategies); + + for (uint i = 0; i < allocations.length; i++) { + assertEq(0, allocations[i].effectBlock, err); + } + } + + function assert_HasPendingIncrease( + User operator, + AllocateParams memory params, + string memory err + ) internal view { + uint32 delay = _getExistingAllocationDelay(operator); + Allocation[] memory allocations = _getAllocations(operator, params.operatorSet, params.strategies); + + for (uint i = 0; i < allocations.length; i++) { + assertEq(allocations[i].effectBlock, uint32(block.number) + delay, err); + assertTrue(allocations[i].currentMagnitude != params.newMagnitudes[i], err); + assertGt(allocations[i].pendingDiff, 0, err); + } + } + + function assert_HasPendingDecrease( + User operator, + AllocateParams memory params, + string memory err + ) internal view { + uint32 deallocationDelay = allocationManager.DEALLOCATION_DELAY(); + Allocation[] memory allocations = _getAllocations(operator, params.operatorSet, params.strategies); + + for (uint i = 0; i < allocations.length; i++) { + assertEq(allocations[i].effectBlock, uint32(block.number) + deallocationDelay + 1, err); + assertTrue(allocations[i].currentMagnitude != params.newMagnitudes[i], err); + assertLt(allocations[i].pendingDiff, 0, err); + } + } + + function assert_IsRegistered( + User operator, + OperatorSet memory operatorSet, + string memory err + ) internal view { + assertTrue(allocationManager.isMemberOfOperatorSet(address(operator), operatorSet), err); + } + + function assert_IsSlashable( + User operator, + OperatorSet memory operatorSet, + string memory err + ) internal view { + assertTrue(allocationManager.isOperatorSlashable(address(operator), operatorSet), err); + } + + function assert_NotSlashable( + User operator, + OperatorSet memory operatorSet, + string memory err + ) internal view { + assertFalse(allocationManager.isOperatorSlashable(address(operator), operatorSet), err); + } + + function assert_IsAllocatedToSet( + User operator, + OperatorSet memory operatorSet, + string memory err + ) internal view { + assertTrue(allocationManager.getAllocatedSets(address(operator)).contains(operatorSet), err); + } + + function assert_IsNotAllocated( + User operator, + OperatorSet memory operatorSet, + string memory err + ) internal view { + assertEq(allocationManager.getAllocatedStrategies(address(operator), operatorSet).length, 0, err); + } + + function assert_IsAllocatedToSetStrats( + User operator, + OperatorSet memory operatorSet, + IStrategy[] memory strategies, + string memory err + ) internal view { + IStrategy[] memory allocatedStrategies = allocationManager.getAllocatedStrategies(address(operator), operatorSet); + + for (uint i = 0; i < strategies.length; i++) { + assertTrue(allocatedStrategies.contains(strategies[i]), err); + } + } + + function assert_HasAllocatedStake( + User operator, + AllocateParams memory params, + string memory err + ) internal view { + OperatorSet memory operatorSet = params.operatorSet; + IStrategy[] memory strategies = params.strategies; + uint64[] memory curMagnitudes = params.newMagnitudes; + + uint64[] memory maxMagnitudes = _getMaxMagnitudes(operator, params.strategies); + uint[] memory operatorShares = _getOperatorShares(operator, params.strategies); + uint[] memory allocatedStake = _getAllocatedStake(operator, operatorSet, strategies); + + for (uint i = 0; i < strategies.length; i++) { + uint expectedAllocated; + if (maxMagnitudes[i] == 0) { + expectedAllocated = 0; + } else { + uint slashableProportion = uint(curMagnitudes[i]).divWad(maxMagnitudes[i]); + expectedAllocated = operatorShares[i].mulWad(slashableProportion); + } + + assertEq(expectedAllocated, allocatedStake[i], err); + } + } + + function assert_HasSlashableStake( + User operator, + AllocateParams memory params, + string memory err + ) internal view { + OperatorSet memory operatorSet = params.operatorSet; + IStrategy[] memory strategies = params.strategies; + uint64[] memory curMagnitudes = params.newMagnitudes; + + uint64[] memory maxMagnitudes = _getMaxMagnitudes(operator, params.strategies); + uint[] memory operatorShares = _getOperatorShares(operator, params.strategies); + uint[] memory slashableStake = _getMinSlashableStake(operator, operatorSet, strategies); + + for (uint i = 0; i < strategies.length; i++) { + uint expectedSlashable; + if (maxMagnitudes[i] == 0) { + expectedSlashable = 0; + } else { + uint slashableProportion = uint(curMagnitudes[i]).divWad(maxMagnitudes[i]); + expectedSlashable = operatorShares[i].mulWad(slashableProportion); + } + + assertEq(expectedSlashable, slashableStake[i], err); + } + } + + function assert_NoSlashableStake( + User operator, + OperatorSet memory operatorSet, + string memory err + ) internal view { + IStrategy[] memory strategies = allocationManager.getStrategiesInOperatorSet(operatorSet); + uint[] memory slashableStake = _getMinSlashableStake(operator, operatorSet, strategies); + + for (uint i = 0; i < slashableStake.length; i++) { + assertEq(slashableStake[i], 0, err); + } + } + + function assert_DSF_Reset( + User staker, + IStrategy[] memory strategies, + string memory err + ) internal { + uint[] memory depositScalingFactors = _getDepositScalingFactors(staker, strategies); + for (uint i = 0; i < strategies.length; i++) { + assertEq(depositScalingFactors[i], WAD, err); + } + } + + /******************************************************************************* + SNAPSHOT ASSERTIONS + TIME TRAVELERS ONLY BEYOND THIS POINT + *******************************************************************************/ + + /******************************************************************************* + SNAPSHOT ASSERTIONS: ALLOCATIONS + *******************************************************************************/ + + function assert_Snap_Became_Registered( + User operator, + OperatorSet memory operatorSet, + string memory err + ) internal { + bool curIsMemberOfSet = _getIsMemberOfSet(operator, operatorSet); + bool prevIsMemberOfSet = _getPrevIsMemberOfSet(operator, operatorSet); + + assertFalse(prevIsMemberOfSet, err); + assertTrue(curIsMemberOfSet, err); + } + + function assert_Snap_Became_Deregistered( + User operator, + OperatorSet memory operatorSet, + string memory err + ) internal { + bool curIsMemberOfSet = _getIsMemberOfSet(operator, operatorSet); + bool prevIsMemberOfSet = _getPrevIsMemberOfSet(operator, operatorSet); + + assertTrue(prevIsMemberOfSet, err); + assertFalse(curIsMemberOfSet, err); + } + + function assert_Snap_Unchanged_Registration( + User operator, + OperatorSet memory operatorSet, + string memory err + ) internal { + bool curIsMemberOfSet = _getIsMemberOfSet(operator, operatorSet); + bool prevIsMemberOfSet = _getPrevIsMemberOfSet(operator, operatorSet); + + assertEq(prevIsMemberOfSet, curIsMemberOfSet, err); + } + + function assert_Snap_Became_Slashable( + User operator, + OperatorSet memory operatorSet, + string memory err + ) internal { + bool curIsSlashable = _getIsSlashable(operator, operatorSet); + bool prevIsSlashable = _getPrevIsSlashable(operator, operatorSet); + + assertFalse(prevIsSlashable, err); + assertTrue(curIsSlashable, err); + } + + function assert_Snap_Remains_Slashable( + User operator, + OperatorSet memory operatorSet, + string memory err + ) internal { + bool curIsSlashable = _getIsSlashable(operator, operatorSet); + bool prevIsSlashable = _getPrevIsSlashable(operator, operatorSet); + + assertTrue(prevIsSlashable, err); + assertTrue(curIsSlashable, err); + } + + function assert_Snap_Unchanged_Slashability( + User operator, + OperatorSet memory operatorSet, + string memory err + ) internal { + bool curIsSlashable = _getIsSlashable(operator, operatorSet); + bool prevIsSlashable = _getPrevIsSlashable(operator, operatorSet); + + assertEq(prevIsSlashable, curIsSlashable, err); + } + + function assert_Snap_Unchanged_AllocatedStrats( + User operator, + OperatorSet memory operatorSet, + string memory err + ) internal { + IStrategy[] memory curAllocatedStrats = _getAllocatedStrats(operator, operatorSet); + IStrategy[] memory prevAllocatedStrats = _getPrevAllocatedStrats(operator, operatorSet); + + assertEq(curAllocatedStrats.length, prevAllocatedStrats.length, err); + + for (uint i = 0; i < curAllocatedStrats.length; i++) { + assertEq(address(curAllocatedStrats[i]), address(prevAllocatedStrats[i]), err); + } + } + + function assert_Snap_Unchanged_StrategyAllocations( + User operator, + OperatorSet memory operatorSet, + IStrategy[] memory strategies, + string memory err + ) internal { + Allocation[] memory curAllocations = _getAllocations(operator, operatorSet, strategies); + Allocation[] memory prevAllocations = _getPrevAllocations(operator, operatorSet, strategies); + + for (uint i = 0; i < strategies.length; i++) { + Allocation memory curAllocation = curAllocations[i]; + Allocation memory prevAllocation = prevAllocations[i]; + + assertEq(curAllocation.currentMagnitude, prevAllocation.currentMagnitude, err); + assertEq(curAllocation.pendingDiff, prevAllocation.pendingDiff, err); + assertEq(curAllocation.effectBlock, prevAllocation.effectBlock, err); + } + } + + function assert_Snap_Added_AllocatedSet( + User operator, + OperatorSet memory operatorSet, + string memory err + ) internal { + OperatorSet[] memory curAllocatedSets = _getAllocatedSets(operator); + OperatorSet[] memory prevAllocatedSets = _getPrevAllocatedSets(operator); + + assertEq(curAllocatedSets.length, prevAllocatedSets.length + 1, err); + assertFalse(prevAllocatedSets.contains(operatorSet), err); + assertTrue(curAllocatedSets.contains(operatorSet), err); + } + + function assert_Snap_Unchanged_AllocatedSets( + User operator, + string memory err + ) internal { + OperatorSet[] memory curAllocatedSets = _getAllocatedSets(operator); + OperatorSet[] memory prevAllocatedSets = _getPrevAllocatedSets(operator); + + assertEq(curAllocatedSets.length, prevAllocatedSets.length, err); + } + + function assert_Snap_Removed_AllocatedSet( + User operator, + OperatorSet memory operatorSet, + string memory err + ) internal { + OperatorSet[] memory curAllocatedSets = _getAllocatedSets(operator); + OperatorSet[] memory prevAllocatedSets = _getPrevAllocatedSets(operator); + + assertEq(curAllocatedSets.length + 1, prevAllocatedSets.length, err); + assertTrue(prevAllocatedSets.contains(operatorSet), err); + assertFalse(curAllocatedSets.contains(operatorSet), err); + } + + function assert_Snap_Added_RegisteredSet( + User operator, + OperatorSet memory operatorSet, + string memory err + ) internal { + OperatorSet[] memory curRegisteredSets = _getRegisteredSets(operator); + OperatorSet[] memory prevRegisteredSets = _getPrevRegisteredSets(operator); + + assertEq(curRegisteredSets.length, prevRegisteredSets.length + 1, err); + assertFalse(prevRegisteredSets.contains(operatorSet), err); + assertTrue(curRegisteredSets.contains(operatorSet), err); + } + + function assert_Snap_Removed_RegisteredSet( + User operator, + OperatorSet memory operatorSet, + string memory err + ) internal { + OperatorSet[] memory curRegisteredSets = _getRegisteredSets(operator); + OperatorSet[] memory prevRegisteredSets = _getPrevRegisteredSets(operator); + + assertEq(curRegisteredSets.length + 1, prevRegisteredSets.length, err); + assertTrue(prevRegisteredSets.contains(operatorSet), err); + assertFalse(curRegisteredSets.contains(operatorSet), err); + } + + function assert_Snap_Unchanged_RegisteredSet( + User operator, + string memory err + ) internal { + OperatorSet[] memory curRegisteredSets = _getRegisteredSets(operator); + OperatorSet[] memory prevRegisteredSets = _getPrevRegisteredSets(operator); + + assertEq(curRegisteredSets.length, prevRegisteredSets.length, err); + for (uint i = 0; i < curRegisteredSets.length; i++) { + assertEq(curRegisteredSets[i].avs, prevRegisteredSets[i].avs, err); + assertEq(curRegisteredSets[i].id, prevRegisteredSets[i].id, err); + } + } + + function assert_Snap_Added_MemberOfSet( + User operator, + OperatorSet memory operatorSet, + string memory err + ) internal { + address[] memory curOperators = _getMembers(operatorSet); + address[] memory prevOperators = _getPrevMembers(operatorSet); + + assertEq(curOperators.length, prevOperators.length + 1, err); + assertFalse(prevOperators.contains(address(operator)), err); + assertTrue(curOperators.contains(address(operator)), err); + } + + function assert_Snap_Removed_MemberOfSet( + User operator, + OperatorSet memory operatorSet, + string memory err + ) internal { + address[] memory curOperators = _getMembers(operatorSet); + address[] memory prevOperators = _getPrevMembers(operatorSet); + + assertEq(curOperators.length + 1, prevOperators.length, err); + assertTrue(prevOperators.contains(address(operator)), err); + assertFalse(curOperators.contains(address(operator)), err); + } + + function assert_Snap_Unchanged_MemberOfSet( + OperatorSet memory operatorSet, + string memory err + ) internal { + address[] memory curOperators = _getMembers(operatorSet); + address[] memory prevOperators = _getPrevMembers(operatorSet); + + assertEq(curOperators.length, prevOperators.length, err); + for (uint i = 0; i < curOperators.length; i++) { + assertEq(curOperators[i], prevOperators[i], err); + } + } + + function assert_Snap_StakeBecameSlashable( + User operator, + OperatorSet memory operatorSet, + IStrategy[] memory strategies, + string memory err + ) internal { + uint[] memory curSlashableStake = _getMinSlashableStake(operator, operatorSet, strategies); + uint[] memory prevSlashableStake = _getPrevMinSlashableStake(operator, operatorSet, strategies); + + for (uint i = 0; i < strategies.length; i++) { + assertTrue(prevSlashableStake[i] < curSlashableStake[i], err); + } + } + + function assert_Snap_StakeBecomeUnslashable( + User operator, + OperatorSet memory operatorSet, + IStrategy[] memory strategies, + string memory err + ) internal { + uint[] memory curSlashableStake = _getMinSlashableStake(operator, operatorSet, strategies); + uint[] memory prevSlashableStake = _getPrevMinSlashableStake(operator, operatorSet, strategies); + + for (uint i = 0; i < strategies.length; i++) { + assertTrue(prevSlashableStake[i] > curSlashableStake[i], err); + } + } + + function assert_Snap_Added_SlashableStake( + User operator, + OperatorSet memory operatorSet, + IStrategy[] memory strategies, + uint[] memory slashableShares, + string memory err + ) internal { + uint[] memory curSlashableStake = _getMinSlashableStake(operator, operatorSet, strategies); + uint[] memory prevSlashableStake = _getPrevMinSlashableStake(operator, operatorSet, strategies); + + for (uint i = 0; i < strategies.length; i++) { + assertEq(curSlashableStake[i], prevSlashableStake[i] + slashableShares[i], err); + } + } + + function assert_Snap_Unchanged_SlashableStake( + User operator, + OperatorSet memory operatorSet, + IStrategy[] memory strategies, + string memory err + ) internal { + uint[] memory curSlashableStake = _getMinSlashableStake(operator, operatorSet, strategies); + uint[] memory prevSlashableStake = _getPrevMinSlashableStake(operator, operatorSet, strategies); + + for (uint i = 0; i < strategies.length; i++) { + assertEq(curSlashableStake[i], prevSlashableStake[i], err); + } + } + + function assert_Snap_Removed_SlashableStake( + User operator, + OperatorSet memory operatorSet, + IStrategy[] memory strategies, + uint[] memory removedSlashableShares, + string memory err + ) internal { + uint[] memory curSlashableStake = _getMinSlashableStake(operator, operatorSet, strategies); + uint[] memory prevSlashableStake = _getPrevMinSlashableStake(operator, operatorSet, strategies); + + for (uint i = 0; i < strategies.length; i++) { + assertEq(curSlashableStake[i] + removedSlashableShares[i], prevSlashableStake[i], err); + } + } + + function assert_Snap_Slashed_SlashableStake( + User operator, + OperatorSet memory operatorSet, + SlashingParams memory params, + string memory err + ) internal { + uint[] memory curSlashableStake = _getMinSlashableStake(operator, operatorSet, params.strategies); + uint[] memory prevSlashableStake = _getPrevMinSlashableStake(operator, operatorSet, params.strategies); + + Magnitudes[] memory curMagnitudes = _getMagnitudes(operator, params.strategies); + Magnitudes[] memory prevMagnitudes = _getPrevMagnitudes(operator, params.strategies); - function assert_HasNoUnderlyingTokenBalance(User user, IStrategy[] memory strategies, string memory err) internal view { - assert_HasUnderlyingTokenBalances(user, strategies, new uint[](strategies.length), err); + for (uint i = 0; i < params.strategies.length; i++) { + uint expectedSlashed = SlashingLib.calcSlashedAmount({ + operatorShares: prevSlashableStake[i], + prevMaxMagnitude: prevMagnitudes[i].max, + newMaxMagnitude: curMagnitudes[i].max + }); + + assertEq(curSlashableStake[i], prevSlashableStake[i] - expectedSlashed, err); + } } - function assert_HasExpectedShares( - User user, - IStrategy[] memory strategies, - uint[] memory expectedShares, + function assert_Snap_StakeBecameAllocated( + User operator, + OperatorSet memory operatorSet, + IStrategy[] memory strategies, string memory err - ) internal view { - uint[] memory actualShares = _getStakerDepositShares(user, strategies); - for(uint i = 0; i < strategies.length; i++) { - assertApproxEqAbs(expectedShares[i], actualShares[i], 1, err); + ) internal { + uint[] memory curMinAllocatedStake = _getAllocatedStake(operator, operatorSet, strategies); + uint[] memory prevMinAllocatedStake = _getPrevAllocatedStake(operator, operatorSet, strategies); + + for (uint i = 0; i < strategies.length; i++) { + assertGt(curMinAllocatedStake[i], prevMinAllocatedStake[i], err); } } - function assert_HasOperatorShares( - User user, - IStrategy[] memory strategies, - uint[] memory expectedShares, + function assert_Snap_StakeBecameDeallocated( + User operator, + OperatorSet memory operatorSet, + IStrategy[] memory strategies, string memory err - ) internal view { + ) internal { + uint[] memory curMinAllocatedStake = _getAllocatedStake(operator, operatorSet, strategies); + uint[] memory prevMinAllocatedStake = _getPrevAllocatedStake(operator, operatorSet, strategies); + for (uint i = 0; i < strategies.length; i++) { - uint actualShares = delegationManager.operatorShares(address(user), strategies[i]); - assertEq(expectedShares[i], actualShares, err); + assertLt(curMinAllocatedStake[i], prevMinAllocatedStake[i], err); } } - /// @dev Asserts that ALL of the `withdrawalRoots` is in `delegationManager.pendingWithdrawals` - function assert_AllWithdrawalsPending(bytes32[] memory withdrawalRoots, string memory err) internal view { - for (uint i = 0; i < withdrawalRoots.length; i++) { - assert_WithdrawalPending(withdrawalRoots[i], err); + function assert_Snap_Unchanged_AllocatedStake( + User operator, + OperatorSet memory operatorSet, + IStrategy[] memory strategies, + string memory err + ) internal { + uint[] memory curAllocatedStake = _getAllocatedStake(operator, operatorSet, strategies); + uint[] memory prevAllocatedStake = _getPrevAllocatedStake(operator, operatorSet, strategies); + + for (uint i = 0; i < curAllocatedStake.length; i++) { + assertEq(curAllocatedStake[i], prevAllocatedStake[i], err); } } - /// @dev Asserts that NONE of the `withdrawalRoots` is in `delegationManager.pendingWithdrawals` - function assert_NoWithdrawalsPending(bytes32[] memory withdrawalRoots, string memory err) internal view { - for (uint i = 0; i < withdrawalRoots.length; i++) { - assert_WithdrawalNotPending(withdrawalRoots[i], err); + function assert_Snap_Slashed_AllocatedStake( + User operator, + OperatorSet memory operatorSet, + SlashingParams memory params, + string memory err + ) internal { + uint[] memory curAllocatedStake = _getAllocatedStake(operator, operatorSet, params.strategies); + uint[] memory prevAllocatedStake = _getPrevAllocatedStake(operator, operatorSet, params.strategies); + + Magnitudes[] memory curMagnitudes = _getMagnitudes(operator, params.strategies); + Magnitudes[] memory prevMagnitudes = _getPrevMagnitudes(operator, params.strategies); + + for (uint i = 0; i < curAllocatedStake.length; i++) { + uint expectedSlashed = SlashingLib.calcSlashedAmount({ + operatorShares: prevAllocatedStake[i], + prevMaxMagnitude: prevMagnitudes[i].max, + newMaxMagnitude: curMagnitudes[i].max + }); + + assertEq(curAllocatedStake[i], prevAllocatedStake[i] - expectedSlashed, err); } } - /// @dev Asserts that the hash of each withdrawal corresponds to the provided withdrawal root - function assert_WithdrawalPending(bytes32 withdrawalRoot, string memory err) internal view { - assertTrue(delegationManager.pendingWithdrawals(withdrawalRoot), err); - } + function assert_Snap_Added_EncumberedMagnitude( + User operator, + IStrategy[] memory strategies, + uint64[] memory magnitudeAdded, + string memory err + ) internal { + Magnitudes[] memory curMagnitudes = _getMagnitudes(operator, strategies); + Magnitudes[] memory prevMagnitudes = _getPrevMagnitudes(operator, strategies); - function assert_WithdrawalNotPending(bytes32 withdrawalRoot, string memory err) internal view { - assertFalse(delegationManager.pendingWithdrawals(withdrawalRoot), err); + for (uint i = 0; i < strategies.length; i++) { + assertEq(curMagnitudes[i].encumbered, prevMagnitudes[i].encumbered + magnitudeAdded[i], err); + } } - function assert_ValidWithdrawalHashes( - IDelegationManagerTypes.Withdrawal[] memory withdrawals, - bytes32[] memory withdrawalRoots, + function assert_Snap_Unchanged_EncumberedMagnitude( + User operator, + IStrategy[] memory strategies, string memory err - ) internal view { - for (uint i = 0; i < withdrawals.length; i++) { - assert_ValidWithdrawalHash(withdrawals[i], withdrawalRoots[i], err); + ) internal { + Magnitudes[] memory curMagnitudes = _getMagnitudes(operator, strategies); + Magnitudes[] memory prevMagnitudes = _getPrevMagnitudes(operator, strategies); + + for (uint i = 0; i < strategies.length; i++) { + assertEq(curMagnitudes[i].encumbered, prevMagnitudes[i].encumbered, err); } } - function assert_ValidWithdrawalHash( - IDelegationManagerTypes.Withdrawal memory withdrawal, - bytes32 withdrawalRoot, + function assert_Snap_Removed_EncumberedMagnitude( + User operator, + IStrategy[] memory strategies, + uint64[] memory magnitudeRemoved, string memory err - ) internal view { - assertEq(withdrawalRoot, delegationManager.calculateWithdrawalRoot(withdrawal), err); + ) internal { + Magnitudes[] memory curMagnitudes = _getMagnitudes(operator, strategies); + Magnitudes[] memory prevMagnitudes = _getPrevMagnitudes(operator, strategies); + + for (uint i = 0; i < strategies.length; i++) { + assertEq(curMagnitudes[i].encumbered + magnitudeRemoved[i], prevMagnitudes[i].encumbered, err); + } } - function assert_PodBalance_Eq( - User staker, - uint expectedBalance, + function assert_Snap_Slashed_EncumberedMagnitude( + User operator, + SlashingParams memory params, string memory err - ) internal view { - EigenPod pod = staker.pod(); - assertEq(address(pod).balance, expectedBalance, err); + ) internal { + Magnitudes[] memory curMagnitudes = _getMagnitudes(operator, params.strategies); + Magnitudes[] memory prevMagnitudes = _getPrevMagnitudes(operator, params.strategies); + + for (uint i = 0; i < params.strategies.length; i++) { + uint expectedSlashed = prevMagnitudes[i].encumbered.mulWadRoundUp(params.wadsToSlash[i]); + assertEq(curMagnitudes[i].encumbered, prevMagnitudes[i].encumbered - expectedSlashed, err); + } } - function assert_ProofsRemainingEqualsActive( - User staker, + function assert_Snap_Added_AllocatableMagnitude( + User operator, + IStrategy[] memory strategies, + uint64[] memory magnitudeFreed, string memory err - ) internal view { - EigenPod pod = staker.pod(); - assertEq(pod.currentCheckpoint().proofsRemaining, pod.activeValidatorCount(), err); + ) internal { + Magnitudes[] memory curMagnitudes = _getMagnitudes(operator, strategies); + Magnitudes[] memory prevMagnitudes = _getPrevMagnitudes(operator, strategies); + + for (uint i = 0; i < strategies.length; i++) { + assertEq(curMagnitudes[i].allocatable, prevMagnitudes[i].allocatable + magnitudeFreed[i], err); + } } - function assert_CheckpointPodBalance( - User staker, - uint64 expectedPodBalanceGwei, + function assert_Snap_Unchanged_AllocatableMagnitude( + User operator, + IStrategy[] memory strategies, string memory err - ) internal view { - EigenPod pod = staker.pod(); - assertEq(pod.currentCheckpoint().podBalanceGwei, expectedPodBalanceGwei, err); + ) internal { + Magnitudes[] memory curMagnitudes = _getMagnitudes(operator, strategies); + Magnitudes[] memory prevMagnitudes = _getPrevMagnitudes(operator, strategies); + + for (uint i = 0; i < strategies.length; i++) { + assertEq(curMagnitudes[i].allocatable, prevMagnitudes[i].allocatable, err); + } } - - /******************************************************************************* - SNAPSHOT ASSERTIONS - TIME TRAVELERS ONLY BEYOND THIS POINT - *******************************************************************************/ - /******************************************************************************* - SNAPSHOT ASSERTIONS: ALLOCATIONS - *******************************************************************************/ + function assert_Snap_Removed_AllocatableMagnitude( + User operator, + IStrategy[] memory strategies, + uint64[] memory magnitudeRemoved, + string memory err + ) internal { + Magnitudes[] memory curMagnitudes = _getMagnitudes(operator, strategies); + Magnitudes[] memory prevMagnitudes = _getPrevMagnitudes(operator, strategies); + + for (uint i = 0; i < strategies.length; i++) { + assertEq(curMagnitudes[i].allocatable, prevMagnitudes[i].allocatable - magnitudeRemoved[i], err); + } + } - function assert_Snap_Allocations_Modified( + function assert_Snap_Allocated_Magnitude( User operator, - IAllocationManagerTypes.AllocateParams memory allocateParams, - bool completed, + IStrategy[] memory strategies, string memory err ) internal { - IAllocationManagerTypes.Allocation[] memory curAllocs = _getAllocations(operator, allocateParams.operatorSet, allocateParams.strategies); - IAllocationManagerTypes.Allocation[] memory prevAllocs = _getPrevAllocations(operator, allocateParams.operatorSet, allocateParams.strategies); - Magnitudes[] memory curMagnitudes = _getMagnitudes(operator, allocateParams.strategies); - Magnitudes[] memory prevMagnitudes = _getPrevMagnitudes(operator, allocateParams.strategies); + Magnitudes[] memory curMagnitudes = _getMagnitudes(operator, strategies); + Magnitudes[] memory prevMagnitudes = _getPrevMagnitudes(operator, strategies); - for (uint i = 0; i < allocateParams.strategies.length; i++) { - IAllocationManagerTypes.Allocation memory curAlloc = curAllocs[i]; - IAllocationManagerTypes.Allocation memory prevAlloc = prevAllocs[i]; - - // Check allocations - if (completed) { - assertEq(curAlloc.currentMagnitude, allocateParams.newMagnitudes[i], string.concat(err, " (currentMagnitude)")); - assertEq(curAlloc.pendingDiff, 0, string.concat(err, " (pendingDiff)")); - assertEq(curAlloc.effectBlock, 0, string.concat(err, " (effectBlock)")); - } else { - assertEq( - curAlloc.currentMagnitude, - prevAlloc.currentMagnitude, - string.concat(err, " (currentMagnitude)") - ); - assertEq( - curAlloc.pendingDiff, - prevAlloc.pendingDiff + int128(int64(allocateParams.newMagnitudes[i])), - string.concat(err, " (pendingDiff)") - ); + /// Check: + /// allocatable increased + /// encumbered decreased + for (uint i = 0; i < strategies.length; i++) { + assertLt(curMagnitudes[i].allocatable, prevMagnitudes[i].allocatable, err); + assertGt(curMagnitudes[i].encumbered, prevMagnitudes[i].encumbered, err); + } + } - (, uint32 delay) = allocationManager.getAllocationDelay(address(operator)); + function assert_Snap_Deallocated_Magnitude( + User operator, + IStrategy[] memory strategies, + string memory err + ) internal { + Magnitudes[] memory curMagnitudes = _getMagnitudes(operator, strategies); + Magnitudes[] memory prevMagnitudes = _getPrevMagnitudes(operator, strategies); - assertEq( - curAlloc.effectBlock, - block.number + delay, - string.concat(err, " (effectBlock)") - ); - } + /// Check: + /// allocatable increased + /// encumbered decreased + for (uint i = 0; i < strategies.length; i++) { + assertGt(curMagnitudes[i].allocatable, prevMagnitudes[i].allocatable, err); + assertLt(curMagnitudes[i].encumbered, prevMagnitudes[i].encumbered, err); + } + } - // Check magnitudes - Magnitudes memory curMagnitude = curMagnitudes[i]; - Magnitudes memory prevMagnitude = prevMagnitudes[i]; + function assert_Snap_Set_CurrentMagnitude( + User operator, + AllocateParams memory params, + string memory err + ) internal { + Allocation[] memory curAllocations = _getAllocations(operator, params.operatorSet, params.strategies); + Allocation[] memory prevAllocations = _getPrevAllocations(operator, params.operatorSet, params.strategies); + + /// Prev allocation.currentMagnitude should NOT equal newly-set magnitude + /// Cur allocation.currentMagnitude SHOULD + for (uint i = 0; i < params.strategies.length; i++) { + assertTrue(prevAllocations[i].currentMagnitude != params.newMagnitudes[i], err); + assertEq(curAllocations[i].currentMagnitude, params.newMagnitudes[i], err); + } + } - // if (isAllocation) ... - if (prevAlloc.currentMagnitude < allocateParams.newMagnitudes[i]) { - uint256 delta = allocateParams.newMagnitudes[i] - prevAlloc.currentMagnitude; - - // FIXME: Fails on `testFuzz_deposit_delegate_allocate` when completed == true. - if (!completed) { - assertEq( - curMagnitude.encumbered, - prevMagnitude.encumbered + delta, - string.concat(err, " (encumbered magnitude)") - ); + function assert_Snap_Slashed_Allocation( + User operator, + OperatorSet memory operatorSet, + SlashingParams memory params, + string memory err + ) internal { + Allocation[] memory curAllocations = _getAllocations(operator, operatorSet, params.strategies); + Allocation[] memory prevAllocations = _getPrevAllocations(operator, operatorSet, params.strategies); - assertEq( - curMagnitude.allocatable, - prevMagnitude.allocatable - delta, - string.concat(err, " (allocatable magnitude)") - ); - } - } else { - uint256 delta = prevAlloc.currentMagnitude - allocateParams.newMagnitudes[i]; + for (uint i = 0; i < params.strategies.length; i++) { + uint expectedSlashed = prevAllocations[i].currentMagnitude.mulWadRoundUp(params.wadsToSlash[i]); + assertEq(curAllocations[i].currentMagnitude, prevAllocations[i].currentMagnitude - expectedSlashed, err); + } + } - // if deallocated, and completed - if (completed) { - assertEq( - curMagnitude.encumbered - delta, - prevMagnitude.encumbered, - string.concat(err, " (encumbered magnitude)") - ); + function assert_Snap_Unchanged_MaxMagnitude( + User operator, + IStrategy[] memory strategies, + string memory err + ) internal { + Magnitudes[] memory curMagnitudes = _getMagnitudes(operator, strategies); + Magnitudes[] memory prevMagnitudes = _getPrevMagnitudes(operator, strategies); - assertEq( - curMagnitude.allocatable, - prevMagnitude.allocatable + delta, - string.concat(err, " (allocatable magnitude)") - ); - } else { - assertEq( - curMagnitude.encumbered, - prevMagnitude.encumbered, - string.concat(err, " (encumbered magnitude)") - ); + for (uint i = 0; i < strategies.length; i++) { + assertEq(curMagnitudes[i].max, prevMagnitudes[i].max, err); + } + } - assertEq( - curMagnitude.allocatable, - prevMagnitude.allocatable, - string.concat(err, " (allocatable magnitude)") - ); - } - } + function assert_Snap_Slashed_MaxMagnitude( + User operator, + SlashingParams memory params, + string memory err + ) internal { + Magnitudes[] memory curMagnitudes = _getMagnitudes(operator, params.strategies); + Magnitudes[] memory prevMagnitudes = _getPrevMagnitudes(operator, params.strategies); - // Max magnitude should not have mutated. - assertEq( - curMagnitude.max, - prevMagnitude.max, - string.concat(err, " (max magnitude)") - ); + for (uint i = 0; i < params.strategies.length; i++) { + uint expectedSlashed = prevMagnitudes[i].max.mulWadRoundUp(params.wadsToSlash[i]); + assertEq(curMagnitudes[i].max, prevMagnitudes[i].max - expectedSlashed, err); } } function assert_Snap_Allocations_Slashed( - IAllocationManagerTypes.SlashingParams memory slashingParams, + SlashingParams memory slashingParams, OperatorSet memory operatorSet, bool completed, string memory err ) internal { User op = User(payable(slashingParams.operator)); - IAllocationManagerTypes.Allocation[] memory curAllocs = _getAllocations(op, operatorSet, slashingParams.strategies); - IAllocationManagerTypes.Allocation[] memory prevAllocs = _getPrevAllocations(op, operatorSet, slashingParams.strategies); + Allocation[] memory curAllocs = _getAllocations(op, operatorSet, slashingParams.strategies); + Allocation[] memory prevAllocs = _getPrevAllocations(op, operatorSet, slashingParams.strategies); Magnitudes[] memory curMagnitudes = _getMagnitudes(op, slashingParams.strategies); Magnitudes[] memory prevMagnitudes = _getPrevMagnitudes(op, slashingParams.strategies); - (, uint32 delay) = allocationManager.getAllocationDelay(slashingParams.operator); + uint32 delay = _getExistingAllocationDelay(User(payable(slashingParams.operator))); for (uint i = 0; i < slashingParams.strategies.length; i++) { - IAllocationManagerTypes.Allocation memory curAlloc = curAllocs[i]; - IAllocationManagerTypes.Allocation memory prevAlloc = prevAllocs[i]; + Allocation memory curAlloc = curAllocs[i]; + Allocation memory prevAlloc = prevAllocs[i]; uint64 slashedMagnitude = uint64(uint256(prevAlloc.currentMagnitude).mulWadRoundUp(slashingParams.wadsToSlash[i])); @@ -548,8 +1268,8 @@ abstract contract IntegrationBase is IntegrationDeployer { function assert_HasUnderlyingTokenBalances_AfterSlash( User staker, - IAllocationManagerTypes.AllocateParams memory allocateParams, - IAllocationManagerTypes.SlashingParams memory slashingParams, + AllocateParams memory allocateParams, + SlashingParams memory slashingParams, uint[] memory expectedBalances, string memory err ) internal view { @@ -575,8 +1295,8 @@ abstract contract IntegrationBase is IntegrationDeployer { function assert_Snap_StakerWithdrawableShares_AfterSlash( User staker, - IAllocationManagerTypes.AllocateParams memory allocateParams, - IAllocationManagerTypes.SlashingParams memory slashingParams, + AllocateParams memory allocateParams, + SlashingParams memory slashingParams, string memory err ) internal { uint[] memory curShares = _getWithdrawableShares(staker, allocateParams.strategies); @@ -637,7 +1357,7 @@ abstract contract IntegrationBase is IntegrationDeployer { // For each strategy, check (prev - removed == cur) for (uint i = 0; i < strategies.length; i++) { - assertEq(prevShares[i] - removedShares[i], curShares[i], err); + assertEq(prevShares[i], curShares[i] + removedShares[i], err); } } @@ -681,6 +1401,47 @@ abstract contract IntegrationBase is IntegrationDeployer { } } + function assert_Snap_Slashed_OperatorShares( + User operator, + SlashingParams memory params, + string memory err + ) internal { + uint[] memory curShares = _getOperatorShares(operator, params.strategies); + uint[] memory prevShares = _getPrevOperatorShares(operator, params.strategies); + + Magnitudes[] memory curMagnitudes = _getMagnitudes(operator, params.strategies); + Magnitudes[] memory prevMagnitudes = _getPrevMagnitudes(operator, params.strategies); + + for (uint i = 0; i < params.strategies.length; i++) { + uint expectedSlashed = SlashingLib.calcSlashedAmount({ + operatorShares: prevShares[i], + prevMaxMagnitude: prevMagnitudes[i].max, + newMaxMagnitude: curMagnitudes[i].max + }); + + assertEq(curShares[i], prevShares[i] - expectedSlashed, err); + } + } + + function assert_Snap_Increased_BurnableShares( + User operator, + SlashingParams memory params, + string memory err + ) internal { + uint[] memory curBurnable = _getBurnableShares(params.strategies); + uint[] memory prevBurnable = _getPrevBurnableShares(params.strategies); + + uint[] memory curShares = _getOperatorShares(operator, params.strategies); + uint[] memory prevShares = _getPrevOperatorShares(operator, params.strategies); + + for (uint i = 0; i < params.strategies.length; i++) { + uint slashedAtLeast = prevShares[i] - curShares[i]; + + // Not factoring in slashable shares in queue here, because that gets more complex (TODO) + assertTrue(curBurnable[i] >= (prevBurnable[i] + slashedAtLeast), err); + } + } + /******************************************************************************* SNAPSHOT ASSERTIONS: STAKER SHARES *******************************************************************************/ @@ -706,20 +1467,15 @@ abstract contract IntegrationBase is IntegrationDeployer { function assert_Snap_Added_Staker_DepositShares( User staker, IStrategy strat, - uint _addedShares, + uint addedShares, string memory err ) internal { - IStrategy[] memory strategies = new IStrategy[](1); - uint[] memory addedShares = new uint[](1); - strategies[0] = strat; - addedShares[0] = _addedShares; - - assert_Snap_Added_Staker_DepositShares(staker, strategies, addedShares, err); + assert_Snap_Added_Staker_DepositShares(staker, strat.toArray(), addedShares.toArrayU256(), err); } /// @dev Check that the staker has `removedShares` fewer delegatable shares /// for each strategy since the last snapshot - function assert_Snap_Removed_StakerDepositShares( + function assert_Snap_Removed_Staker_DepositShares( User staker, IStrategy[] memory strategies, uint[] memory removedShares, @@ -729,28 +1485,58 @@ abstract contract IntegrationBase is IntegrationDeployer { // Use timewarp to get previous staker shares uint[] memory prevShares = _getPrevStakerDepositShares(staker, strategies); - // For each strategy, check (prev - removed == cur) + // For each strategy, check (prev - removed == cur) + for (uint i = 0; i < strategies.length; i++) { + assertEq(prevShares[i] - removedShares[i], curShares[i], err); + } + } + + function assert_Snap_Removed_Staker_DepositShares( + User staker, + IStrategy strat, + uint removedShares, + string memory err + ) internal { + assert_Snap_Removed_Staker_DepositShares(staker, strat.toArray(), removedShares.toArrayU256(), err); + } + + /// @dev Check that the staker's delegatable shares in ALL strategies have not changed + /// since the last snapshot + function assert_Snap_Unchanged_Staker_DepositShares( + User staker, + string memory err + ) internal { + IStrategy[] memory strategies = allStrats; + + uint[] memory curShares = _getStakerDepositShares(staker, strategies); + // Use timewarp to get previous staker shares + uint[] memory prevShares = _getPrevStakerDepositShares(staker, strategies); + + // For each strategy, check (prev == cur) for (uint i = 0; i < strategies.length; i++) { - assertEq(prevShares[i] - removedShares[i], curShares[i], err); + assertEq(prevShares[i], curShares[i], err); } } - function assert_Snap_Removed_StakerDepositShares( + /// @dev Check that the staker's withdrawable shares have increased by `addedShares` + function assert_Snap_Added_Staker_WithdrawableShares( User staker, - IStrategy strat, - uint _removedShares, + IStrategy[] memory strategies, + uint[] memory addedShares, string memory err ) internal { - IStrategy[] memory strategies = new IStrategy[](1); - uint[] memory removedShares = new uint[](1); - strategies[0] = strat; - removedShares[0] = _removedShares; + uint[] memory curShares = _getStakerWithdrawableShares(staker, strategies); + // Use timewarp to get previous staker shares + uint[] memory prevShares = _getPrevStakerWithdrawableShares(staker, strategies); - assert_Snap_Removed_StakerDepositShares(staker, strategies, removedShares, err); + // For each strategy, check (prev - removed == cur) + for (uint i = 0; i < strategies.length; i++) { + assertEq(prevShares[i] + addedShares[i], curShares[i], err); + } } /// @dev Check that the staker's withdrawable shares have decreased by `removedShares` - function assert_Snap_Removed_StakerWithdrawableShares( + function assert_Snap_Removed_Staker_WithdrawableShares( User staker, IStrategy[] memory strategies, uint[] memory removedShares, @@ -766,18 +1552,44 @@ abstract contract IntegrationBase is IntegrationDeployer { } } - function assert_Snap_Removed_StakerWithdrawableShares( + /// @dev Check that all the staker's withdrawable shares have been removed + function assert_Snap_RemovedAll_Staker_WithdrawableShares( + User staker, + IStrategy[] memory strategies, + string memory err + ) internal { + uint[] memory curShares = _getStakerWithdrawableShares(staker, strategies); + // For each strategy, check all shares have been withdrawn + for (uint i = 0; i < strategies.length; i++) { + assertEq(0, curShares[i], err); + } + } + + function assert_Snap_Removed_Staker_WithdrawableShares( User staker, IStrategy strat, - uint _removedShares, + uint removedShares, + string memory err + ) internal { + assert_Snap_Removed_Staker_WithdrawableShares(staker, strat.toArray(), removedShares.toArrayU256(), err); + } + + /// @dev Check that the staker's withdrawable shares have changed by the expected amount + function assert_Snap_Expected_Staker_WithdrawableShares_Delegation( + User staker, + User operator, + IStrategy[] memory strategies, + uint[] memory depositShares, string memory err ) internal { - IStrategy[] memory strategies = new IStrategy[](1); - uint[] memory removedShares = new uint[](1); - strategies[0] = strat; - removedShares[0] = _removedShares; + uint[] memory curShares = _getStakerWithdrawableShares(staker, strategies); + // Use timewarp to get previous staker shares + uint[] memory expectedShares = _getExpectedWithdrawableSharesDelegate(staker, operator, strategies, depositShares); - assert_Snap_Removed_StakerWithdrawableShares(staker, strategies, removedShares, err); + // For each strategy, check expected == current + for (uint i = 0; i < strategies.length; i++) { + assertEq(expectedShares[i], curShares[i], err); + } } /// @dev Check that the staker's withdrawable shares have decreased by at least `removedShares` @@ -804,30 +1616,7 @@ abstract contract IntegrationBase is IntegrationDeployer { uint removedShares, string memory err ) internal { - IStrategy[] memory strategies = new IStrategy[](1); - uint[] memory removedSharesArr = new uint[](1); - strategies[0] = strat; - removedSharesArr[0] = removedShares; - - assert_Snap_Removed_Staker_WithdrawableShares_AtLeast(staker, strategies, removedSharesArr, err); - } - - /// @dev Check that the staker's delegatable shares in ALL strategies have not changed - /// since the last snapshot - function assert_Snap_Unchanged_StakerDepositShares( - User staker, - string memory err - ) internal { - IStrategy[] memory strategies = allStrats; - - uint[] memory curShares = _getStakerDepositShares(staker, strategies); - // Use timewarp to get previous staker shares - uint[] memory prevShares = _getPrevStakerDepositShares(staker, strategies); - - // For each strategy, check (prev == cur) - for (uint i = 0; i < strategies.length; i++) { - assertEq(prevShares[i], curShares[i], err); - } + assert_Snap_Removed_Staker_WithdrawableShares_AtLeast(staker, strat.toArray(), removedShares.toArrayU256(), err); } function assert_Snap_Delta_StakerShares( @@ -846,6 +1635,19 @@ abstract contract IntegrationBase is IntegrationDeployer { } } + function assert_Snap_Unchanged_DSF( + User staker, + IStrategy[] memory strategies, + string memory err + ) internal { + uint[] memory curDSFs = _getDepositScalingFactors(staker, strategies); + uint[] memory prevDSFs = _getPrevDepositScalingFactors(staker, strategies); + + for (uint i = 0; i < strategies.length; i++) { + assertEq(prevDSFs[i], curDSFs[i], err); + } + } + /******************************************************************************* SNAPSHOT ASSERTIONS: STRATEGY SHARES *******************************************************************************/ @@ -958,7 +1760,7 @@ abstract contract IntegrationBase is IntegrationDeployer { function assert_Snap_Added_QueuedWithdrawals( User staker, - IDelegationManagerTypes.Withdrawal[] memory withdrawals, + Withdrawal[] memory withdrawals, string memory err ) internal { uint curQueuedWithdrawals = _getCumulativeWithdrawals(staker); @@ -970,7 +1772,7 @@ abstract contract IntegrationBase is IntegrationDeployer { function assert_Snap_Added_QueuedWithdrawal( User staker, - IDelegationManagerTypes.Withdrawal memory /*withdrawal*/, + Withdrawal memory /*withdrawal*/, string memory err ) internal { uint curQueuedWithdrawal = _getCumulativeWithdrawals(staker); @@ -1023,12 +1825,12 @@ abstract contract IntegrationBase is IntegrationDeployer { ) internal { bytes32[] memory pubkeyHashes = beaconChain.getPubkeyHashes(addedValidators); - IEigenPodTypes.VALIDATOR_STATUS[] memory curStatuses = _getValidatorStatuses(staker, pubkeyHashes); - IEigenPodTypes.VALIDATOR_STATUS[] memory prevStatuses = _getPrevValidatorStatuses(staker, pubkeyHashes); + VALIDATOR_STATUS[] memory curStatuses = _getValidatorStatuses(staker, pubkeyHashes); + VALIDATOR_STATUS[] memory prevStatuses = _getPrevValidatorStatuses(staker, pubkeyHashes); for (uint i = 0; i < curStatuses.length; i++) { - assertTrue(prevStatuses[i] == IEigenPodTypes.VALIDATOR_STATUS.INACTIVE, err); - assertTrue(curStatuses[i] == IEigenPodTypes.VALIDATOR_STATUS.ACTIVE, err); + assertTrue(prevStatuses[i] == VALIDATOR_STATUS.INACTIVE, err); + assertTrue(curStatuses[i] == VALIDATOR_STATUS.ACTIVE, err); } } @@ -1039,12 +1841,12 @@ abstract contract IntegrationBase is IntegrationDeployer { ) internal { bytes32[] memory pubkeyHashes = beaconChain.getPubkeyHashes(exitedValidators); - IEigenPodTypes.VALIDATOR_STATUS[] memory curStatuses = _getValidatorStatuses(staker, pubkeyHashes); - IEigenPodTypes.VALIDATOR_STATUS[] memory prevStatuses = _getPrevValidatorStatuses(staker, pubkeyHashes); + VALIDATOR_STATUS[] memory curStatuses = _getValidatorStatuses(staker, pubkeyHashes); + VALIDATOR_STATUS[] memory prevStatuses = _getPrevValidatorStatuses(staker, pubkeyHashes); for (uint i = 0; i < curStatuses.length; i++) { - assertTrue(prevStatuses[i] == IEigenPodTypes.VALIDATOR_STATUS.ACTIVE, err); - assertTrue(curStatuses[i] == IEigenPodTypes.VALIDATOR_STATUS.WITHDRAWN, err); + assertTrue(prevStatuses[i] == VALIDATOR_STATUS.ACTIVE, err); + assertTrue(curStatuses[i] == VALIDATOR_STATUS.WITHDRAWN, err); } } @@ -1139,6 +1941,183 @@ abstract contract IntegrationBase is IntegrationDeployer { UTILITY METHODS *******************************************************************************/ + /// @dev Fetches the opreator's allocation delay; asserts that it is set + function _getExistingAllocationDelay(User operator) internal view returns (uint32) { + (bool isSet, uint32 delay) = allocationManager.getAllocationDelay(address(operator)); + assertTrue(isSet, "_getExistingAllocationDelay: expected allocation delay to be set"); + + return delay; + } + + /// @dev Generate params to allocate all available magnitude to each strategy in the operator set + function _genAllocation_AllAvailable( + User operator, + OperatorSet memory operatorSet + ) internal view returns (AllocateParams memory params) { + return _genAllocation_AllAvailable({ + operator: operator, + operatorSet: operatorSet, + strategies: allocationManager.getStrategiesInOperatorSet(operatorSet) + }); + } + + /// @dev Generate params to allocate all available magnitude to each strategy in the operator set + function _genAllocation_AllAvailable( + User operator, + OperatorSet memory operatorSet, + IStrategy[] memory strategies + ) internal view returns (AllocateParams memory params) { + params.operatorSet = operatorSet; + params.strategies = strategies; + params.newMagnitudes = new uint64[](params.strategies.length); + + for (uint i = 0; i < params.strategies.length; i++) { + IStrategy strategy = params.strategies[i]; + params.newMagnitudes[i] = allocationManager.getMaxMagnitude(address(operator), strategy); + } + } + + /// @dev Gen params to allocate half of available magnitude to each strategy in the operator set + /// returns the params to complete this allocation + function _genAllocation_HalfAvailable( + User operator, + OperatorSet memory operatorSet + ) internal view returns (AllocateParams memory params) { + return _genAllocation_HalfAvailable({ + operator: operator, + operatorSet: operatorSet, + strategies: allocationManager.getStrategiesInOperatorSet(operatorSet) + }); + } + + /// @dev Gen params to allocate half of available magnitude to each strategy in the operator set + /// returns the params to complete this allocation + function _genAllocation_HalfAvailable( + User operator, + OperatorSet memory operatorSet, + IStrategy[] memory strategies + ) internal view returns (AllocateParams memory params) { + params.operatorSet = operatorSet; + params.strategies = strategies; + params.newMagnitudes = new uint64[](params.strategies.length); + + Allocation[] memory allocations = _getAllocations(operator, operatorSet, strategies); + Magnitudes[] memory magnitudes = _getMagnitudes(operator, strategies); + + for (uint i = 0; i < params.strategies.length; i++) { + uint64 halfAvailable = uint64(magnitudes[i].allocatable) / 2; + params.newMagnitudes[i] = allocations[i].currentMagnitude + halfAvailable; + } + } + + /// @dev Generate params to allocate a random portion of available magnitude to each strategy + /// in the operator set. All strategies will have a nonzero allocation, and the minimum allocation + /// will be 10% of available magnitude + function _genAllocation_Rand( + User operator, + OperatorSet memory operatorSet + ) internal returns (AllocateParams memory params) { + params.operatorSet = operatorSet; + params.strategies = allocationManager.getStrategiesInOperatorSet(operatorSet); + params.newMagnitudes = new uint64[](params.strategies.length); + + Allocation[] memory allocations = _getAllocations(operator, operatorSet, params.strategies); + Magnitudes[] memory magnitudes = _getMagnitudes(operator, params.strategies); + + for (uint i = 0; i < params.strategies.length; i++) { + // minimum of 10%, maximum of 100%. increments of 10%. + uint r = _randUint({min: 1, max: 10}); + uint64 allocation = uint64(magnitudes[i].allocatable) / uint64(r); + + params.newMagnitudes[i] = allocations[i].currentMagnitude + allocation; + } + } + + /// @dev Generates params for a half deallocation from all strategies the operator is allocated to in the operator set + function _genDeallocation_HalfRemaining( + User operator, + OperatorSet memory operatorSet + ) internal view returns (AllocateParams memory params) { + return _genDeallocation_HalfRemaining({ + operator: operator, + operatorSet: operatorSet, + strategies: allocationManager.getStrategiesInOperatorSet(operatorSet) + }); + } + + /// @dev Generates params for a half deallocation from all strategies the operator is allocated to in the operator set + function _genDeallocation_HalfRemaining( + User operator, + OperatorSet memory operatorSet, + IStrategy[] memory strategies + ) internal view returns (AllocateParams memory params) { + params.operatorSet = operatorSet; + params.strategies = strategies; + params.newMagnitudes = new uint64[](params.strategies.length); + + for (uint i = 0; i < params.strategies.length; i++) { + IStrategy strategy = params.strategies[i]; + params.newMagnitudes[i] = allocationManager.getEncumberedMagnitude(address(operator), strategy) / 2; + } + } + + /// @dev Generates params for a full deallocation from all strategies the operator is allocated to in the operator set + function _genDeallocation_Full( + User operator, + OperatorSet memory operatorSet + ) internal view returns (AllocateParams memory params) { + return _genDeallocation_Full({ + operator: operator, + operatorSet: operatorSet, + strategies: allocationManager.getStrategiesInOperatorSet(operatorSet) + }); + } + + /// @dev Generates params for a full deallocation from all strategies the operator is allocated to in the operator set + function _genDeallocation_Full( + User operator, + OperatorSet memory operatorSet, + IStrategy[] memory strategies + ) internal pure returns (AllocateParams memory params) { + params.operatorSet = operatorSet; + params.strategies = strategies; + params.newMagnitudes = new uint64[](params.strategies.length); + } + + /// Generate random slashing between 1 and 99% + function _genSlashing_Rand( + User operator, + OperatorSet memory operatorSet + ) internal returns (SlashingParams memory params) { + params.operator = address(operator); + params.operatorSetId = operatorSet.id; + params.description = "genSlashing_Half"; + params.strategies = allocationManager.getStrategiesInOperatorSet(operatorSet).sort(); + params.wadsToSlash = new uint[](params.strategies.length); + + /// 1% * rand(1, 99) + uint slashWad = 1e16 * _randUint({min: 1, max: 99}); + + for (uint i = 0; i < params.wadsToSlash.length; i++) { + params.wadsToSlash[i] = slashWad; + } + } + + function _genSlashing_Half( + User operator, + OperatorSet memory operatorSet + ) internal view returns (SlashingParams memory params) { + params.operator = address(operator); + params.operatorSetId = operatorSet.id; + params.description = "genSlashing_Half"; + params.strategies = allocationManager.getStrategiesInOperatorSet(operatorSet).sort(); + params.wadsToSlash = new uint[](params.strategies.length); + + for (uint i = 0; i < params.wadsToSlash.length; i++) { + params.wadsToSlash[i] = 1e17; + } + } + function _randWadToSlash() internal returns (uint) { return _randUint({ min: 0.01 ether, max: 1 ether }); } @@ -1302,7 +2281,13 @@ abstract contract IntegrationBase is IntegrationDeployer { } function _calcNativeETHOperatorShareDelta(User staker, int shareDelta) internal view returns (int) { - int curPodOwnerShares = eigenPodManager.podOwnerDepositShares(address(staker)); + // TODO: Maybe we update parent method to have an M2 and Slashing version? + int curPodOwnerShares; + if (!isUpgraded) { + curPodOwnerShares = IEigenPodManager_DeprecatedM2(address(eigenPodManager)).podOwnerShares(address(staker)); + } else { + curPodOwnerShares = eigenPodManager.podOwnerDepositShares(address(staker)); + } int newPodOwnerShares = curPodOwnerShares + shareDelta; if (curPodOwnerShares <= 0) { @@ -1363,7 +2348,7 @@ abstract contract IntegrationBase is IntegrationDeployer { } function _getWithdrawalHashes( - IDelegationManagerTypes.Withdrawal[] memory withdrawals + Withdrawal[] memory withdrawals ) internal view returns (bytes32[] memory) { bytes32[] memory withdrawalRoots = new bytes32[](withdrawals.length); @@ -1398,7 +2383,7 @@ abstract contract IntegrationBase is IntegrationDeployer { } /// @dev Rolls forward by the minimum withdrawal delay blocks. - function _rollBlocksForCompleteWithdrawals(IDelegationManagerTypes.Withdrawal[] memory withdrawals) internal { + function _rollBlocksForCompleteWithdrawals(Withdrawal[] memory withdrawals) internal { uint256 latest; for (uint i = 0; i < withdrawals.length; ++i) { if (withdrawals[i].startBlock > latest) latest = withdrawals[i].startBlock; @@ -1406,6 +2391,24 @@ abstract contract IntegrationBase is IntegrationDeployer { cheats.roll(latest + delegationManager.minWithdrawalDelayBlocks() + 1); } + function _rollForward_AllocationDelay(User operator) internal { + uint32 delay = _getExistingAllocationDelay(operator); + rollForward(delay); + } + + function _rollBackward_AllocationDelay(User operator) internal { + uint32 delay = _getExistingAllocationDelay(operator); + rollBackward(delay); + } + + function _rollForward_DeallocationDelay() internal { + rollForward(allocationManager.DEALLOCATION_DELAY() + 1); + } + + function _rollBackward_DeallocationDelay() internal { + rollBackward(allocationManager.DEALLOCATION_DELAY() + 1); + } + /// @dev Rolls forward by the default allocation delay blocks. function _rollBlocksForCompleteAllocation( User operator, @@ -1441,7 +2444,7 @@ abstract contract IntegrationBase is IntegrationDeployer { User operator, OperatorSet memory operatorSet, IStrategy[] memory strategies - ) internal timewarp() returns (IAllocationManagerTypes.Allocation[] memory) { + ) internal timewarp() returns (Allocation[] memory) { return _getAllocations(operator, operatorSet, strategies); } @@ -1450,13 +2453,63 @@ abstract contract IntegrationBase is IntegrationDeployer { User operator, OperatorSet memory operatorSet, IStrategy[] memory strategies - ) internal view returns (IAllocationManagerTypes.Allocation[] memory allocations) { - allocations = new IAllocationManagerTypes.Allocation[](strategies.length); + ) internal view returns (Allocation[] memory allocations) { + allocations = new Allocation[](strategies.length); for (uint i = 0; i < strategies.length; ++i) { allocations[i] = allocationManager.getAllocation(address(operator), operatorSet, strategies[i]); } } + function _getPrevAllocatedStrats( + User operator, + OperatorSet memory operatorSet + ) internal timewarp() returns (IStrategy[] memory) { + return _getAllocatedStrats(operator, operatorSet); + } + + function _getAllocatedStrats( + User operator, + OperatorSet memory operatorSet + ) internal view returns (IStrategy[] memory) { + return allocationManager.getAllocatedStrategies(address(operator), operatorSet); + } + + function _getPrevAllocatedSets( + User operator + ) internal timewarp() returns (OperatorSet[] memory) { + return _getAllocatedSets(operator); + } + + function _getAllocatedSets( + User operator + ) internal view returns (OperatorSet[] memory) { + return allocationManager.getAllocatedSets(address(operator)); + } + + function _getPrevRegisteredSets( + User operator + ) internal timewarp() returns (OperatorSet[] memory) { + return _getRegisteredSets(operator); + } + + function _getRegisteredSets( + User operator + ) internal view returns (OperatorSet[] memory) { + return allocationManager.getRegisteredSets(address(operator)); + } + + function _getPrevMembers( + OperatorSet memory operatorSet + ) internal timewarp returns (address[] memory) { + return _getMembers(operatorSet); + } + + function _getMembers( + OperatorSet memory operatorSet + ) internal view returns (address[] memory) { + return allocationManager.getMembers(operatorSet); + } + struct Magnitudes { uint256 encumbered; uint256 allocatable; @@ -1477,13 +2530,129 @@ abstract contract IntegrationBase is IntegrationDeployer { magnitudes = new Magnitudes[](strategies.length); for (uint i = 0; i < strategies.length; ++i) { magnitudes[i] = Magnitudes({ - encumbered: allocationManager.encumberedMagnitude(address(operator), strategies[i]), + encumbered: allocationManager.getEncumberedMagnitude(address(operator), strategies[i]), allocatable: allocationManager.getAllocatableMagnitude(address(operator), strategies[i]), max: allocationManager.getMaxMagnitude(address(operator), strategies[i]) }); } } + function _getMaxMagnitudes( + User operator, + IStrategy[] memory strategies + ) internal view returns (uint64[] memory) { + return allocationManager.getMaxMagnitudes(address(operator), strategies); + } + + function _getMaxMagnitudes( + User operator, + IStrategy[] memory strategies, + uint32 blockNum + ) internal view returns (uint64[] memory) { + return allocationManager.getMaxMagnitudesAtBlock(address(operator), strategies, blockNum); + } + + function _getPrevMinSlashableStake( + User operator, + OperatorSet memory operatorSet, + IStrategy[] memory strategies + ) internal timewarp() returns (uint[] memory) { + return _getMinSlashableStake(operator, operatorSet, strategies); + } + + function _getMinSlashableStake( + User operator, + OperatorSet memory operatorSet, + IStrategy[] memory strategies + ) internal view returns (uint[] memory) { + return allocationManager.getMinimumSlashableStake({ + operatorSet: operatorSet, + operators: address(operator).toArray(), + strategies: strategies, + futureBlock: uint32(block.number) + })[0]; + } + + function _getPrevAllocatedStake( + User operator, + OperatorSet memory operatorSet, + IStrategy[] memory strategies + ) internal timewarp() returns (uint[] memory) { + return _getAllocatedStake(operator, operatorSet, strategies); + } + + function _getAllocatedStake( + User operator, + OperatorSet memory operatorSet, + IStrategy[] memory strategies + ) internal view returns (uint[] memory) { + return allocationManager.getAllocatedStake({ + operatorSet: operatorSet, + operators: address(operator).toArray(), + strategies: strategies + })[0]; + } + + function _getPrevIsSlashable( + User operator, + OperatorSet memory operatorSet + ) internal timewarp() returns (bool) { + return _getIsSlashable(operator, operatorSet); + } + + function _getIsSlashable( + User operator, + OperatorSet memory operatorSet + ) internal view returns (bool) { + return allocationManager.isOperatorSlashable(address(operator), operatorSet); + } + + function _getPrevIsMemberOfSet( + User operator, + OperatorSet memory operatorSet + ) internal timewarp() returns (bool) { + return _getIsMemberOfSet(operator, operatorSet); + } + + function _getIsMemberOfSet( + User operator, + OperatorSet memory operatorSet + ) internal view returns (bool) { + return allocationManager.isMemberOfOperatorSet(address(operator), operatorSet); + } + + function _getPrevBurnableShares(IStrategy[] memory strategies) internal timewarp() returns (uint[] memory) { + return _getBurnableShares(strategies); + } + + function _getBurnableShares(IStrategy[] memory strategies) internal view returns (uint[] memory) { + uint[] memory burnableShares = new uint[](strategies.length); + + for (uint i = 0; i < strategies.length; i++) { + if (strategies[i] == beaconChainETHStrategy) { + burnableShares[i] = eigenPodManager.burnableETHShares(); + } else { + burnableShares[i] = strategyManager.getBurnableShares(strategies[i]); + } + } + + return burnableShares; + } + + function _getPrevSlashableSharesInQueue(User operator, IStrategy[] memory strategies) internal timewarp() returns (uint[] memory) { + return _getSlashableSharesInQueue(operator, strategies); + } + + function _getSlashableSharesInQueue(User operator, IStrategy[] memory strategies) internal view returns (uint[] memory) { + uint[] memory slashableShares = new uint[](strategies.length); + + for (uint i = 0; i < strategies.length; i++) { + slashableShares[i] = delegationManager.getSlashableSharesInQueue(address(operator), strategies[i]); + } + + return slashableShares; + } + /// @dev Uses timewarp modifier to get operator shares at the last snapshot function _getPrevOperatorShares( User operator, @@ -1522,12 +2691,7 @@ abstract contract IntegrationBase is IntegrationDeployer { // This method should only be used for tests that handle positive // balances. Negative balances are an edge case that require // the own tests and helper methods. - int shares; - if (forkType != LOCAL && !isUpgraded) { - shares = int(IEigenPodManager_DeprecatedM2(address(eigenPodManager)).podOwnerShares(address(staker))); - } else { - shares = int(eigenPodManager.podOwnerDepositShares(address(staker))); - } + int shares = eigenPodManager.podOwnerDepositShares(address(staker)); if (shares < 0) { revert("_getStakerDepositShares: negative shares"); @@ -1535,11 +2699,7 @@ abstract contract IntegrationBase is IntegrationDeployer { curShares[i] = uint(shares); } else { - if (forkType != LOCAL && !isUpgraded) { - curShares[i] = IStrategyManager_DeprecatedM2(address(strategyManager)).stakerStrategyShares(address(staker), strat); - } else { - curShares[i] = strategyManager.stakerDepositShares(address(staker), strat); - } + curShares[i] = strategyManager.stakerDepositShares(address(staker), strat); } } @@ -1633,6 +2793,62 @@ abstract contract IntegrationBase is IntegrationDeployer { return shares; } + function _getDepositScalingFactors(User staker, IStrategy[] memory strategies) internal view returns (uint[] memory) { + uint[] memory depositScalingFactors = new uint[](strategies.length); + for (uint i=0; i < strategies.length; i++) { + depositScalingFactors[i] = _getDepositScalingFactor(staker, strategies[i]); + } + return depositScalingFactors; + } + + function _getDepositScalingFactor(User staker, IStrategy strategy) internal view returns (uint) { + return delegationManager.depositScalingFactor(address(staker), strategy); + } + + function _getPrevDepositScalingFactors(User staker, IStrategy[] memory strategies) internal timewarp() returns (uint[] memory) { + return _getDepositScalingFactors(staker, strategies); + } + + function _getExpectedDSFUndelegate(User staker) internal view returns (uint expectedDepositScalingFactor) { + return WAD.divWad(_getBeaconChainSlashingFactor(staker)); + } + + function _getExpectedWithdrawableSharesUndelegate(User staker, IStrategy[] memory strategies, uint[] memory shares) internal returns (uint[] memory){ + uint[] memory expectedWithdrawableShares = new uint[](strategies.length); + for (uint i = 0; i < strategies.length; i++) { + if (strategies[i] == BEACONCHAIN_ETH_STRAT) { + expectedWithdrawableShares[i] = shares[i].mulWad(_getExpectedDSFUndelegate(staker)).mulWad(_getBeaconChainSlashingFactor(staker)); + } else { + expectedWithdrawableShares[i] = shares[i]; + } + } + return expectedWithdrawableShares; + } + + function _getExpectedDSFsDelegate(User staker, User operator, IStrategy[] memory strategies) internal returns (uint[] memory) { + uint[] memory expectedDepositScalingFactors = new uint[](strategies.length); + uint[] memory oldDepositScalingFactors = _getPrevDepositScalingFactors(staker, strategies); + uint64[] memory maxMagnitudes = _getMaxMagnitudes(operator, strategies); + for (uint i = 0; i < strategies.length; i++) { + expectedDepositScalingFactors[i] = oldDepositScalingFactors[i].divWad(maxMagnitudes[i]); + } + return expectedDepositScalingFactors; + } + + function _getExpectedWithdrawableSharesDelegate(User staker, User operator, IStrategy[] memory strategies, uint[] memory depositShares) internal returns (uint[] memory){ + uint[] memory expectedWithdrawableShares = new uint[](strategies.length); + uint[] memory expectedDSFs = _getExpectedDSFsDelegate(staker, operator, strategies); + uint64[] memory maxMagnitudes = _getMaxMagnitudes(operator, strategies); + for (uint i = 0; i < strategies.length; i++) { + if (strategies[i] == BEACONCHAIN_ETH_STRAT) { + expectedWithdrawableShares[i] = depositShares[i].mulWad(expectedDSFs[i]).mulWad(maxMagnitudes[i].mulWad(_getBeaconChainSlashingFactor(staker))); + } else { + expectedWithdrawableShares[i] = depositShares[i].mulWad(expectedDSFs[i]).mulWad(maxMagnitudes[i]); + } + } + return expectedWithdrawableShares; + } + function _getPrevWithdrawableShares(User staker, IStrategy[] memory strategies) internal timewarp() returns (uint[] memory) { return _getWithdrawableShares(staker, strategies); } @@ -1650,9 +2866,9 @@ abstract contract IntegrationBase is IntegrationDeployer { return _getActiveValidatorCount(staker); } - function _getValidatorStatuses(User staker, bytes32[] memory pubkeyHashes) internal view returns (IEigenPodTypes.VALIDATOR_STATUS[] memory) { + function _getValidatorStatuses(User staker, bytes32[] memory pubkeyHashes) internal view returns (VALIDATOR_STATUS[] memory) { EigenPod pod = staker.pod(); - IEigenPodTypes.VALIDATOR_STATUS[] memory statuses = new IEigenPodTypes.VALIDATOR_STATUS[](pubkeyHashes.length); + VALIDATOR_STATUS[] memory statuses = new VALIDATOR_STATUS[](pubkeyHashes.length); for (uint i = 0; i < statuses.length; i++) { statuses[i] = pod.validatorStatus(pubkeyHashes[i]); @@ -1661,7 +2877,7 @@ abstract contract IntegrationBase is IntegrationDeployer { return statuses; } - function _getPrevValidatorStatuses(User staker, bytes32[] memory pubkeyHashes) internal timewarp() returns (IEigenPodTypes.VALIDATOR_STATUS[] memory) { + function _getPrevValidatorStatuses(User staker, bytes32[] memory pubkeyHashes) internal timewarp() returns (VALIDATOR_STATUS[] memory) { return _getValidatorStatuses(staker, pubkeyHashes); } @@ -1693,13 +2909,8 @@ abstract contract IntegrationBase is IntegrationDeployer { } function _getCheckpointPodBalanceGwei(User staker) internal view returns (uint64) { - if (forkType != LOCAL && !isUpgraded) { - IEigenPod_DeprecatedM2 pod = IEigenPod_DeprecatedM2(address(staker.pod())); - return uint64(pod.currentCheckpoint().podBalanceGwei); - } else { - EigenPod pod = staker.pod(); - return uint64(pod.currentCheckpoint().podBalanceGwei); - } + EigenPod pod = staker.pod(); + return uint64(pod.currentCheckpoint().podBalanceGwei); } function _getPrevCheckpointPodBalanceGwei(User staker) internal timewarp() returns (uint64) { diff --git a/src/test/integration/IntegrationChecks.t.sol b/src/test/integration/IntegrationChecks.t.sol index cd0ce115da..9efd412cdd 100644 --- a/src/test/integration/IntegrationChecks.t.sol +++ b/src/test/integration/IntegrationChecks.t.sol @@ -9,23 +9,14 @@ import "src/test/integration/users/User_M2.t.sol"; /// @notice Contract that provides utility functions to reuse common test blocks & checks contract IntegrationCheckUtils is IntegrationBase { using ArrayLib for IStrategy[]; + using ArrayLib for IStrategy; using SlashingLib for *; + using StdStyle for *; /******************************************************************************* EIGENPOD CHECKS *******************************************************************************/ - function check_VerifyWC_State( - User_M2 staker, - uint40[] memory validators, - uint64 beaconBalanceGwei - ) internal { - uint beaconBalanceWei = beaconBalanceGwei * GWEI_TO_WEI; - assert_Snap_Added_Staker_DepositShares(staker, BEACONCHAIN_ETH_STRAT, beaconBalanceWei, "staker should have added deposit shares to beacon chain strat"); - assert_Snap_Added_ActiveValidatorCount(staker, validators.length, "staker should have increased active validator count"); - assert_Snap_Added_ActiveValidators(staker, validators, "validators should each be active"); - } - function check_VerifyWC_State( User staker, uint40[] memory validators, @@ -99,8 +90,8 @@ contract IntegrationCheckUtils is IntegrationBase { ) internal { check_CompleteCheckpoint_State(staker); - assert_Snap_Unchanged_StakerDepositShares(staker, "staker shares should not have decreased"); - assert_Snap_Removed_StakerWithdrawableShares(staker, BEACONCHAIN_ETH_STRAT, slashedAmountGwei * GWEI_TO_WEI, "should have decreased withdrawable shares by slashed amount"); + assert_Snap_Unchanged_Staker_DepositShares(staker, "staker shares should not have decreased"); + assert_Snap_Removed_Staker_WithdrawableShares(staker, BEACONCHAIN_ETH_STRAT, slashedAmountGwei * GWEI_TO_WEI, "should have decreased withdrawable shares by slashed amount"); assert_Snap_Removed_ActiveValidatorCount(staker, slashedValidators.length, "should have decreased active validator count"); assert_Snap_Removed_ActiveValidators(staker, slashedValidators, "exited validators should each be WITHDRAWN"); } @@ -112,10 +103,11 @@ contract IntegrationCheckUtils is IntegrationBase { ) internal { check_CompleteCheckpoint_State(staker); - assert_Snap_Unchanged_StakerDepositShares(staker, "staker shares should not have decreased"); + assert_Snap_Unchanged_Staker_DepositShares(staker, "staker shares should not have decreased"); assert_Snap_Removed_Staker_WithdrawableShares_AtLeast(staker, BEACONCHAIN_ETH_STRAT, slashedAmountGwei * GWEI_TO_WEI, "should have decreased withdrawable shares by at least slashed amount"); - assert_Snap_Removed_ActiveValidatorCount(staker, slashedValidators.length, "should have decreased active validator count"); - assert_Snap_Removed_ActiveValidators(staker, slashedValidators, "exited validators should each be WITHDRAWN"); + // TODO - currently only used after a `NoWithdrawNoRewards` action. Investigate re-adding in future. + // assert_Snap_Removed_ActiveValidatorCount(staker, slashedValidators.length, "should have decreased active validator count"); + // assert_Snap_Removed_ActiveValidators(staker, slashedValidators, "exited validators should each be WITHDRAWN"); } function check_CompleteCheckpoint_WithCLSlashing_HandleRoundDown_State( @@ -124,7 +116,7 @@ contract IntegrationCheckUtils is IntegrationBase { ) internal { check_CompleteCheckpoint_State(staker); - assert_Snap_Unchanged_StakerDepositShares(staker, "staker shares should not have decreased"); + assert_Snap_Unchanged_Staker_DepositShares(staker, "staker shares should not have decreased"); assert_Snap_Removed_Staker_WithdrawableShares_AtLeast(staker, BEACONCHAIN_ETH_STRAT, slashedAmountGwei * GWEI_TO_WEI, "should have decreased withdrawable shares by at least slashed amount"); assert_Snap_Unchanged_ActiveValidatorCount(staker, "should not have changed active validator count"); } @@ -135,8 +127,8 @@ contract IntegrationCheckUtils is IntegrationBase { ) internal { check_CompleteCheckpoint_State(staker); - assert_Snap_Unchanged_StakerDepositShares(staker, "staker shares should not have decreased"); - assert_Snap_Removed_StakerWithdrawableShares(staker, BEACONCHAIN_ETH_STRAT, slashedAmountGwei * GWEI_TO_WEI, "should have decreased withdrawable shares by slashed amount"); + assert_Snap_Unchanged_Staker_DepositShares(staker, "staker shares should not have decreased"); + assert_Snap_Removed_Staker_WithdrawableShares(staker, BEACONCHAIN_ETH_STRAT, slashedAmountGwei * GWEI_TO_WEI, "should have decreased withdrawable shares by slashed amount"); assert_Snap_Unchanged_ActiveValidatorCount(staker, "should not have changed active validator count"); } @@ -147,7 +139,7 @@ contract IntegrationCheckUtils is IntegrationBase { ) internal { check_CompleteCheckpoint_WithPodBalance_State(staker, exitedBalanceGwei); - assert_Snap_Unchanged_StakerDepositShares(staker, "staker should not have changed shares"); + assert_Snap_Unchanged_Staker_DepositShares(staker, "staker should not have changed shares"); assert_Snap_Added_BalanceExitedGwei(staker, exitedBalanceGwei, "should have attributed expected gwei to exited balance"); assert_Snap_Removed_ActiveValidatorCount(staker, exitedValidators.length, "should have decreased active validator count"); assert_Snap_Removed_ActiveValidators(staker, exitedValidators, "exited validators should each be WITHDRAWN"); @@ -170,8 +162,8 @@ contract IntegrationCheckUtils is IntegrationBase { // and that the staker now has the expected amount of delegated shares in each strategy assert_HasNoUnderlyingTokenBalance(staker, strategies, "staker should have transferred all underlying tokens"); assert_Snap_Added_Staker_DepositShares(staker, strategies, shares, "staker should expect shares in each strategy after depositing"); + assert_Snap_Added_Staker_WithdrawableShares(staker, strategies, shares, "deposit should increase withdrawable shares"); } - function check_Deposit_State_PartialDeposit(User staker, IStrategy[] memory strategies, uint[] memory shares, uint[] memory tokenBalances) internal { /// Deposit into strategies: @@ -182,11 +174,12 @@ contract IntegrationCheckUtils is IntegrationBase { // and that the staker now has the expected amount of delegated shares in each strategy assert_HasUnderlyingTokenBalances(staker, strategies, tokenBalances, "staker should have transferred some underlying tokens"); assert_Snap_Added_Staker_DepositShares(staker, strategies, shares, "staker should expected shares in each strategy after depositing"); + assert_Snap_Added_Staker_WithdrawableShares(staker, strategies, shares, "deposit should increase withdrawable shares"); } function check_Delegation_State( User staker, - User operator, + User operator, IStrategy[] memory strategies, uint[] memory shares ) internal { @@ -197,9 +190,11 @@ contract IntegrationCheckUtils is IntegrationBase { assertTrue(delegationManager.isDelegated(address(staker)), "staker should be delegated"); assertEq(address(operator), delegationManager.delegatedTo(address(staker)), "staker should be delegated to operator"); assert_HasExpectedShares(staker, strategies, shares, "staker should still have expected shares after delegating"); - assert_Snap_Unchanged_StakerDepositShares(staker, "staker shares should be unchanged after delegating"); - // TODO: fix this assertion - // assert_Snap_Added_OperatorShares(operator, strategies, shares, "operator should have received shares"); + assert_Snap_Unchanged_Staker_DepositShares(staker, "staker shares should be unchanged after delegating"); + assert_Snap_Expected_Staker_WithdrawableShares_Delegation(staker, operator, strategies, shares, "withdrawable shares should be unchanged within rounding error after delegating"); + uint256[] memory delegatableShares = _getPrevStakerWithdrawableShares(staker, strategies); + assert_Snap_Added_OperatorShares(operator, strategies, delegatableShares, "operator should have received shares"); + //assert_Snap_Added_SlashableStake(operator, operatorSet, strategies, delegatableShares, "operator slashable stake should increase"); } function check_QueuedWithdrawal_State( @@ -207,7 +202,7 @@ contract IntegrationCheckUtils is IntegrationBase { User operator, IStrategy[] memory strategies, uint[] memory shares, - IDelegationManagerTypes.Withdrawal[] memory withdrawals, + Withdrawal[] memory withdrawals, bytes32[] memory withdrawalRoots ) internal { // The staker will queue one or more withdrawals for the selected strategies and shares @@ -224,35 +219,88 @@ contract IntegrationCheckUtils is IntegrationBase { "check_QueuedWithdrawal_State: staker should have increased nonce by withdrawals.length"); assert_Snap_Removed_OperatorShares(operator, strategies, shares, "check_QueuedWithdrawal_State: failed to remove operator shares"); - assert_Snap_Removed_StakerDepositShares(staker, strategies, shares, + assert_Snap_Removed_Staker_DepositShares(staker, strategies, shares, "check_QueuedWithdrawal_State: failed to remove staker shares"); + assert_Snap_Removed_Staker_WithdrawableShares(staker, strategies, shares, + "check_QueuedWithdrawal_State: failed to remove staker withdrawable shares"); + // Check that the dsf is either reset to wad or unchanged + for (uint i = 0; i < strategies.length; i++) { + // For a full withdrawal, the dsf should be reset to wad + if (_getStakerDepositShares(staker, strategies[i].toArray())[0] == 0) { + assert_DSF_Reset(staker, strategies[i].toArray(), + "check_QueuedWithdrawal_State: dsf should be reset to wad"); + } + // For a partial withdrawal, the dsf should not be changed + else { + assert_Snap_Unchanged_DSF(staker, strategies[i].toArray(), + "check_QueuedWithdrawal_State: dsf should not be changed"); + } + } } function check_Undelegate_State( User staker, User operator, - IDelegationManagerTypes.Withdrawal[] memory withdrawals, + Withdrawal[] memory withdrawals, bytes32[] memory withdrawalRoots, IStrategy[] memory strategies, - uint[] memory shares + uint[] memory stakerDepositShares, + uint[] memory stakerDelegatedShares ) internal { /// Undelegate from an operator // - // ... check that the staker is undelegated, all strategies from which the staker is deposited are unqeuued, + // ... check that the staker is undelegated, all strategies from which the staker is deposited are unqueued, // that the returned root matches the hashes for each strategy and share amounts, and that the staker // and operator have reduced shares assertFalse(delegationManager.isDelegated(address(staker)), "check_Undelegate_State: staker should not be delegated"); assert_ValidWithdrawalHashes(withdrawals, withdrawalRoots, - "check_Undelegate_State: calculated withdrawl should match returned root"); + "check_Undelegate_State: calculated withdrawal should match returned root"); assert_AllWithdrawalsPending(withdrawalRoots, "check_Undelegate_State: stakers withdrawal should now be pending"); + assert_DSF_Reset(staker, strategies, + "check_Undelegate_State: staker dsfs should be reset to wad"); assert_Snap_Added_QueuedWithdrawals(staker, withdrawals, "check_Undelegate_State: staker should have increased nonce by withdrawals.length"); - assert_Snap_Removed_OperatorShares(operator, strategies, shares, + assert_Snap_Removed_OperatorShares(operator, strategies, stakerDelegatedShares, "check_Undelegate_State: failed to remove operator shares"); - assert_Snap_Removed_StakerDepositShares(staker, strategies, shares, + assert_Snap_Removed_Staker_DepositShares(staker, strategies, stakerDepositShares, "check_Undelegate_State: failed to remove staker shares"); + assert_Snap_RemovedAll_Staker_WithdrawableShares(staker, strategies, + "check_QueuedWithdrawal_State: failed to remove staker withdrawable shares"); + } + + function check_Redelegate_State( + User staker, + User oldOperator, + User newOperator, + IDelegationManagerTypes.Withdrawal[] memory withdrawals, + bytes32[] memory withdrawalRoots, + IStrategy[] memory strategies, + uint[] memory stakerDepositShares, + uint[] memory stakerDelegatedShares + ) internal { + /// Redelegate to a new operator + // + // ... check that the staker is delegated to new operator, all strategies from which the staker is deposited are unqueued, + // that the returned root matches the hashes for each strategy and share amounts, and that the staker + // and operator have reduced shares + assertTrue(delegationManager.isDelegated(address(staker)), + "check_Redelegate_State: staker should not be delegated"); + assert_ValidWithdrawalHashes(withdrawals, withdrawalRoots, + "check_Redelegate_State: calculated withdrawl should match returned root"); + assert_AllWithdrawalsPending(withdrawalRoots, + "check_Redelegate_State: stakers withdrawal should now be pending"); + assert_Snap_Added_QueuedWithdrawals(staker, withdrawals, + "check_Redelegate_State: staker should have increased nonce by withdrawals.length"); + assert_Snap_Removed_OperatorShares(oldOperator, strategies, stakerDelegatedShares, + "check_Redelegate_State: failed to remove operator shares"); + assert_Snap_Removed_Staker_DepositShares(staker, strategies, stakerDepositShares, + "check_Redelegate_State: failed to remove staker shares"); + assert_Snap_RemovedAll_Staker_WithdrawableShares(staker, strategies, + "check_QueuedWithdrawal_State: failed to remove staker withdrawable shares"); + assert_Snap_Unchanged_OperatorShares(newOperator, + "check_Redelegate_State: new operator shares should not have changed"); } /** @@ -268,7 +316,7 @@ contract IntegrationCheckUtils is IntegrationBase { function check_Withdrawal_AsTokens_State( User staker, User operator, - IDelegationManagerTypes.Withdrawal memory withdrawal, + Withdrawal memory withdrawal, IStrategy[] memory strategies, uint[] memory shares, IERC20[] memory tokens, @@ -278,7 +326,8 @@ contract IntegrationCheckUtils is IntegrationBase { assert_WithdrawalNotPending(delegationManager.calculateWithdrawalRoot(withdrawal), "staker withdrawal should no longer be pending"); assert_Snap_Added_TokenBalances(staker, tokens, expectedTokens, "staker should have received expected tokens"); - assert_Snap_Unchanged_StakerDepositShares(staker, "staker shares should not have changed"); + assert_Snap_Unchanged_Staker_DepositShares(staker, "staker shares should not have changed"); + assert_Snap_Unchanged_DSF(staker, strategies, "dsf should not be changed"); assert_Snap_Removed_StrategyShares(strategies, shares, "strategies should have total shares decremented"); // Checks specific to an operator that the Staker has delegated to @@ -293,7 +342,7 @@ contract IntegrationCheckUtils is IntegrationBase { function check_Withdrawal_AsShares_State( User staker, User operator, - IDelegationManagerTypes.Withdrawal memory withdrawal, + Withdrawal memory withdrawal, IStrategy[] memory strategies, uint[] memory shares ) internal { @@ -301,6 +350,7 @@ contract IntegrationCheckUtils is IntegrationBase { assert_WithdrawalNotPending(delegationManager.calculateWithdrawalRoot(withdrawal), "staker withdrawal should no longer be pending"); assert_Snap_Unchanged_TokenBalances(staker, "staker should not have any change in underlying token balances"); assert_Snap_Added_Staker_DepositShares(staker, strategies, shares, "staker should have received expected shares"); + assert_Snap_Added_Staker_WithdrawableShares(staker, strategies, shares, "staker should have received expected withdrawable shares"); assert_Snap_Unchanged_StrategyShares(strategies, "strategies should have total shares unchanged"); // Additional checks or handling for the non-user operator scenario @@ -316,6 +366,30 @@ contract IntegrationCheckUtils is IntegrationBase { function check_Withdrawal_AsShares_Undelegated_State( User staker, User operator, + Withdrawal memory withdrawal, + IStrategy[] memory strategies, + uint[] memory shares + ) internal { + /// Complete withdrawal(s): + // The staker will complete the withdrawal as shares + // + // ... check that the withdrawal is not pending, that the token balances of the staker and operator are unchanged, + // that the withdrawer received the expected shares, and that that the total shares of each o + // strategy withdrawn remains unchanged + assert_WithdrawalNotPending(delegationManager.calculateWithdrawalRoot(withdrawal), "staker withdrawal should no longer be pending"); + assert_Snap_Unchanged_TokenBalances(staker, "staker should not have any change in underlying token balances"); + assert_Snap_Unchanged_TokenBalances(operator, "operator should not have any change in underlying token balances"); + assert_Snap_Added_Staker_DepositShares(staker, strategies, shares, "staker should have received expected deposit shares"); + uint[] memory expectedWithdrawableShares = _getExpectedWithdrawableSharesUndelegate(staker, strategies, shares); + assert_Snap_Added_Staker_WithdrawableShares(staker, strategies, expectedWithdrawableShares, "staker should have received expected withdrawable shares"); + assert_Snap_Unchanged_OperatorShares(operator, "operator should have shares unchanged"); + assert_Snap_Unchanged_StrategyShares(strategies, "strategies should have total shares unchanged"); + } + + function check_Withdrawal_AsShares_Redelegated_State( + User staker, + User operator, + User newOperator, IDelegationManagerTypes.Withdrawal memory withdrawal, IStrategy[] memory strategies, uint[] memory shares @@ -335,17 +409,523 @@ contract IntegrationCheckUtils is IntegrationBase { } /******************************************************************************* - ALLOCATION MANAGER CHECKS + ALM - BASIC INVARIANTS + *******************************************************************************/ + + /// @dev Run a method as if the user's allocation delay had passed + /// When done, reset block number so other tests are not affected + modifier activateAllocation(User operator) { + _rollForward_AllocationDelay(operator); + + _; + + _rollBackward_AllocationDelay(operator); + } + + /// @dev Run a method as if the deallocation delay has passed + /// When done, reset block number so other tests are not affected + modifier activateDeallocation() { + _rollForward_DeallocationDelay(); + + _; + + _rollBackward_DeallocationDelay(); + } + + /// @dev Run a method ONLY IF the operator has a nonzero activation delay + modifier skipIfInstantAlloc(User operator) { + /// Note: if the ALM says the allocation delay is "not set", this will revert + uint32 delay = _getExistingAllocationDelay(operator); + + if (delay != 0) { + _; + } else { + console.log("%s", "skipping checks for operator with allocation delay of 0".italic()); + } + } + + /// @dev Check global max magnitude invariants - these should ALWAYS hold + function check_MaxMag_Invariants( + User operator + ) internal { + assert_MaxMagsEqualMaxMagsAtCurrentBlock(operator, allStrats, "max magnitudes should equal upperlookup at current block"); + assert_MaxEqualsAllocatablePlusEncumbered(operator, "max magnitude should equal encumbered plus allocatable"); + } + + /// @dev Check that the last call to modifyAllocations resulted in a non-pending modification + function check_ActiveModification_State( + User operator, + AllocateParams memory params + ) internal { + OperatorSet memory operatorSet = params.operatorSet; + IStrategy[] memory strategies = params.strategies; + + assert_CurrentMagnitude(operator, params, "current magnitude should match allocate params"); + assert_NoPendingModification(operator, operatorSet, strategies, "there should not be a pending modification for any strategy"); + } + + function check_IsSlashable_State( + User operator, + OperatorSet memory operatorSet, + IStrategy[] memory strategies + ) internal { + assert_IsSlashable(operator, operatorSet, "operator should be slashable for operator set"); + assert_CurMinSlashableEqualsMinAllocated(operator, operatorSet, strategies, "minimum slashable stake should equal allocated stake at current block"); + } + + function check_NotSlashable_State( + User operator, + OperatorSet memory operatorSet + ) internal { + assert_NotSlashable(operator, operatorSet, "operator should not be slashable for operator set"); + assert_NoSlashableStake(operator, operatorSet, "operator should not have any slashable stake"); + } + + /******************************************************************************* + ALM - REGISTRATION *******************************************************************************/ + /// @dev Basic invariants that should hold after EVERY call to `registerForOperatorSets` + /// NOTE: These are only slightly modified from check_Base_Deregistration_State + /// If you add invariants here, consider adding them there (and vice-versa) + function check_Base_Registration_State( + User operator, + OperatorSet memory operatorSet + ) internal { + check_MaxMag_Invariants(operator); + check_IsSlashable_State(operator, operatorSet, allocationManager.getStrategiesInOperatorSet(operatorSet)); + + // Registration SHOULD register the operator, making them slashable and adding them as a member of the set + assert_Snap_Became_Registered(operator, operatorSet, "operator should not have been registered before, and is now registered"); + assert_Snap_Became_Slashable(operator, operatorSet, "operator should not have been slashable before, and is now slashable"); + assert_Snap_Added_RegisteredSet(operator, operatorSet, "should have added operator sets to list of registered sets"); + assert_Snap_Added_MemberOfSet(operator, operatorSet, "should have added operator to list of set members"); + + // Registration should NOT change anything about magnitude, allocations, or allocated sets + assert_Snap_Unchanged_AllocatedSets(operator, "should not have updated allocated sets"); + assert_Snap_Unchanged_AllocatedStrats(operator, operatorSet, "should not have updated allocated strategies"); + assert_Snap_Unchanged_MaxMagnitude(operator, allStrats, "should not have updated max magnitudes in any way"); + assert_Snap_Unchanged_AllocatedStake(operator, operatorSet, allStrats, "should not have updated allocated stake in any way"); + assert_Snap_Unchanged_StrategyAllocations(operator, operatorSet, allStrats, "should not have updated any individual allocations"); + assert_Snap_Unchanged_EncumberedMagnitude(operator, allStrats, "should not have updated encumbered magnitude"); + assert_Snap_Unchanged_AllocatableMagnitude(operator, allStrats, "should not have updated allocatable magnitude"); + } + + /// @dev Check invariants for registerForOperatorSets given a set of strategies + /// for which NO allocation exists (currentMag/pendingDiff are 0) + /// @param unallocated For the given operatorSet, a list of strategies for which NO allocation exists + function check_Registration_State_NoAllocation( + User operator, + OperatorSet memory operatorSet, + IStrategy[] memory unallocated + ) internal { + check_Base_Registration_State(operator, operatorSet); + + /// The operator is NOT allocated, ensure their slashable stake and magnitudes are unchanged + assert_Snap_Unchanged_AllocatedStake(operator, operatorSet, unallocated, "should not have updated allocated stake in any way"); + assert_Snap_Unchanged_SlashableStake(operator, operatorSet, unallocated, "operator should not have increased slashable stake for any given strategy"); + } + + /// @dev Check invariants for registerForOperatorSets AFTER a prior allocation becomes active + /// @param active allocation params to the last call to modifyAllocations + /// + /// ASSUMES: + /// - the effect block for `params` has already passed + /// - params.newMagnitudes does NOT contain any `0` entries + function check_Registration_State_ActiveAllocation( + User operator, + AllocateParams memory active + ) internal { + OperatorSet memory operatorSet = active.operatorSet; + IStrategy[] memory strategies = active.strategies; + + /// Basic registerForOperatorSets invariants + check_Base_Registration_State(operator, operatorSet); + + /// Given an active allocation, check that the allocation is reflected in state + assert_IsAllocatedToSet(operator, operatorSet, "operatorSet should be included in allocatedSets"); + assert_IsAllocatedToSetStrats(operator, operatorSet, strategies, "strategies should be included in allocatedStrategies"); + assert_CurrentMagnitude(operator, active, "queried allocation should equal active allocation"); + + /// Check that additional stake just became slashable + assert_Snap_Unchanged_AllocatedStake(operator, operatorSet, strategies, "should not have updated allocated stake in any way"); + assert_Snap_StakeBecameSlashable(operator, operatorSet, strategies, "registration should make entirety of active allocation slashable"); + } + + /// @dev Check registration invariants. Assumes the operator has a PENDING allocation + /// to the set, but that the allocation's effect block has not yet been reached + function check_Registration_State_PendingAllocation( + User operator, + AllocateParams memory params + ) internal { + OperatorSet memory operatorSet = params.operatorSet; + IStrategy[] memory strategies = params.strategies; + + check_Base_Registration_State(operator, operatorSet); + + assert_IsAllocatedToSet(operator, operatorSet, "operator should be allocated to set, even while pending"); + assert_IsAllocatedToSetStrats(operator, operatorSet, strategies, "strategies should be included in allocatedStrategies"); + + /// Skip pending checks if operator has no allocation delay + uint32 delay = _getExistingAllocationDelay(operator); + if (delay == 0) { + return; + } + + assert_Snap_Unchanged_AllocatedStake(operator, operatorSet, strategies, "should not have updated allocated stake in any way"); + assert_Snap_Unchanged_SlashableStake(operator, operatorSet, allStrats, "operator should not have increased slashable stake"); + } + + /******************************************************************************* + ALM - DEREGISTRATION + *******************************************************************************/ + + /// @dev Basic invariants that should hold after EVERY call to `deregisterFromOperatorSets` + /// NOTE: These are only slightly modified from check_Base_Registration_State + /// If you add invariants here, consider adding them there (and vice-versa) + function check_Base_Deregistration_State( + User operator, + OperatorSet memory operatorSet + ) internal { + check_MaxMag_Invariants(operator); + + // Deregistration SHOULD remove the operator as a member of the set + assert_Snap_Became_Deregistered(operator, operatorSet, "operator should have been registered before, and is now deregistered"); + assert_Snap_Removed_RegisteredSet(operator, operatorSet, "should have removed operator set from list of registered sets"); + assert_Snap_Removed_MemberOfSet(operator, operatorSet, "should have removed operator from list of set members"); + + // Deregistration should NOT change slashability, magnitude, allocations, or allocated sets + assert_Snap_Remains_Slashable(operator, operatorSet, "operator should have been slashable already, and should still be slashable"); + assert_Snap_Unchanged_AllocatedSets(operator, "should not have updated allocated sets"); + assert_Snap_Unchanged_AllocatedStrats(operator, operatorSet, "should not have updated allocated strategies"); + assert_Snap_Unchanged_MaxMagnitude(operator, allStrats, "should not have updated max magnitudes in any way"); + assert_Snap_Unchanged_AllocatedStake(operator, operatorSet, allStrats, "should not have updated allocated stake in any way"); + assert_Snap_Unchanged_StrategyAllocations(operator, operatorSet, allStrats, "should not have updated any individual allocations"); + assert_Snap_Unchanged_EncumberedMagnitude(operator, allStrats, "should not have updated encumbered magnitude"); + assert_Snap_Unchanged_AllocatableMagnitude(operator, allStrats, "should not have updated allocatable magnitude"); + + _rollForward_DeallocationDelay(); + { + check_NotSlashable_State(operator, operatorSet); + } + _rollBackward_DeallocationDelay(); + } + + function check_Deregistration_State_NoAllocation( + User operator, + OperatorSet memory operatorSet + ) internal { + check_Base_Deregistration_State(operator, operatorSet); + + assert_Snap_Unchanged_AllocatedStake(operator, operatorSet, allStrats, "should not have updated allocated stake in any way"); + assert_Snap_Unchanged_SlashableStake(operator, operatorSet, allStrats, "operator should not have increased slashable stake for any given strategy"); + } + + function check_Deregistration_State_ActiveAllocation( + User operator, + OperatorSet memory operatorSet + ) internal { + check_Base_Deregistration_State(operator, operatorSet); + + assert_Snap_Unchanged_AllocatedStake(operator, operatorSet, allStrats, "should not have updated allocated stake in any way"); + assert_Snap_Unchanged_SlashableStake(operator, operatorSet, allStrats, "operator should not have increased slashable stake for any given strategy"); + } + + function check_Deregistration_State_PendingAllocation( + User operator, + OperatorSet memory operatorSet + ) internal { + check_Base_Deregistration_State(operator, operatorSet); + + assert_Snap_Unchanged_AllocatedStake(operator, operatorSet, allStrats, "should not have updated allocated stake in any way"); + assert_Snap_Unchanged_SlashableStake(operator, operatorSet, allStrats, "operator should not have increased slashable stake for any given strategy"); + } + + /******************************************************************************* + ALM - INCREASE ALLOCATION + *******************************************************************************/ + + /// @dev Basic invariants that should hold after all calls to `modifyAllocations` + /// where the input `params` represent an _increase_ in magnitude + function check_Base_IncrAlloc_State( + User operator, + AllocateParams memory params + ) internal { + check_MaxMag_Invariants(operator); + + OperatorSet memory operatorSet = params.operatorSet; + IStrategy[] memory strategies = params.strategies; + uint64[] memory newMagnitudes = params.newMagnitudes; + + // Increasing Allocation should NOT change operator set registration, max magnitude + assert_Snap_Unchanged_Registration(operator, operatorSet, "operator registration status should be unchanged"); + assert_Snap_Unchanged_Slashability(operator, operatorSet, "operator slashability should be unchanged"); + assert_Snap_Unchanged_RegisteredSet(operator, "list of registered sets should remain unchanged"); + assert_Snap_Unchanged_MemberOfSet(operatorSet, "list of set members should remain unchanged"); + assert_Snap_Unchanged_MaxMagnitude(operator, allStrats, "should not have updated max magnitudes in any way"); + + // Increasing Allocation SHOULD consume magnitude and mark the operator as being allocated to the set + assert_IsAllocatedToSet(operator, operatorSet, "operator should be allocated to set"); + assert_IsAllocatedToSetStrats(operator, operatorSet, strategies, "operator should be allocated to strategies for set"); + assert_Snap_Allocated_Magnitude(operator, strategies, "operator should have allocated magnitude"); + } + + /// @dev Invariants for modifyAllocations. Use when: + /// - operator is NOT slashable for this operator set + /// - last call to modifyAllocations created an INCREASE in allocation + function check_IncrAlloc_State_NotSlashable( + User operator, + AllocateParams memory params + ) internal { + check_Base_IncrAlloc_State(operator, params); + check_NotSlashable_State(operator, params.operatorSet); + + /// Run checks on pending allocation, if the operator has a nonzero delay + check_IncrAlloc_State_NotSlashable_Pending(operator, params); + + /// Run checks on active allocation + check_IncrAlloc_State_NotSlashable_Active(operator, params); + } + + /// @dev Invariants for modifyAllocations. Used when: + /// - operator is NOT slashable for this operator set + /// - last call to modifyAllocations created an INCREASE in allocation + /// - effectBlock for the increase HAS NOT been reached + function check_IncrAlloc_State_NotSlashable_Pending( + User operator, + AllocateParams memory params + ) private skipIfInstantAlloc(operator) { + // Validate operator allocation is pending + assert_HasPendingIncrease(operator, params, "params should reflect a pending modification"); + + // Should not have allocated magnitude + assert_Snap_Unchanged_AllocatedStake(operator, params.operatorSet, params.strategies, "should not have updated allocated stake in any way"); + assert_Snap_Unchanged_SlashableStake(operator, params.operatorSet, params.strategies, "should not have updated allocated stake in any way"); + } + + /// @dev Invariants for modifyAllocations. Used when: + /// - operator is NOT slashable for this operator set + /// - last call to modifyAllocations created an INCREASE in allocation + /// - effectBlock for the increase HAS been reached + function check_IncrAlloc_State_NotSlashable_Active( + User operator, + AllocateParams memory params + ) private activateAllocation(operator) { + // Validate allocation is active + check_ActiveModification_State(operator, params); + + // SHOULD set current magnitude and increase allocated stake + assert_Snap_Set_CurrentMagnitude(operator, params, "should have updated the operator's magnitude"); + assert_HasAllocatedStake(operator, params, "operator should have expected allocated stake for each strategy"); + assert_Snap_StakeBecameAllocated(operator, params.operatorSet, params.strategies, "allocated stake should have increased"); + + // Should NOT change slashable stake + assert_Snap_Unchanged_SlashableStake(operator, params.operatorSet, params.strategies, "slashable stake should not be changed"); + } + + /// @dev Invariants for modifyAllocations. Use when: + /// - operator IS slashable for this operator set + /// - last call to modifyAllocations created an INCREASE in allocation + function check_IncrAlloc_State_Slashable( + User operator, + AllocateParams memory params + ) internal { + check_Base_IncrAlloc_State(operator, params); + check_IsSlashable_State(operator, params.operatorSet, params.strategies); + + /// Run checks on pending allocation, if the operator has a nonzero delay + check_IncrAlloc_State_Slashable_Pending(operator, params); + + /// Run checks on active allocation + check_IncrAlloc_State_Slashable_Active(operator, params); + } + + /// @dev Invariants for modifyAllocations. Used when: + /// - operator IS slashable for this operator set + /// - last call to modifyAllocations created an INCREASE in allocation + /// - effectBlock for the increase HAS NOT been reached + function check_IncrAlloc_State_Slashable_Pending( + User operator, + AllocateParams memory params + ) private skipIfInstantAlloc(operator) { + OperatorSet memory operatorSet = params.operatorSet; + IStrategy[] memory strategies = params.strategies; + + // Validate operator has pending allocation and unchanged allocated/slashable stake + assert_HasPendingIncrease(operator, params, "params should reflect a pending modification"); + + // Should not have allocated magnitude + assert_Snap_Unchanged_AllocatedStake(operator, operatorSet, strategies, "should not have updated allocated stake in any way"); + assert_Snap_Unchanged_SlashableStake(operator, operatorSet, strategies, "should not have updated allocated stake in any way"); + } + + /// @dev Invariants for modifyAllocations. Used when: + /// - operator IS slashable for this operator set + /// - last call to modifyAllocations created an INCREASE in allocation + /// - effectBlock for the increase HAS been reached + function check_IncrAlloc_State_Slashable_Active( + User operator, + AllocateParams memory params + ) private activateAllocation(operator) { + // Validate operator does not have a pending modification, and has expected slashable stake + check_ActiveModification_State(operator, params); + + // SHOULD set current magnitude and increase slashable/allocated stake + assert_Snap_Set_CurrentMagnitude(operator, params, "should have updated the operator's magnitude"); + assert_HasAllocatedStake(operator, params, "operator should have expected allocated stake for each strategy"); + assert_HasSlashableStake(operator, params, "operator should have expected slashable stake for each strategy"); + assert_Snap_StakeBecameAllocated(operator, params.operatorSet, params.strategies, "allocated stake should have increased"); + assert_Snap_StakeBecameSlashable(operator, params.operatorSet, params.strategies, "slashable stake should have increased"); + } + + /******************************************************************************* + ALM - DECREASE ALLOCATION + *******************************************************************************/ + + /// @dev Basic invariants that should hold after all calls to `modifyAllocations` + /// where the input `params` represent a decrease in magnitude + function check_Base_DecrAlloc_State( + User operator, + AllocateParams memory params + ) internal { + check_MaxMag_Invariants(operator); + + OperatorSet memory operatorSet = params.operatorSet; + IStrategy[] memory strategies = params.strategies; + uint64[] memory newMagnitudes = params.newMagnitudes; + + // Decreasing Allocation should NOT change operator set registration, max magnitude + assert_Snap_Unchanged_Registration(operator, operatorSet, "operator registration status should be unchanged"); + assert_Snap_Unchanged_Slashability(operator, operatorSet, "operator slashability should be unchanged"); + assert_Snap_Unchanged_RegisteredSet(operator, "list of registered sets should remain unchanged"); + assert_Snap_Unchanged_MemberOfSet(operatorSet, "list of set members should remain unchanged"); + assert_Snap_Unchanged_MaxMagnitude(operator, allStrats, "should not have updated max magnitudes in any way"); + } + + function check_DecrAlloc_State_NotSlashable( + User operator, + AllocateParams memory params + ) internal { + OperatorSet memory operatorSet = params.operatorSet; + IStrategy[] memory strategies = params.strategies; + + check_Base_DecrAlloc_State(operator, params); + check_NotSlashable_State(operator, operatorSet); + check_ActiveModification_State(operator, params); + + // SHOULD set current magnitude and decrease allocated stake + assert_HasAllocatedStake(operator, params, "operator should have expected allocated stake for each strategy"); + assert_Snap_Set_CurrentMagnitude(operator, params, "should have updated the operator's magnitude"); + assert_Snap_StakeBecameDeallocated(operator, operatorSet, strategies, "allocated stake should have increased"); + assert_Snap_Deallocated_Magnitude(operator, strategies, "should have deallocated magnitude"); + } + + function check_DecrAlloc_State_Slashable( + User operator, + AllocateParams memory params + ) internal { + check_Base_DecrAlloc_State(operator, params); + check_IsSlashable_State(operator, params.operatorSet, params.strategies); + + // Run checks on pending deallocation + check_DecrAlloc_State_Slashable_Pending(operator, params); + + // Run checks on active deallocation + check_DecrAlloc_State_Slashable_Active(operator, params); + } + + function check_DecrAlloc_State_Slashable_Pending( + User operator, + AllocateParams memory params + ) private { + // Validate deallocation is pending + assert_HasPendingDecrease(operator, params, "params should reflect a pending modification"); + + // Should NOT have changed allocated magnitude or stake + assert_Snap_Unchanged_EncumberedMagnitude(operator, params.strategies, "should not have changed encumbered magnitude"); + assert_Snap_Unchanged_AllocatableMagnitude(operator, params.strategies, "should not have changed allocatable magnitude"); + assert_Snap_Unchanged_AllocatedSets(operator, "should not have removed operator set from allocated sets"); + assert_Snap_Unchanged_AllocatedStake(operator, params.operatorSet, params.strategies, "should not have updated allocated stake in any way"); + assert_Snap_Unchanged_SlashableStake(operator, params.operatorSet, params.strategies, "should not have updated allocated stake in any way"); + } + + function check_DecrAlloc_State_Slashable_Active( + User operator, + AllocateParams memory params + ) private activateDeallocation() { + OperatorSet memory operatorSet = params.operatorSet; + IStrategy[] memory strategies = params.strategies; + + check_ActiveModification_State(operator, params); + + // SHOULD set current magnitude and decrease allocated stake + assert_Snap_Set_CurrentMagnitude(operator, params, "should have updated the operator's magnitude"); + assert_HasAllocatedStake(operator, params, "operator should have expected allocated stake for each strategy"); + assert_HasSlashableStake(operator, params, "operator should have expected slashable stake for each strategy"); + + assert_Snap_StakeBecomeUnslashable(operator, operatorSet, strategies, "slashable stake should have decreased"); + assert_Snap_StakeBecameDeallocated(operator, params.operatorSet, params.strategies, "allocated stake should have decreased"); + assert_Snap_Deallocated_Magnitude(operator, strategies, "should have deallocated magnitude"); + } + + function check_FullyDeallocated_State( + User operator, + AllocateParams memory allocateParams, + AllocateParams memory deallocateParams + ) internal { + OperatorSet memory operatorSet = allocateParams.operatorSet; + assert_NoSlashableStake(operator, operatorSet, "should not have any slashable stake"); + // TODO - broken; do we want to fix this? + // assert_Snap_Removed_AllocatedSet(operator, operatorSet, "should have removed operator set from allocated sets"); + + // Any instant deallocation + assert_Snap_Removed_EncumberedMagnitude(operator, allocateParams.strategies, allocateParams.newMagnitudes, "should have removed allocation from encumbered magnitude"); + assert_Snap_Added_AllocatableMagnitude(operator, allocateParams.strategies, allocateParams.newMagnitudes, "should have added allocation to allocatable magnitude"); + assert_Snap_Unchanged_MaxMagnitude(operator, allStrats, "max magnitude should not have changed"); + + assert_MaxEqualsAllocatablePlusEncumbered(operator, "max magnitude should equal encumbered plus allocatable"); + check_ActiveModification_State(operator, deallocateParams); + } + + /******************************************************************************* + ALM - SLASHING + *******************************************************************************/ + + function check_Base_Slashing_State( + User operator, + AllocateParams memory allocateParams, + SlashingParams memory slashParams + ) internal { + OperatorSet memory operatorSet = allocateParams.operatorSet; + + check_MaxMag_Invariants(operator); + check_IsSlashable_State(operator, operatorSet, allocateParams.strategies); + + // Slashing SHOULD change max magnitude and current allocation + assert_Snap_Slashed_MaxMagnitude(operator, slashParams, "slash should lower max magnitude"); + assert_Snap_Slashed_EncumberedMagnitude(operator, slashParams, "slash should lower max magnitude"); + assert_Snap_Slashed_AllocatedStake(operator, operatorSet, slashParams, "slash should lower allocated stake"); + assert_Snap_Slashed_SlashableStake(operator, operatorSet, slashParams, "slash should lower slashable stake"); + assert_Snap_Slashed_OperatorShares(operator, slashParams, "slash should remove operator shares"); + assert_Snap_Slashed_Allocation(operator, operatorSet, slashParams, "slash should reduce current magnitude"); + assert_Snap_Increased_BurnableShares(operator, slashParams, "slash should increase burnable shares"); + + // Slashing SHOULD NOT change allocatable magnitude, registration, and slashability status + assert_Snap_Unchanged_AllocatableMagnitude(operator, allStrats, "slashing should not change allocatable magnitude"); + assert_Snap_Unchanged_Registration(operator, operatorSet, "slash should not change registration status"); + assert_Snap_Unchanged_Slashability(operator, operatorSet, "slash should not change slashability status"); + assert_Snap_Unchanged_AllocatedSets(operator, "should not have updated allocated sets"); + assert_Snap_Unchanged_AllocatedStrats(operator, operatorSet, "should not have updated allocated strategies"); + } + // TODO: improvement needed function check_Withdrawal_AsTokens_State_AfterSlash( User staker, User operator, - IDelegationManagerTypes.Withdrawal memory withdrawal, - IAllocationManagerTypes.AllocateParams memory allocateParams, - IAllocationManagerTypes.SlashingParams memory slashingParams, + Withdrawal memory withdrawal, + AllocateParams memory allocateParams, + SlashingParams memory slashingParams, uint[] memory expectedTokens ) internal { IERC20[] memory tokens = new IERC20[](withdrawal.strategies.length); @@ -377,8 +957,9 @@ contract IntegrationCheckUtils is IntegrationBase { // Common checks assert_WithdrawalNotPending(delegationManager.calculateWithdrawalRoot(withdrawal), "staker withdrawal should no longer be pending"); + // TODO FIXME // assert_Snap_Added_TokenBalances(staker, tokens, expectedTokens, "staker should have received expected tokens"); - assert_Snap_Unchanged_StakerDepositShares(staker, "staker shares should not have changed"); + assert_Snap_Unchanged_Staker_DepositShares(staker, "staker shares should not have changed"); assert_Snap_Removed_StrategyShares(withdrawal.strategies, withdrawal.scaledShares, "strategies should have total shares decremented"); // Checks specific to an operator that the Staker has delegated to @@ -443,9 +1024,9 @@ contract IntegrationCheckUtils is IntegrationBase { function check_Withdrawal_AsShares_State_AfterSlash( User staker, User operator, - IDelegationManagerTypes.Withdrawal memory withdrawal, - IAllocationManagerTypes.AllocateParams memory allocateParams, // TODO - was this needed? - IAllocationManagerTypes.SlashingParams memory slashingParams + Withdrawal memory withdrawal, + AllocateParams memory allocateParams, // TODO - was this needed? + SlashingParams memory slashingParams ) internal { IERC20[] memory tokens = new IERC20[](withdrawal.strategies.length); diff --git a/src/test/integration/IntegrationDeployer.t.sol b/src/test/integration/IntegrationDeployer.t.sol index 4f5b07cd7b..90811262cd 100644 --- a/src/test/integration/IntegrationDeployer.t.sol +++ b/src/test/integration/IntegrationDeployer.t.sol @@ -10,6 +10,7 @@ import "@openzeppelin/contracts/proxy/beacon/UpgradeableBeacon.sol"; import "forge-std/Test.sol"; import "src/contracts/core/DelegationManager.sol"; +import "src/contracts/core/AllocationManager.sol"; import "src/contracts/core/StrategyManager.sol"; import "src/contracts/strategies/StrategyFactory.sol"; import "src/contracts/strategies/StrategyBase.sol"; @@ -30,20 +31,6 @@ import "src/test/integration/users/User_M2.t.sol"; import "script/utils/ExistingDeploymentParser.sol"; -// DelegationManager -uint8 constant PAUSED_NEW_DELEGATION = 0; -uint8 constant PAUSED_ENTER_WITHDRAWAL_QUEUE = 1; -uint8 constant PAUSED_EXIT_WITHDRAWAL_QUEUE = 2; -// StrategyManager -uint8 constant PAUSED_DEPOSITS = 0; -// EigenpodManager -uint8 constant PAUSED_NEW_EIGENPODS = 0; -uint8 constant PAUSED_WITHDRAW_RESTAKED_ETH = 1; -uint8 constant PAUSED_EIGENPODS_VERIFY_CREDENTIALS = 2; -uint8 constant PAUSED_EIGENPODS_VERIFY_BALANCE_UPDATE = 3; -uint8 constant PAUSED_EIGENPODS_VERIFY_WITHDRAWAL = 4; -uint8 constant PAUSED_NON_PROOF_WITHDRAWALS = 5; - IStrategy constant beaconChainETHStrategy = IStrategy(0xbeaC0eeEeeeeEEeEeEEEEeeEEeEeeeEeeEEBEaC0); abstract contract IntegrationDeployer is ExistingDeploymentParser { @@ -51,21 +38,20 @@ abstract contract IntegrationDeployer is ExistingDeploymentParser { // Fork ids for specific fork tests bool isUpgraded; - uint mainnetForkBlock = 20_847_130; // Post PI upgrade - uint mainnetForkId; - uint holeskyForkBLock = 1_213_950; - uint holeskyForkId; - uint64 constant DENEB_FORK_TIMESTAMP = 1_705_473_120; + uint mainnetForkBlock = 21_616_692; // Post Protocol Council upgrade + + string version = "v9.9.9"; // Beacon chain genesis time when running locally // Multiple of 12 for sanity's sake uint64 constant GENESIS_TIME_LOCAL = 1 hours * 12; uint64 constant GENESIS_TIME_MAINNET = 1_606_824_023; + uint64 BEACON_GENESIS_TIME; // set after forkType is decided - uint8 constant NUM_LST_STRATS = 32; - - TimeMachine public timeMachine; + // Beacon chain deposit contract. The BeaconChainMock contract etchs ETHPOSDepositMock code here. + IETHPOSDeposit constant DEPOSIT_CONTRACT = IETHPOSDeposit(0x00000000219ab540356cBB839Cbe05303d7705Fa); + uint8 constant NUM_LST_STRATS = 32; // Lists of strategies used in the system // // When we select random user assets, we use the `assetType` to determine @@ -74,16 +60,16 @@ abstract contract IntegrationDeployer is ExistingDeploymentParser { IStrategy[] ethStrats; // only has one strat tbh IStrategy[] allStrats; // just a combination of the above 2 lists IERC20[] allTokens; // `allStrats`, but contains all of the underlying tokens instead + uint maxUniqueAssetsHeld; // If a token is in this mapping, then we will ignore this LST as it causes issues with reading balanceOf mapping(address => bool) public tokensNotTested; // Mock Contracts to deploy - ETHPOSDepositMock ethPOSDeposit; + TimeMachine public timeMachine; BeaconChainMock public beaconChain; // Admin Addresses - address eigenLayerReputedMultisig = address(this); // admin address address constant pauser = address(555); address constant unpauser = address(556); @@ -96,8 +82,26 @@ abstract contract IntegrationDeployer is ExistingDeploymentParser { // Set only once in setUp, if FORK_MAINNET env is set uint forkType; - // Constants - uint64 constant MAX_RESTAKED_BALANCE_GWEI_PER_VALIDATOR = 32e9; + /// @dev used to configure randomness and default user/asset types + /// + /// Tests that want alternate user/asset types can still use this modifier, + /// and then configure user/asset types individually using the methods: + /// _configAssetTypes(...) + /// _configUserTypes(...) + /// + /// (Alternatively, this modifier can be overwritten) + modifier rand(uint24 r) virtual { + _configRand({ + _randomSeed: r, + _assetTypes: HOLDS_LST | HOLDS_ETH | HOLDS_ALL, + _userTypes: DEFAULT | ALT_METHODS + }); + + // Used to create shared setups between tests + _init(); + + _; + } constructor() { address stETH_Holesky = 0x3F1c547b21f65e10480dE3ad8E19fAAC46C95034; @@ -112,6 +116,10 @@ abstract contract IntegrationDeployer is ExistingDeploymentParser { tokensNotTested[osETH_Holesky] = true; tokensNotTested[osETH_Mainnet] = true; tokensNotTested[cbETH_Holesky] = true; + + // Use current contracts by default. Upgrade tests are only run with mainnet fork tests + // using the `UpgradeTest.t.sol` mixin. + isUpgraded = true; } function NAME() public view virtual override returns (string memory) { @@ -126,33 +134,37 @@ abstract contract IntegrationDeployer is ExistingDeploymentParser { * Note that forkIds are also created so you can make explicit fork tests using cheats.selectFork(forkId) */ function setUp() public virtual { - isUpgraded = false; - - /** - * env FOUNDRY_PROFILE=forktest forge t --mc Integration - * - * Running foundry like this will trigger the fork test profile, - * lowering fuzz runs and using a remote RPC to test against mainnet state - */ - bool forkMainnet = _hash("forktest") == _hash(cheats.envOr(string("FOUNDRY_PROFILE"), string("default"))); + bool forkMainnet = isForktest(); if (forkMainnet) { - console.log("Setting up `%s` integration tests:", "MAINNET_FORK".green().bold()); - console.log("RPC:", cheats.rpcUrl("mainnet")); - console.log("Block:", mainnetForkBlock); - - cheats.createSelectFork(cheats.rpcUrl("mainnet"), mainnetForkBlock); forkType = MAINNET; + _setUpMainnet(); } else { - console.log("Setting up `%s` integration tests:", "LOCAL".yellow().bold()); - forkType = LOCAL; + _setUpLocal(); } + } - _deployOrFetchContracts(); + /// @dev Used to create shared setup between tests. This method is called + /// when the `rand` modifier is run, before a test starts + function _init() internal virtual { + return; } - function _setUpLocal() public virtual { + /** + * env FOUNDRY_PROFILE=forktest forge t --mc Integration + * + * Running foundry like this will trigger the fork test profile, + * lowering fuzz runs and using a remote RPC to test against mainnet state + */ + function isForktest() public view returns (bool) { + return _hash("forktest") == _hash(cheats.envOr(string("FOUNDRY_PROFILE"), string("default"))); + } + + /// Deploy EigenLayer locally + function _setUpLocal() public noTracing virtual { + console.log("Setting up `%s` integration tests:", "LOCAL".yellow().bold()); + // Deploy ProxyAdmin eigenLayerProxyAdmin = new ProxyAdmin(); executorMultisig = address(eigenLayerProxyAdmin.owner()); @@ -163,138 +175,25 @@ abstract contract IntegrationDeployer is ExistingDeploymentParser { eigenLayerPauserReg = new PauserRegistry(pausers, unpauser); // Deploy mocks - EmptyContract emptyContract = new EmptyContract(); - ethPOSDeposit = new ETHPOSDepositMock(); + emptyContract = new EmptyContract(); // Matching parameters to testnet DELEGATION_MANAGER_MIN_WITHDRAWAL_DELAY_BLOCKS = 50; DEALLOCATION_DELAY = 50; ALLOCATION_CONFIGURATION_DELAY = 75; - /** - * First, deploy upgradeable proxy contracts that **will point** to the implementations. Since the implementation contracts are - * not yet deployed, we give these proxies an empty contract as the initial implementation, to act as if they have no code. - */ - delegationManager = DelegationManager( - address(new TransparentUpgradeableProxy(address(emptyContract), address(eigenLayerProxyAdmin), "")) - ); - strategyManager = StrategyManager( - address(new TransparentUpgradeableProxy(address(emptyContract), address(eigenLayerProxyAdmin), "")) - ); - eigenPodManager = EigenPodManager( - address(new TransparentUpgradeableProxy(address(emptyContract), address(eigenLayerProxyAdmin), "")) - ); - avsDirectory = AVSDirectory( - address(new TransparentUpgradeableProxy(address(emptyContract), address(eigenLayerProxyAdmin), "")) - ); - strategyFactory = StrategyFactory( - address(new TransparentUpgradeableProxy(address(emptyContract), address(eigenLayerProxyAdmin), "")) - ); - allocationManager = AllocationManager( - address(new TransparentUpgradeableProxy(address(emptyContract), address(eigenLayerProxyAdmin), "")) - ); - permissionController = PermissionController( - address(new TransparentUpgradeableProxy(address(emptyContract), address(eigenLayerProxyAdmin), "")) - ); - - // Deploy EigenPod Contracts - eigenPodImplementation = new EigenPod(ethPOSDeposit, eigenPodManager, GENESIS_TIME_LOCAL); - - eigenPodBeacon = new UpgradeableBeacon(address(eigenPodImplementation)); - // Second, deploy the *implementation* contracts, using the *proxy contracts* as inputs - delegationManagerImplementation = new DelegationManager(strategyManager, eigenPodManager, allocationManager, eigenLayerPauserReg, permissionController, DELEGATION_MANAGER_MIN_WITHDRAWAL_DELAY_BLOCKS); - strategyManagerImplementation = new StrategyManager(delegationManager, eigenLayerPauserReg); - eigenPodManagerImplementation = new EigenPodManager( - ethPOSDeposit, - eigenPodBeacon, - delegationManager, - eigenLayerPauserReg - ); - strategyManagerImplementation = new StrategyManager(delegationManager, eigenLayerPauserReg); - eigenPodManagerImplementation = new EigenPodManager(ethPOSDeposit, eigenPodBeacon, delegationManager, eigenLayerPauserReg); - avsDirectoryImplementation = new AVSDirectory(delegationManager, eigenLayerPauserReg); - strategyFactoryImplementation = new StrategyFactory(strategyManager, eigenLayerPauserReg); - allocationManagerImplementation = new AllocationManager(delegationManager, eigenLayerPauserReg, permissionController, DEALLOCATION_DELAY, ALLOCATION_CONFIGURATION_DELAY); - permissionControllerImplementation = new PermissionController(); - - // Third, upgrade the proxy contracts to point to the implementations - // DelegationManager - eigenLayerProxyAdmin.upgradeAndCall( - ITransparentUpgradeableProxy(payable(address(delegationManager))), - address(delegationManagerImplementation), - abi.encodeWithSelector( - DelegationManager.initialize.selector, - eigenLayerReputedMultisig, // initialOwner - 0 /* initialPausedStatus */ - ) - ); - // StrategyManager - eigenLayerProxyAdmin.upgradeAndCall( - ITransparentUpgradeableProxy(payable(address(strategyManager))), - address(strategyManagerImplementation), - abi.encodeWithSelector( - StrategyManager.initialize.selector, - eigenLayerReputedMultisig, //initialOwner - eigenLayerReputedMultisig, //initial whitelister - 0 // initialPausedStatus - ) - ); - // EigenPodManager - eigenLayerProxyAdmin.upgradeAndCall( - ITransparentUpgradeableProxy(payable(address(eigenPodManager))), - address(eigenPodManagerImplementation), - abi.encodeWithSelector( - EigenPodManager.initialize.selector, - eigenLayerReputedMultisig, // initialOwner - 0 // initialPausedStatus - ) - ); - // AVSDirectory - eigenLayerProxyAdmin.upgradeAndCall( - ITransparentUpgradeableProxy(payable(address(avsDirectory))), - address(avsDirectoryImplementation), - abi.encodeWithSelector( - AVSDirectory.initialize.selector, - eigenLayerReputedMultisig, // initialOwner - 0 // initialPausedStatus - ) - ); - // AllocationManager - eigenLayerProxyAdmin.upgradeAndCall( - ITransparentUpgradeableProxy(payable(address(allocationManager))), - address(allocationManagerImplementation), - abi.encodeWithSelector( - AllocationManager.initialize.selector, - eigenLayerReputedMultisig, // initialOwner - 0 // initialPausedStatus - ) - ); - //PermissionController - eigenLayerProxyAdmin.upgrade( - ITransparentUpgradeableProxy(payable(address(permissionController))), - address(permissionControllerImplementation) - ); - // Create base strategy implementation and deploy a few strategies - baseStrategyImplementation = new StrategyBase(strategyManager, eigenLayerPauserReg); - - // Create a proxy beacon for base strategy implementation - strategyBeacon = new UpgradeableBeacon(address(baseStrategyImplementation)); + REWARDS_COORDINATOR_CALCULATION_INTERVAL_SECONDS = 86400; + REWARDS_COORDINATOR_MAX_REWARDS_DURATION = 6048000; + REWARDS_COORDINATOR_MAX_RETROACTIVE_LENGTH = 7776000; + REWARDS_COORDINATOR_MAX_FUTURE_LENGTH = 2592000; + REWARDS_COORDINATOR_GENESIS_REWARDS_TIMESTAMP = 1710979200; - // Strategy Factory, upgrade and initalized - eigenLayerProxyAdmin.upgradeAndCall( - ITransparentUpgradeableProxy(payable(address(strategyFactory))), - address(strategyFactoryImplementation), - abi.encodeWithSelector( - StrategyFactory.initialize.selector, - eigenLayerReputedMultisig, - 0, // initial paused status - IBeacon(strategyBeacon) - ) - ); - - cheats.prank(eigenLayerReputedMultisig); - strategyManager.setStrategyWhitelister(address(strategyFactory)); + _deployProxies(); + _deployImplementations(); + _upgradeProxies(); + _initializeProxies(); + // Deploy and configure strategies and tokens for (uint i = 1; i < NUM_LST_STRATS + 1; ++i) { string memory name = string.concat("LST-Strat", cheats.toString(i), " token"); string memory symbol = string.concat("lstStrat", cheats.toString(i)); @@ -305,26 +204,59 @@ abstract contract IntegrationDeployer is ExistingDeploymentParser { ethStrats.push(BEACONCHAIN_ETH_STRAT); allStrats.push(BEACONCHAIN_ETH_STRAT); allTokens.push(NATIVE_ETH); + maxUniqueAssetsHeld = allStrats.length; // Create time machine and beacon chain. Set block time to beacon chain genesis time - // TODO: update if needed to sane timestamp - cheats.warp(GENESIS_TIME_LOCAL); + BEACON_GENESIS_TIME = GENESIS_TIME_LOCAL; + cheats.warp(BEACON_GENESIS_TIME); timeMachine = new TimeMachine(); - beaconChain = new BeaconChainMock(eigenPodManager, GENESIS_TIME_LOCAL); + beaconChain = new BeaconChainMock(eigenPodManager, BEACON_GENESIS_TIME); + } + + /// Parse existing contracts from mainnet + function _setUpMainnet() public noTracing virtual { + console.log("Setting up `%s` integration tests:", "MAINNET_FORK".green().bold()); + console.log("RPC:", cheats.rpcUrl("mainnet")); + console.log("Block:", mainnetForkBlock); + + cheats.createSelectFork(cheats.rpcUrl("mainnet"), mainnetForkBlock); + + string memory deploymentInfoPath = "script/configs/mainnet/mainnet-addresses.config.json"; + _parseDeployedContracts(deploymentInfoPath); + string memory existingDeploymentParams = "script/configs/mainnet.json"; + _parseParamsForIntegrationUpgrade(existingDeploymentParams); + + // Add deployed strategies to lstStrats and allStrats + for (uint i; i < deployedStrategyArray.length; i++) { + IStrategy strategy = IStrategy(deployedStrategyArray[i]); + + if (tokensNotTested[address(strategy.underlyingToken())]) { + continue; + } + + // Add to lstStrats and allStrats + lstStrats.push(strategy); + allStrats.push(strategy); + allTokens.push(strategy.underlyingToken()); + } + + maxUniqueAssetsHeld = allStrats.length; + + // Create time machine and mock beacon chain + BEACON_GENESIS_TIME = GENESIS_TIME_MAINNET; + timeMachine = new TimeMachine(); + beaconChain = new BeaconChainMock(eigenPodManager, BEACON_GENESIS_TIME); + + // Since we haven't done the slashing upgrade on mainnet yet, upgrade mainnet contracts + // prior to test. `isUpgraded` is true by default, but is set to false in `UpgradeTest.t.sol` + if (isUpgraded) { + _upgradeMainnetContracts(); + } } - /** - * @notice deploy current implementation contracts and upgrade the existing proxy EigenLayer contracts - * on Mainnet. Setup for integration tests on mainnet fork. - * - * Note that beacon chain oracle and eth deposit contracts are mocked and pointed to different addresses for these tests. - */ function _upgradeMainnetContracts() public virtual { cheats.startPrank(address(executorMultisig)); - ethPOSDeposit = new ETHPOSDepositMock(); - ETHPOSDepositAddress = address(ethPOSDeposit); // overwrite for upgrade checks later - // First, deploy the new contracts as empty contracts emptyContract = new EmptyContract(); allocationManager = AllocationManager( @@ -334,160 +266,165 @@ abstract contract IntegrationDeployer is ExistingDeploymentParser { address(new TransparentUpgradeableProxy(address(emptyContract), address(eigenLayerProxyAdmin), "")) ); - // Second, deploy the *implementation* contracts, using the *proxy contracts* as inputs - allocationManagerImplementation = new AllocationManager(delegationManager, eigenLayerPauserReg, permissionController, DEALLOCATION_DELAY, ALLOCATION_CONFIGURATION_DELAY); - permissionControllerImplementation = new PermissionController(); - delegationManagerImplementation = new DelegationManager(strategyManager, eigenPodManager, allocationManager, eigenLayerPauserReg, permissionController, DELEGATION_MANAGER_MIN_WITHDRAWAL_DELAY_BLOCKS); - strategyManagerImplementation = new StrategyManager(delegationManager, eigenLayerPauserReg); - rewardsCoordinatorImplementation = new RewardsCoordinator( - delegationManager, - strategyManager, - allocationManager, - eigenLayerPauserReg, - permissionController, - REWARDS_COORDINATOR_CALCULATION_INTERVAL_SECONDS, - REWARDS_COORDINATOR_MAX_REWARDS_DURATION, - REWARDS_COORDINATOR_MAX_RETROACTIVE_LENGTH, - REWARDS_COORDINATOR_MAX_FUTURE_LENGTH, - REWARDS_COORDINATOR_GENESIS_REWARDS_TIMESTAMP - ); - avsDirectoryImplementation = new AVSDirectory(delegationManager, eigenLayerPauserReg); - eigenPodManagerImplementation = new EigenPodManager( - ethPOSDeposit, - eigenPodBeacon, - delegationManager, - eigenLayerPauserReg - ); - eigenPodImplementation = new EigenPod(ethPOSDeposit, eigenPodManager, GENESIS_TIME_MAINNET); - strategyFactoryImplementation = new StrategyFactory(strategyManager, eigenLayerPauserReg); - baseStrategyImplementation = new StrategyBase(strategyManager, eigenLayerPauserReg); + emit log_named_uint("EPM pause status", eigenPodManager.paused()); - // Third, upgrade the proxy contracts to point to the implementations - - // Initialize the newly deployed contracts - eigenLayerProxyAdmin.upgradeAndCall( - ITransparentUpgradeableProxy(payable(address(allocationManager))), - address(allocationManagerImplementation), - abi.encodeWithSelector( - AllocationManager.initialize.selector, - executorMultisig, - 0 // initialPausedStatus - ) - ); - eigenLayerProxyAdmin.upgrade( - ITransparentUpgradeableProxy(payable(address(permissionController))), - address(permissionControllerImplementation) - ); - - // DelegationManager - eigenLayerProxyAdmin.upgrade( - ITransparentUpgradeableProxy(payable(address(delegationManager))), address(delegationManagerImplementation) - ); - // StrategyManager - eigenLayerProxyAdmin.upgrade( - ITransparentUpgradeableProxy(payable(address(strategyManager))), address(strategyManagerImplementation) - ); - // RewardsCoordinator - eigenLayerProxyAdmin.upgrade( - ITransparentUpgradeableProxy(payable(address(rewardsCoordinator))), address(rewardsCoordinatorImplementation) - ); - // AVSDirectory - eigenLayerProxyAdmin.upgrade( - ITransparentUpgradeableProxy(payable(address(avsDirectory))), address(avsDirectoryImplementation) - ); - // EigenPodManager - eigenLayerProxyAdmin.upgrade( - ITransparentUpgradeableProxy(payable(address(eigenPodManager))), address(eigenPodManagerImplementation) - ); - // EigenPod - eigenPodBeacon.upgradeTo(address(eigenPodImplementation)); - // StrategyFactory - eigenLayerProxyAdmin.upgrade( - ITransparentUpgradeableProxy(payable(address(strategyFactory))), address(strategyFactoryImplementation) - ); - // Strategy Beacon - strategyBeacon.upgradeTo(address(baseStrategyImplementation)); + // Deploy new implementation contracts and upgrade all proxies to point to them + _deployImplementations(); + _upgradeProxies(); - // Upgrade All deployed strategy contracts to new base strategy - for (uint i = 0; i < numStrategiesDeployed; i++) { - // Upgrade existing strategy - eigenLayerProxyAdmin.upgrade( - ITransparentUpgradeableProxy(payable(address(deployedStrategyArray[i]))), - address(baseStrategyImplementation) - ); - } + emit log_named_uint("EPM pause status", eigenPodManager.paused()); - // Third, unpause core contracts - delegationManager.unpause(0); - eigenPodManager.unpause(0); - strategyManager.unpause(0); + // Initialize the newly-deployed proxy + allocationManager.initialize({ + initialOwner: executorMultisig, + initialPausedStatus: 0 + }); cheats.stopPrank(); ethStrats.push(BEACONCHAIN_ETH_STRAT); allStrats.push(BEACONCHAIN_ETH_STRAT); allTokens.push(NATIVE_ETH); + maxUniqueAssetsHeld = allStrats.length; } - /** - * @notice deploy current implementation contracts and upgrade the existing proxy EigenLayer contracts - * on Holesky. Setup for integration tests on Holesky fork. - * - * Note that beacon chain oracle and eth deposit contracts are mocked and pointed to different addresses for these tests. - */ - function _upgradeHoleskyContracts() public virtual { - cheats.startPrank(address(executorMultisig)); - - ethPOSDeposit = new ETHPOSDepositMock(); - ETHPOSDepositAddress = address(ethPOSDeposit); // overwrite for upgrade checks later - - // Deploy EigenPod Contracts - eigenPodImplementation = new EigenPod(ethPOSDeposit, eigenPodManager, 0); - eigenPodBeacon.upgradeTo(address(eigenPodImplementation)); - // Deploy AVSDirectory, contract has not been deployed on mainnet yet + function _deployProxies() public { + delegationManager = DelegationManager( + address(new TransparentUpgradeableProxy(address(emptyContract), address(eigenLayerProxyAdmin), "")) + ); + strategyManager = StrategyManager( + address(new TransparentUpgradeableProxy(address(emptyContract), address(eigenLayerProxyAdmin), "")) + ); + eigenPodManager = EigenPodManager( + address(new TransparentUpgradeableProxy(address(emptyContract), address(eigenLayerProxyAdmin), "")) + ); + rewardsCoordinator = RewardsCoordinator( + address(new TransparentUpgradeableProxy(address(emptyContract), address(eigenLayerProxyAdmin), "")) + ); avsDirectory = AVSDirectory( address(new TransparentUpgradeableProxy(address(emptyContract), address(eigenLayerProxyAdmin), "")) ); + strategyFactory = StrategyFactory( + address(new TransparentUpgradeableProxy(address(emptyContract), address(eigenLayerProxyAdmin), "")) + ); + allocationManager = AllocationManager( + address(new TransparentUpgradeableProxy(address(emptyContract), address(eigenLayerProxyAdmin), "")) + ); + permissionController = PermissionController( + address(new TransparentUpgradeableProxy(address(emptyContract), address(eigenLayerProxyAdmin), "")) + ); + eigenPodBeacon = new UpgradeableBeacon(address(emptyContract)); + strategyBeacon = new UpgradeableBeacon(address(emptyContract)); + } - // First, deploy the *implementation* contracts, using the *proxy contracts* as inputs - delegationManagerImplementation = new DelegationManager(strategyManager, eigenPodManager, allocationManager, eigenLayerPauserReg, permissionController, DELEGATION_MANAGER_MIN_WITHDRAWAL_DELAY_BLOCKS); - strategyManagerImplementation = new StrategyManager(delegationManager, eigenLayerPauserReg); + /// Deploy an implementation contract for each contract in the system + function _deployImplementations() public { + allocationManagerImplementation = new AllocationManager( + delegationManager, + eigenLayerPauserReg, + permissionController, + DEALLOCATION_DELAY, + ALLOCATION_CONFIGURATION_DELAY, + version + ); + permissionControllerImplementation = new PermissionController(version); + delegationManagerImplementation = new DelegationManager( + strategyManager, + eigenPodManager, + allocationManager, + eigenLayerPauserReg, + permissionController, + DELEGATION_MANAGER_MIN_WITHDRAWAL_DELAY_BLOCKS, + version + ); + strategyManagerImplementation = new StrategyManager(delegationManager, eigenLayerPauserReg, version); + rewardsCoordinatorImplementation = new RewardsCoordinator( + IRewardsCoordinatorTypes.RewardsCoordinatorConstructorParams({ + delegationManager: delegationManager, + strategyManager: strategyManager, + allocationManager: allocationManager, + pauserRegistry: eigenLayerPauserReg, + permissionController: permissionController, + CALCULATION_INTERVAL_SECONDS: REWARDS_COORDINATOR_CALCULATION_INTERVAL_SECONDS, + MAX_REWARDS_DURATION: REWARDS_COORDINATOR_MAX_REWARDS_DURATION, + MAX_RETROACTIVE_LENGTH: REWARDS_COORDINATOR_MAX_RETROACTIVE_LENGTH, + MAX_FUTURE_LENGTH: REWARDS_COORDINATOR_MAX_FUTURE_LENGTH, + GENESIS_REWARDS_TIMESTAMP: REWARDS_COORDINATOR_GENESIS_REWARDS_TIMESTAMP, + version: version + }) + ); + avsDirectoryImplementation = new AVSDirectory(delegationManager, eigenLayerPauserReg, version); eigenPodManagerImplementation = new EigenPodManager( - ethPOSDeposit, + DEPOSIT_CONTRACT, eigenPodBeacon, delegationManager, - eigenLayerPauserReg + eigenLayerPauserReg, + "v9.9.9" ); - strategyManagerImplementation = new StrategyManager(delegationManager, eigenLayerPauserReg); - eigenPodManagerImplementation = new EigenPodManager(ethPOSDeposit, eigenPodBeacon, delegationManager, eigenLayerPauserReg); - avsDirectoryImplementation = new AVSDirectory(delegationManager, eigenLayerPauserReg); + strategyFactoryImplementation = new StrategyFactory(strategyManager, eigenLayerPauserReg, "v9.9.9"); + + // Beacon implementations + eigenPodImplementation = new EigenPod(DEPOSIT_CONTRACT, eigenPodManager, BEACON_GENESIS_TIME, "v9.9.9"); + baseStrategyImplementation = new StrategyBase(strategyManager, eigenLayerPauserReg, "v9.9.9"); - // Second, upgrade the proxy contracts to point to the implementations + // Pre-longtail StrategyBaseTVLLimits implementation + // TODO - need to update ExistingDeploymentParser + } + + function _upgradeProxies() public noTracing { // DelegationManager eigenLayerProxyAdmin.upgrade( - ITransparentUpgradeableProxy(payable(address(delegationManager))), address(delegationManagerImplementation) + ITransparentUpgradeableProxy(payable(address(delegationManager))), + address(delegationManagerImplementation) ); + // StrategyManager eigenLayerProxyAdmin.upgrade( - ITransparentUpgradeableProxy(payable(address(strategyManager))), address(strategyManagerImplementation) + ITransparentUpgradeableProxy(payable(address(strategyManager))), + address(strategyManagerImplementation) ); + // EigenPodManager eigenLayerProxyAdmin.upgrade( - ITransparentUpgradeableProxy(payable(address(eigenPodManager))), address(eigenPodManagerImplementation) + ITransparentUpgradeableProxy(payable(address(eigenPodManager))), + address(eigenPodManagerImplementation) + ); + + // RewardsCoordinator + eigenLayerProxyAdmin.upgrade( + ITransparentUpgradeableProxy(payable(address(rewardsCoordinator))), + address(rewardsCoordinatorImplementation) ); - // AVSDirectory, upgrade and initalized - eigenLayerProxyAdmin.upgradeAndCall( + + // AVSDirectory + eigenLayerProxyAdmin.upgrade( ITransparentUpgradeableProxy(payable(address(avsDirectory))), - address(avsDirectoryImplementation), - abi.encodeWithSelector( - AVSDirectory.initialize.selector, - executorMultisig, - 0 // initialPausedStatus - ) + address(avsDirectoryImplementation) + ); + + // AllocationManager + eigenLayerProxyAdmin.upgrade( + ITransparentUpgradeableProxy(payable(address(allocationManager))), + address(allocationManagerImplementation) + ); + + // PermissionController + eigenLayerProxyAdmin.upgrade( + ITransparentUpgradeableProxy(payable(address(permissionController))), + address(permissionControllerImplementation) ); - // Create base strategy implementation and deploy a few strategies - baseStrategyImplementation = new StrategyBase(strategyManager, eigenLayerPauserReg); + // StrategyFactory + eigenLayerProxyAdmin.upgrade( + ITransparentUpgradeableProxy(payable(address(strategyFactory))), + address(strategyFactoryImplementation) + ); + + // EigenPod beacon + eigenPodBeacon.upgradeTo(address(eigenPodImplementation)); + + // StrategyBase Beacon + strategyBeacon.upgradeTo(address(baseStrategyImplementation)); // Upgrade All deployed strategy contracts to new base strategy for (uint i = 0; i < numStrategiesDeployed; i++) { @@ -497,17 +434,40 @@ abstract contract IntegrationDeployer is ExistingDeploymentParser { address(baseStrategyImplementation) ); } + } - // Third, unpause core contracts - delegationManager.unpause(0); - eigenPodManager.unpause(0); - strategyManager.unpause(0); - - cheats.stopPrank(); - - ethStrats.push(BEACONCHAIN_ETH_STRAT); - allStrats.push(BEACONCHAIN_ETH_STRAT); - allTokens.push(NATIVE_ETH); + function _initializeProxies() public noTracing { + delegationManager.initialize({ + initialOwner: executorMultisig, + initialPausedStatus: 0 + }); + + strategyManager.initialize({ + initialOwner: executorMultisig, + initialStrategyWhitelister: address(strategyFactory), + initialPausedStatus: 0 + }); + + eigenPodManager.initialize({ + initialOwner: executorMultisig, + _initPausedStatus: 0 + }); + + avsDirectory.initialize({ + initialOwner: executorMultisig, + initialPausedStatus: 0 + }); + + allocationManager.initialize({ + initialOwner: executorMultisig, + initialPausedStatus: 0 + }); + + strategyFactory.initialize({ + _initialOwner: executorMultisig, + _initialPausedStatus: 0, + _strategyBeacon: strategyBeacon + }); } /// @dev Deploy a strategy and its underlying token, push to global lists of tokens/strategies, and whitelist @@ -518,7 +478,7 @@ abstract contract IntegrationDeployer is ExistingDeploymentParser { uint initialSupply, address owner, bool useFactory - ) internal { + ) internal noTracing { IERC20 underlyingToken = new ERC20PresetFixedSupply(tokenName, tokenSymbol, initialSupply, owner); StrategyBase strategy; @@ -541,15 +501,8 @@ abstract contract IntegrationDeployer is ExistingDeploymentParser { IStrategy[] memory strategies = new IStrategy[](1); strategies[0] = strategy; - if (forkType == MAINNET) { - cheats.prank(strategyManager.strategyWhitelister()); - IStrategyManager_DeprecatedM1(address(strategyManager)).addStrategiesToDepositWhitelist(strategies); - cheats.prank(eigenLayerPauserReg.unpauser()); - StrategyBaseTVLLimits(address(strategy)).setTVLLimits(type(uint).max, type(uint).max); - } else { - cheats.prank(strategyManager.strategyWhitelister()); - strategyManager.addStrategiesToDepositWhitelist(strategies); - } + cheats.prank(strategyManager.strategyWhitelister()); + strategyManager.addStrategiesToDepositWhitelist(strategies); // Add to lstStrats and allStrats lstStrats.push(strategy); @@ -557,100 +510,33 @@ abstract contract IntegrationDeployer is ExistingDeploymentParser { allTokens.push(underlyingToken); } - function _configRand(uint24 _randomSeed, uint _assetTypes, uint _userTypes) internal { + function _configRand(uint24 _randomSeed, uint _assetTypes, uint _userTypes) private noTracing { // Using uint24 for the seed type so that if a test fails, it's easier // to manually use the seed to replay the same test. random = _hash(_randomSeed); // Convert flag bitmaps to bytes of set bits for easy use with _randUint - assetTypes = _bitmapToBytes(_assetTypes); - userTypes = _bitmapToBytes(_userTypes); + _configAssetTypes(_assetTypes); + _configUserTypes(_userTypes); + } + function _configAssetTypes(uint _assetTypes) internal { + assetTypes = _bitmapToBytes(_assetTypes); assertTrue(assetTypes.length != 0, "_configRand: no asset types selected"); - assertTrue(userTypes.length != 0, "_configRand: no user types selected"); } - /** - * Depending on the forkType, either deploy contracts locally or parse existing contracts - * from network. - * - * Note: for non-LOCAL forktypes, upgrade of contracts will be peformed after user initialization. - */ - function _deployOrFetchContracts() internal { - if (forkType == LOCAL) { - _setUpLocal(); - // Set Upgraded as local setup deploys most up to date contracts - isUpgraded = true; - } else if (forkType == MAINNET) { - // cheats.selectFork(mainnetForkId); - string memory deploymentInfoPath = "script/configs/mainnet/mainnet-addresses.config.json"; - _parseDeployedContracts(deploymentInfoPath); - string memory existingDeploymentParams = "script/configs/mainnet.json"; - _parseParamsForIntegrationUpgrade(existingDeploymentParams); - - // Unpause to enable deposits and withdrawals for initializing random user state - cheats.prank(eigenLayerPauserReg.unpauser()); - strategyManager.unpause(0); - - // Add deployed strategies to lstStrats and allStrats - for (uint i; i < deployedStrategyArray.length; i++) { - IStrategy strategy = IStrategy(deployedStrategyArray[i]); - - if (tokensNotTested[address(strategy.underlyingToken())]) { - continue; - } - - // Add to lstStrats and allStrats - lstStrats.push(strategy); - allStrats.push(strategy); - allTokens.push(strategy.underlyingToken()); - } - - // Create time machine and mock beacon chain - timeMachine = new TimeMachine(); - beaconChain = new BeaconChainMock(eigenPodManager, GENESIS_TIME_MAINNET); - } else if (forkType == HOLESKY) { - revert("_deployOrFetchContracts - holesky tests currently broken sorry"); - // // cheats.selectFork(holeskyForkId); - // string memory deploymentInfoPath = "script/configs/holesky/Holesky_current_deployment.config.json"; - // _parseDeployedContracts(deploymentInfoPath); - - // // Add deployed strategies to lstStrats and allStrats - // for (uint i; i < deployedStrategyArray.length; i++) { - // IStrategy strategy = IStrategy(deployedStrategyArray[i]); - - // if (tokensNotTested[address(strategy.underlyingToken())]) { - // continue; - // } - - // // Add to lstStrats and allStrats - // lstStrats.push(strategy); - // allStrats.push(strategy); - // allTokens.push(strategy.underlyingToken()); - // } - - // // Update deposit contract to be a mock - // ethPOSDeposit = new ETHPOSDepositMock(); - // eigenPodImplementation = new EigenPod( - // ethPOSDeposit, - // eigenPodImplementation.delayedWithdrawalRouter(), - // eigenPodImplementation.eigenPodManager(), - // eigenPodImplementation.MAX_RESTAKED_BALANCE_GWEI_PER_VALIDATOR(), - // 0 - // ); - // // Create time machine and set block timestamp forward so we can create EigenPod proofs in the past - // timeMachine = new TimeMachine(); - // beaconChainOracle = new BeaconChainOracleMock(); - // // Create mock beacon chain / proof gen interface - // beaconChain = new BeaconChainMock(timeMachine, beaconChainOracle, eigenPodManager); - - // cheats.startPrank(executorMultisig); - // eigenPodBeacon.upgradeTo(address(eigenPodImplementation)); - // eigenPodManager.updateBeaconChainOracle(beaconChainOracle); - // cheats.stopPrank(); - } else { - revert("_deployOrFetchContracts: unimplemented forkType"); + function _configAssetAmounts(uint _maxUniqueAssetsHeld) internal { + if (_maxUniqueAssetsHeld > allStrats.length) { + _maxUniqueAssetsHeld = allStrats.length; } + + maxUniqueAssetsHeld = _maxUniqueAssetsHeld; + require(maxUniqueAssetsHeld != 0, "_configAssetAmounts: invalid 0"); + } + + function _configUserTypes(uint _userTypes) internal { + userTypes = _bitmapToBytes(_userTypes); + assertTrue(userTypes.length != 0, "_configRand: no user types selected"); } /** @@ -660,7 +546,7 @@ abstract contract IntegrationDeployer is ExistingDeploymentParser { */ function _randUser( string memory name - ) internal returns (User, IStrategy[] memory, uint[] memory) { + ) internal noTracing returns (User, IStrategy[] memory, uint[] memory) { // For the new user, select what type of assets they'll have and whether // they'll use `xWithSignature` methods. // @@ -682,7 +568,7 @@ abstract contract IntegrationDeployer is ExistingDeploymentParser { /// @dev Create a new user without native ETH. See _randUser above for standard usage function _randUser_NoETH( string memory name - ) internal returns (User, IStrategy[] memory, uint[] memory) { + ) internal noTracing returns (User, IStrategy[] memory, uint[] memory) { // For the new user, select what type of assets they'll have and whether // they'll use `xWithSignature` methods. // @@ -709,9 +595,26 @@ abstract contract IntegrationDeployer is ExistingDeploymentParser { return (user, strategies, tokenBalances); } + /// @dev Creates a new user without any assets + function _randUser_NoAssets( + string memory name + ) internal noTracing returns (User) { + // For the new user, select what type of assets they'll have and whether + // they'll use `xWithSignature` methods. + // + // The values selected here are in the ranges configured via `_configRand` + uint userType = _randUserType(); + + // Deploy new User contract + User user = _genRandUser(name, userType); + + print.user(name, NO_ASSETS, userType, new IStrategy[](0), new uint[](0)); + return user; + } + function _genRandUser(string memory name, uint userType) internal returns (User user) { // Create User contract based on userType: - if (forkType == LOCAL) { + if (forkType == LOCAL || (forkType == MAINNET && isUpgraded)) { user = new User(name); if (userType == DEFAULT) { @@ -722,7 +625,7 @@ abstract contract IntegrationDeployer is ExistingDeploymentParser { } else { revert("_randUser: unimplemented userType"); } - } else if (forkType == MAINNET) { + } else if (forkType == MAINNET && !isUpgraded) { if (userType == DEFAULT) { user = User(new User_M2(name)); } else if (userType == ALT_METHODS) { @@ -731,20 +634,6 @@ abstract contract IntegrationDeployer is ExistingDeploymentParser { } else { revert("_randUser: unimplemented userType"); } - } else if (forkType == HOLESKY) { - // User deployment for Holesky is exact same as holesky. - // Current Holesky deployment is up to date and no deprecated interfaces have been added. - - user = new User(name); - - if (userType == DEFAULT) { - user = new User(name); - } else if (userType == ALT_METHODS) { - // User will use nonstandard methods like `depositIntoStrategyWithSignature` - user = User(new User_AltMethods(name)); - } else { - revert("_randUser: unimplemented userType"); - } } else { revert("_randUser: unimplemented forkType"); } @@ -757,8 +646,6 @@ abstract contract IntegrationDeployer is ExistingDeploymentParser { avs = new AVS(name); } else if (forkType == MAINNET) { avs = new AVS(name); - } else if (forkType == HOLESKY) { - avs = new AVS(name); } else { revert("_genRandAVS: unimplemented forkType"); } @@ -772,7 +659,7 @@ abstract contract IntegrationDeployer is ExistingDeploymentParser { /// `tokenBalances` will contain the user's eth balance /// HOLDS_ALL - `strategies` will contain ALL initialized strategies AND BEACONCHAIN_ETH_STRAT, and /// `tokenBalances` will contain random token/eth balances accordingly - function _dealRandAssets(User user, uint assetType) internal returns (IStrategy[] memory, uint[] memory) { + function _dealRandAssets(User user, uint assetType) internal noTracing returns (IStrategy[] memory, uint[] memory) { IStrategy[] memory strategies; uint[] memory tokenBalances; if (assetType == NO_ASSETS) { @@ -781,7 +668,12 @@ abstract contract IntegrationDeployer is ExistingDeploymentParser { } else if (assetType == HOLDS_LST) { assetType = HOLDS_LST; // Select a random number of assets - uint numAssets = _randUint({min: 1, max: lstStrats.length}); + uint max = lstStrats.length; + if (max > maxUniqueAssetsHeld) { + max = maxUniqueAssetsHeld; + } + uint numAssets = _randUint({min: 1, max: max}); + strategies = new IStrategy[](numAssets); tokenBalances = new uint[](numAssets); @@ -807,7 +699,8 @@ abstract contract IntegrationDeployer is ExistingDeploymentParser { strategies[0] = BEACONCHAIN_ETH_STRAT; tokenBalances[0] = amount; } else if (assetType == HOLDS_ALL || assetType == HOLDS_MAX) { - uint numLSTs = assetType == HOLDS_MAX ? lstStrats.length : 5; + uint randHeld = _randUint({min: 1, max: maxUniqueAssetsHeld-1}); + uint numLSTs = assetType == HOLDS_MAX ? lstStrats.length : randHeld; strategies = new IStrategy[](numLSTs + 1); tokenBalances = new uint[](numLSTs + 1); @@ -837,30 +730,6 @@ abstract contract IntegrationDeployer is ExistingDeploymentParser { return (strategies, tokenBalances); } - /// @dev By default will have a assetType of HOLDS_LST - function _dealRandAssets_M1( - User user - ) internal returns (IStrategy[] memory, uint[] memory) { - // Select a random number of assets - uint numAssets = _randUint({min: 1, max: lstStrats.length}); - - IStrategy[] memory strategies = new IStrategy[](numAssets); - uint[] memory tokenBalances = new uint[](numAssets); - - // For each asset, award the user a random balance of the underlying token - for (uint i = 0; i < numAssets; i++) { - IStrategy strat = lstStrats[i]; - IERC20 underlyingToken = strat.underlyingToken(); - uint balance = _randUint({min: MIN_BALANCE, max: MAX_BALANCE}); - - StdCheats.deal(address(underlyingToken), address(user), balance); - tokenBalances[i] = balance; - strategies[i] = strat; - } - - return (strategies, tokenBalances); - } - /// @dev Uses `random` to return a random uint, with a range given by `min` and `max` (inclusive) /// @return `min` <= result <= `max` function _randUint(uint min, uint max) internal returns (uint) { @@ -928,8 +797,7 @@ abstract contract IntegrationDeployer is ExistingDeploymentParser { for (uint i; i < numOpSets; ++i) { IStrategy[] memory randomStrategies = _shuffle(allStrats); - - uint numStrategies = _randUint({ min: 1, max: allStrats.length }); + uint numStrategies = _randUint({ min: 1, max: maxUniqueAssetsHeld }); // Modify the length of the array in memory (thus ignoring remaining elements). assembly { diff --git a/src/test/integration/TimeMachine.t.sol b/src/test/integration/TimeMachine.t.sol index 506147bfb2..798abcd999 100644 --- a/src/test/integration/TimeMachine.t.sol +++ b/src/test/integration/TimeMachine.t.sol @@ -25,7 +25,7 @@ contract TimeMachine is Test, Logger { // to warp so we don't accidentally prevent our own births. assertTrue(pastExists(), "Global.warpToPast: invalid usage, past does not exist"); uint256 last = lastSnapshot(); - print.method("travelToLast", cheats.toString(last)); + // print.method("travelToLast", cheats.toString(last)); currentSnapshot = createSnapshot(); cheats.revertToState(last); } @@ -33,7 +33,7 @@ contract TimeMachine is Test, Logger { function travel( uint256 snapshot ) public { - print.method("travel", cheats.toString(snapshot)); + // print.method("travel", cheats.toString(snapshot)); cheats.revertToState(snapshot); } diff --git a/src/test/integration/TypeImporter.t.sol b/src/test/integration/TypeImporter.t.sol new file mode 100644 index 0000000000..0364da6f24 --- /dev/null +++ b/src/test/integration/TypeImporter.t.sol @@ -0,0 +1,26 @@ +// SPDX-License-Identifier: BUSL-1.1 +pragma solidity ^0.8.27; + +import "src/contracts/interfaces/IAllocationManager.sol"; +import "src/contracts/interfaces/IAVSDirectory.sol"; +import "src/contracts/interfaces/IDelegationManager.sol"; +import "src/contracts/interfaces/IEigenPod.sol"; +import "src/contracts/interfaces/IEigenPodManager.sol"; +import "src/contracts/interfaces/IStrategyManager.sol"; + + +/// @dev A master interface contract that imports types defined in our +/// contract interfaces so they can be used without needing to refer to +/// the interface, e.g: +/// +/// `AllocateParams memory params;` +/// vs +/// `IAllocationManagerTypes.AllocateParams memory params;` +interface TypeImporter is + IAllocationManagerTypes, + IAVSDirectoryTypes, + IDelegationManagerTypes, + IEigenPodManagerTypes, + IEigenPodTypes +{ +} \ No newline at end of file diff --git a/src/test/integration/UpgradeTest.t.sol b/src/test/integration/UpgradeTest.t.sol new file mode 100644 index 0000000000..eed86ead6c --- /dev/null +++ b/src/test/integration/UpgradeTest.t.sol @@ -0,0 +1,38 @@ +// SPDX-License-Identifier: BUSL-1.1 +pragma solidity ^0.8.27; + +import "src/test/integration/IntegrationDeployer.t.sol"; +import "src/test/integration/IntegrationChecks.t.sol"; + +abstract contract UpgradeTest is IntegrationCheckUtils { + + /// Only run upgrade tests on mainnet forks + function setUp() public virtual override { + if (!isForktest()) { + cheats.skip(true); + } else { + isUpgraded = false; + super.setUp(); + } + } + + /// Deploy current implementation contracts and upgrade existing proxies + function _upgradeEigenLayerContracts() public virtual { + require(forkType == MAINNET, "_upgradeEigenLayerContracts: somehow running upgrade test locally"); + require(!isUpgraded, "_upgradeEigenLayerContracts: already performed upgrade"); + + emit log("_upgradeEigenLayerContracts: upgrading mainnet to slashing"); + + _upgradeMainnetContracts(); + + // Bump block.timestamp forward to allow verifyWC proofs for migrated pods + emit log("advancing block time to start of next epoch:"); + + beaconChain.advanceEpoch_NoRewards(); + + emit log("======"); + + isUpgraded = true; + emit log("_upgradeEigenLayerContracts: slashing upgrade complete"); + } +} \ No newline at end of file diff --git a/src/test/integration/deprecatedInterfaces/mainnet/IDelegationManager.sol b/src/test/integration/deprecatedInterfaces/mainnet/IDelegationManager.sol index 5f041668c5..3fafbeaf4e 100644 --- a/src/test/integration/deprecatedInterfaces/mainnet/IDelegationManager.sol +++ b/src/test/integration/deprecatedInterfaces/mainnet/IDelegationManager.sol @@ -3,7 +3,7 @@ pragma solidity ^0.8.27; import "src/contracts/interfaces/IStrategy.sol"; import "src/contracts/interfaces/IPausable.sol"; -import "src/contracts/interfaces/ISignatureUtils.sol"; +import "src/contracts/interfaces/ISignatureUtilsMixin.sol"; /** * @notice M2 DEPRECATED INTERFACE at commit hash https://github.com/Layr-Labs/eigenlayer-contracts/tree/426f461c59b4f0e16f8becdffd747075edcaded8 @@ -11,7 +11,7 @@ import "src/contracts/interfaces/ISignatureUtils.sol"; * @author Layr Labs, Inc. * @notice Terms of Service: https://docs.eigenlayer.xyz/overview/terms-of-service */ -interface IDelegationManager_DeprecatedM2 is IPausable, ISignatureUtils { +interface IDelegationManager_DeprecatedM2 is IPausable, ISignatureUtilsMixin { // @notice Struct used for storing information about a single operator who has registered with EigenLayer struct OperatorDetails { /// @notice DEPRECATED -- this field is no longer used, payments are handled in PaymentCoordinator.sol diff --git a/src/test/integration/mocks/BeaconChainMock.t.sol b/src/test/integration/mocks/BeaconChainMock.t.sol index 414d18b666..4f93f54739 100644 --- a/src/test/integration/mocks/BeaconChainMock.t.sol +++ b/src/test/integration/mocks/BeaconChainMock.t.sol @@ -7,6 +7,7 @@ import "src/contracts/libraries/BeaconChainProofs.sol"; import "src/contracts/libraries/Merkle.sol"; import "src/contracts/pods/EigenPodManager.sol"; +import "src/test/mocks/ETHDepositMock.sol"; import "src/test/integration/mocks/EIP_4788_Oracle_Mock.t.sol"; import "src/test/utils/Logger.t.sol"; @@ -79,6 +80,7 @@ contract BeaconChainMock is Logger { uint64 public nextTimestamp; EigenPodManager eigenPodManager; + IETHPOSDeposit constant DEPOSIT_CONTRACT = IETHPOSDeposit(0x00000000219ab540356cBB839Cbe05303d7705Fa); EIP_4788_Oracle_Mock constant EIP_4788_ORACLE = EIP_4788_Oracle_Mock(0x000F3df6D732807Ef1319fB7B8bB8522d0Beac02); /** @@ -126,6 +128,7 @@ contract BeaconChainMock is Logger { eigenPodManager = _eigenPodManager; // Create mock 4788 oracle + cheats.etch(address(DEPOSIT_CONTRACT), type(ETHPOSDepositMock).runtimeCode); cheats.etch(address(EIP_4788_ORACLE), type(EIP_4788_Oracle_Mock).runtimeCode); // Calculate nodes of empty merkle tree @@ -286,6 +289,11 @@ contract BeaconChainMock is Logger { _advanceEpoch(); } + function advanceEpoch_NoWithdrawNoRewards() public { + print.method("advanceEpoch_NoWithdrawNoRewards"); + _advanceEpoch(); + } + /// @dev Iterate over all validators. If the validator is still active, /// add CONSENSUS_REWARD_AMOUNT_GWEI to its current balance function _generateRewards() internal { diff --git a/src/test/integration/tests/ALM_Multi.t.sol b/src/test/integration/tests/ALM_Multi.t.sol new file mode 100644 index 0000000000..12c47fd137 --- /dev/null +++ b/src/test/integration/tests/ALM_Multi.t.sol @@ -0,0 +1,431 @@ +// SPDX-License-Identifier: BUSL-1.1 +pragma solidity ^0.8.27; + +import "src/test/integration/IntegrationChecks.t.sol"; + +contract Integration_ALM_Multi is IntegrationCheckUtils { + + using StdStyle for *; + + enum Action { + REGISTER, + DEREGISTER, + INCR_ALLOC, + INCR_ALLOC_FULL, + DECR_ALLOC, + DECR_ALLOC_FULL + } + + enum State { + NONE, + REGISTERED, + ALLOCATED, + FULLY_ALLOCATED, + REG_ALLOC, + REG_FULLY_ALLOC + } + + AVS avs; + OperatorSet operatorSet; + + IStrategy[] strategies; + + /// iteration idx -> list of operators in each state + mapping(uint => mapping(State => User[])) operators; + + /// operator -> list of strategies they have delegated assets in + mapping(User => IStrategy[]) allocatedStrats; + /// Last modifyAllocations params made by the operator + mapping(User => AllocateParams) lastModifyParams; + + uint constant NUM_UNIQUE_ASSETS = 3; + uint constant NUM_OPERATORS = 5; + uint constant NUM_ITERATIONS = 20; + + function _init() internal virtual override { + _configAssetAmounts(NUM_UNIQUE_ASSETS); + + (avs,) = _newRandomAVS(); + operatorSet = avs.createOperatorSet(allStrats); + + for (uint i = 0; i < NUM_OPERATORS; i++) { + (User staker, IStrategy[] memory _strategies, uint[] memory initTokenBalances) + = _newRandomStaker(); + + User operator = _newRandomOperator_NoAssets(); + + // 1. Deposit into strategies + staker.depositIntoEigenlayer(_strategies, initTokenBalances); + uint[] memory initDepositShares = _calculateExpectedShares(_strategies, initTokenBalances); + check_Deposit_State(staker, _strategies, initDepositShares); + + // 2. Delegate to operator + staker.delegateTo(operator); + check_Delegation_State(staker, operator, _strategies, initDepositShares); + + allocatedStrats[operator] = _strategies; + // Add operator to NONE state for the 0th iteration + operators[0][State.NONE].push(operator); + } + } + + /// Reduce fuzz runs because this test is thiccc: + /// + /// forge-config: default.fuzz.runs = 10 + /// forge-config: forktest.fuzz.runs = 3 + function test_Multi(uint24 _r) public rand(_r) { + // Do 20 iterations + for (uint i = 1; i <= NUM_ITERATIONS; i++) { + console.log("%s: %d", "iter".green().italic(), i-1); + + _dispatchNone(i); + _dispatchRegistered(i); + _dispatchAllocated(i); + _dispatchFullyAllocated(i); + _dispatchRegAlloc(i); + _dispatchRegFullyAlloc(i); + + // Ensure all pending actions are completed for the next iteration + _rollForward_DeallocationDelay(); + } + } + + /// @dev NONE operators can: + /// [REGISTER, INCR_ALLOC, INCR_ALLOC_FULL] + function _dispatchNone(uint iter) internal { + // Fetch all NONE operators from previous iteration + User[] memory _operators = operators[iter - 1][State.NONE]; + Action[3] memory actions = [ + Action.REGISTER, + Action.INCR_ALLOC, + Action.INCR_ALLOC_FULL + ]; + + if (_operators.length == 0) { + return; + } + + console.log("%s: %d operators", "_dispatchNone".green(), _operators.length); + + for (uint i = 0; i < _operators.length; i++) { + // Get operator and allocated strategies + User operator = _operators[i]; + IStrategy[] memory _strats = allocatedStrats[operator]; + + // Get action + uint aI = _randUint(0, actions.length-1); + Action action = actions[aI]; + + // Process action + if (action == Action.REGISTER) { + operator.registerForOperatorSet(operatorSet); + check_Registration_State_NoAllocation(operator, operatorSet, allStrats); + + operators[iter][State.REGISTERED].push(operator); + } else if (action == Action.INCR_ALLOC) { + AllocateParams memory params = _genAllocation_HalfAvailable(operator, operatorSet, _strats); + operator.modifyAllocations(params); + check_IncrAlloc_State_NotSlashable(operator, params); + + lastModifyParams[operator] = params; + operators[iter][State.ALLOCATED].push(operator); + } else if (action == Action.INCR_ALLOC_FULL) { + AllocateParams memory params = _genAllocation_AllAvailable(operator, operatorSet, _strats); + operator.modifyAllocations(params); + check_IncrAlloc_State_NotSlashable(operator, params); + + lastModifyParams[operator] = params; + operators[iter][State.FULLY_ALLOCATED].push(operator); + } + } + } + + /// @dev REGISTERED operators can: + /// [DEREGISTER, INCR_ALLOC, INCR_ALLOC_FULL] + function _dispatchRegistered(uint iter) internal { + // Fetch all REGISTERED operators from previous iteration + User[] memory _operators = operators[iter - 1][State.REGISTERED]; + Action[3] memory actions = [ + Action.DEREGISTER, + Action.INCR_ALLOC, + Action.INCR_ALLOC_FULL + ]; + + if (_operators.length == 0) { + return; + } + + console.log("%s: %d operators", "_dispatchRegistered".green(), _operators.length); + + for (uint i = 0; i < _operators.length; i++) { + // Get operator + User operator = _operators[i]; + IStrategy[] memory _strats = allocatedStrats[operator]; + + // Get action + uint aI = _randUint(0, actions.length-1); + Action action = actions[aI]; + + // Process action + if (action == Action.DEREGISTER) { + operator.deregisterFromOperatorSet(operatorSet); + check_Deregistration_State_NoAllocation(operator, operatorSet); + + operators[iter][State.NONE].push(operator); + } else if (action == Action.INCR_ALLOC) { + AllocateParams memory params = _genAllocation_HalfAvailable(operator, operatorSet, _strats); + operator.modifyAllocations(params); + check_IncrAlloc_State_Slashable(operator, params); + + lastModifyParams[operator] = params; + operators[iter][State.REG_ALLOC].push(operator); + } else if (action == Action.INCR_ALLOC_FULL) { + AllocateParams memory params = _genAllocation_AllAvailable(operator, operatorSet, _strats); + operator.modifyAllocations(params); + check_IncrAlloc_State_Slashable(operator, params); + // check_FullyAllocated_State(operator, operatorSet, params.strategies); TODO + + lastModifyParams[operator] = params; + operators[iter][State.REG_FULLY_ALLOC].push(operator); + } + } + } + + /// @dev ALLOCATED operators can: + /// [REGISTER, INCR_ALLOC, INCR_ALLOC_FULL, DECR_ALLOC, DECR_ALLOC_FULL] + function _dispatchAllocated(uint iter) internal { + // Fetch all ALLOCATED operators from previous iteration + User[] memory _operators = operators[iter - 1][State.ALLOCATED]; + Action[5] memory actions = [ + Action.REGISTER, + Action.INCR_ALLOC, + Action.INCR_ALLOC_FULL, + Action.DECR_ALLOC, + Action.DECR_ALLOC_FULL + ]; + + if (_operators.length == 0) { + return; + } + + console.log("%s: %d operators", "_dispatchAllocated".green(), _operators.length); + + for (uint i = 0; i < _operators.length; i++) { + // Get operator + User operator = _operators[i]; + IStrategy[] memory _strats = allocatedStrats[operator]; + + // Get action + uint aI = _randUint(0, actions.length-1); + Action action = actions[aI]; + + // Process action + if (action == Action.REGISTER) { + operator.registerForOperatorSet(operatorSet); + check_Registration_State_ActiveAllocation(operator, lastModifyParams[operator]); + + operators[iter][State.REG_ALLOC].push(operator); + } else if (action == Action.INCR_ALLOC) { + AllocateParams memory params = _genAllocation_HalfAvailable(operator, operatorSet, _strats); + operator.modifyAllocations(params); + check_IncrAlloc_State_NotSlashable(operator, params); + + lastModifyParams[operator] = params; + operators[iter][State.ALLOCATED].push(operator); + } else if (action == Action.INCR_ALLOC_FULL) { + AllocateParams memory params = _genAllocation_AllAvailable(operator, operatorSet, _strats); + operator.modifyAllocations(params); + check_IncrAlloc_State_NotSlashable(operator, params); + // check_FullyAllocated_State(operator); TODO + + lastModifyParams[operator] = params; + operators[iter][State.FULLY_ALLOCATED].push(operator); + } else if (action == Action.DECR_ALLOC) { + AllocateParams memory params = _genDeallocation_HalfRemaining(operator, operatorSet, _strats); + operator.modifyAllocations(params); + check_DecrAlloc_State_NotSlashable(operator, params); + + lastModifyParams[operator] = params; + operators[iter][State.ALLOCATED].push(operator); + } else if (action == Action.DECR_ALLOC_FULL) { + AllocateParams memory params = _genDeallocation_Full(operator, operatorSet, _strats); + operator.modifyAllocations(params); + check_DecrAlloc_State_NotSlashable(operator, params); + // check_FullyDeallocated_State(operator); TODO + + lastModifyParams[operator] = params; + operators[iter][State.NONE].push(operator); + } + } + } + + /// @dev FULLY_ALLOCATED operators can: + /// [REGISTER, DECR_ALLOC, DECR_ALLOC_FULL] + function _dispatchFullyAllocated(uint iter) internal { + // Fetch all FULLY_ALLOCATED operators from previous iteration + User[] memory _operators = operators[iter - 1][State.FULLY_ALLOCATED]; + Action[3] memory actions = [ + Action.REGISTER, + Action.DECR_ALLOC, + Action.DECR_ALLOC_FULL + ]; + + if (_operators.length == 0) { + return; + } + + console.log("%s: %d operators", "_dispatchFullyAllocated".green(), _operators.length); + + for (uint i = 0; i < _operators.length; i++) { + // Get operator + User operator = _operators[i]; + IStrategy[] memory _strats = allocatedStrats[operator]; + + // Get action + uint aI = _randUint(0, actions.length-1); + Action action = actions[aI]; + + // Process action + if (action == Action.REGISTER) { + operator.registerForOperatorSet(operatorSet); + check_Registration_State_ActiveAllocation(operator, lastModifyParams[operator]); + + operators[iter][State.REG_FULLY_ALLOC].push(operator); + } else if (action == Action.DECR_ALLOC) { + AllocateParams memory params = _genDeallocation_HalfRemaining(operator, operatorSet, _strats); + operator.modifyAllocations(params); + check_DecrAlloc_State_NotSlashable(operator, params); + + lastModifyParams[operator] = params; + operators[iter][State.ALLOCATED].push(operator); + } else if (action == Action.DECR_ALLOC_FULL) { + AllocateParams memory params = _genDeallocation_Full(operator, operatorSet, _strats); + operator.modifyAllocations(params); + check_DecrAlloc_State_NotSlashable(operator, params); + // check_FullyDeallocated_State(operator); TODO + + lastModifyParams[operator] = params; + operators[iter][State.NONE].push(operator); + } + } + } + + /// @dev REG_ALLOC operators can: + /// [DEREGISTER, INCR_ALLOC, INCR_ALLOC_FULL, DECR_ALLOC, DECR_ALLOC_FULL] + function _dispatchRegAlloc(uint iter) internal { + // Fetch all REG_ALLOC operators from previous iteration + User[] memory _operators = operators[iter - 1][State.REG_ALLOC]; + Action[5] memory actions = [ + Action.DEREGISTER, + Action.INCR_ALLOC, + Action.INCR_ALLOC_FULL, + Action.DECR_ALLOC, + Action.DECR_ALLOC_FULL + ]; + + if (_operators.length == 0) { + return; + } + + console.log("%s: %d operators", "_dispatchRegAlloc".green(), _operators.length); + + for (uint i = 0; i < _operators.length; i++) { + // Get operator + User operator = _operators[i]; + IStrategy[] memory _strats = allocatedStrats[operator]; + + // Get action + uint aI = _randUint(0, actions.length-1); + Action action = actions[aI]; + + // Process action + if (action == Action.DEREGISTER) { + operator.deregisterFromOperatorSet(operatorSet); + check_Deregistration_State_ActiveAllocation(operator, operatorSet); + + operators[iter][State.ALLOCATED].push(operator); + } else if (action == Action.INCR_ALLOC) { + AllocateParams memory params = _genAllocation_HalfAvailable(operator, operatorSet, _strats); + operator.modifyAllocations(params); + check_IncrAlloc_State_Slashable(operator, params); + + lastModifyParams[operator] = params; + operators[iter][State.REG_ALLOC].push(operator); + } else if (action == Action.INCR_ALLOC_FULL) { + AllocateParams memory params = _genAllocation_AllAvailable(operator, operatorSet, _strats); + operator.modifyAllocations(params); + check_IncrAlloc_State_Slashable(operator, params); + // check_FullyAllocated_State(operator); TODO + + lastModifyParams[operator] = params; + operators[iter][State.REG_FULLY_ALLOC].push(operator); + } else if (action == Action.DECR_ALLOC) { + AllocateParams memory params = _genDeallocation_HalfRemaining(operator, operatorSet, _strats); + operator.modifyAllocations(params); + check_DecrAlloc_State_Slashable(operator, params); + + lastModifyParams[operator] = params; + operators[iter][State.REG_ALLOC].push(operator); + } else if (action == Action.DECR_ALLOC_FULL) { + AllocateParams memory params = _genDeallocation_Full(operator, operatorSet, _strats); + operator.modifyAllocations(params); + check_DecrAlloc_State_Slashable(operator, params); + // check_FullyDeallocated_State(operator); TODO + + lastModifyParams[operator] = params; + operators[iter][State.REGISTERED].push(operator); + } + } + } + + /// @dev REG_FULLY_ALLOC operators can: + /// [DEREGISTER, DECR_ALLOC, DECR_ALLOC_FULL] + function _dispatchRegFullyAlloc(uint iter) internal { + // Fetch all REG_FULLY_ALLOC operators from previous iteration + User[] memory _operators = operators[iter - 1][State.REG_FULLY_ALLOC]; + Action[3] memory actions = [ + Action.DEREGISTER, + Action.DECR_ALLOC, + Action.DECR_ALLOC_FULL + ]; + + if (_operators.length == 0) { + return; + } + + console.log("%s: %d operators", "_dispatchRegFullyAlloc".green(), _operators.length); + + for (uint i = 0; i < _operators.length; i++) { + // Get operator + User operator = _operators[i]; + IStrategy[] memory _strats = allocatedStrats[operator]; + + // Get action + uint aI = _randUint(0, actions.length-1); + Action action = actions[aI]; + + // Process action + if (action == Action.DEREGISTER) { + operator.deregisterFromOperatorSet(operatorSet); + check_Deregistration_State_ActiveAllocation(operator, operatorSet); + + operators[iter][State.FULLY_ALLOCATED].push(operator); + } else if (action == Action.DECR_ALLOC) { + AllocateParams memory params = _genDeallocation_HalfRemaining(operator, operatorSet, _strats); + operator.modifyAllocations(params); + check_DecrAlloc_State_Slashable(operator, params); + + lastModifyParams[operator] = params; + operators[iter][State.REG_ALLOC].push(operator); + } else if (action == Action.DECR_ALLOC_FULL) { + AllocateParams memory params = _genDeallocation_Full(operator, operatorSet, _strats); + operator.modifyAllocations(params); + check_DecrAlloc_State_Slashable(operator, params); + // check_FullyDeallocated_State(operator); TODO + + lastModifyParams[operator] = params; + operators[iter][State.REGISTERED].push(operator); + } + } + } +} \ No newline at end of file diff --git a/src/test/integration/tests/ALM_RegisterAndModify.t.sol b/src/test/integration/tests/ALM_RegisterAndModify.t.sol new file mode 100644 index 0000000000..65a4592a2f --- /dev/null +++ b/src/test/integration/tests/ALM_RegisterAndModify.t.sol @@ -0,0 +1,221 @@ +// SPDX-License-Identifier: BUSL-1.1 +pragma solidity ^0.8.27; + +import "src/test/integration/IntegrationChecks.t.sol"; + +contract Integration_ALMBase is IntegrationCheckUtils { + + AVS avs; + OperatorSet operatorSet; + + User operator; + AllocateParams allocateParams; + + User staker; + IStrategy[] strategies; + uint[] initTokenBalances; + uint[] initDepositShares; + + /// Shared setup: + /// + /// 1. Generate staker with deposited assets, operator, and AVS + /// 2. Deposit asssets and delegate to operator + /// 3. AVS creates an operator set containing the strategies held by the staker + function _init() internal virtual override { + (staker, strategies, initTokenBalances) = _newRandomStaker(); + operator = _newRandomOperator_NoAssets(); + (avs,) = _newRandomAVS(); + + // 1. Deposit Into Strategies + staker.depositIntoEigenlayer(strategies, initTokenBalances); + initDepositShares = _calculateExpectedShares(strategies, initTokenBalances); + check_Deposit_State(staker, strategies, initDepositShares); + + // 2. Delegate to an operator + staker.delegateTo(operator); + check_Delegation_State(staker, operator, strategies, initDepositShares); + + // 3. Create an operator set containing the strategies held by the staker + operatorSet = avs.createOperatorSet(strategies); + } +} + +contract Integration_InitRegistered is Integration_ALMBase { + + /// @dev Integration test variants that start with the operator being registered + /// for the operator set + function _init() internal virtual override { + super._init(); + + // Register for operator set before allocating to any strategies + operator.registerForOperatorSet(operatorSet); + check_Registration_State_NoAllocation(operator, operatorSet, allStrats); + } + + function testFuzz_allocate_deallocate_deregister(uint24 _r) public rand(_r) { + // 1. Allocate to the operator set + allocateParams = _genAllocation_Rand(operator, operatorSet); + operator.modifyAllocations(allocateParams); + check_IncrAlloc_State_Slashable(operator, allocateParams); + + // 2. Roll to the allocation's effect block + _rollForward_AllocationDelay(operator); + + // 3. Deallocate fully from the operator set + AllocateParams memory deallocateParams = _genDeallocation_Full(operator, operatorSet); + operator.modifyAllocations(deallocateParams); + check_DecrAlloc_State_Slashable(operator, deallocateParams); + + // 4. Deregister from operator set + operator.deregisterFromOperatorSet(operatorSet); + check_Deregistration_State_PendingAllocation(operator, operatorSet); + + // 5. Check the operator is fully deallocated after the deallocation delay + _rollForward_DeallocationDelay(); + check_FullyDeallocated_State(operator, allocateParams, deallocateParams); + } + + function testFuzz_allocate_deallocate_waitDeallocate_deregister(uint24 _r) public rand(_r) { + // 1. Allocate to the operator set + allocateParams = _genAllocation_Rand(operator, operatorSet); + operator.modifyAllocations(allocateParams); + check_IncrAlloc_State_Slashable(operator, allocateParams); + + // 2. Roll to the allocation's effect block + _rollForward_AllocationDelay(operator); + + // 3. Deallocate fully from the operator set + AllocateParams memory deallocateParams = _genDeallocation_Full(operator, operatorSet); + operator.modifyAllocations(deallocateParams); + check_DecrAlloc_State_Slashable(operator, deallocateParams); + + // 4. Check the operator is fully deallocated after the deallocation delay + _rollForward_DeallocationDelay(); + check_FullyDeallocated_State(operator, allocateParams, deallocateParams); + + // 5. Deregister from operator set + operator.deregisterFromOperatorSet(operatorSet); + check_Deregistration_State_NoAllocation(operator, operatorSet); + } + + function testFuzz_deregister_waitDeregister_allocate_deallocate(uint24 _r) public rand(_r) { + // 1. Deregister from operator set + operator.deregisterFromOperatorSet(operatorSet); + check_Deregistration_State_NoAllocation(operator, operatorSet); + + // 2. Wait for deallocation delay. Operator is no longer slashable + _rollForward_DeallocationDelay(); + + // 3. Allocate to operator set + allocateParams = _genAllocation_Rand(operator, operatorSet); + operator.modifyAllocations(allocateParams); + check_IncrAlloc_State_NotSlashable(operator, allocateParams); + + // 3. Wait for allocation delay + _rollForward_AllocationDelay(operator); + + // 4. Deallocate operator from operator set + AllocateParams memory deallocateParams = _genDeallocation_Full(operator, operatorSet); + operator.modifyAllocations(deallocateParams); + check_DecrAlloc_State_NotSlashable(operator, deallocateParams); + check_FullyDeallocated_State(operator, allocateParams, deallocateParams); + } + + function testFuzz_deregister_allocate_waitAllocate_deallocate(uint24 _r) public rand(_r) { + // 1. Deregister from operator set + operator.deregisterFromOperatorSet(operatorSet); + check_Deregistration_State_NoAllocation(operator, operatorSet); + + // 2. Before deregistration is complete, allocate to operator set + // The operator should be slashable after the allocation delay + allocateParams = _genAllocation_Rand(operator, operatorSet); + operator.modifyAllocations(allocateParams); + check_IncrAlloc_State_Slashable(operator, allocateParams); + + // 3. Wait for allocation delay. Operator remains slashable + _rollForward_AllocationDelay(operator); + + // 4. Deallocate operator from operator set + AllocateParams memory deallocateParams = _genDeallocation_Full(operator, operatorSet); + operator.modifyAllocations(deallocateParams); + check_DecrAlloc_State_Slashable(operator, deallocateParams); + + // 5. Check the operator is fully deallocated after the deallocation delay + _rollForward_DeallocationDelay(); + check_FullyDeallocated_State(operator, allocateParams, deallocateParams); + } + + function testFuzz_deregister_allocate_waitDeregister_deallocate(uint24 _r) public rand(_r) { + // 1. Deregister from operator set + operator.deregisterFromOperatorSet(operatorSet); + check_Deregistration_State_NoAllocation(operator, operatorSet); + + // 2. Before deregistration is complete, allocate to operator set + // The operator should be slashable after the allocation delay + allocateParams = _genAllocation_Rand(operator, operatorSet); + operator.modifyAllocations(allocateParams); + check_IncrAlloc_State_Slashable(operator, allocateParams); + + // 3. Wait for deallocation delay so operator is no longer slashable + _rollForward_DeallocationDelay(); + + // 4. Instant-deallocate operator from operator set + AllocateParams memory deallocateParams = _genDeallocation_Full(operator, operatorSet); + operator.modifyAllocations(deallocateParams); + check_DecrAlloc_State_NotSlashable(operator, deallocateParams); + check_FullyDeallocated_State(operator, allocateParams, deallocateParams); + } +} + +contract Integration_InitAllocated is Integration_ALMBase { + + /// @dev Integration test variants that start with the operator being allocated + /// for the operator set + function _init() internal virtual override { + super._init(); + + // Allocate fully to operator set + allocateParams = _genAllocation_AllAvailable(operator, operatorSet); + operator.modifyAllocations(allocateParams); + check_IncrAlloc_State_NotSlashable(operator, allocateParams); + } + + function testFuzz_register_deallocate_deregister(uint24 _r) public rand(_r) { + // 1. Register for the operator set + operator.registerForOperatorSet(operatorSet); + check_Registration_State_PendingAllocation(operator, allocateParams); + + // 2. Roll to the allocation's effect block + _rollForward_AllocationDelay(operator); + + // 3. Deallocate fully from the operator set + AllocateParams memory deallocateParams = _genDeallocation_Full(operator, operatorSet); + operator.modifyAllocations(deallocateParams); + check_DecrAlloc_State_Slashable(operator, deallocateParams); + + // 4. Deregister from operator set + operator.deregisterFromOperatorSet(operatorSet); + check_Deregistration_State_PendingAllocation(operator, operatorSet); + + // 5. Roll forward to the deallocation's effect block and check the operator is fully deallocated + _rollForward_DeallocationDelay(); + check_FullyDeallocated_State(operator, allocateParams, deallocateParams); + } + + function testFuzz_waitAllocation_register_deallocate(uint24 _r) public rand(_r) { + _rollForward_AllocationDelay(operator); + + // 1. Register for the operator set. The allocation immediately becomes slashable + operator.registerForOperatorSet(operatorSet); + check_Registration_State_ActiveAllocation(operator, allocateParams); + + // 2. Deallocate fully from the operator set + AllocateParams memory deallocateParams = _genDeallocation_Full(operator, operatorSet); + operator.modifyAllocations(deallocateParams); + check_DecrAlloc_State_Slashable(operator, deallocateParams); + + // 3. Roll forward to the deallocation's effect block and check the operator is fully deallocated + _rollForward_DeallocationDelay(); + check_FullyDeallocated_State(operator, allocateParams, deallocateParams); + } +} \ No newline at end of file diff --git a/src/test/integration/tests/Delegate_Deposit_Queue_Complete.t.sol b/src/test/integration/tests/Delegate_Deposit_Queue_Complete.t.sol index 0ef86e4b04..b58269e028 100644 --- a/src/test/integration/tests/Delegate_Deposit_Queue_Complete.t.sol +++ b/src/test/integration/tests/Delegate_Deposit_Queue_Complete.t.sol @@ -5,13 +5,8 @@ import "src/test/integration/IntegrationChecks.t.sol"; import "src/test/integration/users/User.t.sol"; contract Integration_Delegate_Deposit_Queue_Complete is IntegrationCheckUtils { - function testFuzz_delegate_deposit_queue_completeAsShares(uint24 _random) public { - // Configure the random parameters for the test - _configRand({ - _randomSeed: _random, - _assetTypes: HOLDS_LST | HOLDS_ETH | HOLDS_ALL, - _userTypes: DEFAULT | ALT_METHODS - }); + + function testFuzz_delegate_deposit_queue_completeAsShares(uint24 _random) public rand(_random) { // Create a staker and an operator with a nonzero balance and corresponding strategies (User staker, IStrategy[] memory strategies, uint[] memory tokenBalances) = _newRandomStaker(); (User operator, ,) = _newRandomOperator(); @@ -29,13 +24,10 @@ contract Integration_Delegate_Deposit_Queue_Complete is IntegrationCheckUtils { assert_Snap_Added_OperatorShares(operator, strategies, shares, "operator should have received shares"); // 3. Queue Withdrawal - IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.queueWithdrawals(strategies, shares); + Withdrawal[] memory withdrawals = staker.queueWithdrawals(strategies, shares); bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); check_QueuedWithdrawal_State(staker, operator, strategies, shares, withdrawals, withdrawalRoots); - // Upgrade contracts if forkType is not local - _upgradeEigenLayerContracts(); - // 4. Complete Queued Withdrawal _rollBlocksForCompleteWithdrawals(withdrawals); for (uint i = 0; i < withdrawals.length; i++) { @@ -44,14 +36,7 @@ contract Integration_Delegate_Deposit_Queue_Complete is IntegrationCheckUtils { } } - function testFuzz_delegate_deposit_queue_completeAsTokens(uint24 _random) public { - // Configure the random parameters for the test - _configRand({ - _randomSeed: _random, - _assetTypes: HOLDS_LST | HOLDS_ETH | HOLDS_ALL, - _userTypes: DEFAULT | ALT_METHODS - }); - + function testFuzz_delegate_deposit_queue_completeAsTokens(uint24 _random) public rand(_random) { // Create a staker and an operator with a nonzero balance and corresponding strategies (User staker, IStrategy[] memory strategies, uint[] memory tokenBalances) = _newRandomStaker(); (User operator, ,) = _newRandomOperator(); @@ -63,23 +48,20 @@ contract Integration_Delegate_Deposit_Queue_Complete is IntegrationCheckUtils { // 2. Deposit into strategy staker.depositIntoEigenlayer(strategies, tokenBalances); uint[] memory shares = _calculateExpectedShares(strategies, tokenBalances); + uint[] memory expectedTokens = _calculateExpectedTokens(strategies, shares); // Check that the deposit increased operator shares the staker is delegated to check_Deposit_State(staker, strategies, shares); assert_Snap_Added_OperatorShares(operator, strategies, shares, "operator should have received shares"); // 3. Queue Withdrawal - IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.queueWithdrawals(strategies, shares); + Withdrawal[] memory withdrawals = staker.queueWithdrawals(strategies, shares); bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); check_QueuedWithdrawal_State(staker, operator, strategies, shares, withdrawals, withdrawalRoots); - // Upgrade contracts if forkType is not local - _upgradeEigenLayerContracts(); - // 4. Complete Queued Withdrawal _rollBlocksForCompleteWithdrawals(withdrawals); for (uint i = 0; i < withdrawals.length; i++) { - uint[] memory expectedTokens = _calculateExpectedTokens(strategies, shares); IERC20[] memory tokens = staker.completeWithdrawalAsTokens(withdrawals[i]); check_Withdrawal_AsTokens_State(staker, operator, withdrawals[i], strategies, shares, tokens, expectedTokens); } diff --git a/src/test/integration/tests/Deposit_Delegate_Allocate.t.sol b/src/test/integration/tests/Deposit_Delegate_Allocate.t.sol deleted file mode 100644 index 48cc93ff63..0000000000 --- a/src/test/integration/tests/Deposit_Delegate_Allocate.t.sol +++ /dev/null @@ -1,466 +0,0 @@ -// SPDX-License-Identifier: BUSL-1.1 -pragma solidity ^0.8.27; - -import "src/test/integration/IntegrationChecks.t.sol"; -import "src/test/integration/users/User.t.sol"; - -// TODO: move randomness from tests - -contract Integration_Deposit_Delegate_Allocate is IntegrationCheckUtils { - function testFuzz_deposit_delegate_allocate( - uint24 _random - ) public { - // Configure the random parameters for the test - _configRand({ - _randomSeed: _random, - _assetTypes: HOLDS_LST | HOLDS_ETH | HOLDS_ALL, - _userTypes: DEFAULT | ALT_METHODS - }); - _upgradeEigenLayerContracts(); // Upgrade contracts if forkType is not local - - (User staker, IStrategy[] memory strategies, uint256[] memory tokenBalances) = _newRandomStaker(); - (User operator,,) = _newRandomOperator(); - (AVS avs,) = _newRandomAVS(); - - // 1. Deposit Into Strategies - staker.depositIntoEigenlayer(strategies, tokenBalances); - - // 2. Delegate to an operator - staker.delegateTo(operator); - - // Create an operator set and register an operator. - OperatorSet memory operatorSet = avs.createOperatorSet(strategies); - operator.registerForOperatorSet(operatorSet); - - // 3. Allocate to operator set. - IAllocationManagerTypes.AllocateParams memory allocateParams = - operator.modifyAllocations(operatorSet, _randMagnitudes({sum: 1 ether, len: strategies.length})); - assert_Snap_Allocations_Modified( - operator, allocateParams, false, "operator allocations should be updated before delay" - ); - _rollBlocksForCompleteAllocation(operator, operatorSet, strategies); - assert_Snap_Allocations_Modified( - operator, allocateParams, true, "operator allocations should be updated after delay" - ); - } - - function testFuzz_deposit_delegate_upgrade_allocate( - uint24 _random - ) public { - // Configure the random parameters for the test - _configRand({ - _randomSeed: _random, - _assetTypes: HOLDS_LST | HOLDS_ETH | HOLDS_ALL, - _userTypes: DEFAULT | ALT_METHODS - }); - - (User staker, IStrategy[] memory strategies, uint256[] memory tokenBalances) = _newRandomStaker(); - (User operator,,) = _newRandomOperator(); - - // 1. Deposit Into Strategies - staker.depositIntoEigenlayer(strategies, tokenBalances); - - // 2. Delegate to an operator - staker.delegateTo(operator); - - _upgradeEigenLayerContracts(); // Upgrade contracts if forkType is not local - (AVS avs,) = _newRandomAVS(); - - // 3. Set allocation delay for operator - operator.setAllocationDelay(1); - rollForward({blocks: ALLOCATION_CONFIGURATION_DELAY}); - - // 4. Create an operator set and register an operator. - OperatorSet memory operatorSet = avs.createOperatorSet(strategies); - operator.registerForOperatorSet(operatorSet); - - // 5. Allocate to operator set. - IAllocationManagerTypes.AllocateParams memory allocateParams = - operator.modifyAllocations(operatorSet, _randMagnitudes({sum: 1 ether, len: strategies.length})); - assert_Snap_Allocations_Modified( - operator, allocateParams, false, "operator allocations should be updated before delay" - ); - _rollBlocksForCompleteAllocation(operator, operatorSet, strategies); - assert_Snap_Allocations_Modified( - operator, allocateParams, true, "operator allocations should be updated after delay" - ); - } - - function testFuzz_deposit_delegate_allocate_slash_undelegate_completeAsTokens( - uint24 _random - ) public { - _configRand({_randomSeed: _random, _assetTypes: HOLDS_ALL, _userTypes: DEFAULT}); - _upgradeEigenLayerContracts(); // Upgrade contracts if forkType is not local - - (User staker, IStrategy[] memory strategies, uint256[] memory tokenBalances) = _newRandomStaker(); - (User operator,,) = _newRandomOperator(); - (AVS avs,) = _newRandomAVS(); - - // 1. Deposit Into Strategies - staker.depositIntoEigenlayer(strategies, tokenBalances); - - // 2. Delegate to an operator - staker.delegateTo(operator); - - // Create an operator set and register an operator. - OperatorSet memory operatorSet = avs.createOperatorSet(strategies); - operator.registerForOperatorSet(operatorSet); - - // 3. Allocate to operator set. - IAllocationManagerTypes.AllocateParams memory allocateParams = - operator.modifyAllocations(operatorSet, _randMagnitudes({sum: 1 ether, len: strategies.length})); - assert_Snap_Allocations_Modified( - operator, allocateParams, false, "operator allocations should be updated before delay" - ); - _rollBlocksForCompleteAllocation(operator, operatorSet, strategies); - assert_Snap_Allocations_Modified( - operator, allocateParams, true, "operator allocations should be updated after delay" - ); - - // 4. Slash operator - IAllocationManagerTypes.SlashingParams memory slashingParams; - { - (IStrategy[] memory strategiesToSlash, uint256[] memory wadsToSlash) = - _randStrategiesAndWadsToSlash(operatorSet); - slashingParams = avs.slashOperator(operator, operatorSet.id, strategiesToSlash, wadsToSlash); - assert_Snap_Allocations_Slashed(slashingParams, operatorSet, true, "operator allocations should be slashed"); - assert_Snap_Unchanged_StakerDepositShares(staker, "staker deposit shares should be unchanged after slashing"); - assert_Snap_StakerWithdrawableShares_AfterSlash(staker, allocateParams, slashingParams, "staker deposit shares should be slashed"); - } - - // 5. Undelegate from an operator - IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.undelegate(); - bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); - - // 6. Complete withdrawal - _rollBlocksForCompleteWithdrawals(withdrawals); - for (uint256 i = 0; i < withdrawals.length; ++i) { - uint256[] memory expectedTokens = - _calculateExpectedTokens(withdrawals[i].strategies, withdrawals[i].scaledShares); - staker.completeWithdrawalAsTokens(withdrawals[i]); - check_Withdrawal_AsTokens_State_AfterSlash(staker, operator, withdrawals[i], allocateParams, slashingParams, expectedTokens); - } - - // Check Final State - assert_HasNoDelegatableShares(staker, "staker should have withdrawn all shares"); - assert_HasUnderlyingTokenBalances_AfterSlash( - staker, - allocateParams, - slashingParams, - tokenBalances, - "staker should once again have original token tokenBalances minus slashed" - ); - assert_NoWithdrawalsPending(withdrawalRoots, "all withdrawals should be removed from pending"); - } - - function testFuzz_deposit_delegate_allocate_slash_undelegate_completeAsShares( - uint24 _random - ) public { - _configRand({_randomSeed: _random, _assetTypes: HOLDS_ALL, _userTypes: DEFAULT}); - _upgradeEigenLayerContracts(); // Upgrade contracts if forkType is not local - - (User staker, IStrategy[] memory strategies, uint256[] memory tokenBalances) = _newRandomStaker(); - (User operator,,) = _newRandomOperator(); - (AVS avs,) = _newRandomAVS(); - - - // 1. Deposit Into Strategies - staker.depositIntoEigenlayer(strategies, tokenBalances); - uint256[] memory shares = _calculateExpectedShares(strategies, tokenBalances); - // TODO - post-deposit and post-delegate checks? - - // 2. Delegate to an operator - staker.delegateTo(operator); - - // Create an operator set and register an operator. - OperatorSet memory operatorSet = avs.createOperatorSet(strategies); - operator.registerForOperatorSet(operatorSet); - - // 3. Allocate to operator set. - IAllocationManagerTypes.AllocateParams memory allocateParams = - operator.modifyAllocations(operatorSet, _randMagnitudes({sum: 1 ether, len: strategies.length})); - assert_Snap_Allocations_Modified( - operator, allocateParams, false, "operator allocations should be updated before delay" - ); - _rollBlocksForCompleteAllocation(operator, operatorSet, strategies); - assert_Snap_Allocations_Modified( - operator, allocateParams, true, "operator allocations should be updated after delay" - ); - - // 4. Slash operator - IAllocationManagerTypes.SlashingParams memory slashingParams; - { - (IStrategy[] memory strategiesToSlash, uint256[] memory wadsToSlash) = - _randStrategiesAndWadsToSlash(operatorSet); - slashingParams = avs.slashOperator(operator, operatorSet.id, strategiesToSlash, wadsToSlash); - assert_Snap_Allocations_Slashed(slashingParams, operatorSet, true, "operator allocations should be slashed"); - assert_Snap_Unchanged_StakerDepositShares(staker, "staker deposit shares should be unchanged after slashing"); - assert_Snap_StakerWithdrawableShares_AfterSlash(staker, allocateParams, slashingParams, "staker deposit shares should be slashed"); - } - - // 5. Undelegate from an operator - IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.undelegate(); - bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); - - // 4. Complete withdrawal - // Fast forward to when we can complete the withdrawal - _rollBlocksForCompleteWithdrawals(withdrawals); - - for (uint256 i = 0; i < withdrawals.length; ++i) { - staker.completeWithdrawalAsShares(withdrawals[i]); - check_Withdrawal_AsShares_State_AfterSlash(staker, operator, withdrawals[i], allocateParams, slashingParams); - } - - // Check final state: - assert_HasNoUnderlyingTokenBalance(staker, strategies, "staker not have any underlying tokens"); - assert_NoWithdrawalsPending(withdrawalRoots, "all withdrawals should be removed from pending"); - } - - function testFuzz_deposit_delegate_allocate_queue_slash_completeAsTokens( - uint24 _random - ) public { - _configRand({_randomSeed: _random, _assetTypes: HOLDS_ALL, _userTypes: DEFAULT}); - _upgradeEigenLayerContracts(); // Upgrade contracts if forkType is not local - - (User staker, IStrategy[] memory strategies, uint256[] memory tokenBalances) = _newRandomStaker(); - (User operator,,) = _newRandomOperator(); - (AVS avs,) = _newRandomAVS(); - - // 1. Deposit Into Strategies - staker.depositIntoEigenlayer(strategies, tokenBalances); - // 2. Delegate to an operator - staker.delegateTo(operator); - - // Create an operator set and register an operator. - OperatorSet memory operatorSet = avs.createOperatorSet(strategies); - operator.registerForOperatorSet(operatorSet); - - // 3. Allocate to operator set. - IAllocationManagerTypes.AllocateParams memory allocateParams = - operator.modifyAllocations(operatorSet, _randMagnitudes({sum: 1 ether, len: strategies.length})); - assert_Snap_Allocations_Modified( - operator, allocateParams, false, "operator allocations should be updated before delay" - ); - _rollBlocksForCompleteAllocation(operator, operatorSet, strategies); - assert_Snap_Allocations_Modified( - operator, allocateParams, true, "operator allocations should be updated after delay" - ); - - // 4. Queue withdrawal - IDelegationManagerTypes.Withdrawal[] memory withdrawals = - staker.queueWithdrawals(strategies, _calculateExpectedShares(strategies, tokenBalances)); - bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); - - // 5. Slash operator - IAllocationManagerTypes.SlashingParams memory slashingParams; - { - (IStrategy[] memory strategiesToSlash, uint256[] memory wadsToSlash) = - _randStrategiesAndWadsToSlash(operatorSet); - slashingParams = avs.slashOperator(operator, operatorSet.id, strategiesToSlash, wadsToSlash); - assert_Snap_Allocations_Slashed(slashingParams, operatorSet, true, "operator allocations should be slashed"); - assert_Snap_Unchanged_StakerDepositShares(staker, "staker deposit shares should be unchanged after slashing"); - assert_Snap_StakerWithdrawableShares_AfterSlash(staker, allocateParams, slashingParams, "staker deposit shares should be slashed"); - } - - // 6. Complete withdrawal - _rollBlocksForCompleteWithdrawals(withdrawals); - for (uint256 i = 0; i < withdrawals.length; ++i) { - uint256[] memory expectedTokens = - _calculateExpectedTokens(withdrawals[i].strategies, withdrawals[i].scaledShares); - staker.completeWithdrawalAsTokens(withdrawals[i]); - check_Withdrawal_AsTokens_State_AfterSlash( - staker, operator, withdrawals[i], allocateParams, slashingParams, expectedTokens - ); - } - - // Check Final State - assert_HasNoDelegatableShares(staker, "staker should have withdrawn all shares"); - assert_HasUnderlyingTokenBalances_AfterSlash( - staker, - allocateParams, - slashingParams, - tokenBalances, - "staker should once again have original token tokenBalances minus slashed" - ); - assert_NoWithdrawalsPending(withdrawalRoots, "all withdrawals should be removed from pending"); - } - - function testFuzz_deposit_delegate_allocate_queue_slash_completeAsShares( - uint24 _random - ) public { - _configRand({_randomSeed: _random, _assetTypes: HOLDS_ALL, _userTypes: DEFAULT}); - _upgradeEigenLayerContracts(); // Upgrade contracts if forkType is not local - - (User staker, IStrategy[] memory strategies, uint256[] memory tokenBalances) = _newRandomStaker(); - (User operator,,) = _newRandomOperator(); - (AVS avs,) = _newRandomAVS(); - - // 1. Deposit Into Strategies - staker.depositIntoEigenlayer(strategies, tokenBalances); - // 2. Delegate to an operator - staker.delegateTo(operator); - - // Create an operator set and register an operator. - OperatorSet memory operatorSet = avs.createOperatorSet(strategies); - operator.registerForOperatorSet(operatorSet); - operator.setAllocationDelay(1); - - // 3. Allocate to operator set. - IAllocationManagerTypes.AllocateParams memory allocateParams = - operator.modifyAllocations(operatorSet, _randMagnitudes({sum: 1 ether, len: strategies.length})); - assert_Snap_Allocations_Modified( - operator, allocateParams, false, "operator allocations should be updated before delay" - ); - _rollBlocksForCompleteAllocation(operator, operatorSet, strategies); - assert_Snap_Allocations_Modified( - operator, allocateParams, true, "operator allocations should be updated after delay" - ); - - // 4. Queue withdrawal - IDelegationManagerTypes.Withdrawal[] memory withdrawals = - staker.queueWithdrawals(strategies, _calculateExpectedShares(strategies, tokenBalances)); - bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); - - // 5. Slash operator - IAllocationManagerTypes.SlashingParams memory slashingParams; - { - (IStrategy[] memory strategiesToSlash, uint256[] memory wadsToSlash) = - _randStrategiesAndWadsToSlash(operatorSet); - slashingParams = avs.slashOperator(operator, operatorSet.id, strategiesToSlash, wadsToSlash); - assert_Snap_Allocations_Slashed(slashingParams, operatorSet, true, "operator allocations should be slashed"); - assert_Snap_Unchanged_StakerDepositShares(staker, "staker deposit shares should be unchanged after slashing"); - assert_Snap_StakerWithdrawableShares_AfterSlash(staker, allocateParams, slashingParams, "staker deposit shares should be slashed"); - } - - // 4. Complete withdrawal - // Fast forward to when we can complete the withdrawal - _rollBlocksForCompleteWithdrawals(withdrawals); - - for (uint256 i = 0; i < withdrawals.length; ++i) { - staker.completeWithdrawalAsShares(withdrawals[i]); - check_Withdrawal_AsShares_State_AfterSlash(staker, operator, withdrawals[i], allocateParams, slashingParams); - } - - // Check final state: - assert_HasNoUnderlyingTokenBalance(staker, strategies, "staker not have any underlying tokens"); - assert_NoWithdrawalsPending(withdrawalRoots, "all withdrawals should be removed from pending"); - } - - function testFuzz_deposit_delegate_allocate_deallocate_slash_queue_completeAsTokens( - uint24 _random - ) public { - _configRand({_randomSeed: _random, _assetTypes: HOLDS_ALL, _userTypes: DEFAULT}); - _upgradeEigenLayerContracts(); // Upgrade contracts if forkType is not local - - (User staker, IStrategy[] memory strategies, uint256[] memory tokenBalances) = _newRandomStaker(); - (User operator,,) = _newRandomOperator(); - (AVS avs,) = _newRandomAVS(); - - // 1. Deposit Into Strategies - staker.depositIntoEigenlayer(strategies, tokenBalances); - // 2. Delegate to an operator - staker.delegateTo(operator); - - // Create an operator set and register an operator. - OperatorSet memory operatorSet = avs.createOperatorSet(strategies); - operator.registerForOperatorSet(operatorSet); - operator.setAllocationDelay(1); - - console.log("block allocated", block.number); - // 3. Allocate to operator set. - IAllocationManagerTypes.AllocateParams memory allocateParams = - operator.modifyAllocations(operatorSet, _randMagnitudes({sum: 1 ether, len: strategies.length})); - assert_Snap_Allocations_Modified( - operator, allocateParams, false, "operator allocations should be updated before delay" - ); - _rollBlocksForCompleteAllocation(operator, operatorSet, strategies); - assert_Snap_Allocations_Modified( - operator, allocateParams, true, "operator allocations should be updated after delay" - ); - - // 4. Deallocate all. - IAllocationManagerTypes.AllocateParams memory deallocateParams = operator.deallocateAll(operatorSet); - _rollBlocksForCompleteAllocation(operator, operatorSet, strategies); - - // 5. Slash operator - IAllocationManagerTypes.SlashingParams memory slashingParams; - { - (IStrategy[] memory strategiesToSlash, uint256[] memory wadsToSlash) = - _randStrategiesAndWadsToSlash(operatorSet); - slashingParams = avs.slashOperator(operator, operatorSet.id, strategiesToSlash, wadsToSlash); - assert_Snap_Allocations_Slashed(slashingParams, operatorSet, true, "operator allocations should be slashed"); - assert_Snap_Unchanged_StakerDepositShares(staker, "staker deposit shares should be unchanged after slashing"); - assert_Snap_StakerWithdrawableShares_AfterSlash(staker, deallocateParams, slashingParams, "staker deposit shares should be slashed"); - } - - // 6. Queue withdrawals - IDelegationManagerTypes.Withdrawal[] memory withdrawals = - staker.queueWithdrawals(strategies, _calculateExpectedShares(strategies, tokenBalances)); - bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); - - // 7. Complete withdrawal - _rollBlocksForCompleteWithdrawals(withdrawals); - for (uint256 i = 0; i < withdrawals.length; ++i) { - uint256[] memory expectedTokens = - _calculateExpectedTokens(withdrawals[i].strategies, withdrawals[i].scaledShares); - staker.completeWithdrawalAsTokens(withdrawals[i]); - check_Withdrawal_AsTokens_State_AfterSlash( - staker, operator, withdrawals[i], allocateParams, slashingParams, expectedTokens - ); - } - - // Check Final State - assert_HasUnderlyingTokenBalances( - staker, - allocateParams.strategies, - tokenBalances, - "staker should have withdrawn all shares" - ); - assert_NoWithdrawalsPending(withdrawalRoots, "all withdrawals should be removed from pending"); - } - - function testFuzz_deposit_delegate_allocate_deregister_slash( - uint24 _random - ) public { - _configRand({_randomSeed: _random, _assetTypes: HOLDS_ALL, _userTypes: DEFAULT}); - _upgradeEigenLayerContracts(); // Upgrade contracts if forkType is not local - - (User staker, IStrategy[] memory strategies, uint256[] memory tokenBalances) = _newRandomStaker(); - (User operator,,) = _newRandomOperator(); - (AVS avs,) = _newRandomAVS(); - - // 1. Deposit Into Strategies - staker.depositIntoEigenlayer(strategies, tokenBalances); - // 2. Delegate to an operator - staker.delegateTo(operator); - - // Create an operator set and register an operator. - OperatorSet memory operatorSet = avs.createOperatorSet(strategies); - operator.registerForOperatorSet(operatorSet); - - // 3. Allocate to operator set. - IAllocationManagerTypes.AllocateParams memory allocateParams = - operator.modifyAllocations(operatorSet, _randMagnitudes({sum: 1 ether, len: strategies.length})); - assert_Snap_Allocations_Modified( - operator, allocateParams, false, "operator allocations should be updated before delay" - ); - _rollBlocksForCompleteAllocation(operator, operatorSet, strategies); - assert_Snap_Allocations_Modified( - operator, allocateParams, true, "operator allocations should be updated after delay" - ); - - // 4. Deregister. - operator.deregisterFromOperatorSet(operatorSet); - - // 5. Slash operator - IAllocationManagerTypes.SlashingParams memory slashingParams; - { - (IStrategy[] memory strategiesToSlash, uint256[] memory wadsToSlash) = - _randStrategiesAndWadsToSlash(operatorSet); - slashingParams = avs.slashOperator(operator, operatorSet.id, strategiesToSlash, wadsToSlash); - assert_Snap_Allocations_Slashed(slashingParams, operatorSet, true, "operator allocations should be slashed"); - assert_Snap_Unchanged_StakerDepositShares(staker, "staker deposit shares should be unchanged after slashing"); - assert_Snap_StakerWithdrawableShares_AfterSlash(staker, allocateParams, slashingParams, "staker deposit shares should be slashed"); - } - } -} diff --git a/src/test/integration/tests/Deposit_Delegate_Queue_Complete.t.sol b/src/test/integration/tests/Deposit_Delegate_Queue_Complete.t.sol index 8c2c4e086c..2245f53a90 100644 --- a/src/test/integration/tests/Deposit_Delegate_Queue_Complete.t.sol +++ b/src/test/integration/tests/Deposit_Delegate_Queue_Complete.t.sol @@ -16,14 +16,7 @@ contract Integration_Deposit_Delegate_Queue_Complete is IntegrationCheckUtils { /// 2. delegates to an operator /// 3. queues a withdrawal for a ALL shares /// 4. completes the queued withdrawal as tokens - function testFuzz_deposit_delegate_queue_completeAsTokens(uint24 _random) public { - // When new Users are created, they will choose a random configuration from these params: - _configRand({ - _randomSeed: _random, - _assetTypes: HOLDS_LST | HOLDS_ETH | HOLDS_ALL, - _userTypes: DEFAULT | ALT_METHODS - }); - + function testFuzz_deposit_delegate_queue_completeAsTokens(uint24 _random) public rand(_random) { /// 0. Create an operator and a staker with: // - some nonzero underlying token balances // - corresponding to a random subset of valid strategies (StrategyManager and/or EigenPodManager) @@ -35,8 +28,6 @@ contract Integration_Deposit_Delegate_Queue_Complete is IntegrationCheckUtils { uint[] memory tokenBalances ) = _newRandomStaker(); (User operator, ,) = _newRandomOperator(); - // Upgrade contracts if forkType is not local - _upgradeEigenLayerContracts(); uint[] memory shares = _calculateExpectedShares(strategies, tokenBalances); @@ -52,7 +43,7 @@ contract Integration_Deposit_Delegate_Queue_Complete is IntegrationCheckUtils { check_Delegation_State(staker, operator, strategies, shares); // 3. Queue Withdrawals - IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.queueWithdrawals(strategies, shares); + Withdrawal[] memory withdrawals = staker.queueWithdrawals(strategies, shares); bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); check_QueuedWithdrawal_State(staker, operator, strategies, shares, withdrawals, withdrawalRoots); @@ -78,14 +69,7 @@ contract Integration_Deposit_Delegate_Queue_Complete is IntegrationCheckUtils { /// 2. delegates to an operator /// 3. queues a withdrawal for a ALL shares /// 4. completes the queued withdrawal as shares - function testFuzz_deposit_delegate_queue_completeAsShares(uint24 _random) public { - // When new Users are created, they will choose a random configuration from these params: - _configRand({ - _randomSeed: _random, - _assetTypes: HOLDS_LST | HOLDS_ETH | HOLDS_ALL, - _userTypes: DEFAULT | ALT_METHODS - }); - + function testFuzz_deposit_delegate_queue_completeAsShares(uint24 _random) public rand(_random) { /// 0. Create an operator and a staker with: // - some nonzero underlying token balances // - corresponding to a random subset of valid strategies (StrategyManager and/or EigenPodManager) @@ -97,8 +81,6 @@ contract Integration_Deposit_Delegate_Queue_Complete is IntegrationCheckUtils { uint[] memory tokenBalances ) = _newRandomStaker(); (User operator, ,) = _newRandomOperator(); - // Upgrade contracts if forkType is not local - _upgradeEigenLayerContracts(); uint[] memory shares = _calculateExpectedShares(strategies, tokenBalances); @@ -114,7 +96,7 @@ contract Integration_Deposit_Delegate_Queue_Complete is IntegrationCheckUtils { check_Delegation_State(staker, operator, strategies, shares); // 3. Queue Withdrawals - IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.queueWithdrawals(strategies, shares); + Withdrawal[] memory withdrawals = staker.queueWithdrawals(strategies, shares); bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); check_QueuedWithdrawal_State(staker, operator, strategies, shares, withdrawals, withdrawalRoots); @@ -143,14 +125,7 @@ contract Integration_Deposit_Delegate_Queue_Complete is IntegrationCheckUtils { /// 2. delegates to an operator /// 3. queues a withdrawal for a random subset of shares /// 4. completes the queued withdrawal as tokens - function testFuzz_deposit_delegate_queueRand_completeAsTokens(uint24 _random) public { - // When new Users are created, they will choose a random configuration from these params: - _configRand({ - _randomSeed: _random, - _assetTypes: HOLDS_LST | HOLDS_ETH | HOLDS_ALL, - _userTypes: DEFAULT | ALT_METHODS - }); - + function testFuzz_deposit_delegate_queueRand_completeAsTokens(uint24 _random) public rand(_random) { /// 0. Create an operator and a staker with: // - some nonzero underlying token balances // - corresponding to a random subset of valid strategies (StrategyManager and/or EigenPodManager) @@ -162,8 +137,6 @@ contract Integration_Deposit_Delegate_Queue_Complete is IntegrationCheckUtils { uint[] memory tokenBalances ) = _newRandomStaker(); (User operator, ,) = _newRandomOperator(); - // Upgrade contracts if forkType is not local - _upgradeEigenLayerContracts(); uint[] memory shares = _calculateExpectedShares(strategies, tokenBalances); @@ -185,7 +158,7 @@ contract Integration_Deposit_Delegate_Queue_Complete is IntegrationCheckUtils { uint[] memory withdrawShares ) = _randWithdrawal(strategies, shares); - IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.queueWithdrawals(withdrawStrats, withdrawShares); + Withdrawal[] memory withdrawals = staker.queueWithdrawals(withdrawStrats, withdrawShares); bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); check_QueuedWithdrawal_State(staker, operator, withdrawStrats, withdrawShares, withdrawals, withdrawalRoots); @@ -208,14 +181,7 @@ contract Integration_Deposit_Delegate_Queue_Complete is IntegrationCheckUtils { /// 2. delegates to an operator /// 3. queues a withdrawal for a random subset of shares /// 4. completes the queued withdrawal as shares - function testFuzz_deposit_delegate_queueRand_completeAsShares(uint24 _random) public { - // When new Users are created, they will choose a random configuration from these params: - _configRand({ - _randomSeed: _random, - _assetTypes: HOLDS_LST | HOLDS_ETH | HOLDS_ALL, - _userTypes: DEFAULT | ALT_METHODS - }); - + function testFuzz_deposit_delegate_queueRand_completeAsShares(uint24 _random) public rand(_random) { /// 0. Create an operator and a staker with: // - some nonzero underlying token balances // - corresponding to a random subset of valid strategies (StrategyManager and/or EigenPodManager) @@ -227,8 +193,6 @@ contract Integration_Deposit_Delegate_Queue_Complete is IntegrationCheckUtils { uint[] memory tokenBalances ) = _newRandomStaker(); (User operator, ,) = _newRandomOperator(); - // Upgrade contracts if forkType is not local - _upgradeEigenLayerContracts(); uint[] memory shares = _calculateExpectedShares(strategies, tokenBalances); @@ -250,7 +214,7 @@ contract Integration_Deposit_Delegate_Queue_Complete is IntegrationCheckUtils { uint[] memory withdrawShares ) = _randWithdrawal(strategies, shares); - IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.queueWithdrawals(withdrawStrats, withdrawShares); + Withdrawal[] memory withdrawals = staker.queueWithdrawals(withdrawStrats, withdrawShares); bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); check_QueuedWithdrawal_State(staker, operator, withdrawStrats, withdrawShares, withdrawals, withdrawalRoots); @@ -280,12 +244,8 @@ contract Integration_Deposit_Delegate_Queue_Complete is IntegrationCheckUtils { /// 2. delegates to an operator /// /// ... we check that the final step fails - function testFuzz_deposit_delegate_revert_alreadyDelegated(uint24 _random) public { - _configRand({ - _randomSeed: _random, - _assetTypes: NO_ASSETS | HOLDS_LST | HOLDS_ETH | HOLDS_ALL, - _userTypes: DEFAULT | ALT_METHODS - }); + function testFuzz_deposit_delegate_revert_alreadyDelegated(uint24 _random) public rand(_random) { + _configAssetTypes(NO_ASSETS | HOLDS_LST | HOLDS_ETH | HOLDS_ALL); /// 0. Create a staker and operator ( @@ -294,8 +254,6 @@ contract Integration_Deposit_Delegate_Queue_Complete is IntegrationCheckUtils { uint[] memory tokenBalances ) = _newRandomStaker(); (User operator, ,) = _newRandomOperator(); - // Upgrade contracts if forkType is not local - _upgradeEigenLayerContracts(); uint[] memory shares = _calculateExpectedShares(strategies, tokenBalances); diff --git a/src/test/integration/tests/Deposit_Delegate_Redelegate_Complete.t.sol b/src/test/integration/tests/Deposit_Delegate_Redelegate_Complete.t.sol index 7825645917..48b37cad8b 100644 --- a/src/test/integration/tests/Deposit_Delegate_Redelegate_Complete.t.sol +++ b/src/test/integration/tests/Deposit_Delegate_Redelegate_Complete.t.sol @@ -5,6 +5,8 @@ import "src/test/integration/users/User.t.sol"; import "src/test/integration/IntegrationChecks.t.sol"; contract Integration_Deposit_Delegate_Redelegate_Complete is IntegrationCheckUtils { + using ArrayLib for *; + /// Randomly generates a user with different held assets. Then: /// 1. deposit into strategy /// 2. delegate to an operator @@ -13,14 +15,7 @@ contract Integration_Deposit_Delegate_Redelegate_Complete is IntegrationCheckUti /// 5. delegate to a new operator /// 5. queueWithdrawal /// 7. complete their queued withdrawal as tokens - function testFuzz_deposit_delegate_reDelegate_completeAsTokens(uint24 _random) public { - // When new Users are created, they will choose a random configuration from these params: - _configRand({ - _randomSeed: _random, - _assetTypes: HOLDS_LST | HOLDS_ETH | HOLDS_ALL, - _userTypes: DEFAULT | ALT_METHODS - }); - + function testFuzz_deposit_delegate_reDelegate_completeAsTokens(uint24 _random) public rand(_random) { /// 0. Create an operator and a staker with: // - some nonzero underlying token balances // - corresponding to a random number of strategies @@ -34,10 +29,10 @@ contract Integration_Deposit_Delegate_Redelegate_Complete is IntegrationCheckUti ) = _newRandomStaker(); (User operator1, ,) = _newRandomOperator(); (User operator2, ,) = _newRandomOperator(); - // Upgrade contracts if forkType is not local - _upgradeEigenLayerContracts(); uint[] memory shares = _calculateExpectedShares(strategies, tokenBalances); + //delegatable shares equals deposit shares here because no bc slashing + uint[] memory delegatableShares = shares; assert_HasNoDelegatableShares(staker, "staker should not have delegatable shares before depositing"); assertFalse(delegationManager.isDelegated(address(staker)), "staker should not be delegated"); @@ -51,9 +46,9 @@ contract Integration_Deposit_Delegate_Redelegate_Complete is IntegrationCheckUti check_Delegation_State(staker, operator1, strategies, shares); // 3. Undelegate from an operator - IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.undelegate(); + Withdrawal[] memory withdrawals = staker.undelegate(); bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); - check_Undelegate_State(staker, operator1, withdrawals, withdrawalRoots, strategies, shares); + check_Undelegate_State(staker, operator1, withdrawals, withdrawalRoots, strategies, shares, delegatableShares); // 4. Complete withdrawal as shares // Fast forward to when we can complete the withdrawal @@ -85,14 +80,7 @@ contract Integration_Deposit_Delegate_Redelegate_Complete is IntegrationCheckUti } } - function testFuzz_deposit_delegate_reDelegate_completeAsShares(uint24 _random) public { - // When new Users are created, they will choose a random configuration from these params: - _configRand({ - _randomSeed: _random, - _assetTypes: HOLDS_LST | HOLDS_ETH | HOLDS_ALL, - _userTypes: DEFAULT | ALT_METHODS - }); - + function testFuzz_deposit_delegate_reDelegate_completeAsShares(uint24 _random) public rand(_random) { /// 0. Create an operator and a staker with: // - some nonzero underlying token balances // - corresponding to a random number of strategies @@ -106,10 +94,10 @@ contract Integration_Deposit_Delegate_Redelegate_Complete is IntegrationCheckUti ) = _newRandomStaker(); (User operator1, ,) = _newRandomOperator(); (User operator2, ,) = _newRandomOperator(); - // Upgrade contracts if forkType is not local - _upgradeEigenLayerContracts(); uint[] memory shares = _calculateExpectedShares(strategies, tokenBalances); + //delegatable shares equals deposit shares here because no bc slashing + uint[] memory delegatableShares = shares; assert_HasNoDelegatableShares(staker, "staker should not have delegatable shares before depositing"); assertFalse(delegationManager.isDelegated(address(staker)), "staker should not be delegated"); @@ -123,9 +111,9 @@ contract Integration_Deposit_Delegate_Redelegate_Complete is IntegrationCheckUti check_Delegation_State(staker, operator1, strategies, shares); // 3. Undelegate from an operator - IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.undelegate(); + Withdrawal[] memory withdrawals = staker.undelegate(); bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); - check_Undelegate_State(staker, operator1, withdrawals, withdrawalRoots, strategies, shares); + check_Undelegate_State(staker, operator1, withdrawals, withdrawalRoots, strategies, shares, delegatableShares); // 4. Complete withdrawal as shares // Fast forward to when we can complete the withdrawal @@ -170,13 +158,8 @@ contract Integration_Deposit_Delegate_Redelegate_Complete is IntegrationCheckUti ); } - function testFuzz_deposit_delegate_reDelegate_depositAfterRedelegate(uint24 _random) public { - // When new Users are created, they will choose a random configuration from these params: - _configRand({ - _randomSeed: _random, - _assetTypes: HOLDS_LST, // not holding ETH since we can only deposit 32 ETH multiples - _userTypes: DEFAULT | ALT_METHODS - }); + function testFuzz_deposit_delegate_reDelegate_depositAfterRedelegate(uint24 _random) public rand(_random) { + _configAssetTypes(HOLDS_LST); // not holding ETH since we can only deposit 32 ETH multiples /// 0. Create an operator and a staker with: // - some nonzero underlying token balances @@ -191,8 +174,6 @@ contract Integration_Deposit_Delegate_Redelegate_Complete is IntegrationCheckUti ) = _newRandomStaker(); (User operator1, ,) = _newRandomOperator(); (User operator2, ,) = _newRandomOperator(); - // Upgrade contracts if forkType is not local - _upgradeEigenLayerContracts(); uint[] memory shares = _calculateExpectedShares(strategies, tokenBalances); @@ -208,6 +189,8 @@ contract Integration_Deposit_Delegate_Redelegate_Complete is IntegrationCheckUti numTokensRemaining[i] = tokenBalances[i] - numTokensToDeposit[i]; } uint[] memory halfShares = _calculateExpectedShares(strategies, numTokensToDeposit); + //delegatable shares equals deposit shares here because no bc slashing + uint[] memory delegatableShares = halfShares; /// 1. Deposit Into Strategies staker.depositIntoEigenlayer(strategies, numTokensToDeposit); @@ -218,9 +201,9 @@ contract Integration_Deposit_Delegate_Redelegate_Complete is IntegrationCheckUti check_Delegation_State(staker, operator1, strategies, halfShares); // 3. Undelegate from an operator - IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.undelegate(); + Withdrawal[] memory withdrawals = staker.undelegate(); bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); - check_Undelegate_State(staker, operator1, withdrawals, withdrawalRoots, strategies, halfShares); + check_Undelegate_State(staker, operator1, withdrawals, withdrawalRoots, strategies, halfShares, delegatableShares); // 4. Complete withdrawal as shares // Fast forward to when we can complete the withdrawal @@ -245,7 +228,7 @@ contract Integration_Deposit_Delegate_Redelegate_Complete is IntegrationCheckUti { // 7. Queue Withdrawal shares = _calculateExpectedShares(strategies, tokenBalances); - IDelegationManagerTypes.Withdrawal[] memory newWithdrawals = staker.queueWithdrawals(strategies, shares); + Withdrawal[] memory newWithdrawals = staker.queueWithdrawals(strategies, shares); bytes32[] memory newWithdrawalRoots = _getWithdrawalHashes(newWithdrawals); check_QueuedWithdrawal_State(staker, operator2, strategies, shares, newWithdrawals, newWithdrawalRoots); @@ -262,13 +245,8 @@ contract Integration_Deposit_Delegate_Redelegate_Complete is IntegrationCheckUti } } - function testFuzz_deposit_delegate_reDelegate_depositBeforeRedelegate(uint24 _random) public { - // When new Users are created, they will choose a random configuration from these params: - _configRand({ - _randomSeed: _random, - _assetTypes: HOLDS_LST, // not holding ETH since we can only deposit 32 ETH multiples - _userTypes: DEFAULT | ALT_METHODS - }); + function testFuzz_deposit_delegate_reDelegate_depositBeforeRedelegate(uint24 _random) public rand(_random) { + _configAssetTypes(HOLDS_LST); // not holding ETH since we can only deposit 32 ETH multiples /// 0. Create an operator and a staker with: // - some nonzero underlying token balances @@ -283,10 +261,8 @@ contract Integration_Deposit_Delegate_Redelegate_Complete is IntegrationCheckUti ) = _newRandomStaker(); (User operator1, ,) = _newRandomOperator(); (User operator2, ,) = _newRandomOperator(); - // Upgrade contracts if forkType is not local - _upgradeEigenLayerContracts(); - uint[] memory shares = _calculateExpectedShares(strategies, tokenBalances); + uint[] memory totalShares = new uint[](strategies.length); assert_HasNoDelegatableShares(staker, "staker should not have delegatable shares before depositing"); assertFalse(delegationManager.isDelegated(address(staker)), "staker should not be delegated"); @@ -295,51 +271,59 @@ contract Integration_Deposit_Delegate_Redelegate_Complete is IntegrationCheckUti // Divide shares by 2 in new array to do deposits after redelegate uint[] memory numTokensToDeposit = new uint[](tokenBalances.length); uint[] memory numTokensRemaining = new uint[](tokenBalances.length); - for (uint i = 0; i < shares.length; i++) { + for (uint i = 0; i < strategies.length; i++) { numTokensToDeposit[i] = tokenBalances[i] / 2; numTokensRemaining[i] = tokenBalances[i] - numTokensToDeposit[i]; } - uint[] memory halfShares = _calculateExpectedShares(strategies, numTokensToDeposit); - - /// 1. Deposit Into Strategies - staker.depositIntoEigenlayer(strategies, numTokensToDeposit); - check_Deposit_State_PartialDeposit(staker, strategies, halfShares, numTokensRemaining); - - // 2. Delegate to an operator - staker.delegateTo(operator1); - check_Delegation_State(staker, operator1, strategies, halfShares); - - // 3. Undelegate from an operator - IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.undelegate(); - bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); - check_Undelegate_State(staker, operator1, withdrawals, withdrawalRoots, strategies, halfShares); - - // 4. Complete withdrawal as shares - // Fast forward to when we can complete the withdrawal - _rollBlocksForCompleteWithdrawals(withdrawals); - for (uint256 i = 0; i < withdrawals.length; ++i) { - staker.completeWithdrawalAsShares(withdrawals[i]); - check_Withdrawal_AsShares_Undelegated_State(staker, operator1, withdrawals[i], withdrawals[i].strategies, withdrawals[i].scaledShares); + { + uint[] memory sharesFromFirstDeposit = _calculateExpectedShares(strategies, numTokensToDeposit); + //delegatable shares equals deposit shares here because no bc slashing + uint[] memory delegatableShares = sharesFromFirstDeposit; + + /// 1. Deposit Into Strategies + staker.depositIntoEigenlayer(strategies, numTokensToDeposit); + check_Deposit_State_PartialDeposit(staker, strategies, sharesFromFirstDeposit, numTokensRemaining); + + // 2. Delegate to an operator + staker.delegateTo(operator1); + check_Delegation_State(staker, operator1, strategies, sharesFromFirstDeposit); + + // 3. Undelegate from an operator + Withdrawal[] memory withdrawals = staker.undelegate(); + bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); + check_Undelegate_State(staker, operator1, withdrawals, withdrawalRoots, strategies, sharesFromFirstDeposit, delegatableShares); + + // 4. Complete withdrawal as shares + // Fast forward to when we can complete the withdrawal + _rollBlocksForCompleteWithdrawals(withdrawals); + for (uint256 i = 0; i < withdrawals.length; ++i) { + staker.completeWithdrawalAsShares(withdrawals[i]); + check_Withdrawal_AsShares_Undelegated_State(staker, operator1, withdrawals[i], withdrawals[i].strategies, withdrawals[i].scaledShares); + } + + // 5. Deposit into Strategies + uint[] memory sharesFromSecondDeposit = _calculateExpectedShares(strategies, numTokensRemaining); + for (uint i = 0; i < strategies.length; i++) { + totalShares[i] = sharesFromFirstDeposit[i] + sharesFromSecondDeposit[i]; + } + + staker.depositIntoEigenlayer(strategies, numTokensRemaining); + tokenBalances = _calculateExpectedTokens(strategies, totalShares); + check_Deposit_State(staker, strategies, sharesFromSecondDeposit); } - // 5. Deposit into Strategies - uint[] memory sharesAdded = _calculateExpectedShares(strategies, numTokensRemaining); - staker.depositIntoEigenlayer(strategies, numTokensRemaining); - tokenBalances = _calculateExpectedTokens(strategies, shares); - check_Deposit_State(staker, strategies, sharesAdded); - // 6. Delegate to a new operator staker.delegateTo(operator2); - check_Delegation_State(staker, operator2, strategies, shares); + check_Delegation_State(staker, operator2, strategies, totalShares); assertNotEq(address(operator1), delegationManager.delegatedTo(address(staker)), "staker should not be delegated to operator1"); } { // 7. Queue Withdrawal - shares = _calculateExpectedShares(strategies, tokenBalances); - IDelegationManagerTypes.Withdrawal[] memory newWithdrawals = staker.queueWithdrawals(strategies, shares); + totalShares = _calculateExpectedShares(strategies, tokenBalances); + Withdrawal[] memory newWithdrawals = staker.queueWithdrawals(strategies, totalShares); bytes32[] memory newWithdrawalRoots = _getWithdrawalHashes(newWithdrawals); - check_QueuedWithdrawal_State(staker, operator2, strategies, shares, newWithdrawals, newWithdrawalRoots); + check_QueuedWithdrawal_State(staker, operator2, strategies, totalShares, newWithdrawals, newWithdrawalRoots); // 8. Complete withdrawal // Fast forward to when we can complete the withdrawal @@ -349,19 +333,12 @@ contract Integration_Deposit_Delegate_Redelegate_Complete is IntegrationCheckUti for (uint i = 0; i < newWithdrawals.length; i++) { uint[] memory expectedTokens = _calculateExpectedTokens(newWithdrawals[i].strategies, newWithdrawals[i].scaledShares); IERC20[] memory tokens = staker.completeWithdrawalAsTokens(newWithdrawals[i]); - check_Withdrawal_AsTokens_State(staker, operator2, newWithdrawals[i], strategies, shares, tokens, expectedTokens); + check_Withdrawal_AsTokens_State(staker, operator2, newWithdrawals[i], strategies, totalShares, tokens, expectedTokens); } } } - function testFuzz_deposit_delegate_undelegate_withdrawAsTokens_reDelegate_completeAsTokens(uint24 _random) public { - // When new Users are created, they will choose a random configuration from these params: - _configRand({ - _randomSeed: _random, - _assetTypes: HOLDS_LST | HOLDS_ETH | HOLDS_ALL, - _userTypes: DEFAULT | ALT_METHODS - }); - + function testFuzz_deposit_delegate_undelegate_withdrawAsTokens_reDelegate_completeAsTokens(uint24 _random) public rand(_random) { /// 0. Create operators and a staker ( User staker, @@ -370,10 +347,10 @@ contract Integration_Deposit_Delegate_Redelegate_Complete is IntegrationCheckUti ) = _newRandomStaker(); (User operator1, ,) = _newRandomOperator(); (User operator2, ,) = _newRandomOperator(); - // Upgrade contracts if forkType is not local - _upgradeEigenLayerContracts(); uint[] memory shares = _calculateExpectedShares(strategies, tokenBalances); + //delegatable shares equals deposit shares here because no bc slashing + uint[] memory delegatableShares = shares; assert_HasNoDelegatableShares(staker, "staker should not have delegatable shares before depositing"); assertFalse(delegationManager.isDelegated(address(staker)), "staker should not be delegated"); @@ -388,9 +365,9 @@ contract Integration_Deposit_Delegate_Redelegate_Complete is IntegrationCheckUti check_Delegation_State(staker, operator1, strategies, shares); // 3. Undelegate from an operator - IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.undelegate(); + Withdrawal[] memory withdrawals = staker.undelegate(); bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); - check_Undelegate_State(staker, operator1, withdrawals, withdrawalRoots, strategies, shares); + check_Undelegate_State(staker, operator1, withdrawals, withdrawalRoots, strategies, shares, delegatableShares); // 4. Complete withdrawal as tokens // Fast forward to when we can complete the withdrawal @@ -428,14 +405,7 @@ contract Integration_Deposit_Delegate_Redelegate_Complete is IntegrationCheckUti } } - function testFuzz_deposit_delegate_undelegate_withdrawAsTokens_reDelegate_completeAsShares(uint24 _random) public { - // When new Users are created, they will choose a random configuration from these params: - _configRand({ - _randomSeed: _random, - _assetTypes: HOLDS_LST | HOLDS_ETH | HOLDS_ALL, - _userTypes: DEFAULT | ALT_METHODS - }); - + function testFuzz_deposit_delegate_undelegate_withdrawAsTokens_reDelegate_completeAsShares(uint24 _random) public rand(_random) { /// 0. Create operators and a staker ( User staker, @@ -444,10 +414,10 @@ contract Integration_Deposit_Delegate_Redelegate_Complete is IntegrationCheckUti ) = _newRandomStaker(); (User operator1, ,) = _newRandomOperator(); (User operator2, ,) = _newRandomOperator(); - // Upgrade contracts if forkType is not local - _upgradeEigenLayerContracts(); uint[] memory shares = _calculateExpectedShares(strategies, tokenBalances); + //delegatable shares equals deposit shares here because no bc slashing + uint[] memory delegatableShares = shares; assert_HasNoDelegatableShares(staker, "staker should not have delegatable shares before depositing"); assertFalse(delegationManager.isDelegated(address(staker)), "staker should not be delegated"); @@ -462,9 +432,9 @@ contract Integration_Deposit_Delegate_Redelegate_Complete is IntegrationCheckUti check_Delegation_State(staker, operator1, strategies, shares); // 3. Undelegate from an operator - IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.undelegate(); + Withdrawal[] memory withdrawals = staker.undelegate(); bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); - check_Undelegate_State(staker, operator1, withdrawals, withdrawalRoots, strategies, shares); + check_Undelegate_State(staker, operator1, withdrawals, withdrawalRoots, strategies, shares, delegatableShares); // 4. Complete withdrawal as Tokens // Fast forward to when we can complete the withdrawal @@ -475,7 +445,8 @@ contract Integration_Deposit_Delegate_Redelegate_Complete is IntegrationCheckUti check_Withdrawal_AsTokens_State(staker, operator1, withdrawals[i], withdrawals[i].strategies, withdrawals[i].scaledShares, tokens, expectedTokens); } - //5. Deposit into Strategies + // 5. Deposit into Strategies + shares = _calculateExpectedShares(strategies, withdrawnTokenBalances); staker.depositIntoEigenlayer(strategies, withdrawnTokenBalances); check_Deposit_State(staker, strategies, shares); diff --git a/src/test/integration/tests/Deposit_Delegate_Undelegate_Complete.t.sol b/src/test/integration/tests/Deposit_Delegate_Undelegate_Complete.t.sol index ab157f0ced..4979ee1672 100644 --- a/src/test/integration/tests/Deposit_Delegate_Undelegate_Complete.t.sol +++ b/src/test/integration/tests/Deposit_Delegate_Undelegate_Complete.t.sol @@ -10,14 +10,7 @@ contract Integration_Deposit_Delegate_Undelegate_Complete is IntegrationCheckUti /// 2. delegate to an operator /// 3. undelegates from the operator /// 4. complete their queued withdrawal as tokens - function testFuzz_deposit_undelegate_completeAsTokens(uint24 _random) public { - // When new Users are created, they will choose a random configuration from these params: - _configRand({ - _randomSeed: _random, - _assetTypes: HOLDS_LST | HOLDS_ETH | HOLDS_ALL, - _userTypes: DEFAULT | ALT_METHODS - }); - + function testFuzz_deposit_undelegate_completeAsTokens(uint24 _random) public rand(_random) { /// 0. Create an operator and a staker with: // - some nonzero underlying token balances // - corresponding to a random number of strategies @@ -30,10 +23,10 @@ contract Integration_Deposit_Delegate_Undelegate_Complete is IntegrationCheckUti uint[] memory tokenBalances ) = _newRandomStaker(); (User operator, ,) = _newRandomOperator(); - // Upgrade contracts if forkType is not local - _upgradeEigenLayerContracts(); uint[] memory shares = _calculateExpectedShares(strategies, tokenBalances); + //delegatable shares equals deposit shares here because no bc slashing + uint[] memory delegatableShares = shares; assert_HasNoDelegatableShares(staker, "staker should not have delegatable shares before depositing"); assertFalse(delegationManager.isDelegated(address(staker)), "staker should not be delegated"); @@ -47,9 +40,9 @@ contract Integration_Deposit_Delegate_Undelegate_Complete is IntegrationCheckUti check_Delegation_State(staker, operator, strategies, shares); // 3. Undelegate from an operator - IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.undelegate(); + Withdrawal[] memory withdrawals = staker.undelegate(); bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); - check_Undelegate_State(staker, operator, withdrawals, withdrawalRoots, strategies, shares); + check_Undelegate_State(staker, operator, withdrawals, withdrawalRoots, strategies, shares, delegatableShares); // 4. Complete withdrawal // Fast forward to when we can complete the withdrawal @@ -73,14 +66,7 @@ contract Integration_Deposit_Delegate_Undelegate_Complete is IntegrationCheckUti /// 2. delegate to an operator /// 3. undelegates from the operator /// 4. complete their queued withdrawal as shares - function testFuzz_deposit_undelegate_completeAsShares(uint24 _random) public { - // When new Users are created, they will choose a random configuration from these params: - _configRand({ - _randomSeed: _random, - _assetTypes: HOLDS_LST | HOLDS_ETH | HOLDS_ALL, - _userTypes: DEFAULT | ALT_METHODS - }); - + function testFuzz_deposit_undelegate_completeAsShares(uint24 _random) public rand(_random) { /// 0. Create an operator and a staker with: // - some nonzero underlying token balances // - corresponding to a random number of strategies @@ -93,10 +79,10 @@ contract Integration_Deposit_Delegate_Undelegate_Complete is IntegrationCheckUti uint[] memory tokenBalances ) = _newRandomStaker(); (User operator, ,) = _newRandomOperator(); - // Upgrade contracts if forkType is not local - _upgradeEigenLayerContracts(); uint[] memory shares = _calculateExpectedShares(strategies, tokenBalances); + //delegatable shares equals deposit shares here because no bc slashing + uint[] memory delegatableShares = shares; assert_HasNoDelegatableShares(staker, "staker should not have delegatable shares before depositing"); assertFalse(delegationManager.isDelegated(address(staker)), "staker should not be delegated"); @@ -110,9 +96,9 @@ contract Integration_Deposit_Delegate_Undelegate_Complete is IntegrationCheckUti check_Delegation_State(staker, operator, strategies, shares); // 3. Undelegate from an operator - IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.undelegate(); + Withdrawal[] memory withdrawals = staker.undelegate(); bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); - check_Undelegate_State(staker, operator, withdrawals, withdrawalRoots, strategies, shares); + check_Undelegate_State(staker, operator, withdrawals, withdrawalRoots, strategies, shares, delegatableShares); // 4. Complete withdrawal // Fast forward to when we can complete the withdrawal @@ -129,14 +115,7 @@ contract Integration_Deposit_Delegate_Undelegate_Complete is IntegrationCheckUti assert_NoWithdrawalsPending(withdrawalRoots, "all withdrawals should be removed from pending"); } - function testFuzz_deposit_delegate_forceUndelegate_completeAsTokens(uint24 _random) public { - // When new Users are created, they will choose a random configuration from these params: - _configRand({ - _randomSeed: _random, - _assetTypes: HOLDS_LST | HOLDS_ETH | HOLDS_ALL, - _userTypes: DEFAULT | ALT_METHODS - }); - + function testFuzz_deposit_delegate_forceUndelegate_completeAsTokens(uint24 _random) public rand(_random) { /// 0. Create an operator and a staker with: // - some nonzero underlying token balances // - corresponding to a random number of strategies @@ -149,10 +128,11 @@ contract Integration_Deposit_Delegate_Undelegate_Complete is IntegrationCheckUti uint[] memory tokenBalances ) = _newRandomStaker(); (User operator, ,) = _newRandomOperator(); - // Upgrade contracts if forkType is not local - _upgradeEigenLayerContracts(); uint[] memory shares = _calculateExpectedShares(strategies, tokenBalances); + //delegatable shares equals deposit shares here because no bc slashing + uint[] memory delegatableShares = shares; + assert_HasNoDelegatableShares(staker, "staker should not have delegatable shares before depositing"); assertFalse(delegationManager.isDelegated(address(staker)), "staker should not be delegated"); @@ -166,9 +146,9 @@ contract Integration_Deposit_Delegate_Undelegate_Complete is IntegrationCheckUti check_Delegation_State(staker, operator, strategies, shares); // 3. Force undelegate - IDelegationManagerTypes.Withdrawal[] memory withdrawals = operator.forceUndelegate(staker); + Withdrawal[] memory withdrawals = operator.forceUndelegate(staker); bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); - check_Undelegate_State(staker, operator, withdrawals, withdrawalRoots, strategies, shares); + check_Undelegate_State(staker, operator, withdrawals, withdrawalRoots, strategies, shares, delegatableShares); // 4. Complete withdrawal // Fast forward to when we can complete the withdrawal @@ -186,14 +166,7 @@ contract Integration_Deposit_Delegate_Undelegate_Complete is IntegrationCheckUti assert_NoWithdrawalsPending(withdrawalRoots, "all withdrawals should be removed from pending"); } - function testFuzz_deposit_delegate_forceUndelegate_completeAsShares(uint24 _random) public { - // When new Users are created, they will choose a random configuration from these params: - _configRand({ - _randomSeed: _random, - _assetTypes: HOLDS_LST | HOLDS_ETH | HOLDS_ALL, - _userTypes: DEFAULT | ALT_METHODS - }); - + function testFuzz_deposit_delegate_forceUndelegate_completeAsShares(uint24 _random) public rand(_random) { /// 0. Create an operator and a staker with: // - some nonzero underlying token balances // - corresponding to a random number of strategies @@ -206,10 +179,10 @@ contract Integration_Deposit_Delegate_Undelegate_Complete is IntegrationCheckUti uint[] memory tokenBalances ) = _newRandomStaker(); (User operator, ,) = _newRandomOperator(); - // Upgrade contracts if forkType is not local - _upgradeEigenLayerContracts(); uint[] memory shares = _calculateExpectedShares(strategies, tokenBalances); + //delegatable shares equals deposit shares here because no bc slashing + uint[] memory delegatableShares = shares; assert_HasNoDelegatableShares(staker, "staker should not have delegatable shares before depositing"); assertFalse(delegationManager.isDelegated(address(staker)), "staker should not be delegated"); @@ -223,9 +196,9 @@ contract Integration_Deposit_Delegate_Undelegate_Complete is IntegrationCheckUti check_Delegation_State(staker, operator, strategies, shares); // 3. Force undelegate - IDelegationManagerTypes.Withdrawal[] memory withdrawals = operator.forceUndelegate(staker); + Withdrawal[] memory withdrawals = operator.forceUndelegate(staker); bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); - check_Undelegate_State(staker, operator, withdrawals, withdrawalRoots, strategies, shares); + check_Undelegate_State(staker, operator, withdrawals, withdrawalRoots, strategies, shares, delegatableShares); // 4. Complete withdrawal // Fast forward to when we can complete the withdrawal @@ -243,9 +216,8 @@ contract Integration_Deposit_Delegate_Undelegate_Complete is IntegrationCheckUti function testFuzz_deposit_delegate_undelegate_completeAsTokens_Max_Strategies( uint24 _random - ) public { - _configRand({_randomSeed: _random, _assetTypes: HOLDS_MAX, _userTypes: DEFAULT}); - _upgradeEigenLayerContracts(); // Upgrade contracts if forkType is not local + ) public rand(_random) { + _configAssetTypes(HOLDS_MAX); (User staker, IStrategy[] memory strategies, uint256[] memory tokenBalances) = _newRandomStaker(); (User operator,,) = _newRandomOperator(); @@ -253,6 +225,8 @@ contract Integration_Deposit_Delegate_Undelegate_Complete is IntegrationCheckUti if (forkType == LOCAL) assertEq(strategies.length, 33, "sanity"); uint[] memory shares = _calculateExpectedShares(strategies, tokenBalances); + //delegatable shares equals deposit shares here because no bc slashing + uint[] memory delegatableShares = shares; assert_HasNoDelegatableShares(staker, "staker should not have delegatable shares before depositing"); assertFalse(delegationManager.isDelegated(address(staker)), "staker should not be delegated"); @@ -266,9 +240,9 @@ contract Integration_Deposit_Delegate_Undelegate_Complete is IntegrationCheckUti check_Delegation_State(staker, operator, strategies, shares); // 3. Undelegate from an operator - IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.undelegate(); + Withdrawal[] memory withdrawals = staker.undelegate(); bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); - check_Undelegate_State(staker, operator, withdrawals, withdrawalRoots, strategies, shares); + check_Undelegate_State(staker, operator, withdrawals, withdrawalRoots, strategies, shares, delegatableShares); // 4. Complete withdrawal // Fast forward to when we can complete the withdrawal diff --git a/src/test/integration/tests/Deposit_Delegate_UpdateBalance.t.sol b/src/test/integration/tests/Deposit_Delegate_UpdateBalance.t.sol index bcbdd6d86b..359ed44d06 100644 --- a/src/test/integration/tests/Deposit_Delegate_UpdateBalance.t.sol +++ b/src/test/integration/tests/Deposit_Delegate_UpdateBalance.t.sol @@ -43,7 +43,7 @@ contract Integration_Deposit_Delegate_UpdateBalance is IntegrationCheckUtils { // check_Delegation_State(staker, operator, strategies, shares); // /// 3. Queue withdrawals for ALL shares - // IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.queueWithdrawals(strategies, shares); + // Withdrawal[] memory withdrawals = staker.queueWithdrawals(strategies, shares); // bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); // check_QueuedWithdrawal_State(staker, operator, strategies, shares, withdrawals, withdrawalRoots); diff --git a/src/test/integration/tests/Deposit_Queue_Complete.t.sol b/src/test/integration/tests/Deposit_Queue_Complete.t.sol index 748b2bfa24..3fb7eab532 100644 --- a/src/test/integration/tests/Deposit_Queue_Complete.t.sol +++ b/src/test/integration/tests/Deposit_Queue_Complete.t.sol @@ -9,18 +9,9 @@ contract Integration_Deposit_QueueWithdrawal_Complete is IntegrationCheckUtils { /// 1. deposit into strategy /// 2. queueWithdrawal /// 3. completeQueuedWithdrawal" - function testFuzz_deposit_queueWithdrawal_completeAsTokens(uint24 _random) public { - // Configure the random parameters for the test - _configRand({ - _randomSeed: _random, - _assetTypes: HOLDS_LST | HOLDS_ETH | HOLDS_ALL, - _userTypes: DEFAULT | ALT_METHODS - }); - + function testFuzz_deposit_queueWithdrawal_completeAsTokens(uint24 _random) public rand(_random) { // Create a staker with a nonzero balance and corresponding strategies (User staker, IStrategy[] memory strategies, uint[] memory tokenBalances) = _newRandomStaker(); - // Upgrade contracts if forkType is not local - _upgradeEigenLayerContracts(); // 1. Deposit into strategy staker.depositIntoEigenlayer(strategies, tokenBalances); @@ -31,7 +22,7 @@ contract Integration_Deposit_QueueWithdrawal_Complete is IntegrationCheckUtils { assertFalse(delegationManager.isDelegated(address(staker)), "Staker should not be delegated after deposit"); // 2. Queue Withdrawal - IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.queueWithdrawals(strategies, shares); + Withdrawal[] memory withdrawals = staker.queueWithdrawals(strategies, shares); // 3. Complete Queued Withdrawal _rollBlocksForCompleteWithdrawals(withdrawals); @@ -45,18 +36,9 @@ contract Integration_Deposit_QueueWithdrawal_Complete is IntegrationCheckUtils { assertFalse(delegationManager.isDelegated(address(staker)), "Staker should still not be delegated after withdrawal"); } - function testFuzz_deposit_queueWithdrawal_completeAsShares(uint24 _random) public { - // Configure the random parameters for the test - _configRand({ - _randomSeed: _random, - _assetTypes: HOLDS_LST | HOLDS_ETH | HOLDS_ALL, - _userTypes: DEFAULT | ALT_METHODS - }); - + function testFuzz_deposit_queueWithdrawal_completeAsShares(uint24 _random) public rand(_random) { // Create a staker with a nonzero balance and corresponding strategies (User staker, IStrategy[] memory strategies, uint[] memory tokenBalances) = _newRandomStaker(); - // Upgrade contracts if forkType is not local - _upgradeEigenLayerContracts(); // 1. Deposit into strategy staker.depositIntoEigenlayer(strategies, tokenBalances); @@ -67,7 +49,7 @@ contract Integration_Deposit_QueueWithdrawal_Complete is IntegrationCheckUtils { assertFalse(delegationManager.isDelegated(address(staker)), "Staker should not be delegated after deposit"); // 2. Queue Withdrawal - IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.queueWithdrawals(strategies, shares); + Withdrawal[] memory withdrawals = staker.queueWithdrawals(strategies, shares); // 3. Complete Queued Withdrawal _rollBlocksForCompleteWithdrawals(withdrawals); diff --git a/src/test/integration/tests/Deposit_Register_QueueWithdrawal_Complete.t.sol b/src/test/integration/tests/Deposit_Register_QueueWithdrawal_Complete.t.sol index b0482c8551..20c4ccbcaf 100644 --- a/src/test/integration/tests/Deposit_Register_QueueWithdrawal_Complete.t.sol +++ b/src/test/integration/tests/Deposit_Register_QueueWithdrawal_Complete.t.sol @@ -5,18 +5,9 @@ import "src/test/integration/users/User.t.sol"; import "src/test/integration/IntegrationChecks.t.sol"; contract Integration_Deposit_Register_QueueWithdrawal_Complete is IntegrationCheckUtils { - function testFuzz_deposit_registerOperator_queueWithdrawal_completeAsShares(uint24 _random) public { - // Configure the random parameters for the test - _configRand({ - _randomSeed: _random, - _assetTypes: HOLDS_LST | HOLDS_ETH | HOLDS_ALL, - _userTypes: DEFAULT | ALT_METHODS - }); - + function testFuzz_deposit_registerOperator_queueWithdrawal_completeAsShares(uint24 _random) public rand(_random) { // Create a staker with a nonzero balance and corresponding strategies (User staker, IStrategy[] memory strategies, uint[] memory tokenBalances) = _newRandomStaker(); - // Upgrade contracts if forkType is not local - _upgradeEigenLayerContracts(); // 1. Staker deposits into strategy staker.depositIntoEigenlayer(strategies, tokenBalances); @@ -28,7 +19,7 @@ contract Integration_Deposit_Register_QueueWithdrawal_Complete is IntegrationChe assertTrue(delegationManager.isOperator(address(staker)), "Staker should be registered as an operator"); // 3. Queue Withdrawal - IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.queueWithdrawals(strategies, shares); + Withdrawal[] memory withdrawals = staker.queueWithdrawals(strategies, shares); bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); check_QueuedWithdrawal_State(staker, staker, strategies, shares, withdrawals, withdrawalRoots); @@ -40,19 +31,9 @@ contract Integration_Deposit_Register_QueueWithdrawal_Complete is IntegrationChe } } - function testFuzz_deposit_registerOperator_queueWithdrawal_completeAsTokens(uint24 _random) public { - // Configure the random parameters for the test - _configRand({ - _randomSeed: _random, - _assetTypes: HOLDS_LST | HOLDS_ETH | HOLDS_ALL, - _userTypes: DEFAULT | ALT_METHODS - }); - + function testFuzz_deposit_registerOperator_queueWithdrawal_completeAsTokens(uint24 _random) public rand(_random) { // Create a staker with a nonzero balance and corresponding strategies (User staker, IStrategy[] memory strategies, uint[] memory tokenBalances) = _newRandomStaker(); - // Upgrade contracts if forkType is not local - _upgradeEigenLayerContracts(); - // 1. Staker deposits into strategy staker.depositIntoEigenlayer(strategies, tokenBalances); uint[] memory shares = _calculateExpectedShares(strategies, tokenBalances); @@ -63,7 +44,7 @@ contract Integration_Deposit_Register_QueueWithdrawal_Complete is IntegrationChe assertTrue(delegationManager.isOperator(address(staker)), "Staker should be registered as an operator"); // 3. Queue Withdrawal - IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.queueWithdrawals(strategies, shares); + Withdrawal[] memory withdrawals = staker.queueWithdrawals(strategies, shares); bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); check_QueuedWithdrawal_State(staker, staker, strategies, shares, withdrawals, withdrawalRoots); diff --git a/src/test/integration/tests/Slashed_Eigenpod.t.sol b/src/test/integration/tests/Slashed_Eigenpod.t.sol new file mode 100644 index 0000000000..5bd01ae746 --- /dev/null +++ b/src/test/integration/tests/Slashed_Eigenpod.t.sol @@ -0,0 +1,306 @@ +// SPDX-License-Identifier: BUSL-1.1 +pragma solidity ^0.8.27; + +import "src/test/integration/IntegrationChecks.t.sol"; + +contract Integration_SlashedEigenpod is IntegrationCheckUtils { + using ArrayLib for *; + + AVS avs; + OperatorSet operatorSet; + + User operator; + IAllocationManagerTypes.AllocateParams allocateParams; + + User staker; + IStrategy[] strategies; + uint[] initTokenBalances; + uint64 slashedGwei; + + function _init() internal override { + _configAssetTypes(HOLDS_ETH); + (staker, strategies, initTokenBalances) = _newRandomStaker(); + (operator,,) = _newRandomOperator(); + (avs,) = _newRandomAVS(); + + cheats.assume(initTokenBalances[0] >= 64 ether); + + //Slash on Beacon chain + (uint40[] memory validators,) = staker.startValidators(); + beaconChain.advanceEpoch_NoRewards(); + staker.verifyWithdrawalCredentials(validators); + + uint[] memory shares = _calculateExpectedShares(strategies, initTokenBalances); + check_Deposit_State(staker, strategies, shares); + + uint40[] memory slashedValidators = _choose(validators); + slashedGwei = beaconChain.slashValidators(slashedValidators); + console.log(slashedGwei); + beaconChain.advanceEpoch_NoWithdrawNoRewards(); + + staker.startCheckpoint(); + staker.completeCheckpoint(); + check_CompleteCheckpoint_WithSlashing_HandleRoundDown_State(staker, slashedValidators, slashedGwei); + } + + function testFuzz_delegateSlashedStaker_dsfWad(uint24 _random) public rand(_random) { + + uint256[] memory initDelegatableShares = _getWithdrawableShares(staker, strategies); + uint256[] memory initDepositShares = _getStakerDepositShares(staker, strategies); + + // Delegate to an operator + staker.delegateTo(operator); + check_Delegation_State(staker, operator, strategies, initDepositShares); + + // Create an operator set and register an operator. + operatorSet = avs.createOperatorSet(strategies); + operator.registerForOperatorSet(operatorSet); + check_Registration_State_NoAllocation(operator, operatorSet, strategies); + + // Allocate to operator set + allocateParams = _genAllocation_AllAvailable(operator, operatorSet, strategies); + operator.modifyAllocations(allocateParams); + check_IncrAlloc_State_Slashable(operator, allocateParams); + _rollBlocksForCompleteAllocation(operator, operatorSet, strategies); + + (uint256[] memory withdrawableSharesBefore, ) = delegationManager.getWithdrawableShares(address(staker), strategies); + + // Undelegate from an operator + IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.undelegate(); + bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); + check_Undelegate_State(staker, operator, withdrawals, withdrawalRoots, strategies, initDepositShares, initDelegatableShares); + + // Complete withdrawal as shares + // Fast forward to when we can complete the withdrawal + _rollBlocksForCompleteWithdrawals(withdrawals); + for (uint256 i = 0; i < withdrawals.length; ++i) { + staker.completeWithdrawalAsShares(withdrawals[i]); + check_Withdrawal_AsShares_Undelegated_State(staker, operator, withdrawals[i], withdrawals[i].strategies, initDelegatableShares); + } + + (uint256[] memory withdrawableSharesAfter, uint256[] memory depositSharesAfter) = delegationManager.getWithdrawableShares(address(staker), strategies); + assertEq(depositSharesAfter[0], initDelegatableShares[0], "Deposit shares should reset to reflect slash(es)"); + assertApproxEqAbs(withdrawableSharesAfter[0], depositSharesAfter[0], 100, "Withdrawable shares should equal deposit shares after withdrawal"); + } + + function testFuzz_delegateSlashedStaker_dsfNonWad(uint24 _random) public rand(_random) { + + //Additional deposit on beacon chain so dsf is nonwad + uint amount = 32 ether * _randUint({min: 1, max: 5}); + cheats.deal(address(staker), amount); + (uint40[] memory validators,) = staker.startValidators(); + beaconChain.advanceEpoch_NoWithdrawNoRewards(); + staker.verifyWithdrawalCredentials(validators); + + staker.startCheckpoint(); + staker.completeCheckpoint(); + + + uint256[] memory initDelegatableShares = _getWithdrawableShares(staker, strategies); + uint256[] memory initDepositShares = _getStakerDepositShares(staker, strategies); + // Delegate to an operator + staker.delegateTo(operator); + check_Delegation_State(staker, operator, strategies, initDepositShares); + + uint256[] memory withdrawableSharesAfterDelegation = _getWithdrawableShares(staker, strategies); + + // Create an operator set and register an operator. + operatorSet = avs.createOperatorSet(strategies); + operator.registerForOperatorSet(operatorSet); + check_Registration_State_NoAllocation(operator, operatorSet, strategies); + + // Allocate to operator set + allocateParams = _genAllocation_AllAvailable(operator, operatorSet, strategies); + operator.modifyAllocations(allocateParams); + check_IncrAlloc_State_Slashable(operator, allocateParams); + _rollBlocksForCompleteAllocation(operator, operatorSet, strategies); + + (uint256[] memory withdrawableSharesBefore, ) = delegationManager.getWithdrawableShares(address(staker), strategies); + // Undelegate from an operator + IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.undelegate(); + bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); + check_Undelegate_State(staker, operator, withdrawals, withdrawalRoots, strategies, initDepositShares, initDelegatableShares); + + // Complete withdrawal as shares + // Fast forward to when we can complete the withdrawal + _rollBlocksForCompleteWithdrawals(withdrawals); + for (uint256 i = 0; i < withdrawals.length; ++i) { + staker.completeWithdrawalAsShares(withdrawals[i]); + check_Withdrawal_AsShares_Undelegated_State(staker, operator, withdrawals[i], withdrawals[i].strategies, initDelegatableShares); + } + + (uint256[] memory withdrawableSharesAfter, uint256[] memory depositSharesAfter) = delegationManager.getWithdrawableShares(address(staker), strategies); + assertEq(depositSharesAfter[0], initDelegatableShares[0], "Deposit shares should reset to reflect slash(es)"); + assertApproxEqAbs(withdrawableSharesAfter[0], depositSharesAfter[0], 100, "Withdrawable shares should equal deposit shares after withdrawal"); + } + + function testFuzz_delegateSlashedStaker_slashedOperator(uint24 _random) public rand(_random) { + + + (User staker2,,) = _newRandomStaker(); + (uint40[] memory validators2,) = staker2.startValidators(); + beaconChain.advanceEpoch_NoWithdrawNoRewards(); + staker2.verifyWithdrawalCredentials(validators2); + staker2.startCheckpoint(); + staker2.completeCheckpoint(); + staker2.delegateTo(operator); + + //randomize additional deposit to eigenpod + if(_randBool()){ + uint amount = 32 ether * _randUint({min: 1, max: 5}); + cheats.deal(address(staker), amount); + (uint40[] memory validators,) = staker.startValidators(); + beaconChain.advanceEpoch_NoWithdrawNoRewards(); + staker.verifyWithdrawalCredentials(validators); + + staker.startCheckpoint(); + staker.completeCheckpoint(); + } + + // Create an operator set and register an operator. + operatorSet = avs.createOperatorSet(strategies); + operator.registerForOperatorSet(operatorSet); + check_Registration_State_NoAllocation(operator, operatorSet, strategies); + + // Allocate to operator set + allocateParams = _genAllocation_AllAvailable(operator, operatorSet, strategies); + operator.modifyAllocations(allocateParams); + check_IncrAlloc_State_Slashable(operator, allocateParams); + _rollBlocksForCompleteAllocation(operator, operatorSet, strategies); + + //Slash operator before delegation + IAllocationManagerTypes.SlashingParams memory slashingParams; + uint wadToSlash = _randWadToSlash(); + slashingParams = avs.slashOperator(operator, operatorSet.id, strategies, wadToSlash.toArrayU256()); + assert_Snap_Allocations_Slashed(slashingParams, operatorSet, true, "operator allocations should be slashed"); + + uint256[] memory initDelegatableShares = _getWithdrawableShares(staker, strategies); + uint256[] memory initDepositShares = _getStakerDepositShares(staker, strategies); + + // Delegate to an operator + staker.delegateTo(operator); + (uint256[] memory delegatedShares, ) = delegationManager.getWithdrawableShares(address(staker), strategies); + check_Delegation_State(staker, operator, strategies, initDepositShares); + + // Undelegate from an operator + IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.undelegate(); + bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); + check_Undelegate_State(staker, operator, withdrawals, withdrawalRoots, strategies, initDepositShares, delegatedShares); + + // Complete withdrawal as shares + // Fast forward to when we can complete the withdrawal + _rollBlocksForCompleteWithdrawals(withdrawals); + for (uint256 i = 0; i < withdrawals.length; ++i) { + staker.completeWithdrawalAsShares(withdrawals[i]); + check_Withdrawal_AsShares_Undelegated_State(staker, operator, withdrawals[i], withdrawals[i].strategies, delegatedShares); + } + + (uint256[] memory withdrawableSharesAfter, uint256[] memory depositSharesAfter) = delegationManager.getWithdrawableShares(address(staker), strategies); + assertEq(depositSharesAfter[0], delegatedShares[0], "Deposit shares should reset to reflect slash(es)"); + assertApproxEqAbs(withdrawableSharesAfter[0], depositSharesAfter[0], 100, "Withdrawable shares should equal deposit shares after withdrawal"); + } + + function testFuzz_delegateSlashedStaker_redelegate_complete(uint24 _random) public rand(_random){ + + (User operator2, ,) = _newRandomOperator(); + + //Additional deposit on beacon chain so dsf is nonwad + uint amount = 32 ether * _randUint({min: 1, max: 5}); + cheats.deal(address(staker), amount); + (uint40[] memory validators,) = staker.startValidators(); + beaconChain.advanceEpoch_NoWithdrawNoRewards(); + staker.verifyWithdrawalCredentials(validators); + + staker.startCheckpoint(); + staker.completeCheckpoint(); + + + uint256[] memory initDepositShares = _getStakerDepositShares(staker, strategies); + + // Delegate to an operator + staker.delegateTo(operator); + check_Delegation_State(staker, operator, strategies, initDepositShares); + (uint256[] memory delegatedShares, ) = delegationManager.getWithdrawableShares(address(staker), strategies); + + // Create an operator set and register an operator. + operatorSet = avs.createOperatorSet(strategies); + operator.registerForOperatorSet(operatorSet); + check_Registration_State_NoAllocation(operator, operatorSet, strategies); + + // Allocate to operator set + allocateParams = _genAllocation_AllAvailable(operator, operatorSet, strategies); + operator.modifyAllocations(allocateParams); + check_IncrAlloc_State_Slashable(operator, allocateParams); + _rollBlocksForCompleteAllocation(operator, operatorSet, strategies); + + // Undelegate from an operator + IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.redelegate(operator2); + bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); + check_Redelegate_State(staker, operator, operator2, withdrawals, withdrawalRoots, strategies, initDepositShares, delegatedShares); + + // Complete withdrawal as shares + // Fast forward to when we can complete the withdrawal + _rollBlocksForCompleteWithdrawals(withdrawals); + for (uint256 i = 0; i < withdrawals.length; ++i) { + staker.completeWithdrawalAsShares(withdrawals[i]); + check_Withdrawal_AsShares_Redelegated_State(staker, operator, operator2, withdrawals[i], withdrawals[i].strategies, delegatedShares); + } + + (uint256[] memory withdrawableSharesAfter, uint256[] memory depositSharesAfter) = delegationManager.getWithdrawableShares(address(staker), strategies); + assertEq(depositSharesAfter[0], delegatedShares[0], "Deposit shares should reset to reflect slash(es)"); + assertApproxEqAbs(withdrawableSharesAfter[0], depositSharesAfter[0], 100, "Withdrawable shares should equal deposit shares after withdrawal"); + } + + + function testFuzz_delegateSlashedStaker_slashedOperator_withdrawAllShares_complete(uint24 _random) public rand(_random){ + //Additional deposit on beacon chain so dsf is nonwad + uint amount = 32 ether * _randUint({min: 1, max: 5}); + cheats.deal(address(staker), amount); + (uint40[] memory validators,) = staker.startValidators(); + beaconChain.advanceEpoch_NoWithdrawNoRewards(); + staker.verifyWithdrawalCredentials(validators); + + staker.startCheckpoint(); + staker.completeCheckpoint(); + + uint256[] memory initDepositShares = _getStakerDepositShares(staker, strategies); + + // Create an operator set and register an operator. + operatorSet = avs.createOperatorSet(strategies); + operator.registerForOperatorSet(operatorSet); + check_Registration_State_NoAllocation(operator, operatorSet, strategies); + + //Slash operator before delegation + IAllocationManagerTypes.SlashingParams memory slashingParams; + uint wadToSlash = _randWadToSlash(); + slashingParams = avs.slashOperator(operator, operatorSet.id, strategies, wadToSlash.toArrayU256()); + assert_Snap_Allocations_Slashed(slashingParams, operatorSet, true, "operator allocations should be slashed"); + + // Delegate to an operator + staker.delegateTo(operator); + check_Delegation_State(staker, operator, strategies, initDepositShares); + (uint256[] memory delegatedShares, ) = delegationManager.getWithdrawableShares(address(staker), strategies); + + // Allocate to operator set + allocateParams = _genAllocation_AllAvailable(operator, operatorSet, strategies); + operator.modifyAllocations(allocateParams); + check_IncrAlloc_State_Slashable(operator, allocateParams); + _rollBlocksForCompleteAllocation(operator, operatorSet, strategies); + + //Withdraw all shares + IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.queueWithdrawals(strategies, initDepositShares); + bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); + + // Complete withdrawal as shares + // Fast forward to when we can complete the withdrawal + _rollBlocksForCompleteWithdrawals(withdrawals); + for (uint256 i = 0; i < withdrawals.length; ++i) { + staker.completeWithdrawalAsShares(withdrawals[i]); + } + + (uint256[] memory withdrawableSharesAfter, uint256[] memory depositSharesAfter) = delegationManager.getWithdrawableShares(address(staker), strategies); + assertEq(depositSharesAfter[0], delegatedShares[0], "Deposit shares should reset to reflect slash(es)"); + assertApproxEqAbs(withdrawableSharesAfter[0], depositSharesAfter[0], 100, "Withdrawable shares should equal deposit shares after withdrawal"); + } + +} \ No newline at end of file diff --git a/src/test/integration/tests/SlashingWithdrawals.t.sol b/src/test/integration/tests/SlashingWithdrawals.t.sol new file mode 100644 index 0000000000..e0349aefcb --- /dev/null +++ b/src/test/integration/tests/SlashingWithdrawals.t.sol @@ -0,0 +1,344 @@ +// SPDX-License-Identifier: BUSL-1.1 +pragma solidity ^0.8.27; + +import "src/test/integration/IntegrationChecks.t.sol"; + +contract Integration_ALMSlashBase is IntegrationCheckUtils { + + AVS avs; + OperatorSet operatorSet; + + User operator; + AllocateParams allocateParams; + + User staker; + IStrategy[] strategies; + uint[] initTokenBalances; + uint[] initDepositShares; + + /// Shared setup: + /// + /// 1. Generate staker, operator, and AVS + /// 2. Staker deposits and delegates to operator + /// 3. AVS creates an operator set containing the strategies held by the staker + /// 4. Operator allocates to operator set + /// 5. Operator registers for operator set + /// NOTE: Steps 4 and 5 are done in random order, as these should not have an outcome on the test + function _init() internal virtual override { + _configAssetTypes(HOLDS_LST); + // (staker, strategies, initTokenBalances) = _newRandomStaker(); + // operator = _newRandomOperator_NoAssets(); + // (avs,) = _newRandomAVS(); + + (staker, strategies, initTokenBalances) = _newBasicStaker(); + operator = _newRandomOperator_NoAssets(); + (avs,) = _newRandomAVS(); + + // 1. Deposit Into Strategies + staker.depositIntoEigenlayer(strategies, initTokenBalances); + initDepositShares = _calculateExpectedShares(strategies, initTokenBalances); + check_Deposit_State(staker, strategies, initDepositShares); + + // 2. Delegate to an operator + staker.delegateTo(operator); + check_Delegation_State(staker, operator, strategies, initDepositShares); + + // 3. Create an operator set and register an operator. + operatorSet = avs.createOperatorSet(strategies); + + // randomly choose between: + // register -> allocate / allocate -> register + if (_randBool()) { + // register -> allocate + operator.registerForOperatorSet(operatorSet); + check_Registration_State_NoAllocation(operator, operatorSet, allStrats); + + allocateParams = _genAllocation_AllAvailable(operator, operatorSet); + operator.modifyAllocations(allocateParams); + check_IncrAlloc_State_Slashable(operator, allocateParams); + } else { + // allocate -> register + allocateParams = _genAllocation_AllAvailable(operator, operatorSet); + operator.modifyAllocations(allocateParams); + check_IncrAlloc_State_NotSlashable(operator, allocateParams); + + operator.registerForOperatorSet(operatorSet); + check_Registration_State_PendingAllocation(operator, allocateParams); + } + + _rollBlocksForCompleteAllocation(operator, operatorSet, strategies); + } +} + +contract Integration_InitSlash is Integration_ALMSlashBase { + + SlashingParams slashParams; + + function testFuzz_slashSingle(uint24 _r) public rand(_r) { + slashParams = _genSlashing_Rand(operator, operatorSet); + avs.slashOperator(slashParams); + check_Base_Slashing_State(operator, allocateParams, slashParams); + } + + function testFuzz_slashMulti_WithdrawTokens(uint24 _r) public rand(_r) { + for (uint i = 0; i < 25; i++) { + slashParams = _genSlashing_Rand(operator, operatorSet); + avs.slashOperator(slashParams); + check_Base_Slashing_State(operator, allocateParams, slashParams); + } + + // undelegate + uint[] memory shares = _getStakerWithdrawableShares(staker, strategies); + Withdrawal[] memory withdrawals = staker.undelegate(); + bytes32[] memory roots = _getWithdrawalHashes(withdrawals); + check_Undelegate_State(staker, operator, withdrawals, roots, strategies, initDepositShares, shares); + + _rollBlocksForCompleteWithdrawals(withdrawals); + + // try withdrawing as tokens: + IERC20[] memory tokens = _getUnderlyingTokens(strategies); + uint[] memory expectedTokens = _calculateExpectedTokens(strategies, shares); + + staker.completeWithdrawalsAsTokens(withdrawals); + for (uint i = 0; i < withdrawals.length; i++) { + check_Withdrawal_AsTokens_State(staker, operator, withdrawals[i], strategies, shares, tokens, expectedTokens); + } + } + + function testFuzz_slashMulti_WithdrawShares(uint24 _r) public rand(_r) { + for (uint i = 0; i < 25; i++) { + slashParams = _genSlashing_Rand(operator, operatorSet); + avs.slashOperator(slashParams); + check_Base_Slashing_State(operator, allocateParams, slashParams); + } + + // undelegate + uint[] memory shares = _getStakerWithdrawableShares(staker, strategies); + Withdrawal[] memory withdrawals = staker.undelegate(); + bytes32[] memory roots = _getWithdrawalHashes(withdrawals); + check_Undelegate_State(staker, operator, withdrawals, roots, strategies, initDepositShares, shares); + + _rollBlocksForCompleteWithdrawals(withdrawals); + + // try withdrawing as shares + staker.completeWithdrawalsAsShares(withdrawals); + for (uint i = 0; i < withdrawals.length; i++) { + check_Withdrawal_AsShares_Undelegated_State(staker, operator, withdrawals[i], strategies, shares); + } + } +} + +contract Integration_SlashingWithdrawals is Integration_ALMSlashBase { + + function testFuzz_slash_undelegate_completeAsTokens( + uint24 _random + ) public rand(_random) { + // 4. Slash operator + SlashingParams memory slashingParams; + { + (IStrategy[] memory strategiesToSlash, uint256[] memory wadsToSlash) = + _randStrategiesAndWadsToSlash(operatorSet); + slashingParams = avs.slashOperator(operator, operatorSet.id, strategiesToSlash, wadsToSlash); + assert_Snap_Allocations_Slashed(slashingParams, operatorSet, true, "operator allocations should be slashed"); + assert_Snap_Unchanged_Staker_DepositShares(staker, "staker deposit shares should be unchanged after slashing"); + assert_Snap_StakerWithdrawableShares_AfterSlash(staker, allocateParams, slashingParams, "staker deposit shares should be slashed"); + } + + // 5. Undelegate from an operator + Withdrawal[] memory withdrawals = staker.undelegate(); + bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); + + // 6. Complete withdrawal + _rollBlocksForCompleteWithdrawals(withdrawals); + for (uint256 i = 0; i < withdrawals.length; ++i) { + uint256[] memory expectedTokens = + _calculateExpectedTokens(withdrawals[i].strategies, withdrawals[i].scaledShares); + staker.completeWithdrawalAsTokens(withdrawals[i]); + check_Withdrawal_AsTokens_State_AfterSlash(staker, operator, withdrawals[i], allocateParams, slashingParams, expectedTokens); + } + + // Check Final State + assert_HasNoDelegatableShares(staker, "staker should have withdrawn all shares"); + assert_HasUnderlyingTokenBalances_AfterSlash( + staker, + allocateParams, + slashingParams, + initTokenBalances, + "staker should once again have original token initTokenBalances minus slashed" + ); + assert_NoWithdrawalsPending(withdrawalRoots, "all withdrawals should be removed from pending"); + } + + function testFuzz_slash_undelegate_completeAsShares( + uint24 _random + ) public rand(_random) { + // 4. Slash operator + SlashingParams memory slashingParams; + { + (IStrategy[] memory strategiesToSlash, uint256[] memory wadsToSlash) = + _randStrategiesAndWadsToSlash(operatorSet); + slashingParams = avs.slashOperator(operator, operatorSet.id, strategiesToSlash, wadsToSlash); + assert_Snap_Allocations_Slashed(slashingParams, operatorSet, true, "operator allocations should be slashed"); + assert_Snap_Unchanged_Staker_DepositShares(staker, "staker deposit shares should be unchanged after slashing"); + assert_Snap_StakerWithdrawableShares_AfterSlash(staker, allocateParams, slashingParams, "staker deposit shares should be slashed"); + } + + // 5. Undelegate from an operator + Withdrawal[] memory withdrawals = staker.undelegate(); + bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); + + // 4. Complete withdrawal + // Fast forward to when we can complete the withdrawal + _rollBlocksForCompleteWithdrawals(withdrawals); + + for (uint256 i = 0; i < withdrawals.length; ++i) { + staker.completeWithdrawalAsShares(withdrawals[i]); + check_Withdrawal_AsShares_State_AfterSlash(staker, operator, withdrawals[i], allocateParams, slashingParams); + } + + // Check final state: + assert_HasNoUnderlyingTokenBalance(staker, strategies, "staker not have any underlying tokens"); + assert_NoWithdrawalsPending(withdrawalRoots, "all withdrawals should be removed from pending"); + } + + function testFuzz_queue_slash_completeAsTokens( + uint24 _random + ) public rand(_random) { + // 4. Queue withdrawal + Withdrawal[] memory withdrawals = + staker.queueWithdrawals(strategies, _calculateExpectedShares(strategies, initTokenBalances)); + bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); + + // 5. Slash operator + SlashingParams memory slashingParams; + { + (IStrategy[] memory strategiesToSlash, uint256[] memory wadsToSlash) = + _randStrategiesAndWadsToSlash(operatorSet); + slashingParams = avs.slashOperator(operator, operatorSet.id, strategiesToSlash, wadsToSlash); + assert_Snap_Allocations_Slashed(slashingParams, operatorSet, true, "operator allocations should be slashed"); + assert_Snap_Unchanged_Staker_DepositShares(staker, "staker deposit shares should be unchanged after slashing"); + assert_Snap_StakerWithdrawableShares_AfterSlash(staker, allocateParams, slashingParams, "staker deposit shares should be slashed"); + } + + // 6. Complete withdrawal + _rollBlocksForCompleteWithdrawals(withdrawals); + for (uint256 i = 0; i < withdrawals.length; ++i) { + uint256[] memory expectedTokens = + _calculateExpectedTokens(withdrawals[i].strategies, withdrawals[i].scaledShares); + staker.completeWithdrawalAsTokens(withdrawals[i]); + check_Withdrawal_AsTokens_State_AfterSlash( + staker, operator, withdrawals[i], allocateParams, slashingParams, expectedTokens + ); + } + + // Check Final State + assert_HasNoDelegatableShares(staker, "staker should have withdrawn all shares"); + assert_HasUnderlyingTokenBalances_AfterSlash( + staker, + allocateParams, + slashingParams, + initTokenBalances, + "staker should once again have original token initTokenBalances minus slashed" + ); + assert_NoWithdrawalsPending(withdrawalRoots, "all withdrawals should be removed from pending"); + } + + function testFuzz_queue_slash_completeAsShares( + uint24 _random + ) public rand(_random) { + // 4. Queue withdrawal + Withdrawal[] memory withdrawals = + staker.queueWithdrawals(strategies, _calculateExpectedShares(strategies, initTokenBalances)); + bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); + + // 5. Slash operator + SlashingParams memory slashingParams; + { + (IStrategy[] memory strategiesToSlash, uint256[] memory wadsToSlash) = + _randStrategiesAndWadsToSlash(operatorSet); + slashingParams = avs.slashOperator(operator, operatorSet.id, strategiesToSlash, wadsToSlash); + assert_Snap_Allocations_Slashed(slashingParams, operatorSet, true, "operator allocations should be slashed"); + assert_Snap_Unchanged_Staker_DepositShares(staker, "staker deposit shares should be unchanged after slashing"); + assert_Snap_StakerWithdrawableShares_AfterSlash(staker, allocateParams, slashingParams, "staker deposit shares should be slashed"); + } + + // 4. Complete withdrawal + // Fast forward to when we can complete the withdrawal + _rollBlocksForCompleteWithdrawals(withdrawals); + + for (uint256 i = 0; i < withdrawals.length; ++i) { + staker.completeWithdrawalAsShares(withdrawals[i]); + check_Withdrawal_AsShares_State_AfterSlash(staker, operator, withdrawals[i], allocateParams, slashingParams); + } + + // Check final state: + assert_HasNoUnderlyingTokenBalance(staker, strategies, "staker not have any underlying tokens"); + assert_NoWithdrawalsPending(withdrawalRoots, "all withdrawals should be removed from pending"); + } + + function testFuzz_deallocate_slash_queue_completeAsTokens( + uint24 _random + ) public rand(_random) { + // 4. Deallocate all. + AllocateParams memory deallocateParams = _genDeallocation_Full(operator, operatorSet); + operator.modifyAllocations(deallocateParams); + check_DecrAlloc_State_Slashable(operator, deallocateParams); + + _rollForward_DeallocationDelay(); + + // 5. Slash operator + SlashingParams memory slashingParams; + { + (IStrategy[] memory strategiesToSlash, uint256[] memory wadsToSlash) = + _randStrategiesAndWadsToSlash(operatorSet); + slashingParams = avs.slashOperator(operator, operatorSet.id, strategiesToSlash, wadsToSlash); + assert_Snap_Allocations_Slashed(slashingParams, operatorSet, true, "operator allocations should be slashed"); + assert_Snap_Unchanged_Staker_DepositShares(staker, "staker deposit shares should be unchanged after slashing"); + assert_Snap_StakerWithdrawableShares_AfterSlash(staker, deallocateParams, slashingParams, "staker deposit shares should be slashed"); + } + + // 6. Queue withdrawals + Withdrawal[] memory withdrawals = + staker.queueWithdrawals(strategies, _calculateExpectedShares(strategies, initTokenBalances)); + bytes32[] memory withdrawalRoots = _getWithdrawalHashes(withdrawals); + + // 7. Complete withdrawal + _rollBlocksForCompleteWithdrawals(withdrawals); + for (uint256 i = 0; i < withdrawals.length; ++i) { + uint256[] memory expectedTokens = + _calculateExpectedTokens(withdrawals[i].strategies, withdrawals[i].scaledShares); + staker.completeWithdrawalAsTokens(withdrawals[i]); + check_Withdrawal_AsTokens_State_AfterSlash( + staker, operator, withdrawals[i], allocateParams, slashingParams, expectedTokens + ); + } + + // Check Final State + assert_HasUnderlyingTokenBalances( + staker, + allocateParams.strategies, + initTokenBalances, + "staker should have withdrawn all shares" + ); + assert_NoWithdrawalsPending(withdrawalRoots, "all withdrawals should be removed from pending"); + } + + function testFuzz_deregister_slash( + uint24 _random + ) public rand(_random) { + // 4. Deregister. + operator.deregisterFromOperatorSet(operatorSet); + check_Deregistration_State_PendingAllocation(operator, operatorSet); + + // 5. Slash operator + SlashingParams memory slashingParams; + { + (IStrategy[] memory strategiesToSlash, uint256[] memory wadsToSlash) = + _randStrategiesAndWadsToSlash(operatorSet); + slashingParams = avs.slashOperator(operator, operatorSet.id, strategiesToSlash, wadsToSlash); + assert_Snap_Allocations_Slashed(slashingParams, operatorSet, true, "operator allocations should be slashed"); + assert_Snap_Unchanged_Staker_DepositShares(staker, "staker deposit shares should be unchanged after slashing"); + assert_Snap_StakerWithdrawableShares_AfterSlash(staker, allocateParams, slashingParams, "staker deposit shares should be slashed"); + } + } +} \ No newline at end of file diff --git a/src/test/integration/tests/eigenpod/VerifyWC_StartCP_CompleteCP.t.sol b/src/test/integration/tests/eigenpod/VerifyWC_StartCP_CompleteCP.t.sol index 2c425d3a5d..e72a39a0cb 100644 --- a/src/test/integration/tests/eigenpod/VerifyWC_StartCP_CompleteCP.t.sol +++ b/src/test/integration/tests/eigenpod/VerifyWC_StartCP_CompleteCP.t.sol @@ -6,19 +6,14 @@ import "src/test/integration/users/User.t.sol"; contract Integration_VerifyWC_StartCP_CompleteCP is IntegrationCheckUtils { - modifier r(uint24 _rand) { - _configRand({ - _randomSeed: _rand, - _assetTypes: HOLDS_ETH, - _userTypes: DEFAULT - }); - - _; + function _init() internal override { + _configAssetTypes(HOLDS_ETH); + _configUserTypes(DEFAULT); } - function test_GasMetering() public r(0) { + function test_GasMetering() public rand(0) { (User staker, ,) = _newRandomStaker(); - _upgradeEigenLayerContracts(); + // Deal user 20 full stakers worth of ETH emit log_named_string("Dealing 20 * 32 ETH to", staker.NAME()); cheats.deal(address(staker), 32 ether * 20); @@ -81,9 +76,8 @@ contract Integration_VerifyWC_StartCP_CompleteCP is IntegrationCheckUtils { /// 2. start a checkpoint /// 3. complete a checkpoint /// => no change in shares between 1 and 3 - function test_VerifyWC_StartCP_CompleteCP(uint24 _rand) public r(_rand) { + function test_VerifyWC_StartCP_CompleteCP(uint24 _rand) public rand(_rand) { (User staker, ,) = _newRandomStaker(); - _upgradeEigenLayerContracts(); (uint40[] memory validators, uint64 beaconBalanceGwei) = staker.startValidators(); beaconChain.advanceEpoch_NoRewards(); @@ -101,9 +95,8 @@ contract Integration_VerifyWC_StartCP_CompleteCP is IntegrationCheckUtils { /// 1. Verify validators' withdrawal credentials /// 2. Verify validators' withdrawal credentials again /// => This should fail - function test_VerifyWC_VerifyWC_Fails(uint24 _rand) public r(_rand) { + function test_VerifyWC_VerifyWC_Fails(uint24 _rand) public rand(_rand) { (User staker, ,) = _newRandomStaker(); - _upgradeEigenLayerContracts(); (uint40[] memory validators, uint64 beaconBalanceGwei) = staker.startValidators(); beaconChain.advanceEpoch_NoRewards(); @@ -119,9 +112,8 @@ contract Integration_VerifyWC_StartCP_CompleteCP is IntegrationCheckUtils { /// 2. start a checkpoint /// 3. start a checkpoint again /// => This should fail - function test_VerifyWC_StartCP_StartCP_Fails(uint24 _rand) public r(_rand) { + function test_VerifyWC_StartCP_StartCP_Fails(uint24 _rand) public rand(_rand) { (User staker, ,) = _newRandomStaker(); - _upgradeEigenLayerContracts(); (uint40[] memory validators, uint64 beaconBalanceGwei) = staker.startValidators(); beaconChain.advanceEpoch_NoRewards(); @@ -141,9 +133,8 @@ contract Integration_VerifyWC_StartCP_CompleteCP is IntegrationCheckUtils { /// 3. complete a checkpoint /// 4. start a checkpoint without advancing a block /// => this should fail - function test_VerifyWC_StartCP_CompleteCP_StartCP_Fails(uint24 _rand) public r(_rand) { + function test_VerifyWC_StartCP_CompleteCP_StartCP_Fails(uint24 _rand) public rand(_rand) { (User staker, ,) = _newRandomStaker(); - _upgradeEigenLayerContracts(); (uint40[] memory validators, uint64 beaconBalanceGwei) = staker.startValidators(); beaconChain.advanceEpoch_NoRewards(); @@ -166,9 +157,8 @@ contract Integration_VerifyWC_StartCP_CompleteCP is IntegrationCheckUtils { /// 2. start a checkpoint /// 3. complete a checkpoint /// => no change in shares between 1 and 3 - function test_VerifyWC_Advance_StartCP_CompleteCP(uint24 _rand) public r(_rand) { + function test_VerifyWC_Advance_StartCP_CompleteCP(uint24 _rand) public rand(_rand) { (User staker, ,) = _newRandomStaker(); - _upgradeEigenLayerContracts(); (uint40[] memory validators, uint64 beaconBalanceGwei) = staker.startValidators(); beaconChain.advanceEpoch_NoRewards(); @@ -191,9 +181,8 @@ contract Integration_VerifyWC_StartCP_CompleteCP is IntegrationCheckUtils { /// -- move forward 1 or more epochs /// 3. complete a checkpoint /// => no change in shares between 1 and 3 - function test_VerifyWC_StartCP_Advance_CompleteCP(uint24 _rand) public r(_rand) { + function test_VerifyWC_StartCP_Advance_CompleteCP(uint24 _rand) public rand(_rand) { (User staker, ,) = _newRandomStaker(); - _upgradeEigenLayerContracts(); (uint40[] memory validators, uint64 beaconBalanceGwei) = staker.startValidators(); beaconChain.advanceEpoch_NoRewards(); @@ -219,9 +208,8 @@ contract Integration_VerifyWC_StartCP_CompleteCP is IntegrationCheckUtils { /// -- Fully exit validators before verifying withdrawal credentials /// 1. Verify validators' withdrawal credentials /// => This should fail - function test_ExitValidators_VerifyWC_Fails(uint24 _rand) public r(_rand) { + function test_ExitValidators_VerifyWC_Fails(uint24 _rand) public rand(_rand) { (User staker, ,) = _newRandomStaker(); - _upgradeEigenLayerContracts(); (uint40[] memory validators, ) = staker.startValidators(); staker.exitValidators(validators); @@ -236,9 +224,8 @@ contract Integration_VerifyWC_StartCP_CompleteCP is IntegrationCheckUtils { /// 2. start a checkpoint /// 3. complete a checkpoint /// => no change in shares between 1 and 3 - function test_VerifyWC_ExitValidators_StartCP_CompleteCP(uint24 _rand) public r(_rand) { + function test_VerifyWC_ExitValidators_StartCP_CompleteCP(uint24 _rand) public rand(_rand) { (User staker, ,) = _newRandomStaker(); - _upgradeEigenLayerContracts(); (uint40[] memory validators, uint64 beaconBalanceGwei) = staker.startValidators(); beaconChain.advanceEpoch_NoRewards(); @@ -267,9 +254,8 @@ contract Integration_VerifyWC_StartCP_CompleteCP is IntegrationCheckUtils { /// 4. start a checkpoint /// 5. complete a checkpoint /// => exited balance should be reflected in 4 and 5 - function test_VerifyWC_StartCP_ExitValidators_CompleteCP(uint24 _rand) public r(_rand) { + function test_VerifyWC_StartCP_ExitValidators_CompleteCP(uint24 _rand) public rand(_rand) { (User staker, ,) = _newRandomStaker(); - _upgradeEigenLayerContracts(); (uint40[] memory validators, uint64 beaconBalanceGwei) = staker.startValidators(); beaconChain.advanceEpoch_NoRewards(); @@ -303,9 +289,8 @@ contract Integration_VerifyWC_StartCP_CompleteCP is IntegrationCheckUtils { /// -- get slashed on beacon chain /// 1. Try to verify validators' withdrawal credentials /// => this should fail - function test_SlashToPod_VerifyWC_Fails(uint24 _rand) public r(_rand) { + function test_SlashToPod_VerifyWC_Fails(uint24 _rand) public rand(_rand) { (User staker, ,) = _newRandomStaker(); - _upgradeEigenLayerContracts(); (uint40[] memory validators, ) = staker.startValidators(); beaconChain.slashValidators(validators); @@ -321,9 +306,8 @@ contract Integration_VerifyWC_StartCP_CompleteCP is IntegrationCheckUtils { /// 2. start a checkpoint /// 3. complete a checkpoint /// => after 3, shares should decrease by slashed amount - function test_VerifyWC_SlashToPod_StartCP_CompleteCP(uint24 _rand) public r(_rand) { + function test_VerifyWC_SlashToPod_StartCP_CompleteCP(uint24 _rand) public rand(_rand) { (User staker, ,) = _newRandomStaker(); - _upgradeEigenLayerContracts(); (uint40[] memory validators, uint64 beaconBalanceGwei) = staker.startValidators(); // Advance epoch without generating rewards @@ -351,9 +335,8 @@ contract Integration_VerifyWC_StartCP_CompleteCP is IntegrationCheckUtils { /// 4. start a checkpoint /// 5. complete a checkpoint /// => slashed balance should be reflected in 4 and 5 - function test_VerifyWC_StartCP_SlashToPod_CompleteCP(uint24 _rand) public r(_rand) { + function test_VerifyWC_StartCP_SlashToPod_CompleteCP(uint24 _rand) public rand(_rand) { (User staker, ,) = _newRandomStaker(); - _upgradeEigenLayerContracts(); (uint40[] memory validators, uint64 beaconBalanceGwei) = staker.startValidators(); // Advance epoch without generating rewards @@ -384,9 +367,8 @@ contract Integration_VerifyWC_StartCP_CompleteCP is IntegrationCheckUtils { /// 4. verify withdrawal credentials for another validator while checkpoint in progress /// 5. complete a checkpoint /// => Increase in shares between 1 and 4 should reflect the new validator, less the slashed amount - function test_VerifyWC_Slash_StartCP_VerifyWC_CompleteCP(uint24 _rand) public r(_rand) { + function test_VerifyWC_Slash_StartCP_VerifyWC_CompleteCP(uint24 _rand) public rand(_rand) { (User staker, ,) = _newRandomStaker(); - _upgradeEigenLayerContracts(); (uint40[] memory validators, uint64 beaconBalanceGwei) = staker.startValidators(); beaconChain.advanceEpoch_NoRewards(); @@ -422,9 +404,8 @@ contract Integration_VerifyWC_StartCP_CompleteCP is IntegrationCheckUtils { /// 2. start a checkpoint /// 3. complete a checkpoint /// => after 3, shares should decrease by slashed amount - function test_VerifyWC_SlashToPod_VerifyStale_CompleteCP(uint24 _rand) public r(_rand) { + function test_VerifyWC_SlashToPod_VerifyStale_CompleteCP(uint24 _rand) public rand(_rand) { (User staker, ,) = _newRandomStaker(); - _upgradeEigenLayerContracts(); (uint40[] memory validators, uint64 beaconBalanceGwei) = staker.startValidators(); // Advance epoch without generating rewards @@ -448,9 +429,8 @@ contract Integration_VerifyWC_StartCP_CompleteCP is IntegrationCheckUtils { /// 2. start a checkpoint /// 3. complete a checkpoint /// => after 3, shares should decrease by slashed amount - function test_VerifyWC_SlashToCL_VerifyStale_CompleteCP_SlashAgain(uint24 _rand) public r(_rand) { + function test_VerifyWC_SlashToCL_VerifyStale_CompleteCP_SlashAgain(uint24 _rand) public rand(_rand) { (User staker, ,) = _newRandomStaker(); - _upgradeEigenLayerContracts(); (uint40[] memory validators, uint64 beaconBalanceGwei) = staker.startValidators(); // Advance epoch without generating rewards @@ -489,9 +469,8 @@ contract Integration_VerifyWC_StartCP_CompleteCP is IntegrationCheckUtils { /// 4. start a checkpoint /// 5. complete a checkpoint /// => slashed balance should be reflected in 4 and 5 - function test_VerifyWC_StartCP_SlashToPod_CompleteCP_VerifyStale(uint24 _rand) public r(_rand) { + function test_VerifyWC_StartCP_SlashToPod_CompleteCP_VerifyStale(uint24 _rand) public rand(_rand) { (User staker, ,) = _newRandomStaker(); - _upgradeEigenLayerContracts(); (uint40[] memory validators, uint64 beaconBalanceGwei) = staker.startValidators(); // Advance epoch without generating rewards @@ -526,9 +505,8 @@ contract Integration_VerifyWC_StartCP_CompleteCP is IntegrationCheckUtils { /// 2. start a checkpoint /// 3. complete a checkpoint /// => after 3, shares increase by rewards earned on beacon chain - function test_EarnOnBeacon_VerifyWC_StartCP_CompleteCP(uint24 _rand) public r(_rand) { + function test_EarnOnBeacon_VerifyWC_StartCP_CompleteCP(uint24 _rand) public rand(_rand) { (User staker, ,) = _newRandomStaker(); - _upgradeEigenLayerContracts(); (uint40[] memory validators, uint64 beaconBalanceGwei) = staker.startValidators(); // Advance epoch and generate consensus rewards, but don't withdraw to pod @@ -550,9 +528,8 @@ contract Integration_VerifyWC_StartCP_CompleteCP is IntegrationCheckUtils { /// 2. start a checkpoint /// 3. complete a checkpoint /// => after 3, shares increase by rewards earned on beacon chain - function test_VerifyWC_EarnOnBeacon_StartCP_CompleteCP(uint24 _rand) public r(_rand) { + function test_VerifyWC_EarnOnBeacon_StartCP_CompleteCP(uint24 _rand) public rand(_rand) { (User staker, ,) = _newRandomStaker(); - _upgradeEigenLayerContracts(); (uint40[] memory validators, uint64 beaconBalanceGwei) = staker.startValidators(); beaconChain.advanceEpoch_NoRewards(); @@ -576,9 +553,8 @@ contract Integration_VerifyWC_StartCP_CompleteCP is IntegrationCheckUtils { /// -- earn rewards on beacon chain (not withdrawn to pod) /// 3. complete a checkpoint /// => no change in shares between 1 and 3 - function test_VerifyWC_StartCP_EarnOnBeacon_CompleteCP(uint24 _rand) public r(_rand) { + function test_VerifyWC_StartCP_EarnOnBeacon_CompleteCP(uint24 _rand) public rand(_rand) { (User staker, ,) = _newRandomStaker(); - _upgradeEigenLayerContracts(); (uint40[] memory validators, uint64 beaconBalanceGwei) = staker.startValidators(); beaconChain.advanceEpoch_NoRewards(); @@ -606,9 +582,8 @@ contract Integration_VerifyWC_StartCP_CompleteCP is IntegrationCheckUtils { /// 2. start a checkpoint /// 3. complete a checkpoint /// => after 3, shares increase by rewards withdrawn to pod - function test_EarnToPod_VerifyWC_StartCP_CompleteCP(uint24 _rand) public r(_rand) { + function test_EarnToPod_VerifyWC_StartCP_CompleteCP(uint24 _rand) public rand(_rand) { (User staker, ,) = _newRandomStaker(); - _upgradeEigenLayerContracts(); (uint40[] memory validators, uint64 beaconBalanceGwei) = staker.startValidators(); // Advance epoch, generating consensus rewards and withdrawing anything over 32 ETH @@ -630,9 +605,8 @@ contract Integration_VerifyWC_StartCP_CompleteCP is IntegrationCheckUtils { /// 2. start a checkpoint /// 3. complete a checkpoint /// => after 3, shares increase by rewards withdrawn to pod - function test_VerifyWC_EarnToPod_StartCP_CompleteCP(uint24 _rand) public r(_rand) { + function test_VerifyWC_EarnToPod_StartCP_CompleteCP(uint24 _rand) public rand(_rand) { (User staker, ,) = _newRandomStaker(); - _upgradeEigenLayerContracts(); (uint40[] memory validators, uint64 beaconBalanceGwei) = staker.startValidators(); beaconChain.advanceEpoch_NoRewards(); @@ -656,9 +630,8 @@ contract Integration_VerifyWC_StartCP_CompleteCP is IntegrationCheckUtils { /// -- earn rewards on beacon chain (withdrawn to pod) /// 3. complete a checkpoint /// => no change in shares between 1 and 3 - function test_VerifyWC_StartCP_EarnToPod_CompleteCP(uint24 _rand) public r(_rand) { + function test_VerifyWC_StartCP_EarnToPod_CompleteCP(uint24 _rand) public rand(_rand) { (User staker, ,) = _newRandomStaker(); - _upgradeEigenLayerContracts(); (uint40[] memory validators, uint64 beaconBalanceGwei) = staker.startValidators(); beaconChain.advanceEpoch_NoRewards(); @@ -689,9 +662,9 @@ contract Integration_VerifyWC_StartCP_CompleteCP is IntegrationCheckUtils { /// -- Pod receives native ETH via fallback /// 1. start a checkpoint /// => checkpoint should auto-complete, awarding shares for ETH in pod - function test_NativeETH_StartCP(uint24 _rand) public r(_rand) { + function test_NativeETH_StartCP(uint24 _rand) public rand(_rand) { (User staker, ,) = _newRandomStaker(); - _upgradeEigenLayerContracts(); + // Send a random amount of ETH to staker's fallback (uint64 gweiSent, ) = _sendRandomETH(address(staker.pod())); @@ -708,9 +681,8 @@ contract Integration_VerifyWC_StartCP_CompleteCP is IntegrationCheckUtils { /// 2. start a checkpoint /// 3. complete a checkpoint /// => after 3, shares should account for native ETH - function test_NativeETH_VerifyWC_StartCP_CompleteCP(uint24 _rand) public r(_rand) { + function test_NativeETH_VerifyWC_StartCP_CompleteCP(uint24 _rand) public rand(_rand) { (User staker, ,) = _newRandomStaker(); - _upgradeEigenLayerContracts(); (uint40[] memory validators, uint64 beaconBalanceGwei) = staker.startValidators(); beaconChain.advanceEpoch_NoRewards(); @@ -736,9 +708,8 @@ contract Integration_VerifyWC_StartCP_CompleteCP is IntegrationCheckUtils { /// 2. start a checkpoint /// 3. complete a checkpoint /// => after 3, shares should account for native ETH - function test_VerifyWC_NativeETH_StartCP_CompleteCP(uint24 _rand) public r(_rand) { + function test_VerifyWC_NativeETH_StartCP_CompleteCP(uint24 _rand) public rand(_rand) { (User staker, ,) = _newRandomStaker(); - _upgradeEigenLayerContracts(); (uint40[] memory validators, uint64 beaconBalanceGwei) = staker.startValidators(); beaconChain.advanceEpoch_NoRewards(); @@ -764,9 +735,8 @@ contract Integration_VerifyWC_StartCP_CompleteCP is IntegrationCheckUtils { /// -- Pod receives native ETH via fallback /// 3. complete a checkpoint /// => no change in shares between 1 and 3 - function test_VerifyWC_StartCP_NativeETH_CompleteCP(uint24 _rand) public r(_rand) { + function test_VerifyWC_StartCP_NativeETH_CompleteCP(uint24 _rand) public rand(_rand) { (User staker, ,) = _newRandomStaker(); - _upgradeEigenLayerContracts(); (uint40[] memory validators, uint64 beaconBalanceGwei) = staker.startValidators(); beaconChain.advanceEpoch_NoRewards(); diff --git a/src/test/integration/tests/upgrade/Complete_PreSlashing_Withdrawal.t.sol b/src/test/integration/tests/upgrade/Complete_PreSlashing_Withdrawal.t.sol new file mode 100644 index 0000000000..17d839632a --- /dev/null +++ b/src/test/integration/tests/upgrade/Complete_PreSlashing_Withdrawal.t.sol @@ -0,0 +1,107 @@ +// SPDX-License-Identifier: BUSL-1.1 +pragma solidity ^0.8.27; + +import "src/test/integration/UpgradeTest.t.sol"; + +contract Integration_Upgrade_Complete_PreSlashing_Withdrawal is UpgradeTest { + + function testFuzz_deposit_queue_upgrade_completeAsShares(uint24 _random) public rand(_random) { + /// Pre-upgrade: + /// 1. Create staker with some assets + /// 2. Staker deposits into EigenLayer + /// 3. Staker queues a withdrawal + (User staker, IStrategy[] memory strategies, uint[] memory tokenBalances) = _newRandomStaker(); + User operator = User(payable(0)); + + staker.depositIntoEigenlayer(strategies, tokenBalances); + uint[] memory shares = _calculateExpectedShares(strategies, tokenBalances); + Withdrawal[] memory withdrawals = staker.queueWithdrawals(strategies, shares); + + /// Upgrade to slashing contracts + _upgradeEigenLayerContracts(); + + // Complete pre-slashing withdrawals as shares + _rollBlocksForCompleteWithdrawals(withdrawals); + for (uint i = 0; i < withdrawals.length; i++) { + staker.completeWithdrawalAsShares(withdrawals[i]); + check_Withdrawal_AsShares_State(staker, operator, withdrawals[i], strategies, shares); + } + } + + function testFuzz_delegate_deposit_queue_upgrade_completeAsShares(uint24 _random) public rand(_random) { + /// Pre-upgrade: + /// 1. Create staker and operator with some asset amounts + /// 2. Staker delegates to operator + /// 3. Staker deposits into EigenLayer + /// 4. Staker queues a withdrawal + (User staker, IStrategy[] memory strategies, uint[] memory tokenBalances) = _newRandomStaker(); + (User operator, ,) = _newRandomOperator(); + + staker.delegateTo(operator); + staker.depositIntoEigenlayer(strategies, tokenBalances); + uint[] memory shares = _calculateExpectedShares(strategies, tokenBalances); + Withdrawal[] memory withdrawals = staker.queueWithdrawals(strategies, shares); + + /// Upgrade to slashing contracts + _upgradeEigenLayerContracts(); + + // Complete pre-slashing withdrawals as shares + _rollBlocksForCompleteWithdrawals(withdrawals); + for (uint i = 0; i < withdrawals.length; i++) { + staker.completeWithdrawalAsShares(withdrawals[i]); + check_Withdrawal_AsShares_State(staker, operator, withdrawals[i], strategies, shares); + } + } + + function testFuzz_deposit_queue_upgrade_completeAsTokens(uint24 _random) public rand(_random) { + /// Pre-upgrade: + /// 1. Create staker with some assets + /// 2. Staker deposits into EigenLayer + /// 3. Staker queues a withdrawal + (User staker, IStrategy[] memory strategies, uint[] memory tokenBalances) = _newRandomStaker(); + User operator = User(payable(0)); + + staker.depositIntoEigenlayer(strategies, tokenBalances); + uint[] memory shares = _calculateExpectedShares(strategies, tokenBalances); + uint[] memory expectedTokens = _calculateExpectedTokens(strategies, shares); + Withdrawal[] memory withdrawals = staker.queueWithdrawals(strategies, shares); + + /// Upgrade to slashing contracts + _upgradeEigenLayerContracts(); + + // Complete pre-slashing withdrawals as tokens + _rollBlocksForCompleteWithdrawals(withdrawals); + for (uint i = 0; i < withdrawals.length; i++) { + IERC20[] memory tokens = staker.completeWithdrawalAsTokens(withdrawals[i]); + check_Withdrawal_AsTokens_State(staker, operator, withdrawals[i], strategies, shares, tokens, expectedTokens); + } + } + + function testFuzz_delegate_deposit_queue_upgrade_completeAsTokens(uint24 _random) public rand(_random) { + /// Pre-upgrade: + /// 1. Create staker and operator with some asset amounts + /// 2. Staker delegates to operator + /// 3. Staker deposits into EigenLayer + /// 4. Staker queues a withdrawal + (User staker, IStrategy[] memory strategies, uint[] memory tokenBalances) = _newRandomStaker(); + (User operator, ,) = _newRandomOperator(); + + staker.delegateTo(operator); + staker.depositIntoEigenlayer(strategies, tokenBalances); + uint[] memory shares = _calculateExpectedShares(strategies, tokenBalances); + uint[] memory expectedTokens = _calculateExpectedTokens(strategies, shares); + Withdrawal[] memory withdrawals = staker.queueWithdrawals(strategies, shares); + + /// Upgrade to slashing contracts + _upgradeEigenLayerContracts(); + + // Complete pre-slashing withdrawals as tokens + _rollBlocksForCompleteWithdrawals(withdrawals); + for (uint i = 0; i < withdrawals.length; i++) { + IERC20[] memory tokens = staker.completeWithdrawalAsTokens(withdrawals[i]); + check_Withdrawal_AsTokens_State(staker, operator, withdrawals[i], strategies, shares, tokens, expectedTokens); + } + } + + /// TODO - complete pre-upgrade withdrawal after earliest possible operator slashing +} diff --git a/src/test/integration/tests/upgrade/Delegate_Upgrade_Allocate.t.sol b/src/test/integration/tests/upgrade/Delegate_Upgrade_Allocate.t.sol new file mode 100644 index 0000000000..8d878beec9 --- /dev/null +++ b/src/test/integration/tests/upgrade/Delegate_Upgrade_Allocate.t.sol @@ -0,0 +1,40 @@ +// SPDX-License-Identifier: BUSL-1.1 +pragma solidity ^0.8.27; + +import "src/test/integration/UpgradeTest.t.sol"; + +contract Integration_Upgrade_Deposit_Delegate_Allocate is UpgradeTest { + + function testFuzz_deposit_delegate_upgrade_allocate(uint24 _random) public rand(_random) { + (User staker, IStrategy[] memory strategies, uint256[] memory tokenBalances) = _newRandomStaker(); + (User operator,,) = _newRandomOperator(); + + // Pre-upgrade: + // 1. Create staker and operator with assets, then deposit into EigenLayer + // 2. Delegate to operator + staker.depositIntoEigenlayer(strategies, tokenBalances); + staker.delegateTo(operator); + + // Upgrade to slashing release + _upgradeEigenLayerContracts(); + (AVS avs,) = _newRandomAVS(); + + // 3. Set allocation delay for operator + operator.setAllocationDelay(1); + rollForward({blocks: ALLOCATION_CONFIGURATION_DELAY + 1}); + + // 4. Create an operator set and register an operator. + OperatorSet memory operatorSet = avs.createOperatorSet(strategies); + operator.registerForOperatorSet(operatorSet); + check_Registration_State_NoAllocation(operator, operatorSet, allStrats); + + // 5. Allocate to operator set. + AllocateParams memory allocateParams = AllocateParams({ + operatorSet: operatorSet, + strategies: strategies, + newMagnitudes: _randMagnitudes({sum: 1 ether, len: strategies.length}) + }); + operator.modifyAllocations(allocateParams); + check_IncrAlloc_State_Slashable(operator, allocateParams); + } +} \ No newline at end of file diff --git a/src/test/integration/tests/upgrade/EigenPod_Negative_Shares.t.sol b/src/test/integration/tests/upgrade/EigenPod_Negative_Shares.t.sol new file mode 100644 index 0000000000..0897123c93 --- /dev/null +++ b/src/test/integration/tests/upgrade/EigenPod_Negative_Shares.t.sol @@ -0,0 +1,133 @@ +// SPDX-License-Identifier: BUSL-1.1 +pragma solidity ^0.8.27; + +import "src/test/integration/UpgradeTest.t.sol"; + +contract Integration_Upgrade_EigenPod_Negative_Shares is UpgradeTest { + function _init() internal override { + _configAssetTypes(HOLDS_ETH); + _configUserTypes(DEFAULT); + } + + function testFuzz_deposit_delegate_updateBalance_upgrade_completeAsShares( + uint24 _rand + ) public rand(_rand) { + /// 0. Create an operator and staker with some underlying assets + (User staker, IStrategy[] memory strategies, uint256[] memory tokenBalances) = _newRandomStaker(); + (User operator,,) = _newRandomOperator(); + uint256[] memory shares = _calculateExpectedShares(strategies, tokenBalances); + + /// 1. Deposit into strategies + staker.depositIntoEigenlayer(strategies, tokenBalances); + + /// 2. Delegate to operator + staker.delegateTo(operator); + + /// 3. Queue a withdrawal for all shares + IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.queueWithdrawals(strategies, shares); + IDelegationManagerTypes.Withdrawal memory withdrawal = withdrawals[0]; + + /// 4. Update balance randomly (can be positive or negative) + (int256[] memory tokenDeltas, int256[] memory balanceUpdateShareDelta,) = _randBalanceUpdate(staker, strategies); + staker.updateBalances(strategies, tokenDeltas); + + /// 5. Upgrade contracts + _upgradeEigenLayerContracts(); + + /// 6. Complete the withdrawal as shares + _rollBlocksForCompleteWithdrawals(withdrawals); + staker.completeWithdrawalAsShares(withdrawal); + + // Manually complete checks since we could still negative shares prior to the upgrade, causing a revert in the share check + (uint256[] memory expectedOperatorShareDelta, int256[] memory expectedStakerShareDelta) = + _getPostWithdrawalExpectedShareDeltas(balanceUpdateShareDelta[0], withdrawal); + assert_WithdrawalNotPending(delegationManager.calculateWithdrawalRoot(withdrawal), "staker withdrawal should no longer be pending"); + assert_Snap_Unchanged_TokenBalances(staker, "staker should not have any change in underlying token balances"); + assert_Snap_Added_OperatorShares(operator, withdrawal.strategies, expectedOperatorShareDelta, "operator should have received shares"); + assert_Snap_Delta_StakerShares(staker, strategies, expectedStakerShareDelta, "staker should have received expected shares"); + } + + function testFuzz_deposit_delegate_updateBalance_upgrade_completeAsTokens( + uint24 _rand + ) public rand(_rand) { + /// 0. Create an operator and staker with some underlying assets + (User staker, IStrategy[] memory strategies, uint256[] memory tokenBalances) = _newRandomStaker(); + (User operator,,) = _newRandomOperator(); + uint256[] memory shares = _calculateExpectedShares(strategies, tokenBalances); + + /// 1. Deposit into strategies + staker.depositIntoEigenlayer(strategies, tokenBalances); + + /// 2. Delegate to operator + staker.delegateTo(operator); + + /// 3. Queue a withdrawal for all shares + IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.queueWithdrawals(strategies, shares); + IDelegationManagerTypes.Withdrawal memory withdrawal = withdrawals[0]; + + /// 4. Update balance randomly (can be positive or negative) + (int256[] memory tokenDeltas, int256[] memory balanceUpdateShareDelta,) = _randBalanceUpdate(staker, strategies); + staker.updateBalances(strategies, tokenDeltas); + + /// 5. Upgrade contracts + _upgradeEigenLayerContracts(); + + /// 6. Complete the withdrawal as shares + _rollBlocksForCompleteWithdrawals(withdrawals); + IERC20[] memory tokens = staker.completeWithdrawalAsTokens(withdrawal); + uint256[] memory expectedTokens = _getPostWithdrawalExpectedTokenDeltas(balanceUpdateShareDelta[0], withdrawal); + + // Manually complete checks since we could still negative shares prior to the upgrade, causing a revert in the share check + assert_WithdrawalNotPending(delegationManager.calculateWithdrawalRoot(withdrawal), "staker withdrawal should no longer be pending"); + assert_Snap_Added_TokenBalances(staker, tokens, expectedTokens, "staker should have received expected tokens"); + assert_Snap_Unchanged_OperatorShares(operator, "operator shares should not have changed"); + + // If we had a positive balance update, then the staker shares should not have changed + if (balanceUpdateShareDelta[0] > 0) { + assert_Snap_Unchanged_Staker_DepositShares(staker, "staker shares should not have changed"); + } + // Else, the staker shares should have increased by the magnitude of the negative share delta + else { + int256[] memory expectedStakerShareDelta = new int256[](1); + expectedStakerShareDelta[0] = -balanceUpdateShareDelta[0]; + assert_Snap_Delta_StakerShares(staker, strategies, expectedStakerShareDelta, "staker should have received expected shares"); + } + } + + + + function _getPostWithdrawalExpectedShareDeltas( + int256 balanceUpdateShareDelta, + IDelegationManagerTypes.Withdrawal memory withdrawal + ) internal pure returns (uint256[] memory, int256[] memory) { + uint256[] memory operatorShareDelta = new uint256[](1); + int256[] memory stakerShareDelta = new int256[](1); + // The staker share delta is the withdrawal scaled shares since it can go from negative to positive + stakerShareDelta[0] = int256(withdrawal.scaledShares[0]); + + if (balanceUpdateShareDelta > 0) { + // If balanceUpdateShareDelta is positive, then the operator delta is the withdrawal scaled shares + operatorShareDelta[0] = withdrawal.scaledShares[0]; + } else { + // Operator shares never went negative, so we can just add the withdrawal scaled shares and the negative share delta + operatorShareDelta[0] = uint256(int256(withdrawal.scaledShares[0]) + balanceUpdateShareDelta); + } + + return (operatorShareDelta, stakerShareDelta); + } + + function _getPostWithdrawalExpectedTokenDeltas( + int256 balanceUpdateShareDelta, + IDelegationManagerTypes.Withdrawal memory withdrawal + ) internal pure returns (uint256[] memory) { + uint256[] memory expectedTokenDeltas = new uint256[](1); + if (balanceUpdateShareDelta > 0) { + // If we had a positive balance update, then the expected token delta is the withdrawal scaled shares + expectedTokenDeltas[0] = withdrawal.scaledShares[0]; + } else { + // If we had a negative balance update, then the expected token delta is the withdrawal scaled shares plus the negative share delta + expectedTokenDeltas[0] = uint256(int256(withdrawal.scaledShares[0]) + balanceUpdateShareDelta); + } + return expectedTokenDeltas; + } +} diff --git a/src/test/integration/tests/eigenpod/EigenPod_Slashing_Migration.t.sol b/src/test/integration/tests/upgrade/EigenPod_Slashing_Migration.t.sol similarity index 73% rename from src/test/integration/tests/eigenpod/EigenPod_Slashing_Migration.t.sol rename to src/test/integration/tests/upgrade/EigenPod_Slashing_Migration.t.sol index 79a29826ca..f7ed80228e 100644 --- a/src/test/integration/tests/eigenpod/EigenPod_Slashing_Migration.t.sol +++ b/src/test/integration/tests/upgrade/EigenPod_Slashing_Migration.t.sol @@ -1,18 +1,13 @@ // SPDX-License-Identifier: BUSL-1.1 pragma solidity ^0.8.27; -import "src/test/integration/IntegrationChecks.t.sol"; -import "src/test/integration/users/User.t.sol"; +import "src/test/integration/UpgradeTest.t.sol"; -contract Integration_EigenPod_Slashing_Migration is IntegrationCheckUtils, EigenPodPausingConstants { - modifier r(uint24 _rand) { - _configRand({ - _randomSeed: _rand, - _assetTypes: HOLDS_ETH, - _userTypes: DEFAULT - }); - - _; +contract Integration_Upgrade_EigenPod_Slashing_Migration is UpgradeTest, EigenPodPausingConstants { + + function _init() internal override { + _configAssetTypes(HOLDS_ETH); + _configUserTypes(DEFAULT); } /** @@ -24,12 +19,7 @@ contract Integration_EigenPod_Slashing_Migration is IntegrationCheckUtils, Eigen * 5. Upgrade EigenPod contracts * 6. Exit subset of Validators */ - function test_upgrade_eigenpod_migration(uint24 _rand) public r(_rand) { - // Only run this test as a fork test - if (forkType == LOCAL) { - return; - } - + function test_upgrade_eigenpod_migration(uint24 _rand) public rand(_rand) { // Initialize state (User staker, ,) = _newRandomStaker(); @@ -41,7 +31,6 @@ contract Integration_EigenPod_Slashing_Migration is IntegrationCheckUtils, Eigen // Advance epoch, generating consensus rewards and withdrawing anything over 32 ETH beaconChain.advanceEpoch(); - uint64 expectedWithdrawnGwei = uint64(validators.length) * beaconChain.CONSENSUS_REWARD_AMOUNT_GWEI(); // 2. Start a checkpoint staker.startCheckpoint(); @@ -49,17 +38,19 @@ contract Integration_EigenPod_Slashing_Migration is IntegrationCheckUtils, Eigen // 3. Pause checkpoint starting cheats.prank(pauserMultisig); eigenPodManager.pause(2 ** PAUSED_START_CHECKPOINT); - cheats.expectRevert("EigenPod.onlyWhenNotPaused: index is paused in EigenPodManager"); staker.startCheckpoint(); // 4. Complete in progress checkpoint staker.completeCheckpoint(); - check_CompleteCheckpoint_WithPodBalance_State(staker, expectedWithdrawnGwei); // 5. Upgrade Contracts for slashing _upgradeEigenLayerContracts(); + // Unpause EigenPodManager + cheats.prank(eigenLayerPauserReg.unpauser()); + eigenPodManager.unpause(0); + // 6. Exit validators // Fully exit one or more validators and advance epoch without generating rewards uint40[] memory subset = _choose(validators); diff --git a/src/test/integration/tests/upgrade/README.md b/src/test/integration/tests/upgrade/README.md new file mode 100644 index 0000000000..c9844a3143 --- /dev/null +++ b/src/test/integration/tests/upgrade/README.md @@ -0,0 +1,45 @@ +## Upgrade Tests + +This folder contains specific tests we want to conduct to determine upgrade compatibility. Tests in this folder are only run if the `forktest` profile is selected, e.g: + +`env FOUNDRY_PROFILE=forktest forge t --mc Upgrade` + +#### How to Write + +Upgrade tests inherit from the `UpgradeTest` mixin, which imports everything you need for a standard integration test. A standard integration test automatically upgrades all contracts to the latest repo contracts, even when forking from mainnet. + +In contrast, the `UpgradeTest` mixin ensures that (when a test begins) the contracts we're working with are _not upgraded_. This allows the test writer to perform some initial setup actions before calling `_upgradeEigenLayerContracts()`, after which we can check that the upgrade correctly handles pre-upgrade state. + +#### Example + +Say we want to check that withdrawals initiated before the slashing upgrade are completable after the slashing upgrade. This example test shows how: + +```solidity +contract Integration_Upgrade_Complete_PreSlashing_Withdrawal is UpgradeTest { + + function testFuzz_deposit_queue_upgrade_completeAsShares(uint24 _random) public rand(_random) { + /// Pre-upgrade: + /// 1. Create staker with some assets + /// 2. Staker deposits into EigenLayer + /// 3. Staker queues a withdrawal + (User staker, IStrategy[] memory strategies, uint[] memory tokenBalances) = _newRandomStaker(); + User operator = User(payable(0)); + + staker.depositIntoEigenlayer(strategies, tokenBalances); + uint[] memory shares = _calculateExpectedShares(strategies, tokenBalances); + IDelegationManagerTypes.Withdrawal[] memory withdrawals = staker.queueWithdrawals(strategies, shares); + + /// Upgrade to slashing contracts + _upgradeEigenLayerContracts(); + + // Complete pre-slashing withdrawals as shares + _rollBlocksForCompleteWithdrawals(withdrawals); + for (uint i = 0; i < withdrawals.length; i++) { + staker.completeWithdrawalAsShares(withdrawals[i]); + check_Withdrawal_AsShares_State(staker, operator, withdrawals[i], strategies, shares); + } + } +} +``` + +**Note** how the initial staker actions are NOT followed by `check_X_State` methods. This is because, before calling `_upgradeEigenLayerContracts`, the test is being run on old contracts. Adding invariant checks to old state transitions is not the point of this test and would add a lot of maintenance overhead. \ No newline at end of file diff --git a/src/test/integration/users/AVS.t.sol b/src/test/integration/users/AVS.t.sol index 969078b164..c459aa2fbf 100644 --- a/src/test/integration/users/AVS.t.sol +++ b/src/test/integration/users/AVS.t.sol @@ -67,6 +67,18 @@ contract AVS is Logger, IAllocationManagerTypes, IAVSRegistrar { /// AllocationManager /// ----------------------------------------------------------------------- + function updateAVSMetadataURI( + string memory uri + ) public createSnapshot { + print.method("updateAVSMetadataURI"); + + console.log("Setting AVS metadata URI to: %s", uri); + _tryPrankAppointee_AllocationManager(IAllocationManager.updateAVSMetadataURI.selector); + allocationManager.updateAVSMetadataURI(address(this), uri); + + print.gasUsed(); + } + function createOperatorSets( IStrategy[][] memory strategies ) public createSnapshot returns (OperatorSet[] memory operatorSets) { @@ -103,6 +115,37 @@ contract AVS is Logger, IAllocationManagerTypes, IAVSRegistrar { print.gasUsed(); } + function slashOperator( + SlashingParams memory params + ) public createSnapshot { + + + for (uint256 i; i < params.strategies.length; ++i) { + string memory strategyName = params.strategies[i] == beaconChainETHStrategy ? + "Native ETH" : + IERC20Metadata(address(params.strategies[i].underlyingToken())).name(); + + print.method( + "slashOperator", + string.concat( + "{operator: ", + User(payable(params.operator)).NAME_COLORED(), + ", operatorSetId: ", + cheats.toString(params.operatorSetId), + ", strategy: ", + strategyName, + ", wadToSlash: ", + params.wadsToSlash[i].asWad(), + "}" + ) + ); + } + + _tryPrankAppointee_AllocationManager(IAllocationManager.slashOperator.selector); + allocationManager.slashOperator(address(this), params); + print.gasUsed(); + } + function slashOperator( User operator, uint32 operatorSetId, diff --git a/src/test/integration/users/User.t.sol b/src/test/integration/users/User.t.sol index 83e251eb4a..291668fe7d 100644 --- a/src/test/integration/users/User.t.sol +++ b/src/test/integration/users/User.t.sol @@ -48,6 +48,8 @@ contract User is Logger, IDelegationManagerTypes, IAllocationManagerTypes { TimeMachine timeMachine; BeaconChainMock beaconChain; + uint32 public allocationDelay = 1; + string _NAME; // User's EigenPod and each of their validator indices within that pod @@ -92,44 +94,35 @@ contract User is Logger, IDelegationManagerTypes, IAllocationManagerTypes { /// @dev Allocates randomly accross the operator set's strategies with a sum of `magnitudeSum`. /// NOTE: Calling more than once will lead to deallocations... function modifyAllocations( - OperatorSet memory operatorSet, - uint64[] memory magnitudes - ) public virtual createSnapshot returns (AllocateParams memory) { + AllocateParams memory params + ) public virtual createSnapshot { print.method( "modifyAllocations", string.concat( "{avs: ", - Logger(operatorSet.avs).NAME_COLORED(), + Logger(params.operatorSet.avs).NAME_COLORED(), ", operatorSetId: ", - cheats.toString(operatorSet.id), + cheats.toString(params.operatorSet.id), "}" ) ); - IStrategy[] memory strategies = allocationManager().getStrategiesInOperatorSet(operatorSet); - - require(strategies.length == magnitudes.length, "User.modifyAllocations: length mismatch"); - - AllocateParams[] memory allocateParams = AllocateParams({ - operatorSet: operatorSet, - strategies: strategies, - newMagnitudes: magnitudes - }).toArray(); - _tryPrankAppointee_AllocationManager(IAllocationManager.modifyAllocations.selector); - allocationManager().modifyAllocations(address(this), allocateParams); + allocationManager().modifyAllocations(address(this), params.toArray()); print.gasUsed(); - - return allocateParams[0]; } function deallocateAll( OperatorSet memory operatorSet ) public virtual returns (AllocateParams memory) { - return modifyAllocations( - operatorSet, - new uint64[](allocationManager().getStrategiesInOperatorSet(operatorSet).length) - ); + AllocateParams memory params; + params.operatorSet = operatorSet; + params.strategies = allocationManager().getStrategiesInOperatorSet(operatorSet); + params.newMagnitudes = new uint64[](params.strategies.length); + + modifyAllocations(params); + + return params; } function registerForOperatorSets( @@ -192,17 +185,17 @@ contract User is Logger, IDelegationManagerTypes, IAllocationManagerTypes { _tryPrankAppointee_AllocationManager(IAllocationManager.setAllocationDelay.selector); allocationManager().setAllocationDelay(address(this), delay); print.gasUsed(); + + allocationDelay = delay; } /// ----------------------------------------------------------------------- /// Delegation Manager Methods /// ----------------------------------------------------------------------- - uint32 withdrawalDelay = 1; - function registerAsOperator() public virtual createSnapshot { print.method("registerAsOperator"); - delegationManager.registerAsOperator(address(0), withdrawalDelay, "metadata"); + delegationManager.registerAsOperator(address(0), allocationDelay, "metadata"); print.gasUsed(); } @@ -212,7 +205,7 @@ contract User is Logger, IDelegationManagerTypes, IAllocationManagerTypes { ) public virtual createSnapshot { print.method("delegateTo", operator.NAME_COLORED()); - ISignatureUtils.SignatureWithExpiry memory emptySig; + ISignatureUtilsMixinTypes.SignatureWithExpiry memory emptySig; delegationManager.delegateTo(address(operator), emptySig, bytes32(0)); print.gasUsed(); } @@ -244,6 +237,34 @@ contract User is Logger, IDelegationManagerTypes, IAllocationManagerTypes { return expectedWithdrawals; } + /// @dev Redelegate to a new operator + function redelegate( + User newOperator + ) public virtual createSnapshot returns (Withdrawal[] memory) { + print.method("redelegate", newOperator.NAME_COLORED()); + Withdrawal[] memory expectedWithdrawals = _getExpectedWithdrawalStructsForStaker(address(this)); + ISignatureUtilsMixinTypes.SignatureWithExpiry memory emptySig; + _tryPrankAppointee_DelegationManager(IDelegationManager.redelegate.selector); + delegationManager.redelegate(address(newOperator), emptySig, bytes32(0)); + print.gasUsed(); + + for (uint256 i = 0; i < expectedWithdrawals.length; i++) { + IStrategy strat = expectedWithdrawals[i].strategies[0]; + + string memory name = strat == beaconChainETHStrategy + ? "Native ETH" + : IERC20Metadata(address(strat.underlyingToken())).name(); + + console.log( + " Expecting withdrawal with nonce %s of %s for %s scaled shares.", + expectedWithdrawals[i].nonce, + name, + expectedWithdrawals[i].scaledShares[0] + ); + } + return expectedWithdrawals; + } + /// @dev Force undelegate staker function forceUndelegate( User staker @@ -275,6 +296,15 @@ contract User is Logger, IDelegationManagerTypes, IAllocationManagerTypes { __deprecated_withdrawer: address(0) }); + uint256[] memory scaledSharesForWithdrawal = new uint256[](strategies.length); + for (uint256 i = 0; i < strategies.length; ++i) { + DepositScalingFactor memory dsf = DepositScalingFactor( + delegationManager.depositScalingFactor(address(this), strategies[i]) + ); + + scaledSharesForWithdrawal[i] = dsf.scaleForQueueWithdrawal(depositShares[i]); + } + // Create Withdrawal struct using same info Withdrawal[] memory withdrawals = new Withdrawal[](1); withdrawals[0] = Withdrawal({ @@ -284,7 +314,7 @@ contract User is Logger, IDelegationManagerTypes, IAllocationManagerTypes { nonce: nonce, startBlock: uint32(block.number), strategies: strategies, - scaledShares: depositShares // TODO: convert depositShares to shares and then scale in withdrawal + scaledShares: scaledSharesForWithdrawal }); bytes32[] memory withdrawalRoots = delegationManager.queueWithdrawals(params); @@ -316,7 +346,7 @@ contract User is Logger, IDelegationManagerTypes, IAllocationManagerTypes { function completeWithdrawalsAsShares( Withdrawal[] memory withdrawals ) public virtual createSnapshot returns (IERC20[][] memory tokens) { - print.method("completeWithdrawalAsShares"); + print.method("completeWithdrawalsAsShares"); tokens = new IERC20[][](withdrawals.length); for (uint256 i = 0; i < withdrawals.length; i++) { tokens[i] = _completeQueuedWithdrawal(withdrawals[i], false); @@ -465,9 +495,9 @@ contract User is Logger, IDelegationManagerTypes, IAllocationManagerTypes { if (strat == BEACONCHAIN_ETH_STRAT) { tokens[i] = NATIVE_ETH; - // If we're withdrawing native ETH as tokens, stop ALL validators - // and complete a checkpoint - if (receiveAsTokens) { + // If we're withdrawing native ETH as tokens && do not have negative shares + // stop ALL validators and complete a checkpoint + if (receiveAsTokens && eigenPodManager.podOwnerDepositShares(address(this)) >= 0) { console.log("- exiting all validators and completing checkpoint"); _exitValidators(getActiveValidators()); @@ -650,10 +680,6 @@ contract User is Logger, IDelegationManagerTypes, IAllocationManagerTypes { uint256 scaledShares = dsf.scaleForQueueWithdrawal(depositShares[i]); - if (strategies[i] == beaconChainETHStrategy) { - scaledShares -= scaledShares % 1 gwei; - } - expectedWithdrawals[i] = Withdrawal({ staker: staker, delegatedTo: delegatedTo, diff --git a/src/test/integration/users/User_M1.t.sol b/src/test/integration/users/User_M1.t.sol index e0ebb17a91..86b6f34904 100644 --- a/src/test/integration/users/User_M1.t.sol +++ b/src/test/integration/users/User_M1.t.sol @@ -5,7 +5,7 @@ import "src/test/integration/deprecatedInterfaces/mainnet/IEigenPod.sol"; import "src/test/integration/deprecatedInterfaces/mainnet/IEigenPodManager.sol"; import "src/test/integration/deprecatedInterfaces/mainnet/IStrategyManager.sol"; import "src/test/integration/users/User.t.sol"; -import "src/contracts/mixins/SignatureUtils.sol"; +import "src/contracts/mixins/SignatureUtilsMixin.sol"; interface IUserM1MainnetForkDeployer { function delegationManager() external view returns (DelegationManager); @@ -70,11 +70,6 @@ contract User_M1 is User { } contract User_M1_AltMethods is User_M1 { - /// @notice The EIP-712 typehash for the contract's domain. - bytes32 internal constant EIP712_DOMAIN_TYPEHASH = - keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)"); - - mapping(bytes32 => bool) public signedHashes; constructor(string memory name) User_M1(name) {} diff --git a/src/test/integration/users/User_M2.t.sol b/src/test/integration/users/User_M2.t.sol index 3ec5fbc614..aaee7efe62 100644 --- a/src/test/integration/users/User_M2.t.sol +++ b/src/test/integration/users/User_M2.t.sol @@ -137,7 +137,7 @@ contract User_M2 is User { // If any balance update has occured, a checkpoint will pick it up _startCheckpoint(); if (pod.activeValidatorCount() != 0) { - _completeCheckpoint(); + _completeCheckpoint_M2(); } } else { uint256 tokens = uint256(delta); diff --git a/src/test/mocks/DelegationManagerMock.sol b/src/test/mocks/DelegationManagerMock.sol index 0c9ed77411..9fc9cd28ce 100644 --- a/src/test/mocks/DelegationManagerMock.sol +++ b/src/test/mocks/DelegationManagerMock.sol @@ -52,7 +52,7 @@ contract DelegationManagerMock is Test { } } - function delegateTo(address operator, ISignatureUtils.SignatureWithExpiry memory /*approverSignatureAndExpiry*/, bytes32 /*approverSalt*/) external { + function delegateTo(address operator, ISignatureUtilsMixinTypes.SignatureWithExpiry memory /*approverSignatureAndExpiry*/, bytes32 /*approverSalt*/) external { delegatedTo[msg.sender] = operator; } @@ -89,11 +89,10 @@ contract DelegationManagerMock is Test { function addShares( IStrategyManager strategyManager, address staker, - IERC20 token, IStrategy strategy, uint256 shares ) external { - strategyManager.addShares(staker, strategy, token, shares); + strategyManager.addShares(staker, strategy, shares); } function removeDepositShares( diff --git a/src/test/mocks/EigenPodManagerMock.sol b/src/test/mocks/EigenPodManagerMock.sol index ecf6028707..d9b5f29242 100644 --- a/src/test/mocks/EigenPodManagerMock.sol +++ b/src/test/mocks/EigenPodManagerMock.sol @@ -39,7 +39,6 @@ contract EigenPodManagerMock is Test, Pausable { function addShares( address podOwner, IStrategy, - IERC20, uint256 shares ) external returns (uint256, uint256) { uint256 existingDepositShares = uint256(podOwnerDepositShares[podOwner]); @@ -51,8 +50,10 @@ contract EigenPodManagerMock is Test, Pausable { address podOwner, IStrategy, // strategy uint256 shares - ) external { - podOwnerDepositShares[podOwner] -= int256(shares); + ) external returns (uint256) { + int256 updatedShares = podOwnerDepositShares[podOwner] - int256(shares); + podOwnerDepositShares[podOwner] = updatedShares; + return uint256(updatedShares); } function denebForkTimestamp() external pure returns (uint64) { diff --git a/src/test/mocks/EigenPodMock.sol b/src/test/mocks/EigenPodMock.sol index d1e12199f9..f74b966c4a 100644 --- a/src/test/mocks/EigenPodMock.sol +++ b/src/test/mocks/EigenPodMock.sol @@ -3,8 +3,10 @@ pragma solidity ^0.8.9; import "forge-std/Test.sol"; import "../../contracts/interfaces/IEigenPod.sol"; +import "../../contracts/mixins/SemVerMixin.sol"; -contract EigenPodMock is IEigenPod, Test { +contract EigenPodMock is IEigenPod, SemVerMixin, Test { + constructor() SemVerMixin("v9.9.9") {} function nonBeaconChainETHBalanceWei() external view returns(uint256) {} diff --git a/src/test/mocks/StrategyManagerMock.sol b/src/test/mocks/StrategyManagerMock.sol index 57ffd5f520..74ec746fdb 100644 --- a/src/test/mocks/StrategyManagerMock.sol +++ b/src/test/mocks/StrategyManagerMock.sol @@ -83,9 +83,11 @@ contract StrategyManagerMock is Test { function removeDepositShares( address staker, IStrategy strategy, uint256 sharesToRemove - ) external { + ) external returns (uint256) { uint256 strategyIndex = _getStrategyIndex(staker, strategy); - sharesToReturn[staker][strategyIndex] -= sharesToRemove; + uint256 updatedShares = sharesToReturn[staker][strategyIndex] - sharesToRemove; + sharesToReturn[staker][strategyIndex] = updatedShares; + return updatedShares; } function removeStrategiesFromDepositWhitelist(IStrategy[] calldata /*strategiesToRemoveFromWhitelist*/) external pure {} @@ -102,8 +104,7 @@ contract StrategyManagerMock is Test { function addShares( address staker, - IStrategy strategy, - IERC20, // token + IStrategy strategy, uint256 addedShares ) external returns (uint, uint) { // Increase the staker's shares diff --git a/src/test/unit/AVSDirectoryUnit.t.sol b/src/test/unit/AVSDirectoryUnit.t.sol index bd9e2b8b05..7a8694d4db 100644 --- a/src/test/unit/AVSDirectoryUnit.t.sol +++ b/src/test/unit/AVSDirectoryUnit.t.sol @@ -4,7 +4,7 @@ pragma solidity ^0.8.27; import "src/contracts/core/AVSDirectory.sol"; import "src/test/utils/EigenLayerUnitTestSetup.sol"; -contract AVSDirectoryUnitTests is EigenLayerUnitTestSetup, IAVSDirectoryEvents, IAVSDirectoryErrors, ISignatureUtils { +contract AVSDirectoryUnitTests is EigenLayerUnitTestSetup, IAVSDirectoryEvents, IAVSDirectoryErrors, ISignatureUtilsMixinTypes { uint8 constant PAUSED_OPERATOR_REGISTER_DEREGISTER_TO_AVS = 0; AVSDirectory avsDirectory; @@ -39,7 +39,7 @@ contract AVSDirectoryUnitTests is EigenLayerUnitTestSetup, IAVSDirectoryEvents, avsd = AVSDirectory( address( new TransparentUpgradeableProxy( - address(new AVSDirectory(IDelegationManager(delegationManager), pauserRegistry)), + address(new AVSDirectory(IDelegationManager(delegationManager), pauserRegistry, "v9.9.9")), address(eigenLayerProxyAdmin), abi.encodeWithSelector( AVSDirectory.initialize.selector, @@ -51,7 +51,18 @@ contract AVSDirectoryUnitTests is EigenLayerUnitTestSetup, IAVSDirectoryEvents, ); isExcludedFuzzAddress[address(avsd)] = true; - assertTrue(avsd.domainSeparator() != bytes32(0), "sanity check"); + bytes memory v = bytes(avsd.version()); + bytes32 expectedDomainSeparator = keccak256( + abi.encode( + EIP712_DOMAIN_TYPEHASH, + keccak256(bytes("EigenLayer")), + keccak256(bytes.concat(v[0], v[1])), + block.chainid, + address(avsd) + ) + ); + + assertEq(avsd.domainSeparator(), expectedDomainSeparator, "sanity check"); } function _newOperatorRegistrationSignature( @@ -110,7 +121,7 @@ contract AVSDirectoryUnitTests is EigenLayerUnitTestSetup, IAVSDirectoryEvents, function test_registerOperatorToAVS_SignatureExpired() public { defaultOperatorSignature.expiry = block.timestamp - 1; - cheats.expectRevert(SignatureExpired.selector); + cheats.expectRevert(ISignatureUtilsMixinErrors.SignatureExpired.selector); avsDirectory.registerOperatorToAVS(defaultOperator, defaultOperatorSignature); } diff --git a/src/test/unit/AllocationManagerUnit.t.sol b/src/test/unit/AllocationManagerUnit.t.sol index e68288e004..791429b842 100644 --- a/src/test/unit/AllocationManagerUnit.t.sol +++ b/src/test/unit/AllocationManagerUnit.t.sol @@ -1,7 +1,7 @@ // SPDX-License-Identifier: BUSL-1.1 pragma solidity ^0.8.27; -import "src/contracts/core/AllocationManager.sol"; +import "src/test/harnesses/AllocationManagerHarness.sol"; import "src/test/utils/EigenLayerUnitTestSetup.sol"; import "src/test/mocks/MockAVSRegistrar.sol"; @@ -33,7 +33,7 @@ contract AllocationManagerUnitTests is EigenLayerUnitTestSetup, IAllocationManag /// Mocks /// ----------------------------------------------------------------------- - AllocationManager allocationManager; + AllocationManagerHarness allocationManager; ERC20PresetFixedSupply tokenMock; StrategyBase strategyMock; @@ -62,7 +62,7 @@ contract AllocationManagerUnitTests is EigenLayerUnitTestSetup, IAllocationManag strategyMock = StrategyBase( address( new TransparentUpgradeableProxy( - address(new StrategyBase(IStrategyManager(address(strategyManagerMock)), pauserRegistry)), + address(new StrategyBase(IStrategyManager(address(strategyManagerMock)), pauserRegistry, "v9.9.9")), address(eigenLayerProxyAdmin), abi.encodeWithSelector(StrategyBase.initialize.selector, tokenMock) ) @@ -71,6 +71,10 @@ contract AllocationManagerUnitTests is EigenLayerUnitTestSetup, IAllocationManag defaultStrategies = strategyMock.toArray(); defaultOperatorSet = OperatorSet(defaultAVS, 0); + cheats.prank(defaultAVS); + allocationManager.updateAVSMetadataURI(defaultAVS, "https://example.com"); + + _createOperatorSet(defaultOperatorSet, defaultStrategies); _registerOperator(defaultOperator); _setAllocationDelay(defaultOperator, DEFAULT_OPERATOR_ALLOCATION_DELAY); @@ -86,12 +90,12 @@ contract AllocationManagerUnitTests is EigenLayerUnitTestSetup, IAllocationManag address _initialOwner, IPauserRegistry _pauserRegistry, uint256 _initialPausedStatus - ) internal returns (AllocationManager) { - return allocationManager = AllocationManager( + ) internal returns (AllocationManagerHarness) { + return allocationManager = AllocationManagerHarness( address( new TransparentUpgradeableProxy( address( - new AllocationManager( + new AllocationManagerHarness( IDelegationManager(address(delegationManagerMock)), _pauserRegistry, IPermissionController(address(permissionController)), @@ -228,7 +232,7 @@ contract AllocationManagerUnitTests is EigenLayerUnitTestSetup, IAllocationManag assertEq(expectedAllocation.pendingDiff, allocation.pendingDiff, "pendingDiff != expected"); assertEq(expectedAllocation.effectBlock, allocation.effectBlock, "effectBlock != expected"); - uint256 encumberedMagnitude = allocationManager.encumberedMagnitude(operator, strategy); + uint256 encumberedMagnitude = allocationManager.getEncumberedMagnitude(operator, strategy); uint256 maxMagnitude = allocationManager.getMaxMagnitudes(operator, strategy.toArray())[0]; uint256 allocatableMagnitude = allocationManager.getAllocatableMagnitude(operator, strategy); @@ -259,6 +263,23 @@ contract AllocationManagerUnitTests is EigenLayerUnitTestSetup, IAllocationManag console.log("Success!".green().bold()); } + /// @dev Check that the deallocation queue is in ascending order of effectBlocks + function _checkDeallocationQueueOrder(address operator, IStrategy strategy, uint256 numDeallocations) internal view { + uint32 lastEffectBlock = 0; + + for (uint256 i = 0; i < numDeallocations; ++i) { + bytes32 operatorSetKey = allocationManager.deallocationQueueAtIndex(operator, strategy, i); + Allocation memory allocation = allocationManager.getAllocation(operator, OperatorSetLib.decode(operatorSetKey), strategy); + + assertTrue( + lastEffectBlock <= allocation.effectBlock, + "Deallocation queue is not in ascending order of effectBlocks" + ); + + lastEffectBlock = allocation.effectBlock; + } + } + function _checkSlashableStake( OperatorSet memory operatorSet, address operator, @@ -275,17 +296,17 @@ contract AllocationManagerUnitTests is EigenLayerUnitTestSetup, IAllocationManag uint256 expectedSlashableStake, uint256 futureBlock ) internal view { - uint256[] memory slashableStake = allocationManager.getMinimumSlashableStake({ + uint256[][] memory slashableStake = allocationManager.getMinimumSlashableStake({ operatorSet: operatorSet, operators: operator.toArray(), strategies: strategies, futureBlock: uint32(futureBlock) - })[0]; + }); for (uint256 i = 0; i < strategies.length; i++) { console.log("\nChecking Slashable Stake:".yellow()); - console.log(" slashableStake[%d] = %d", i, slashableStake[i]); - assertEq(slashableStake[i], expectedSlashableStake, "slashableStake != expected"); + console.log(" slashableStake[%d] = %d", i, slashableStake[0][i]); + assertEq(slashableStake[0][i], expectedSlashableStake, "slashableStake != expected"); } console.log("Success!".green().bold()); @@ -683,7 +704,7 @@ contract AllocationManagerUnitTests_SlashOperator is AllocationManagerUnitTests cheats.prank(defaultOperator); allocationManager.modifyAllocations(defaultOperator, allocateParams); - uint64 encumberedMagnitudeBefore = allocationManager.encumberedMagnitude(defaultOperator, strategyMock); + uint64 encumberedMagnitudeBefore = allocationManager.getEncumberedMagnitude(defaultOperator, strategyMock); uint64 maxMagnitudeBefore = allocationManager.getMaxMagnitudes(defaultOperator, strategyMock.toArray())[0]; // The only slash event we expect is the OperatorSlashed. Validate the number @@ -710,7 +731,7 @@ contract AllocationManagerUnitTests_SlashOperator is AllocationManagerUnitTests // Assert encumberedMagnitude and maxMagnitude are unchanged assertEq( encumberedMagnitudeBefore, - allocationManager.encumberedMagnitude(defaultOperator, strategyMock), + allocationManager.getEncumberedMagnitude(defaultOperator, strategyMock), "encumberedMagnitude mutated" ); @@ -1412,7 +1433,7 @@ contract AllocationManagerUnitTests_SlashOperator is AllocationManagerUnitTests cheats.roll(block.number + DEFAULT_OPERATOR_ALLOCATION_DELAY); // Get slashable shares for each operatorSet - uint256 opset2SlashableSharesBefore = allocationManager.getMinimumSlashableStake(operatorSet2, defaultOperator.toArray(), defaultStrategies, uint32(block.number))[0][0]; + uint256[][] memory opset2SlashableSharesBefore = allocationManager.getMinimumSlashableStake(operatorSet2, defaultOperator.toArray(), defaultStrategies, uint32(block.number)); // Slash operator on operatorSet1 for 50% SlashingParams memory slashingParams = SlashingParams({ operator: defaultOperator, @@ -1467,10 +1488,10 @@ contract AllocationManagerUnitTests_SlashOperator is AllocationManagerUnitTests ); // Assert that slashable stake is the same - we add slippage here due to rounding error from the slash itself + uint256[][] memory minSlashableStake = allocationManager.getMinimumSlashableStake(operatorSet2, defaultOperator.toArray(), defaultStrategies, uint32(block.number)); assertEq( - opset2SlashableSharesBefore, - allocationManager.getMinimumSlashableStake(operatorSet2, defaultOperator.toArray(), defaultStrategies, uint32(block.number))[0][0] - + 1, + opset2SlashableSharesBefore[0][0], + minSlashableStake[0][0] + 1, "opSet2 slashable shares should be the same" ); } @@ -1916,6 +1937,194 @@ contract AllocationManagerUnitTests_ModifyAllocations is AllocationManagerUnitTe allocationManager.modifyAllocations(defaultOperator, allocateParams); } + /** + * @notice Regression tests for the bugfix where pending modifications were checked by + * require(allocation.pendingDiff == 0, ModificationAlreadyPending()); + * which would overwrite the effectBlock, pendingDiff if a pendingDiff + * of a deallocation was slashed to become 0. + * + * This test checks that the effectBlock, pendingDiff are not overwritten even if the pendingDiff is 0 + * when attempting to modify allocations again + */ + function test_modifyAllocations_PendingDiffZero() public { + // Step 1: Allocate to the operator set + AllocateParams[] memory allocateParams = _newAllocateParams(defaultOperatorSet, 501); + cheats.prank(defaultOperator); + allocationManager.modifyAllocations(defaultOperator, allocateParams); + + // Step 2: Roll blocks forward until the allocation effectBlock + cheats.roll(block.number + DEFAULT_OPERATOR_ALLOCATION_DELAY); + + // Step 3: Deallocate from the operator set + AllocateParams[] memory deallocateParams = _newAllocateParams(defaultOperatorSet, 500); + cheats.prank(defaultOperator); + allocationManager.modifyAllocations(defaultOperator, deallocateParams); + + Allocation memory allocation = allocationManager.getAllocation(defaultOperator, defaultOperatorSet, strategyMock); + uint32 originalEffectBlock = allocation.effectBlock; + + // Step 4: Slash the operator to adjust pendingDiff to 0, slashing rounds up the amount of magnitude to slash + // so with an existing deallocation/pendingDiff of 1, it should result in a pendingDiff of 0 + SlashingParams memory slashingParams = SlashingParams({ + operator: defaultOperator, + operatorSetId: defaultOperatorSet.id, + strategies: defaultStrategies, + wadsToSlash: 5e17.toArrayU256(), + description: "Test slashing" + }); + cheats.prank(defaultAVS); + allocationManager.slashOperator(defaultAVS, slashingParams); + allocation = allocationManager.getAllocation(defaultOperator, defaultOperatorSet, strategyMock); + assertEq(allocation.pendingDiff, 0, "Pending diff should be 0"); + assertEq(allocation.effectBlock, originalEffectBlock, "Effect block should not have changed"); + + // Step 5: Modify allocations again (Should not be called) + AllocateParams[] memory newAllocateParams = _newAllocateParams(defaultOperatorSet, 1000); + cheats.prank(defaultOperator); + cheats.expectRevert(ModificationAlreadyPending.selector); + allocationManager.modifyAllocations(defaultOperator, newAllocateParams); + + // Assert that the allocation was modified without reverting + allocation = allocationManager.getAllocation(defaultOperator, defaultOperatorSet, strategyMock); + assertEq(allocation.currentMagnitude, 250, "Allocation should be updated to 250 after slashing 50%"); + + // Note: These 2 assertions fail prior to the bugfix and if we kept the same + // require(allocation.pendingDiff == 0, ModificationAlreadyPending()); + // in the code. The effectBlock, pendingDiff would get overwritten with the new modification + // but the deallocationQueue would now be unordered(in terms of effectBlocks) with this overwrite. + assertEq(allocation.effectBlock, originalEffectBlock, "Effect block should not have changed"); + assertEq(allocation.pendingDiff, 0, "Pending diff should still be 0"); + } + + /** + * @notice Regression tests for the bugfix where pending modifications were checked by + * require(allocation.pendingDiff == 0, ModificationAlreadyPending()); + * which would overwrite the effectBlock, pendingDiff if a pendingDiff + * of a deallocation was slashed to become 0. + * + * This test checks that the deallocationQueue is ascending ordered by effectBlocks + */ + function test_modifyAllocations_PendingDiffZero_CheckOrderedDeallocationQueue() public { + // Step 1: Register the operator to multiple operator sets + OperatorSet memory operatorSet1 = OperatorSet(defaultAVS, 1); + OperatorSet memory operatorSet2 = OperatorSet(defaultAVS, 2); + _createOperatorSet(operatorSet1, defaultStrategies); + _createOperatorSet(operatorSet2, defaultStrategies); + _registerForOperatorSet(defaultOperator, operatorSet1); + _registerForOperatorSet(defaultOperator, operatorSet2); + + // Step 2: Allocate to both operator sets + AllocateParams[] memory allocateParams1 = _newAllocateParams(operatorSet1, 1001); + AllocateParams[] memory allocateParams2 = _newAllocateParams(operatorSet2, 1000); + cheats.prank(defaultOperator); + allocationManager.modifyAllocations(defaultOperator, allocateParams1); + cheats.prank(defaultOperator); + allocationManager.modifyAllocations(defaultOperator, allocateParams2); + + // Step 3: Roll blocks forward until the allocation effectBlock + cheats.roll(block.number + DEFAULT_OPERATOR_ALLOCATION_DELAY); + + // Step 4: Deallocate from both operator sets + AllocateParams[] memory deallocateParams1 = _newAllocateParams(operatorSet1, 1000); + AllocateParams[] memory deallocateParams2 = _newAllocateParams(operatorSet2, 0); + cheats.prank(defaultOperator); + allocationManager.modifyAllocations(defaultOperator, deallocateParams1); + // roll blocks forward so that deallocations have different effectBlocks + cheats.roll(block.number + 100); + cheats.prank(defaultOperator); + allocationManager.modifyAllocations(defaultOperator, deallocateParams2); + + // Step 5: Slash the first deallocation to adjust pendingDiff to 0 + SlashingParams memory slashingParams1 = SlashingParams({ + operator: defaultOperator, + operatorSetId: operatorSet1.id, + strategies: defaultStrategies, + wadsToSlash: 5e17.toArrayU256(), + description: "Test slashing" + }); + cheats.prank(defaultAVS); + allocationManager.slashOperator(defaultAVS, slashingParams1); + + // Step 6: Modify allocations again for operatorSet1 making another deallocation and + // overwriting/increasing the effectBlock + // roll blocks forward so that deallocations have different effectBlocks + cheats.roll(block.number + 100); + // Note: this should revert but previously it would not prior to the bugfix + AllocateParams[] memory newAllocateParams1 = _newAllocateParams(operatorSet1, 400); + cheats.prank(defaultOperator); + cheats.expectRevert(ModificationAlreadyPending.selector); + allocationManager.modifyAllocations(defaultOperator, newAllocateParams1); + + // Assert that the deallocationQueue is unordered for the 2 deallocations in queue + _checkDeallocationQueueOrder(defaultOperator, defaultStrategies[0], 2); + } + + /** + * @notice Regression tests for the bugfix where pending modifications were checked by + * require(allocation.pendingDiff == 0, ModificationAlreadyPending()); + * which would overwrite the effectBlock, pendingDiff if a pendingDiff + * of a deallocation was slashed to become 0. + * + * This test checks that the deallocationQueue is ascending ordered by effectBlocks + * In this case the new modifyAllocations call is an allocation + * where the effectBlock is increased and the deallocationQueue is unordered as well because the operator + * allocationDelay configured to be long enough. + */ + function test_modifyAllocations_PendingDiffZero_Allocation() public { + // Step 1: Register the operator to multiple operator sets + OperatorSet memory operatorSet1 = OperatorSet(defaultAVS, 1); + OperatorSet memory operatorSet2 = OperatorSet(defaultAVS, 2); + _createOperatorSet(operatorSet1, defaultStrategies); + _createOperatorSet(operatorSet2, defaultStrategies); + _registerForOperatorSet(defaultOperator, operatorSet1); + _registerForOperatorSet(defaultOperator, operatorSet2); + + // Step 2: Allocate to both operator sets + AllocateParams[] memory allocateParams1 = _newAllocateParams(operatorSet1, 1001); + AllocateParams[] memory allocateParams2 = _newAllocateParams(operatorSet2, 1000); + cheats.prank(defaultOperator); + allocationManager.modifyAllocations(defaultOperator, allocateParams1); + cheats.prank(defaultOperator); + allocationManager.modifyAllocations(defaultOperator, allocateParams2); + + // Step 3: Update operator allocation delay + cheats.prank(defaultOperator); + allocationManager.setAllocationDelay(defaultOperator, DEALLOCATION_DELAY + 10 days); + cheats.roll(block.number + ALLOCATION_CONFIGURATION_DELAY); + + // Step 4: Deallocate from both operator sets + AllocateParams[] memory deallocateParams1 = _newAllocateParams(operatorSet1, 1000); + AllocateParams[] memory deallocateParams2 = _newAllocateParams(operatorSet2, 0); + cheats.prank(defaultOperator); + allocationManager.modifyAllocations(defaultOperator, deallocateParams1); + // roll blocks forward so that deallocations have different effectBlocks + cheats.roll(block.number + 100); + cheats.prank(defaultOperator); + allocationManager.modifyAllocations(defaultOperator, deallocateParams2); + + // Step 5: Slash the first deallocation to adjust pendingDiff to 0 + SlashingParams memory slashingParams1 = SlashingParams({ + operator: defaultOperator, + operatorSetId: operatorSet1.id, + strategies: defaultStrategies, + wadsToSlash: 5e17.toArrayU256(), + description: "Test slashing" + }); + cheats.prank(defaultAVS); + allocationManager.slashOperator(defaultAVS, slashingParams1); + + // Step 6: Modify allocations again for operatorSet1 making an allocation and + // overwriting/increasing the effectBlock + // Note: this should revert but previously it would not prior to the bugfix + AllocateParams[] memory newAllocateParams1 = _newAllocateParams(operatorSet1, 5000); + cheats.prank(defaultOperator); + cheats.expectRevert(ModificationAlreadyPending.selector); + allocationManager.modifyAllocations(defaultOperator, newAllocateParams1); + + // Assert that the deallocationQueue is unordered for the 2 deallocations in queue + _checkDeallocationQueueOrder(defaultOperator, defaultStrategies[0], 2); + } + function test_revert_allocateZeroMagnitude() public { // Allocate exact same magnitude as initial allocation (0) AllocateParams[] memory allocateParams = _randAllocateParams_DefaultOpSet(); @@ -1993,6 +2202,58 @@ contract AllocationManagerUnitTests_ModifyAllocations is AllocationManagerUnitTe allocationManager.modifyAllocations(defaultOperator, allocateParams); } + function test_revert_safeCastOverflow() public { + // setup additional operatorSets for tests + OperatorSet memory opSet1 = OperatorSet(defaultAVS, 1); + _createOperatorSet(opSet1, defaultStrategies); + _registerOperator(defaultOperator); + _setAllocationDelay(defaultOperator, DEFAULT_OPERATOR_ALLOCATION_DELAY); + _registerForOperatorSet(defaultOperator, opSet1); + + OperatorSet memory opSet2 = OperatorSet(defaultAVS, 2); + _createOperatorSet(opSet2, defaultStrategies); + _registerOperator(defaultOperator); + _setAllocationDelay(defaultOperator, DEFAULT_OPERATOR_ALLOCATION_DELAY); + _registerForOperatorSet(defaultOperator, opSet2); + + // 1. Allocate all available magnitude for the strategy (WAD) + AllocateParams[] memory allocateParams = _randAllocateParams_DefaultOpSet(); + allocateParams[0].newMagnitudes[0] = WAD; + cheats.prank(defaultOperator); + allocationManager.modifyAllocations(defaultOperator, allocateParams); + assertEq( + allocationManager.getAllocatableMagnitude(defaultOperator, strategyMock), + 0, + "Allocatable magnitude should be 0" + ); + assertEq( + allocationManager.getEncumberedMagnitude(defaultOperator, strategyMock), + WAD, + "Encumbered magnitude should be WAD" + ); + + // 2. allocate to another operatorSet for the same strategy to reset encumberedMagnitude back to 0 + allocateParams[0].operatorSet = opSet1; + allocateParams[0].newMagnitudes[0] = type(uint64).max - WAD + 1; + cheats.prank(defaultOperator); + cheats.expectRevert("SafeCast: value doesn't fit in 64 bits"); + allocationManager.modifyAllocations(defaultOperator, allocateParams); + + // 3. after resetting encumberedMagnitude, attempt to allocate to opSet2 with WAD + allocateParams[0].operatorSet = opSet2; + allocateParams[0].newMagnitudes[0] = WAD; + cheats.prank(defaultOperator); + cheats.expectRevert(InsufficientMagnitude.selector); + allocationManager.modifyAllocations(defaultOperator, allocateParams); + + // 4. after resetting encumberedMagnitude, attempt to allocate to opSet2 with 1 + allocateParams[0].operatorSet = opSet2; + allocateParams[0].newMagnitudes[0] = 1; + cheats.prank(defaultOperator); + cheats.expectRevert(InsufficientMagnitude.selector); + allocationManager.modifyAllocations(defaultOperator, allocateParams); + } + /** * @notice Tests edge cases around allocation delay: * 1. Set allocation delay to a value greater than ALLOCATION_CONFIGURATION_DELAY @@ -2309,7 +2570,7 @@ contract AllocationManagerUnitTests_ModifyAllocations is AllocationManagerUnitTe for (uint256 i; i < numStrats; ++i) { assertEq( WAD, - allocationManager.encumberedMagnitude(defaultOperator, strategies[i]), + allocationManager.getEncumberedMagnitude(defaultOperator, strategies[i]), "encumberedMagnitude not max" ); } @@ -2385,7 +2646,7 @@ contract AllocationManagerUnitTests_ModifyAllocations is AllocationManagerUnitTe operatorSet: defaultOperatorSet, strategy: strategyMock, expectedAllocation: Allocation({currentMagnitude: secondMod, pendingDiff: 0, effectBlock: 0}), - expectedMagnitudes: Magnitudes({encumbered: firstMod, max: WAD, allocatable: WAD - secondMod}) + expectedMagnitudes: Magnitudes({encumbered: secondMod, max: WAD, allocatable: WAD - secondMod}) }); // Check storage after clearing deallocation queue @@ -2484,7 +2745,7 @@ contract AllocationManagerUnitTests_ModifyAllocations is AllocationManagerUnitTe operatorSet: defaultOperatorSet, strategy: strategyMock, expectedAllocation: Allocation({currentMagnitude: deallocateParams[0].newMagnitudes[0], pendingDiff: 0, effectBlock: 0}), - expectedMagnitudes: Magnitudes({encumbered: allocateParams[0].newMagnitudes[0], max: WAD, allocatable: WAD - deallocateParams[0].newMagnitudes[0]}) + expectedMagnitudes: Magnitudes({encumbered: deallocateParams[0].newMagnitudes[0], max: WAD, allocatable: WAD - deallocateParams[0].newMagnitudes[0]}) }); } @@ -2862,7 +3123,7 @@ contract AllocationManagerUnitTests_ModifyAllocations is AllocationManagerUnitTe effectBlock: 0 }), expectedMagnitudes: Magnitudes({ - encumbered: allocateParams[i].newMagnitudes[j], + encumbered: deallocateParams[i].newMagnitudes[j], max: WAD, allocatable: WAD - deallocateParams[i].newMagnitudes[j] }) @@ -3131,7 +3392,7 @@ contract AllocationManagerUnitTests_ClearDeallocationQueue is AllocationManagerU // At this point, we should be able to allocate again to opSet1 AND have only 5e17 encumbered magnitude assertEq( 5e17, - allocationManager.encumberedMagnitude(defaultOperator, strategyMock), + allocationManager.getEncumberedMagnitude(defaultOperator, strategyMock), "encumbered magnitude not correct" ); AllocateParams[] memory thirdAllocation = _newAllocateParams(defaultOperatorSet, 5e17); @@ -3573,6 +3834,13 @@ contract AllocationManagerUnitTests_createOperatorSets is AllocationManagerUnitT allocationManager.createOperatorSets(defaultAVS, CreateSetParams(defaultOperatorSet.id, defaultStrategies).toArray()); } + function testRevert_createOperatorSets_NonexistentAVSMetadata(Randomness r) public rand(r) { + address avs = r.Address(); + cheats.expectRevert(NonexistentAVSMetadata.selector); + cheats.prank(avs); + allocationManager.createOperatorSets(avs, CreateSetParams(defaultOperatorSet.id, defaultStrategies).toArray()); + } + function testFuzz_createOperatorSets_Correctness( Randomness r ) public rand(r) { @@ -3580,6 +3848,9 @@ contract AllocationManagerUnitTests_createOperatorSets is AllocationManagerUnitT uint256 numOpSets = r.Uint256(1, FUZZ_MAX_OP_SETS); uint256 numStrategies = r.Uint256(1, FUZZ_MAX_STRATS); + cheats.prank(avs); + allocationManager.updateAVSMetadataURI(avs, "https://example.com"); + CreateSetParams[] memory createSetParams = new CreateSetParams[](numOpSets); for (uint256 i; i < numOpSets; ++i) { @@ -3692,6 +3963,7 @@ contract AllocationManagerUnitTests_getStrategyAllocations is AllocationManagerU contract AllocationManagerUnitTests_getSlashableStake is AllocationManagerUnitTests { using SlashingLib for *; + using ArrayLib for *; /** * Allocates half of magnitude for a single strategy to an operatorSet. Then allocates again. Slashes 50% @@ -3910,6 +4182,92 @@ contract AllocationManagerUnitTests_getSlashableStake is AllocationManagerUnitTe expectedSlashableStake: expectedCurrentMagnitude - uint128(-expectedPendingDiff) - 1 }); } + + function testFuzz_allocate_deregister( + Randomness r + ) public rand(r) { + AllocateParams[] memory allocateParams = _newAllocateParams(defaultOperatorSet, 5e17); + cheats.prank(defaultOperator); + allocationManager.modifyAllocations(defaultOperator, allocateParams); + cheats.roll(block.number + DEFAULT_OPERATOR_ALLOCATION_DELAY); + + cheats.prank(defaultOperator); + allocationManager.deregisterFromOperatorSets( + DeregisterParams(defaultOperator, defaultOperatorSet.avs, defaultOperatorSet.id.toArrayU32()) + ); + + // Check slashable stake right after deregistration + _checkSlashableStake({ + operatorSet: allocateParams[0].operatorSet, + operator: defaultOperator, + strategies: allocateParams[0].strategies, + expectedSlashableStake: DEFAULT_OPERATOR_SHARES.mulWad(5e17) + }); + + // Assert slashable stake after deregistration delay is 0 + cheats.roll(block.number + DEALLOCATION_DELAY + 1); + _checkSlashableStake({ + operatorSet: allocateParams[0].operatorSet, + operator: defaultOperator, + strategies: allocateParams[0].strategies, + expectedSlashableStake: 0 + }); + } +} + +contract AllocationManagerUnitTests_isOperatorSlashable is AllocationManagerUnitTests { + using SlashingLib for *; + using ArrayLib for *; + + function test_registeredOperator() public { + assertEq( + allocationManager.isOperatorSlashable(defaultOperator, defaultOperatorSet), + true, + "registered operator should be slashable" + ); + assertEq( + allocationManager.isMemberOfOperatorSet(defaultOperator, defaultOperatorSet), + true, + "operator should be member of set" + ); + } + + function test_deregisteredOperatorAndSlashable() public { + // 1. deregister defaultOperator from defaultOperator set + uint32 deregisterBlock = uint32(block.number); + cheats.prank(defaultOperator); + allocationManager.deregisterFromOperatorSets( + DeregisterParams(defaultOperator, defaultOperatorSet.avs, defaultOperatorSet.id.toArrayU32()) + ); + assertEq( + allocationManager.isMemberOfOperatorSet(defaultOperator, defaultOperatorSet), + false, + "operator should not be member of set" + ); + + // 2. assert operator is still slashable + assertEq( + allocationManager.isOperatorSlashable(defaultOperator, defaultOperatorSet), + true, + "deregistered operator should be slashable" + ); + + // 3. roll blocks forward to slashableUntil block assert still slashable + cheats.roll(deregisterBlock + DEALLOCATION_DELAY); + assertEq( + allocationManager.isOperatorSlashable(defaultOperator, defaultOperatorSet), + true, + "deregistered operator should be slashable" + ); + + // 4. roll 1 block forward and assert not slashable + cheats.roll(deregisterBlock + DEALLOCATION_DELAY + 1); + assertEq( + allocationManager.isOperatorSlashable(defaultOperator, defaultOperatorSet), + false, + "deregistered operator should not be slashable" + ); + } } contract AllocationManagerUnitTests_getMaxMagnitudesAtBlock is AllocationManagerUnitTests { @@ -3961,4 +4319,85 @@ contract AllocationManagerUnitTests_getMaxMagnitudesAtBlock is AllocationManager "max magnitude after second slash not correct" ); } +} + +contract AllocationManagerUnitTests_getAllocatedStake is AllocationManagerUnitTests { + using ArrayLib for *; + using SlashingLib for *; + + /** + * Allocates to `firstMod` magnitude and validates allocated stake is correct + */ + function testFuzz_allocate( + Randomness r + ) public rand(r) { + // Generate allocation for `strategyMock`, we allocate half + AllocateParams[] memory allocateParams = _newAllocateParams(defaultOperatorSet, 5e17); + cheats.prank(defaultOperator); + allocationManager.modifyAllocations(defaultOperator, allocateParams); + cheats.roll(block.number + DEFAULT_OPERATOR_ALLOCATION_DELAY); + + uint256[][] memory allocatedStake = allocationManager.getAllocatedStake(defaultOperatorSet, defaultOperator.toArray(), defaultStrategies); + + assertEq(allocatedStake[0][0], DEFAULT_OPERATOR_SHARES.mulWad(5e17), "allocated stake not correct"); + } + + /** + * Allocates to `firstMod` magnitude and then deallocate to `secondMod` magnitude + * Validates allocated stake is updated even after deallocation is cleared in storage + */ + function testFuzz_allocate_deallocate( + Randomness r + ) public rand(r) { + // Bound allocation and deallocation + uint64 firstMod = r.Uint64(1, WAD); + uint64 secondMod = r.Uint64(0, firstMod - 1); + + // 1. Allocate magnitude to default registered set & warp to allocation complete block + AllocateParams[] memory allocateParams = _newAllocateParams(defaultOperatorSet, firstMod); + cheats.prank(defaultOperator); + allocationManager.modifyAllocations(defaultOperator, allocateParams); + cheats.roll(block.number + DEFAULT_OPERATOR_ALLOCATION_DELAY); + + // 2. Deallocate + allocateParams = _newAllocateParams(defaultOperatorSet, secondMod); + cheats.prank(defaultOperator); + allocationManager.modifyAllocations(defaultOperator, allocateParams); + + // 3. Check allocated stake right after deallocation - shouldn't be updated + uint256[][] memory allocatedStake = allocationManager.getAllocatedStake(defaultOperatorSet, defaultOperator.toArray(), defaultStrategies); + assertEq(allocatedStake[0][0], DEFAULT_OPERATOR_SHARES.mulWad(firstMod), "allocated stake not correct"); + + // 4. Check slashable stake at the deallocation effect block + // Warp to deallocation effect block + cheats.roll(block.number + DEALLOCATION_DELAY + 1); + + allocatedStake = allocationManager.getAllocatedStake(defaultOperatorSet, defaultOperator.toArray(), defaultStrategies); + assertEq(allocatedStake[0][0], DEFAULT_OPERATOR_SHARES.mulWad(secondMod), "allocated stake not correct"); + } + + /** + * Allocates to `firstMod` magnitude and then deregisters the operator. + * Validates allocated stake is nonzero even after deregistration delay + */ + function testFuzz_allocate_deregister( + Randomness r + ) public rand(r) { + // 1. Generate allocation for `strategyMock`, we allocate half + AllocateParams[] memory allocateParams = _newAllocateParams(defaultOperatorSet, 5e17); + cheats.prank(defaultOperator); + allocationManager.modifyAllocations(defaultOperator, allocateParams); + cheats.roll(block.number + DEFAULT_OPERATOR_ALLOCATION_DELAY); + + // 2. Deregister from operator set & warp to deregistration effect block + cheats.prank(defaultOperator); + allocationManager.deregisterFromOperatorSets( + DeregisterParams(defaultOperator, defaultOperatorSet.avs, defaultOperatorSet.id.toArrayU32()) + ); + cheats.roll(block.number + DEALLOCATION_DELAY + 1); + + // 3. Check allocated stake + uint256[][] memory allocatedStake = allocationManager.getAllocatedStake(defaultOperatorSet, defaultOperator.toArray(), defaultStrategies); + assertEq(allocatedStake[0][0], DEFAULT_OPERATOR_SHARES.mulWad(5e17), "allocated stake should remain same after deregistration"); + } } \ No newline at end of file diff --git a/src/test/unit/DelegationUnit.t.sol b/src/test/unit/DelegationUnit.t.sol index 35573510ee..63e75b1768 100644 --- a/src/test/unit/DelegationUnit.t.sol +++ b/src/test/unit/DelegationUnit.t.sol @@ -18,7 +18,7 @@ import "src/test/harnesses/DelegationManagerHarness.sol"; * Contracts not mocked: StrategyBase, PauserRegistry */ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManagerEvents, IDelegationManagerErrors { - using SlashingLib for *; + using SlashingLib for *; using ArrayLib for *; using Math for *; @@ -58,12 +58,14 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag uint256 delegationSignerPrivateKey = uint256(0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80); address defaultApprover = cheats.addr(delegationSignerPrivateKey); uint256 stakerPrivateKey = uint256(123_456_789); + uint256 staker2PrivateKey = uint256(234_567_891); address defaultStaker = cheats.addr(stakerPrivateKey); + address defaultStaker2 = cheats.addr(staker2PrivateKey); address defaultOperator = address(this); address defaultOperator2 = address(0x123); address defaultAVS = address(this); string emptyStringForMetadataURI; - ISignatureUtils.SignatureWithExpiry emptyApproverSignatureAndExpiry; + ISignatureUtilsMixinTypes.SignatureWithExpiry emptyApproverSignatureAndExpiry; bytes32 emptySalt; // Helper to use in storage DepositScalingFactor dsf; @@ -110,7 +112,7 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag // Deploy mock token and strategy tokenMock = new ERC20PresetFixedSupply("Mock Token", "MOCK", tokenMockInitialSupply, address(this)); - strategyImplementation = new StrategyBase(IStrategyManager(address(strategyManagerMock)), pauserRegistry); + strategyImplementation = new StrategyBase(IStrategyManager(address(strategyManagerMock)), pauserRegistry, "v9.9.9"); strategyMock = StrategyBase( address( new TransparentUpgradeableProxy( @@ -175,7 +177,7 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag } /** - * @notice internal function to deploy mock tokens and strategies and have the staker deposit into them. + * @notice internal function to deploy mock tokens and strategies and have the staker deposit into them. * Since we are mocking the strategyManager we call strategyManagerMock.setDeposits so that when * DelegationManager calls getDeposits, we can have these share amounts returned. */ @@ -191,7 +193,7 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag if (strategies[i] == beaconChainETHStrategy) { eigenPodManagerMock.setPodOwnerShares(staker, int256(sharesAmounts[i])); } else { - strategyManagerMock.addDeposit(staker, strategies[i], sharesAmounts[i]); + strategyManagerMock.addDeposit(staker, strategies[i], sharesAmounts[i]); } } } @@ -206,15 +208,11 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag address operator, bytes32 salt, uint256 expiry - ) internal view returns (ISignatureUtils.SignatureWithExpiry memory approverSignatureAndExpiry) { + ) internal view returns (ISignatureUtilsMixinTypes.SignatureWithExpiry memory approverSignatureAndExpiry) { approverSignatureAndExpiry.expiry = expiry; { bytes32 digestHash = delegationManager.calculateDelegationApprovalDigestHash( - staker, - operator, - delegationManager.delegationApprover(operator), - salt, - expiry + staker, operator, delegationManager.delegationApprover(operator), salt, expiry ); (uint8 v, bytes32 r, bytes32 s) = cheats.sign(_delegationSignerPrivateKey, digestHash); approverSignatureAndExpiry.signature = abi.encodePacked(r, s, v); @@ -224,14 +222,14 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag // @notice Assumes operator does not have a delegation approver & staker != approver function _delegateToOperatorWhoAcceptsAllStakers(address staker, address operator) internal { - ISignatureUtils.SignatureWithExpiry memory approverSignatureAndExpiry; + ISignatureUtilsMixinTypes.SignatureWithExpiry memory approverSignatureAndExpiry; cheats.prank(staker); delegationManager.delegateTo(operator, approverSignatureAndExpiry, emptySalt); } function _delegateToOperatorWhoRequiresSig(address staker, address operator, bytes32 salt) internal { uint256 expiry = type(uint256).max; - ISignatureUtils.SignatureWithExpiry memory approverSignatureAndExpiry = _getApproverSignature( + ISignatureUtilsMixinTypes.SignatureWithExpiry memory approverSignatureAndExpiry = _getApproverSignature( delegationSignerPrivateKey, staker, operator, @@ -246,15 +244,21 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag _delegateToOperatorWhoRequiresSig(staker, operator, emptySalt); } - function _registerOperatorWithBaseDetails(address operator) internal { + function _registerOperatorWithBaseDetails( + address operator + ) internal { _registerOperator(operator, address(0), emptyStringForMetadataURI); } - function _registerOperatorWithDelegationApprover(address operator) internal { + function _registerOperatorWithDelegationApprover( + address operator + ) internal { _registerOperator(operator, defaultApprover, emptyStringForMetadataURI); } - function _registerOperatorWith1271DelegationApprover(address operator) internal returns (ERC1271WalletMock) { + function _registerOperatorWith1271DelegationApprover( + address operator + ) internal returns (ERC1271WalletMock) { address delegationSigner = defaultApprover; /** * deploy a ERC1271WalletMock contract with the `delegationSigner` address as the owner, @@ -282,12 +286,15 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag function _fuzzDepositWithdrawalAmounts( Randomness r, uint32 numStrategies - ) internal returns ( - uint256[] memory depositAmounts, - uint256[] memory withdrawalAmounts, - uint64[] memory prevMagnitudes, - uint64[] memory newMagnitudes - ) { + ) + internal + returns ( + uint256[] memory depositAmounts, + uint256[] memory withdrawalAmounts, + uint64[] memory prevMagnitudes, + uint64[] memory newMagnitudes + ) + { withdrawalAmounts = new uint256[](numStrategies); depositAmounts = new uint256[](numStrategies); prevMagnitudes = new uint64[](numStrategies); @@ -297,7 +304,6 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag // generate withdrawal amount within range s.t withdrawAmount <= depositAmount withdrawalAmounts[i] = r.Uint256(1, depositAmounts[i]); - prevMagnitudes[i] = r.Uint64(2, WAD); newMagnitudes[i] = r.Uint64(1, prevMagnitudes[i]); } @@ -308,11 +314,7 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag address staker, IStrategy strategy, uint256 depositSharesToWithdraw - ) internal view returns ( - QueuedWithdrawalParams[] memory, - Withdrawal memory, - bytes32 - ) { + ) internal view returns (QueuedWithdrawalParams[] memory, Withdrawal memory, bytes32) { IStrategy[] memory strategyArray = strategy.toArray(); QueuedWithdrawalParams[] memory queuedWithdrawalParams = new QueuedWithdrawalParams[](1); { @@ -345,11 +347,7 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag address staker, IStrategy[] memory strategies, uint256[] memory depositWithdrawalAmounts - ) internal view returns ( - QueuedWithdrawalParams[] memory, - Withdrawal memory, - bytes32 - ) { + ) internal view returns (QueuedWithdrawalParams[] memory, Withdrawal memory, bytes32) { QueuedWithdrawalParams[] memory queuedWithdrawalParams = new QueuedWithdrawalParams[](1); { queuedWithdrawalParams[0] = QueuedWithdrawalParams({ @@ -364,7 +362,7 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag for (uint256 i = 0; i < strategies.length; i++) { scaledSharesArray[i] = _getScaledShares(staker, strategies[i], depositWithdrawalAmounts[i]); } - + Withdrawal memory withdrawal = Withdrawal({ staker: staker, delegatedTo: delegationManager.delegatedTo(staker), @@ -391,9 +389,14 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag delegationManager.queueWithdrawals(queuedWithdrawalParams); } - function _getScaledShares(address staker, IStrategy strategy, uint256 depositSharesToWithdraw) internal view returns (uint256) { - DepositScalingFactor memory _dsf = DepositScalingFactor(delegationManager.depositScalingFactor(staker, strategy)); - + function _getScaledShares( + address staker, + IStrategy strategy, + uint256 depositSharesToWithdraw + ) internal view returns (uint256) { + DepositScalingFactor memory _dsf = + DepositScalingFactor(delegationManager.depositScalingFactor(staker, strategy)); + return _dsf.scaleForQueueWithdrawal(depositSharesToWithdraw); } @@ -445,11 +448,8 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag uint256[] memory depositAmounts = new uint256[](1); depositAmounts[0] = depositAmount; IStrategy[] memory strategies = _deployAndDepositIntoStrategies(staker, depositAmounts, isBeaconChainStrategy); - ( - QueuedWithdrawalParams[] memory queuedWithdrawalParams, - Withdrawal memory withdrawal, - bytes32 withdrawalRoot - ) = _setUpQueueWithdrawalsSingleStrat({ + (QueuedWithdrawalParams[] memory queuedWithdrawalParams, Withdrawal memory withdrawal, bytes32 withdrawalRoot) = + _setUpQueueWithdrawalsSingleStrat({ staker: staker, strategy: strategies[0], depositSharesToWithdraw: withdrawalAmount @@ -462,7 +462,7 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag strategyManagerMock.setDeposits(staker, strategies, currentAmounts); IERC20[] memory tokens = new IERC20[](strategies.length); - for (uint i = 0; i < tokens.length; i++) { + for (uint256 i = 0; i < tokens.length; i++) { tokens[i] = strategies[i].underlyingToken(); } @@ -471,7 +471,7 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag /** * Deploy and deposit staker into a single strategy, then set up multiple queued withdrawals for the staker - * Assumptions: + * Assumptions: * - operator is already a registered operator. * - total deposit amount = depositAmount * numWithdrawals * - this will fully withdraw from the single strategy @@ -480,11 +480,7 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag address staker, uint256 depositAmount, uint256 numWithdrawals - ) internal returns ( - Withdrawal[] memory withdrawals, - IERC20[][] memory tokens, - bytes32[] memory withdrawalRoots - ) { + ) internal returns (Withdrawal[] memory withdrawals, IERC20[][] memory tokens, bytes32[] memory withdrawalRoots) { uint256[] memory depositAmounts = new uint256[](1); depositAmounts[0] = depositAmount * numWithdrawals; IStrategy[] memory strategies = _deployAndDepositIntoStrategies(staker, depositAmounts, false); @@ -493,7 +489,7 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag tokens = new IERC20[][](numWithdrawals); withdrawalRoots = new bytes32[](numWithdrawals); - for (uint i = 0; i < numWithdrawals; i++) { + for (uint256 i = 0; i < numWithdrawals; i++) { ( QueuedWithdrawalParams[] memory queuedWithdrawalParams, Withdrawal memory withdrawal, @@ -519,7 +515,6 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag currentAmounts[0] = 0; strategyManagerMock.setDeposits(staker, strategies, currentAmounts); } - return (withdrawals, tokens, withdrawalRoots); } @@ -536,22 +531,16 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag uint256[] memory withdrawalAmounts, bool depositBeaconChainShares ) internal returns (Withdrawal memory, IERC20[] memory, bytes32) { - IStrategy[] memory strategies = _deployAndDepositIntoStrategies(staker, depositAmounts, depositBeaconChainShares); + IStrategy[] memory strategies = + _deployAndDepositIntoStrategies(staker, depositAmounts, depositBeaconChainShares); IERC20[] memory tokens = new IERC20[](strategies.length); for (uint256 i = 0; i < strategies.length; i++) { tokens[i] = strategies[i].underlyingToken(); } - ( - QueuedWithdrawalParams[] memory queuedWithdrawalParams, - Withdrawal memory withdrawal, - bytes32 withdrawalRoot - ) = _setUpQueueWithdrawals({ - staker: staker, - strategies: strategies, - depositWithdrawalAmounts: withdrawalAmounts - }); + (QueuedWithdrawalParams[] memory queuedWithdrawalParams, Withdrawal memory withdrawal, bytes32 withdrawalRoot) = + _setUpQueueWithdrawals({staker: staker, strategies: strategies, depositWithdrawalAmounts: withdrawalAmounts}); cheats.prank(staker); delegationManager.queueWithdrawals(queuedWithdrawalParams); @@ -559,11 +548,7 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag return (withdrawal, tokens, withdrawalRoot); } - function _setOperatorMagnitude( - address operator, - IStrategy strategy, - uint64 magnitude - ) internal { + function _setOperatorMagnitude(address operator, IStrategy strategy, uint64 magnitude) internal { allocationManagerMock.setMaxMagnitude(operator, strategy, magnitude); } @@ -571,10 +556,7 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag address staker, int256 beaconShares, uint256 sharesDecrease - ) internal returns ( - uint64 prevBeaconSlashingFactor, - uint64 newBeaconSlashingFactor - ) { + ) internal returns (uint64 prevBeaconSlashingFactor, uint64 newBeaconSlashingFactor) { uint256 newRestakedBalanceWei = uint256(beaconShares) - sharesDecrease; prevBeaconSlashingFactor = eigenPodManagerMock.beaconChainSlashingFactor(staker); newBeaconSlashingFactor = uint64(prevBeaconSlashingFactor.mulDiv(newRestakedBalanceWei, uint256(beaconShares))); @@ -586,10 +568,8 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag int256 beaconShares, uint256 sharesDecrease ) internal returns (uint64 prevBeaconSlashingFactor, uint64 newBeaconSlashingFactor) { - ( - prevBeaconSlashingFactor, - newBeaconSlashingFactor - ) = _setNewBeaconChainSlashingFactor(staker, beaconShares, sharesDecrease); + (prevBeaconSlashingFactor, newBeaconSlashingFactor) = + _setNewBeaconChainSlashingFactor(staker, beaconShares, sharesDecrease); cheats.prank(address(eigenPodManagerMock)); delegationManager.decreaseDelegatedShares({ @@ -609,7 +589,9 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag string metadataURI; } - function _registerOperator_expectEmit(RegisterAsOperatorEmitStruct memory params) internal { + function _registerOperator_expectEmit( + RegisterAsOperatorEmitStruct memory params + ) internal { cheats.expectEmit(true, true, true, true, address(delegationManager)); emit DelegationApproverUpdated(params.operator, params.delegationApprover); cheats.expectEmit(true, true, true, true, address(delegationManager)); @@ -628,7 +610,9 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag uint256[] depositScalingFactors; } - function _delegateTo_expectEmit(DelegateToEmitStruct memory params) internal { + function _delegateTo_expectEmit( + DelegateToEmitStruct memory params + ) internal { cheats.expectEmit(true, true, true, true, address(delegationManager)); emit StakerDelegated(params.staker, params.operator); for (uint256 i = 0; i < params.strategies.length; i++) { @@ -647,7 +631,9 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag uint256 depositScalingFactor; } - function _delegateTo_expectEmit_singleStrat(DelegateToSingleStratEmitStruct memory params) internal { + function _delegateTo_expectEmit_singleStrat( + DelegateToSingleStratEmitStruct memory params + ) internal { cheats.expectEmit(true, true, true, true, address(delegationManager)); emit StakerDelegated(params.staker, params.operator); if (params.depositShares > 0) { @@ -684,9 +670,13 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag if (address(params.strategy) != address(0)) { cheats.expectEmit(true, true, true, true, address(delegationManager)); - emit OperatorSharesDecreased(params.operator, params.staker, params.strategy, params.operatorSharesDecreased); + emit OperatorSharesDecreased( + params.operator, params.staker, params.strategy, params.operatorSharesDecreased + ); cheats.expectEmit(true, true, true, true, address(delegationManager)); - emit SlashingWithdrawalQueued(params.withdrawalRoot, params.withdrawal, params.operatorSharesDecreased.toArrayU256()); + emit SlashingWithdrawalQueued( + params.withdrawalRoot, params.withdrawal, params.operatorSharesDecreased.toArrayU256() + ); } } @@ -698,7 +688,9 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag uint256 depositScalingFactor; } - function _increaseDelegatedShares_expectEmit(IncreaseDelegatedSharesEmitStruct memory params) internal { + function _increaseDelegatedShares_expectEmit( + IncreaseDelegatedSharesEmitStruct memory params + ) internal { cheats.expectEmit(true, true, true, true, address(delegationManager)); emit DepositScalingFactorUpdated(params.staker, params.strategy, params.depositScalingFactor); cheats.expectEmit(true, true, true, true, address(delegationManager)); @@ -711,7 +703,9 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag uint256 sharesToDecrease; } - function _decreaseDelegatedShares_expectEmit(DecreaseDelegatedSharesEmitStruct memory params) internal { + function _decreaseDelegatedShares_expectEmit( + DecreaseDelegatedSharesEmitStruct memory params + ) internal { cheats.expectEmit(true, true, true, true, address(delegationManager)); emit OperatorSharesDecreased(params.operator, params.staker, beaconChainETHStrategy, params.sharesToDecrease); } @@ -724,24 +718,25 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag bytes32 withdrawalRoot; } - function _queueWithdrawals_expectEmit(QueueWithdrawalsEmitStruct memory params) internal { + function _queueWithdrawals_expectEmit( + QueueWithdrawalsEmitStruct memory params + ) internal { for (uint256 i = 0; i < params.queuedWithdrawalParams.length; i++) { uint256[] memory sharesToWithdraw = new uint256[](params.queuedWithdrawalParams[i].strategies.length); for (uint256 j = 0; j < params.queuedWithdrawalParams[i].strategies.length; j++) { - uint256 depositScalingFactor = delegationManager.depositScalingFactor(defaultStaker, params.queuedWithdrawalParams[i].strategies[j]); - uint256 newMaxMagnitude = allocationManagerMock.getMaxMagnitudes(params.operator, params.queuedWithdrawalParams[i].strategies)[j]; + uint256 depositScalingFactor = delegationManager.depositScalingFactor( + defaultStaker, params.queuedWithdrawalParams[i].strategies[j] + ); + uint256 newMaxMagnitude = allocationManagerMock.getMaxMagnitudes( + params.operator, params.queuedWithdrawalParams[i].strategies + )[j]; sharesToWithdraw[j] = _calcWithdrawableShares( - params.queuedWithdrawalParams[i].depositShares[j], - depositScalingFactor, - newMaxMagnitude + params.queuedWithdrawalParams[i].depositShares[j], depositScalingFactor, newMaxMagnitude ); cheats.expectEmit(true, true, true, true, address(delegationManager)); emit OperatorSharesDecreased( - params.operator, - params.staker, - params.queuedWithdrawalParams[i].strategies[j], - sharesToWithdraw[j] + params.operator, params.staker, params.queuedWithdrawalParams[i].strategies[j], sharesToWithdraw[j] ); } cheats.expectEmit(true, true, true, true, address(delegationManager)); @@ -755,7 +750,9 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag bool receiveAsTokens; } - function _completeQueuedWithdrawal_expectEmit(CompleteQueuedWithdrawalEmitStruct memory params) internal { + function _completeQueuedWithdrawal_expectEmit( + CompleteQueuedWithdrawalEmitStruct memory params + ) internal { if (!params.receiveAsTokens) { address operator = delegationManager.delegatedTo(params.withdrawal.staker); uint64[] memory slashingFactors = new uint64[](params.withdrawal.strategies.length); @@ -766,47 +763,45 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag // Get updated deposit scaling factor uint256 curDepositShares; if (params.withdrawal.strategies[i] == beaconChainETHStrategy) { - curDepositShares = uint256(eigenPodManagerMock.stakerDepositShares(params.withdrawal.staker, address(0))); - slashingFactors[i] = uint64(slashingFactors[i] - .mulWad(eigenPodManagerMock.beaconChainSlashingFactor(params.withdrawal.staker)) + curDepositShares = + uint256(eigenPodManagerMock.stakerDepositShares(params.withdrawal.staker, address(0))); + slashingFactors[i] = uint64( + slashingFactors[i].mulWad( + eigenPodManagerMock.beaconChainSlashingFactor(params.withdrawal.staker) + ) ); } else { - curDepositShares = strategyManagerMock.stakerDepositShares(params.withdrawal.staker, params.withdrawal.strategies[i]); + curDepositShares = strategyManagerMock.stakerDepositShares( + params.withdrawal.staker, params.withdrawal.strategies[i] + ); } - uint256 sharesToWithdraw = _calcCompletedWithdrawnShares( - params.withdrawal.scaledShares[i], - slashingFactors[i] - ); + uint256 sharesToWithdraw = + _calcCompletedWithdrawnShares(params.withdrawal.scaledShares[i], slashingFactors[i]); uint256 expectedDepositScalingFactor = _calcDepositScalingFactor({ - prevDsf: delegationManager.depositScalingFactor(params.withdrawal.staker, params.withdrawal.strategies[i]), + prevDsf: delegationManager.depositScalingFactor( + params.withdrawal.staker, params.withdrawal.strategies[i] + ), prevDepositShares: curDepositShares, addedDepositShares: sharesToWithdraw, slashingFactor: slashingFactors[i] }); cheats.expectEmit(true, true, true, true, address(delegationManager)); emit DepositScalingFactorUpdated( - params.withdrawal.staker, - params.withdrawal.strategies[i], - expectedDepositScalingFactor + params.withdrawal.staker, params.withdrawal.strategies[i], expectedDepositScalingFactor ); if (operator != address(0)) { cheats.expectEmit(true, true, true, true, address(delegationManager)); emit OperatorSharesIncreased( - operator, - params.withdrawal.staker, - params.withdrawal.strategies[i], - sharesToWithdraw - ); + operator, params.withdrawal.staker, params.withdrawal.strategies[i], sharesToWithdraw + ); } } } - emit SlashingWithdrawalCompleted( - delegationManager.calculateWithdrawalRoot(params.withdrawal) - ); + emit SlashingWithdrawalCompleted(delegationManager.calculateWithdrawalRoot(params.withdrawal)); } struct CompleteQueuedWithdrawalsEmitStruct { @@ -836,7 +831,9 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag uint256 sharesToBurn; } - function _slashOperatorShares_expectEmit(SlashOperatorSharesEmitStruct memory params) internal { + function _slashOperatorShares_expectEmit( + SlashOperatorSharesEmitStruct memory params + ) internal { cheats.expectEmit(true, true, true, true, address(delegationManager)); emit OperatorSharesDecreased(params.operator, address(0), params.strategy, params.sharesToDecrease); } @@ -853,9 +850,7 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag uint256 depositScalingFactor, uint256 slashingFactor ) internal pure returns (uint256) { - return depositShares - .mulWad(depositScalingFactor) - .mulWad(slashingFactor); + return depositShares.mulWad(depositScalingFactor).mulWad(slashingFactor); } function _calcCompletedWithdrawnShares( @@ -874,17 +869,11 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag ) internal pure returns (uint256) { if (prevDepositShares == 0) return uint256(WAD).divWad(slashingFactor); - uint256 currWithdrawableShares = _calcWithdrawableShares( - prevDepositShares, - prevDsf, - slashingFactor - ); + uint256 currWithdrawableShares = _calcWithdrawableShares(prevDepositShares, prevDsf, slashingFactor); uint256 newWithdrawableShares = currWithdrawableShares + addedDepositShares; - uint256 newDsf = newWithdrawableShares - .divWad(prevDepositShares + addedDepositShares) - .divWad(slashingFactor); + uint256 newDsf = newWithdrawableShares.divWad(prevDepositShares + addedDepositShares).divWad(slashingFactor); return newDsf; } @@ -913,10 +902,8 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag uint256 prevDsf, uint256 depositAmount ) internal view { - ( - uint256[] memory withdrawableShares, - uint256[] memory depositShares - ) = delegationManager.getWithdrawableShares(staker, strategy.toArray()); + (uint256[] memory withdrawableShares, uint256[] memory depositShares) = + delegationManager.getWithdrawableShares(staker, strategy.toArray()); // Check deposit shares added correctly assertEq( depositShares[0], @@ -936,17 +923,9 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag { uint64 maxMagnitude = allocationManagerMock.getMaxMagnitude(operator, strategy); uint256 slashingFactor = _getSlashingFactor(staker, strategy, maxMagnitude); - expectedDsf = _calcDepositScalingFactor( - prevDsf, - depositSharesBefore, - depositAmount, - slashingFactor - ); - expectedWithdrawableShares = _calcWithdrawableShares( - depositSharesBefore + depositAmount, - expectedDsf, - slashingFactor - ); + expectedDsf = _calcDepositScalingFactor(prevDsf, depositSharesBefore, depositAmount, slashingFactor); + expectedWithdrawableShares = + _calcWithdrawableShares(depositSharesBefore + depositAmount, expectedDsf, slashingFactor); } // Check the new dsf is accurate assertEq( @@ -970,6 +949,63 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag ); } + /// @notice Asserts for depositShares, withdrawableShares, and depositScalingFactor after a delegation + function _assertDelegation( + address staker, + address operator, + IStrategy strategy, + uint256 operatorSharesBefore, + uint256 withdrawableSharesBefore, + uint256 depositSharesBefore, + uint256 prevDsf + ) internal view { + (uint256[] memory withdrawableShares, uint256[] memory depositShares) = + delegationManager.getWithdrawableShares(staker, strategy.toArray()); + // Check deposit shares don't change + assertEq( + depositShares[0], + depositSharesBefore, + "depositShares should be equal to depositSharesBefore" + ); + // Check withdrawable shares don't change + assertApproxEqRel( + withdrawableShares[0], + withdrawableSharesBefore, + APPROX_REL_DIFF, + "withdrawableShares should be equal to withdrawableSharesBefore" + ); + // Check the new dsf is accurate + uint256 expectedWithdrawableShares; + uint256 expectedDsf; + { + uint64 maxMagnitude = allocationManagerMock.getMaxMagnitude(operator, strategy); + expectedDsf = prevDsf.divWad(maxMagnitude); + uint256 slashingFactor = _getSlashingFactor(staker, strategy, maxMagnitude); + expectedWithdrawableShares = + _calcWithdrawableShares(depositSharesBefore, expectedDsf, slashingFactor); + } + // Check the new dsf is accurate + assertEq( + expectedDsf, + delegationManager.depositScalingFactor(staker, strategy), + "depositScalingFactor should be equal to expectedDsf" + ); + // Check new operatorShares increased correctly + if (operator != address(0)) { + assertEq( + operatorSharesBefore + withdrawableSharesBefore, + delegationManager.operatorShares(operator, strategy), + "OperatorShares not increased correctly" + ); + } + // Check the newly calculated withdrawable shares are correct + assertEq( + withdrawableShares[0], + expectedWithdrawableShares, + "withdrawableShares should be equal to expectedWithdrawableShares" + ); + } + /// @notice Asserts for depositShares, and operatorShares decremented properly after a withdrawal function _assertWithdrawal( address staker, @@ -981,10 +1017,8 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag uint256 depositScalingFactor, uint256 slashingFactor ) internal view { - ( - uint256[] memory withdrawableShares, - uint256[] memory depositShares - ) = delegationManager.getWithdrawableShares(staker, strategy.toArray()); + (uint256[] memory withdrawableShares, uint256[] memory depositShares) = + delegationManager.getWithdrawableShares(staker, strategy.toArray()); // Check deposit shares decreased correctly assertEq( depositShares[0], @@ -992,22 +1026,16 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag "depositShares should be equal to depositSharesBefore - depositSharesWithdrawn" ); // Check withdrawable shares are decreased, with rounding error - uint256 expectedWithdrawableShares = _calcWithdrawableShares( - depositSharesBefore - depositSharesWithdrawn, - depositScalingFactor, - slashingFactor - ); + uint256 expectedWithdrawableShares = + _calcWithdrawableShares(depositSharesBefore - depositSharesWithdrawn, depositScalingFactor, slashingFactor); assertEq( withdrawableShares[0], expectedWithdrawableShares, "withdrawableShares should be equal to expectedWithdrawableShares" ); // Check operatorShares decreased properly - uint256 expectedWithdrawnShares = _calcWithdrawableShares( - depositSharesWithdrawn, - depositScalingFactor, - slashingFactor - ); + uint256 expectedWithdrawnShares = + _calcWithdrawableShares(depositSharesWithdrawn, depositScalingFactor, slashingFactor); assertEq( operatorSharesBefore - expectedWithdrawnShares, delegationManager.operatorShares(operator, strategy), @@ -1048,10 +1076,8 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag for (uint256 i = 0; i < params.withdrawal.strategies.length; i++) { { // assert deposit and withdrawable shares unchanged - ( - uint256[] memory withdrawableShares, - uint256[] memory depositShares - ) = delegationManager.getWithdrawableShares(params.staker, params.withdrawal.strategies[i].toArray()); + (uint256[] memory withdrawableShares, uint256[] memory depositShares) = delegationManager + .getWithdrawableShares(params.staker, params.withdrawal.strategies[i].toArray()); assertEq( params.withdrawableSharesBefore[i], withdrawableShares[0], @@ -1080,12 +1106,11 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag for (uint256 i = 0; i < params.withdrawal.strategies.length; i++) { // calculate shares to complete withdraw and add back as shares if (params.withdrawal.strategies[i] == beaconChainETHStrategy) { - params.slashingFactors[i] = uint64(params.slashingFactors[i].mulWad(params.beaconChainSlashingFactor)); + params.slashingFactors[i] = + uint64(params.slashingFactors[i].mulWad(params.beaconChainSlashingFactor)); } - uint256 sharesToAddBack = _calcCompletedWithdrawnShares( - params.withdrawal.scaledShares[i], - params.slashingFactors[i] - ); + uint256 sharesToAddBack = + _calcCompletedWithdrawnShares(params.withdrawal.scaledShares[i], params.slashingFactors[i]); // assert deposit shares, withdrawable shares, and operator shares, and depositScalingFactor _assertDeposit({ staker: params.staker, @@ -1102,19 +1127,13 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag } /// @notice assert withdrawals completed are reflected as completed in storage for the withdrawal root and staker - function _assertWithdrawalRootsComplete( - address staker, - Withdrawal[] memory withdrawals - ) internal view { + function _assertWithdrawalRootsComplete(address staker, Withdrawal[] memory withdrawals) internal view { for (uint256 i = 0; i < withdrawals.length; ++i) { // Check the withdrawal root is no longer pending // and also doesn't exist in storage for the staker bytes32 withdrawalRootToCheck = delegationManager.calculateWithdrawalRoot(withdrawals[i]); - assertFalse( - delegationManager.pendingWithdrawals(withdrawalRootToCheck), - "withdrawalRoot not pending" - ); - (Withdrawal[] memory withdrawalsInStorage, ) = delegationManager.getQueuedWithdrawals(staker); + assertFalse(delegationManager.pendingWithdrawals(withdrawalRootToCheck), "withdrawalRoot not pending"); + (Withdrawal[] memory withdrawalsInStorage,) = delegationManager.getQueuedWithdrawals(staker); for (uint256 j = 0; j < withdrawalsInStorage.length; ++j) { assertTrue( withdrawalRootToCheck != delegationManager.calculateWithdrawalRoot(withdrawalsInStorage[j]), @@ -1157,7 +1176,7 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag uint256 prevMaxMagnitude, uint256 currMaxMagnitude ) internal view { - (uint256[] memory withdrawableShares, ) = delegationManager.getWithdrawableShares(staker, strategy.toArray()); + (uint256[] memory withdrawableShares,) = delegationManager.getWithdrawableShares(staker, strategy.toArray()); assertApproxEqRel( uint256(withdrawableSharesBefore).mulDiv(currMaxMagnitude, prevMaxMagnitude), @@ -1179,7 +1198,8 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag uint256 expectedWithdrawableShares, uint256 prevBeaconSlashingFactor ) internal view { - (uint256[] memory withdrawableShares, ) = delegationManager.getWithdrawableShares(staker, beaconChainETHStrategy.toArray()); + (uint256[] memory withdrawableShares,) = + delegationManager.getWithdrawableShares(staker, beaconChainETHStrategy.toArray()); uint256 currBeaconSlashingFactor = eigenPodManagerMock.beaconChainSlashingFactor(defaultStaker); assertEq( withdrawableShares[0], @@ -1195,26 +1215,17 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag } /// @notice Due to rounding, withdrawable shares and operator shares may not align even if the operator - /// only has the single staker with deposits. + /// only has the single staker with deposits. function _assertWithdrawableAndOperatorShares( uint256 withdrawableShares, uint256 operatorShares, string memory errorMessage ) internal pure { - if (withdrawableShares > 0 ) { - assertApproxEqRel( - withdrawableShares, - operatorShares, - APPROX_REL_DIFF, - errorMessage - ); - } else { - - } + if (withdrawableShares > 0) { + assertApproxEqRel(withdrawableShares, operatorShares, APPROX_REL_DIFF, errorMessage); + } else {} assertLe( - withdrawableShares, - operatorShares, - "withdrawableShares should be less than or equal to operatorShares" + withdrawableShares, operatorShares, "withdrawableShares should be less than or equal to operatorShares" ); } @@ -1227,49 +1238,22 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag address staker ) internal view { for (uint256 i = 0; i < stakerQueuedWithdrawals[staker].length; ++i) { - Withdrawal memory withdrawal = stakerQueuedWithdrawals[staker][i]; + Withdrawal memory withdrawal = stakerQueuedWithdrawals[staker][i]; bytes32 withdrawalRootToCheck = delegationManager.calculateWithdrawalRoot(withdrawal); - assertTrue( - delegationManager.pendingWithdrawals(withdrawalRootToCheck), - "withdrawalRoot not pending" - ); + assertTrue(delegationManager.pendingWithdrawals(withdrawalRootToCheck), "withdrawalRoot not pending"); - (Withdrawal[] memory withdrawals, ) = delegationManager.getQueuedWithdrawals(staker); + (Withdrawal[] memory withdrawals,) = delegationManager.getQueuedWithdrawals(staker); for (uint256 j = 0; j < withdrawals.length; ++j) { if (withdrawalRootToCheck == delegationManager.calculateWithdrawalRoot(withdrawals[j])) { - assertEq( - withdrawals[j].staker, - withdrawal.staker - ); - assertEq( - withdrawals[j].withdrawer, - withdrawal.withdrawer - ); - assertEq( - withdrawals[j].delegatedTo, - withdrawal.delegatedTo - ); - assertEq( - withdrawals[j].nonce, - withdrawal.nonce - ); - assertEq( - withdrawals[j].startBlock, - withdrawal.startBlock - ); - assertEq( - withdrawals[j].scaledShares.length, - withdrawal.scaledShares.length - ); + assertEq(withdrawals[j].staker, withdrawal.staker); + assertEq(withdrawals[j].withdrawer, withdrawal.withdrawer); + assertEq(withdrawals[j].delegatedTo, withdrawal.delegatedTo); + assertEq(withdrawals[j].nonce, withdrawal.nonce); + assertEq(withdrawals[j].startBlock, withdrawal.startBlock); + assertEq(withdrawals[j].scaledShares.length, withdrawal.scaledShares.length); for (uint256 k = 0; k < withdrawal.scaledShares.length; ++k) { - assertEq( - withdrawals[j].scaledShares[k], - withdrawal.scaledShares[k] - ); - assertEq( - address(withdrawals[j].strategies[k]), - address(withdrawal.strategies[k]) - ); + assertEq(withdrawals[j].scaledShares[k], withdrawal.scaledShares[k]); + assertEq(address(withdrawals[j].strategies[k]), address(withdrawal.strategies[k])); } } } @@ -1281,51 +1265,21 @@ contract DelegationManagerUnitTests is EigenLayerUnitTestSetup, IDelegationManag * - Asserts exact match of Withdrawal struct exists in storage * - Asserts Withdrawal root is pending */ - function _assertQueuedWithdrawalExists( - address staker, - Withdrawal memory withdrawal - ) internal view { + function _assertQueuedWithdrawalExists(address staker, Withdrawal memory withdrawal) internal view { bytes32 withdrawalRootToCheck = delegationManager.calculateWithdrawalRoot(withdrawal); - assertTrue( - delegationManager.pendingWithdrawals(withdrawalRootToCheck), - "withdrawalRoot not pending" - ); + assertTrue(delegationManager.pendingWithdrawals(withdrawalRootToCheck), "withdrawalRoot not pending"); - (Withdrawal[] memory withdrawals, ) = delegationManager.getQueuedWithdrawals(staker); + (Withdrawal[] memory withdrawals,) = delegationManager.getQueuedWithdrawals(staker); for (uint256 i = 0; i < withdrawals.length; ++i) { - assertEq( - withdrawals[i].staker, - withdrawal.staker - ); - assertEq( - withdrawals[i].withdrawer, - withdrawal.withdrawer - ); - assertEq( - withdrawals[i].delegatedTo, - withdrawal.delegatedTo - ); - assertEq( - withdrawals[i].nonce, - withdrawal.nonce - ); - assertEq( - withdrawals[i].startBlock, - withdrawal.startBlock - ); - assertEq( - withdrawals[i].scaledShares.length, - withdrawal.scaledShares.length - ); + assertEq(withdrawals[i].staker, withdrawal.staker); + assertEq(withdrawals[i].withdrawer, withdrawal.withdrawer); + assertEq(withdrawals[i].delegatedTo, withdrawal.delegatedTo); + assertEq(withdrawals[i].nonce, withdrawal.nonce); + assertEq(withdrawals[i].startBlock, withdrawal.startBlock); + assertEq(withdrawals[i].scaledShares.length, withdrawal.scaledShares.length); for (uint256 j = 0; j < withdrawal.scaledShares.length; ++j) { - assertEq( - withdrawals[i].scaledShares[j], - withdrawal.scaledShares[j] - ); - assertEq( - address(withdrawals[i].strategies[j]), - address(withdrawal.strategies[j]) - ); + assertEq(withdrawals[i].scaledShares[j], withdrawal.scaledShares[j]); + assertEq(address(withdrawals[i].strategies[j]), address(withdrawal.strategies[j])); } } } @@ -1361,6 +1315,19 @@ contract DelegationManagerUnitTests_Initialization_Setters is DelegationManagerU ); assertEq(delegationManager.owner(), address(this), "constructor / initializer incorrect, owner set wrong"); assertEq(delegationManager.paused(), 0, "constructor / initializer incorrect, paused status set wrong"); + + bytes memory v = bytes(delegationManager.version()); + bytes32 expectedDomainSeparator = keccak256( + abi.encode( + EIP712_DOMAIN_TYPEHASH, + keccak256(bytes("EigenLayer")), + keccak256(bytes.concat(v[0], v[1])), + block.chainid, + address(delegationManager) + ) + ); + + assertEq(delegationManager.domainSeparator(), expectedDomainSeparator, "sanity check"); } /// @notice Verifies that the DelegationManager cannot be iniitalized multiple times @@ -1372,7 +1339,7 @@ contract DelegationManagerUnitTests_Initialization_Setters is DelegationManagerU contract DelegationManagerUnitTests_RegisterModifyOperator is DelegationManagerUnitTests { using ArrayLib for *; - + function test_registerAsOperator_revert_paused() public { // set the pausing flag cheats.prank(pauser); @@ -1422,9 +1389,7 @@ contract DelegationManagerUnitTests_RegisterModifyOperator is DelegationManagerU // Storage checks assertEq( - delegationApprover, - delegationManager.delegationApprover(operator), - "delegationApprover not set correctly" + delegationApprover, delegationManager.delegationApprover(operator), "delegationApprover not set correctly" ); assertEq(delegationManager.delegatedTo(operator), operator, "operator not delegated to self"); } @@ -1455,17 +1420,10 @@ contract DelegationManagerUnitTests_RegisterModifyOperator is DelegationManagerU }) ); _registerOperator(operator2, delegationApprover2, emptyStringForMetadataURI); - assertTrue( - delegationManager.isOperator(operator1), - "operator1 not registered" - ); - assertTrue( - delegationManager.isOperator(operator2), - "operator2 not registered" - ); + assertTrue(delegationManager.isOperator(operator1), "operator1 not registered"); + assertTrue(delegationManager.isOperator(operator2), "operator2 not registered"); } - // @notice Verifies that a staker who is actively delegated to an operator cannot register as an operator (without first undelegating, at least) function testFuzz_Revert_registerAsOperator_cannotRegisterWhileDelegated( address staker, @@ -1478,7 +1436,7 @@ contract DelegationManagerUnitTests_RegisterModifyOperator is DelegationManagerU // delegate from the `staker` to the operator cheats.startPrank(staker); - ISignatureUtils.SignatureWithExpiry memory approverSignatureAndExpiry; + ISignatureUtilsMixinTypes.SignatureWithExpiry memory approverSignatureAndExpiry; delegationManager.delegateTo(defaultOperator, approverSignatureAndExpiry, emptySalt); // expect revert if attempt to register as operator @@ -1487,12 +1445,14 @@ contract DelegationManagerUnitTests_RegisterModifyOperator is DelegationManagerU cheats.stopPrank(); } - + /// @notice Add test for registerAsOperator where the operator has existing deposits in strategies /// Assert: /// depositShares == operatorShares == withdrawableShares /// check operatorDetails hash encode matches the operatorDetails hash stored (call view function) - function testFuzz_registerAsOperator_withDeposits(Randomness r) public rand(r) { + function testFuzz_registerAsOperator_withDeposits( + Randomness r + ) public rand(r) { uint256 shares = r.Uint256(1, MAX_STRATEGY_SHARES); // Set staker shares in StrategyManager IStrategy[] memory strategiesToReturn = strategyMock.toArray(); @@ -1513,12 +1473,9 @@ contract DelegationManagerUnitTests_RegisterModifyOperator is DelegationManagerU // check depositShares == operatorShares == withdrawableShares assertEq(operatorSharesAfter, shares, "operator shares not set correctly"); - (uint256[] memory withdrawableShares, ) = delegationManager.getWithdrawableShares(defaultOperator, strategiesToReturn); - assertEq( - withdrawableShares[0], - shares, - "withdrawable shares not set correctly" - ); + (uint256[] memory withdrawableShares,) = + delegationManager.getWithdrawableShares(defaultOperator, strategiesToReturn); + assertEq(withdrawableShares[0], shares, "withdrawable shares not set correctly"); assertEq( strategyManagerMock.stakerDepositShares(defaultOperator, strategyMock), shares, @@ -1535,10 +1492,7 @@ contract DelegationManagerUnitTests_RegisterModifyOperator is DelegationManagerU * Reverts if operator tries to decrease their `stakerOptOutWindowBlocks` parameter * @param delegationApprover1 and @param delegationApprover2 are fuzzed inputs */ - function testFuzz_modifyOperatorParameters( - address delegationApprover1, - address delegationApprover2 - ) public { + function testFuzz_modifyOperatorParameters(address delegationApprover1, address delegationApprover2) public { _registerOperator_expectEmit( RegisterAsOperatorEmitStruct({ operator: defaultOperator, @@ -1574,7 +1528,6 @@ contract DelegationManagerUnitTests_RegisterModifyOperator is DelegationManagerU delegationManager.updateOperatorMetadataURI(defaultOperator, emptyStringForMetadataURI); } - function test_Revert_updateOperatorMetadataUri_notOperator() public { cheats.expectRevert(OperatorNotRegistered.selector); delegationManager.modifyOperatorDetails(defaultOperator, defaultOperator); @@ -1585,7 +1538,9 @@ contract DelegationManagerUnitTests_RegisterModifyOperator is DelegationManagerU * @dev This is an important check to ensure that our definition of 'operator' remains consistent, in particular for preserving the * invariant that 'operators' are always delegated to themselves */ - function testFuzz_UpdateOperatorMetadataURI(string memory metadataURI) public { + function testFuzz_UpdateOperatorMetadataURI( + string memory metadataURI + ) public { _registerOperatorWithBaseDetails(defaultOperator); // call `updateOperatorMetadataURI` and check for event @@ -1622,7 +1577,9 @@ contract DelegationManagerUnitTests_RegisterModifyOperator is DelegationManagerU ); } - function testFuzz_UAM_updateOperatorMetadataURI(string memory metadataURI) public { + function testFuzz_UAM_updateOperatorMetadataURI( + string memory metadataURI + ) public { // Set admin cheats.prank(defaultOperator); permissionController.setAppointee( @@ -1647,17 +1604,13 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { function test_Revert_WhenPaused() public { cheats.prank(defaultOperator); - delegationManager.registerAsOperator( - address(0), - 0, - emptyStringForMetadataURI - ); + delegationManager.registerAsOperator(address(0), 0, emptyStringForMetadataURI); // set the pausing flag cheats.prank(pauser); delegationManager.pause(2 ** PAUSED_NEW_DELEGATION); - ISignatureUtils.SignatureWithExpiry memory approverSignatureAndExpiry; + ISignatureUtilsMixinTypes.SignatureWithExpiry memory approverSignatureAndExpiry; cheats.prank(defaultStaker); cheats.expectRevert(IPausable.CurrentlyPaused.selector); delegationManager.delegateTo(defaultOperator, approverSignatureAndExpiry, emptySalt); @@ -1668,7 +1621,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { */ function testFuzz_Revert_WhenDelegateWhileDelegated( Randomness r, - ISignatureUtils.SignatureWithExpiry memory approverSignatureAndExpiry + ISignatureUtilsMixinTypes.SignatureWithExpiry memory approverSignatureAndExpiry ) public rand(r) { address staker = r.Address(); address operator = r.Address(); @@ -1685,7 +1638,9 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { } /// @notice Verifies that `staker` cannot delegate to an unregistered `operator` - function testFuzz_Revert_WhenDelegateToUnregisteredOperator(Randomness r) public rand(r) { + function testFuzz_Revert_WhenDelegateToUnregisteredOperator( + Randomness r + ) public rand(r) { address staker = r.Address(); address operator = r.Address(); assertFalse(delegationManager.isOperator(operator), "incorrect test input?"); @@ -1693,7 +1648,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // try to delegate and check that the call reverts cheats.prank(staker); cheats.expectRevert(OperatorNotRegistered.selector); - ISignatureUtils.SignatureWithExpiry memory approverSignatureAndExpiry; + ISignatureUtilsMixinTypes.SignatureWithExpiry memory approverSignatureAndExpiry; delegationManager.delegateTo(operator, approverSignatureAndExpiry, emptySalt); } @@ -1711,7 +1666,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { */ function testFuzz_OperatorWhoAcceptsAllStakers_StrategyManagerShares( Randomness r, - ISignatureUtils.SignatureWithExpiry memory approverSignatureAndExpiry + ISignatureUtilsMixinTypes.SignatureWithExpiry memory approverSignatureAndExpiry ) public rand(r) { address staker = r.Address(); bytes32 salt = r.Bytes32(); @@ -1721,10 +1676,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // verify that the salt hasn't been used before assertFalse( - delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - salt - ), + delegationManager.delegationApproverSaltIsSpent(delegationManager.delegationApprover(defaultOperator), salt), "salt somehow spent too early?" ); // Set staker shares in StrategyManager @@ -1757,10 +1709,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { assertFalse(delegationManager.isOperator(staker), "staker incorrectly registered as operator"); // verify that the salt is still marked as unused (since it wasn't checked or used) assertFalse( - delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - salt - ), + delegationManager.delegationApproverSaltIsSpent(delegationManager.delegationApprover(defaultOperator), salt), "salt somehow spent too early?" ); } @@ -1780,7 +1729,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { */ function testFuzz_OperatorWhoAcceptsAllStakers_beaconChainStrategyShares( Randomness r, - ISignatureUtils.SignatureWithExpiry memory approverSignatureAndExpiry + ISignatureUtilsMixinTypes.SignatureWithExpiry memory approverSignatureAndExpiry ) public rand(r) { address staker = r.Address(); bytes32 salt = r.Bytes32(); @@ -1792,10 +1741,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // verify that the salt hasn't been used before assertFalse( - delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - salt - ), + delegationManager.delegationApproverSaltIsSpent(delegationManager.delegationApprover(defaultOperator), salt), "salt somehow spent too early?" ); // Set staker shares in BeaconChainStrategy @@ -1829,13 +1775,11 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { assertFalse(delegationManager.isOperator(staker), "staker incorrectly registered as operator"); // verify that the salt is still marked as unused (since it wasn't checked or used) assertFalse( - delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - salt - ), + delegationManager.delegationApproverSaltIsSpent(delegationManager.delegationApprover(defaultOperator), salt), "salt somehow spent too early?" ); - (uint256[] memory withdrawableShares, ) = delegationManager.getWithdrawableShares(staker, beaconChainETHStrategy.toArray()); + (uint256[] memory withdrawableShares,) = + delegationManager.getWithdrawableShares(staker, beaconChainETHStrategy.toArray()); _assertWithdrawableAndOperatorShares( withdrawableShares[0], delegationManager.operatorShares(defaultOperator, beaconChainETHStrategy), @@ -1873,14 +1817,15 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { cheats.expectRevert(FullySlashed.selector); delegationManager.delegateTo(defaultOperator, emptyApproverSignatureAndExpiry, emptySalt); - assertTrue(delegationManager.delegatedTo(staker) != defaultOperator, "staker should not be delegated to the operator"); + assertTrue( + delegationManager.delegatedTo(staker) != defaultOperator, "staker should not be delegated to the operator" + ); assertFalse(delegationManager.isDelegated(staker), "staker should not be delegated"); assertFalse(delegationManager.isOperator(staker), "staker incorrectly registered as operator"); // verify that the salt is still marked as unused (since it wasn't checked or used) assertFalse( delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - emptySalt + delegationManager.delegationApprover(defaultOperator), emptySalt ), "salt somehow spent too early?" ); @@ -1899,7 +1844,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { */ function testFuzz_Revert_OperatorWhoAcceptsAllStakers_AlreadySlashed100Percent_BeaconChainStrategyShares( Randomness r, - ISignatureUtils.SignatureWithExpiry memory approverSignatureAndExpiry + ISignatureUtilsMixinTypes.SignatureWithExpiry memory approverSignatureAndExpiry ) public rand(r) { address staker = r.Address(); bytes32 salt = r.Bytes32(); @@ -1909,10 +1854,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // verify that the salt hasn't been used before assertFalse( - delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - salt - ), + delegationManager.delegationApproverSaltIsSpent(delegationManager.delegationApprover(defaultOperator), salt), "salt somehow spent too early?" ); // Set staker shares in BeaconChainStrategy @@ -1933,15 +1875,14 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { beaconSharesAfter, "operator beaconchain shares should not have increased with negative shares" ); - assertTrue(delegationManager.delegatedTo(staker) != defaultOperator, "staker should not be delegated to the operator"); + assertTrue( + delegationManager.delegatedTo(staker) != defaultOperator, "staker should not be delegated to the operator" + ); assertFalse(delegationManager.isDelegated(staker), "staker should not be delegated"); assertFalse(delegationManager.isOperator(staker), "staker incorrectly registered as operator"); // verify that the salt is still marked as unused (since it wasn't checked or used) assertFalse( - delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - salt - ), + delegationManager.delegationApproverSaltIsSpent(delegationManager.delegationApprover(defaultOperator), salt), "salt somehow spent too early?" ); } @@ -2001,13 +1942,12 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // verify that the salt is still marked as unused (since it wasn't checked or used) assertFalse( delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - emptySalt + delegationManager.delegationApprover(defaultOperator), emptySalt ), "salt somehow spent too early?" ); - (uint256[] memory withdrawableShares, ) = delegationManager.getWithdrawableShares(staker, strategyMock.toArray()); + (uint256[] memory withdrawableShares,) = delegationManager.getWithdrawableShares(staker, strategyMock.toArray()); _assertWithdrawableAndOperatorShares( withdrawableShares[0], delegationManager.operatorShares(defaultOperator, strategyMock), @@ -2070,15 +2010,13 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // verify that the salt is still marked as unused (since it wasn't checked or used) assertFalse( delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - emptySalt + delegationManager.delegationApprover(defaultOperator), emptySalt ), "salt somehow spent too early?" ); - ( - uint256[] memory withdrawableShares, - ) = delegationManager.getWithdrawableShares(staker, beaconChainETHStrategy.toArray()); + (uint256[] memory withdrawableShares,) = + delegationManager.getWithdrawableShares(staker, beaconChainETHStrategy.toArray()); _assertWithdrawableAndOperatorShares( withdrawableShares[0], delegationManager.operatorShares(defaultOperator, beaconChainETHStrategy), @@ -2095,7 +2033,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { * - depositShares incremented for staker correctly * - withdrawableShares are correct * - depositScalingFactor is updated correctly - * - operatorShares increase by depositShares amount + * - operatorShares increase by withdrawableShares amount * - defaultOperator is an operator, staker is delegated to defaultOperator, staker is not an operator * - That the staker withdrawableShares is <= operatorShares (less due to rounding from non-WAD maxMagnitude) */ @@ -2113,6 +2051,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { eigenPodManagerMock.setBeaconChainSlashingFactor(staker, beaconChainSlashingFactor); // Set staker shares in BeaconChainStrategy eigenPodManagerMock.setPodOwnerShares(staker, beaconShares); + (uint256[] memory withdrawableShares,) = delegationManager.getWithdrawableShares(staker, beaconChainETHStrategy.toArray()); // delegate from the `staker` to the operator, check for events emitted cheats.startPrank(staker); @@ -2121,21 +2060,20 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { staker: staker, operator: defaultOperator, strategy: beaconChainETHStrategy, - depositShares: beaconShares > 0 ? uint256(beaconShares) : 0, - depositScalingFactor: uint256(WAD).divWad(maxMagnitude.mulWad(beaconChainSlashingFactor)) + depositShares: beaconShares > 0 ? withdrawableShares[0] : 0, + depositScalingFactor: uint256(WAD).divWad(maxMagnitude) }) ); delegationManager.delegateTo(defaultOperator, emptyApproverSignatureAndExpiry, emptySalt); - _assertDeposit({ + _assertDelegation({ staker: staker, operator: defaultOperator, strategy: beaconChainETHStrategy, operatorSharesBefore: 0, - withdrawableSharesBefore: 0, - depositSharesBefore: 0, - prevDsf: WAD, - depositAmount: uint256(beaconShares) + withdrawableSharesBefore: withdrawableShares[0], + depositSharesBefore: uint256(beaconShares), + prevDsf: WAD }); assertTrue(delegationManager.isOperator(defaultOperator), "staker not registered as operator"); assertEq(delegationManager.delegatedTo(staker), defaultOperator, "staker delegated to the wrong address"); @@ -2143,17 +2081,15 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // verify that the salt is still marked as unused (since it wasn't checked or used) assertFalse( delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - emptySalt + delegationManager.delegationApprover(defaultOperator), emptySalt ), "salt somehow spent too early?" ); - ( - uint256[] memory withdrawableShares, - ) = delegationManager.getWithdrawableShares(staker, beaconChainETHStrategy.toArray()); + (uint256[] memory withdrawableSharesAfter,) = + delegationManager.getWithdrawableShares(staker, beaconChainETHStrategy.toArray()); _assertWithdrawableAndOperatorShares( - withdrawableShares[0], + withdrawableSharesAfter[0], delegationManager.operatorShares(defaultOperator, beaconChainETHStrategy), "withdrawableShares not set correctly" ); @@ -2174,7 +2110,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { */ function testFuzz_OperatorWhoAcceptsAllStakers_BeaconChainAndStrategyManagerShares( Randomness r, - ISignatureUtils.SignatureWithExpiry memory approverSignatureAndExpiry + ISignatureUtilsMixinTypes.SignatureWithExpiry memory approverSignatureAndExpiry ) public rand(r) { address staker = r.Address(); bytes32 salt = r.Bytes32(); @@ -2185,19 +2121,14 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // verify that the salt hasn't been used before assertFalse( - delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - salt - ), + delegationManager.delegationApproverSaltIsSpent(delegationManager.delegationApprover(defaultOperator), salt), "salt somehow spent too early?" ); // Set staker shares in BeaconChainStrategy and StrategyMananger strategyManagerMock.addDeposit(staker, strategyMock, shares); eigenPodManagerMock.setPodOwnerShares(staker, beaconShares); - ( - IStrategy[] memory strategiesToReturn, - uint256[] memory sharesToReturn - ) = delegationManager.getDepositedShares(staker); + (IStrategy[] memory strategiesToReturn, uint256[] memory sharesToReturn) = + delegationManager.getDepositedShares(staker); uint256[] memory depositScalingFactors = new uint256[](2); depositScalingFactors[0] = uint256(WAD); depositScalingFactors[1] = uint256(WAD); @@ -2235,7 +2166,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { prevDsf: WAD, depositAmount: shares }); - (uint256[] memory withdrawableShares, ) = delegationManager.getWithdrawableShares(staker, strategiesToReturn); + (uint256[] memory withdrawableShares,) = delegationManager.getWithdrawableShares(staker, strategiesToReturn); _assertWithdrawableAndOperatorShares( withdrawableShares[0], delegationManager.operatorShares(defaultOperator, strategyMock), @@ -2252,10 +2183,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { assertFalse(delegationManager.isOperator(staker), "staker incorrectly registered as operator"); // verify that the salt is still marked as unused (since it wasn't checked or used) assertFalse( - delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - salt - ), + delegationManager.delegationApproverSaltIsSpent(delegationManager.delegationApprover(defaultOperator), salt), "salt somehow spent too early?" ); } @@ -2289,10 +2217,8 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // 2. Set staker shares in BeaconChainStrategy and StrategyMananger strategyManagerMock.addDeposit(defaultStaker, strategyMock, shares); eigenPodManagerMock.setPodOwnerShares(defaultStaker, beaconShares); - ( - IStrategy[] memory strategiesToReturn, - uint256[] memory sharesToReturn - ) = delegationManager.getDepositedShares(defaultStaker); + (IStrategy[] memory strategiesToReturn, uint256[] memory sharesToReturn) = + delegationManager.getDepositedShares(defaultStaker); // 3. delegate from the `staker` to the operator with expected emitted events cheats.startPrank(defaultStaker); @@ -2333,17 +2259,21 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { depositAmount: shares }); assertTrue(delegationManager.isOperator(defaultOperator), "defaultStaker not registered as operator"); - assertEq(delegationManager.delegatedTo(defaultStaker), defaultOperator, "defaultStaker delegated to the wrong address"); + assertEq( + delegationManager.delegatedTo(defaultStaker), + defaultOperator, + "defaultStaker delegated to the wrong address" + ); assertFalse(delegationManager.isOperator(defaultStaker), "staker incorrectly registered as operator"); // verify that the salt is still marked as unused (since it wasn't checked or used) assertFalse( delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - emptySalt + delegationManager.delegationApprover(defaultOperator), emptySalt ), "salt somehow spent too early?" ); - (uint256[] memory withdrawableShares, ) = delegationManager.getWithdrawableShares(defaultStaker, strategiesToReturn); + (uint256[] memory withdrawableShares,) = + delegationManager.getWithdrawableShares(defaultStaker, strategiesToReturn); _assertWithdrawableAndOperatorShares( withdrawableShares[0], delegationManager.operatorShares(defaultOperator, strategyMock), @@ -2363,7 +2293,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { */ function testFuzz_OperatorWhoAcceptsAllStakers_ZeroDelegatableShares( Randomness r, - ISignatureUtils.SignatureWithExpiry memory approverSignatureAndExpiry + ISignatureUtilsMixinTypes.SignatureWithExpiry memory approverSignatureAndExpiry ) public rand(r) { address staker = r.Address(); bytes32 salt = r.Bytes32(); @@ -2371,10 +2301,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // verify that the salt hasn't been used before assertFalse( - delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - salt - ), + delegationManager.delegationApproverSaltIsSpent(delegationManager.delegationApprover(defaultOperator), salt), "salt somehow spent too early?" ); @@ -2390,10 +2317,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { assertFalse(delegationManager.isOperator(staker), "staker incorrectly registered as operator"); // verify that the salt is still marked as unused (since it wasn't checked or used) assertFalse( - delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - salt - ), + delegationManager.delegationApproverSaltIsSpent(delegationManager.delegationApprover(defaultOperator), salt), "salt somehow spent too early?" ); } @@ -2413,7 +2337,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { _registerOperatorWithDelegationApprover(defaultOperator); // calculate the delegationSigner's signature - ISignatureUtils.SignatureWithExpiry memory approverSignatureAndExpiry = _getApproverSignature( + ISignatureUtilsMixinTypes.SignatureWithExpiry memory approverSignatureAndExpiry = _getApproverSignature( delegationSignerPrivateKey, staker, defaultOperator, @@ -2423,7 +2347,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // delegate from the `staker` to the operator cheats.startPrank(staker); - cheats.expectRevert(ISignatureUtils.SignatureExpired.selector); + cheats.expectRevert(ISignatureUtilsMixinErrors.SignatureExpired.selector); delegationManager.delegateTo(defaultOperator, approverSignatureAndExpiry, salt); cheats.stopPrank(); } @@ -2443,14 +2367,11 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // verify that the salt hasn't been used before assertFalse( - delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - salt - ), + delegationManager.delegationApproverSaltIsSpent(delegationManager.delegationApprover(defaultOperator), salt), "salt somehow spent too early?" ); // calculate the delegationSigner's signature - ISignatureUtils.SignatureWithExpiry memory approverSignatureAndExpiry = _getApproverSignature( + ISignatureUtilsMixinTypes.SignatureWithExpiry memory approverSignatureAndExpiry = _getApproverSignature( delegationSignerPrivateKey, staker, defaultOperator, @@ -2463,10 +2384,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { cheats.startPrank(staker); delegationManager.delegateTo(defaultOperator, approverSignatureAndExpiry, salt); assertTrue( - delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - salt - ), + delegationManager.delegationApproverSaltIsSpent(delegationManager.delegationApprover(defaultOperator), salt), "salt somehow spent not spent?" ); delegationManager.undelegate(staker); @@ -2487,15 +2405,11 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { _registerOperatorWithDelegationApprover(defaultOperator); // calculate the signature - ISignatureUtils.SignatureWithExpiry memory approverSignatureAndExpiry; + ISignatureUtilsMixinTypes.SignatureWithExpiry memory approverSignatureAndExpiry; approverSignatureAndExpiry.expiry = expiry; { bytes32 digestHash = delegationManager.calculateDelegationApprovalDigestHash( - staker, - defaultOperator, - delegationManager.delegationApprover(defaultOperator), - emptySalt, - expiry + staker, defaultOperator, delegationManager.delegationApprover(defaultOperator), emptySalt, expiry ); (uint8 v, bytes32 r, bytes32 s) = cheats.sign(delegationSignerPrivateKey, digestHash); // mess up the signature by flipping v's parity @@ -2505,7 +2419,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // try to delegate from the `staker` to the operator, and check reversion cheats.startPrank(staker); - cheats.expectRevert(ISignatureUtils.InvalidSignature.selector); + cheats.expectRevert(ISignatureUtilsMixinErrors.InvalidSignature.selector); delegationManager.delegateTo(defaultOperator, approverSignatureAndExpiry, emptySalt); cheats.stopPrank(); } @@ -2519,7 +2433,9 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { * Reverts if the staker is already delegated (to the operator or to anyone else) * Reverts if the ‘operator’ is not actually registered as an operator */ - function testFuzz_OperatorWhoRequiresECDSASignature(Randomness r) public rand(r) { + function testFuzz_OperatorWhoRequiresECDSASignature( + Randomness r + ) public rand(r) { address staker = r.Address(); bytes32 salt = r.Bytes32(); uint256 expiry = r.Uint256(block.timestamp, type(uint256).max); @@ -2528,14 +2444,11 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // verify that the salt hasn't been used before assertFalse( - delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - salt - ), + delegationManager.delegationApproverSaltIsSpent(delegationManager.delegationApprover(defaultOperator), salt), "salt somehow spent too early?" ); // calculate the delegationSigner's signature - ISignatureUtils.SignatureWithExpiry memory approverSignatureAndExpiry = _getApproverSignature( + ISignatureUtilsMixinTypes.SignatureWithExpiry memory approverSignatureAndExpiry = _getApproverSignature( delegationSignerPrivateKey, staker, defaultOperator, @@ -2558,8 +2471,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // verify that the salt is still marked as unused (since it wasn't checked or used) assertFalse( delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - salt + delegationManager.delegationApprover(defaultOperator), salt ), "salt somehow spent too incorrectly?" ); @@ -2567,8 +2479,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // verify that the salt is marked as used assertTrue( delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - salt + delegationManager.delegationApprover(defaultOperator), salt ), "salt somehow spent not spent?" ); @@ -2597,14 +2508,11 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // verify that the salt hasn't been used before assertFalse( - delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - salt - ), + delegationManager.delegationApproverSaltIsSpent(delegationManager.delegationApprover(defaultOperator), salt), "salt somehow spent too early?" ); // calculate the delegationSigner's signature - ISignatureUtils.SignatureWithExpiry memory approverSignatureAndExpiry = _getApproverSignature( + ISignatureUtilsMixinTypes.SignatureWithExpiry memory approverSignatureAndExpiry = _getApproverSignature( delegationSignerPrivateKey, staker, defaultOperator, @@ -2640,7 +2548,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { assertFalse(delegationManager.isOperator(staker), "staker incorrectly registered as operator"); assertEq(delegationManager.delegatedTo(staker), defaultOperator, "staker delegated to the wrong address"); assertFalse(delegationManager.isOperator(staker), "staker incorrectly registered as operator"); - (uint256[] memory withdrawableShares, ) = delegationManager.getWithdrawableShares(staker, strategyMock.toArray()); + (uint256[] memory withdrawableShares,) = delegationManager.getWithdrawableShares(staker, strategyMock.toArray()); _assertWithdrawableAndOperatorShares( withdrawableShares[0], delegationManager.operatorShares(defaultOperator, strategyMock), @@ -2651,8 +2559,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // verify that the salt is still marked as unused (since it wasn't checked or used) assertFalse( delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - salt + delegationManager.delegationApprover(defaultOperator), salt ), "salt somehow spent too incorrectly?" ); @@ -2660,8 +2567,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // verify that the salt is marked as used assertTrue( delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - salt + delegationManager.delegationApprover(defaultOperator), salt ), "salt somehow spent not spent?" ); @@ -2690,14 +2596,11 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // verify that the salt hasn't been used before assertFalse( - delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - salt - ), + delegationManager.delegationApproverSaltIsSpent(delegationManager.delegationApprover(defaultOperator), salt), "salt somehow spent too early?" ); // calculate the delegationSigner's signature - ISignatureUtils.SignatureWithExpiry memory approverSignatureAndExpiry = _getApproverSignature( + ISignatureUtilsMixinTypes.SignatureWithExpiry memory approverSignatureAndExpiry = _getApproverSignature( delegationSignerPrivateKey, staker, defaultOperator, @@ -2731,9 +2634,8 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { prevDsf: WAD, depositAmount: uint256(beaconShares) }); - ( - uint256[] memory withdrawableShares, - ) = delegationManager.getWithdrawableShares(staker, beaconChainETHStrategy.toArray()); + (uint256[] memory withdrawableShares,) = + delegationManager.getWithdrawableShares(staker, beaconChainETHStrategy.toArray()); _assertWithdrawableAndOperatorShares( withdrawableShares[0], delegationManager.operatorShares(defaultOperator, beaconChainETHStrategy), @@ -2746,8 +2648,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // verify that the salt is still marked as unused (since it wasn't checked or used) assertFalse( delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - salt + delegationManager.delegationApprover(defaultOperator), salt ), "salt somehow spent too incorrectly?" ); @@ -2755,8 +2656,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // verify that the salt is marked as used assertTrue( delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - salt + delegationManager.delegationApprover(defaultOperator), salt ), "salt somehow spent not spent?" ); @@ -2788,14 +2688,11 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // verify that the salt hasn't been used before assertFalse( - delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - salt - ), + delegationManager.delegationApproverSaltIsSpent(delegationManager.delegationApprover(defaultOperator), salt), "salt somehow spent too early?" ); // calculate the delegationSigner's signature - ISignatureUtils.SignatureWithExpiry memory approverSignatureAndExpiry = _getApproverSignature( + ISignatureUtilsMixinTypes.SignatureWithExpiry memory approverSignatureAndExpiry = _getApproverSignature( delegationSignerPrivateKey, staker, defaultOperator, @@ -2809,10 +2706,8 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { depositScalingFactors[1] = uint256(WAD); strategyManagerMock.addDeposit(staker, strategyMock, shares); eigenPodManagerMock.setPodOwnerShares(staker, beaconShares); - ( - IStrategy[] memory strategiesToReturn, - uint256[] memory sharesToReturn - ) = delegationManager.getDepositedShares(staker); + (IStrategy[] memory strategiesToReturn, uint256[] memory sharesToReturn) = + delegationManager.getDepositedShares(staker); // delegate from the `staker` to the operator cheats.startPrank(staker); _delegateTo_expectEmit( @@ -2847,7 +2742,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { prevDsf: WAD, depositAmount: shares }); - (uint256[] memory withdrawableShares, ) = delegationManager.getWithdrawableShares(staker, strategiesToReturn); + (uint256[] memory withdrawableShares,) = delegationManager.getWithdrawableShares(staker, strategiesToReturn); _assertWithdrawableAndOperatorShares( withdrawableShares[0], delegationManager.operatorShares(defaultOperator, strategyMock), @@ -2865,8 +2760,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // verify that the salt is still marked as unused (since it wasn't checked or used) assertFalse( delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - salt + delegationManager.delegationApprover(defaultOperator), salt ), "salt somehow spent too incorrectly?" ); @@ -2874,8 +2768,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // verify that the salt is marked as used assertTrue( delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - salt + delegationManager.delegationApprover(defaultOperator), salt ), "salt somehow spent not spent?" ); @@ -2899,12 +2792,12 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { _registerOperatorWithDelegationApprover(defaultOperator); // create the signature struct - ISignatureUtils.SignatureWithExpiry memory approverSignatureAndExpiry; + ISignatureUtilsMixinTypes.SignatureWithExpiry memory approverSignatureAndExpiry; approverSignatureAndExpiry.expiry = expiry; // try to delegate from the `staker` to the operator, and check reversion cheats.startPrank(staker); - cheats.expectRevert(ISignatureUtils.SignatureExpired.selector); + cheats.expectRevert(ISignatureUtilsMixinErrors.SignatureExpired.selector); delegationManager.delegateTo(defaultOperator, approverSignatureAndExpiry, emptySalt); cheats.stopPrank(); } @@ -2926,7 +2819,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { _registerOperatorWith1271DelegationApprover(defaultOperator); // calculate the delegationSigner's signature - ISignatureUtils.SignatureWithExpiry memory approverSignatureAndExpiry = _getApproverSignature( + ISignatureUtilsMixinTypes.SignatureWithExpiry memory approverSignatureAndExpiry = _getApproverSignature( delegationSignerPrivateKey, staker, defaultOperator, @@ -2961,7 +2854,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { _registerOperator(defaultOperator, address(wallet), emptyStringForMetadataURI); // create the signature struct - ISignatureUtils.SignatureWithExpiry memory approverSignatureAndExpiry; + ISignatureUtilsMixinTypes.SignatureWithExpiry memory approverSignatureAndExpiry; approverSignatureAndExpiry.expiry = expiry; // try to delegate from the `staker` to the operator, and check reversion @@ -2990,7 +2883,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // calculate the delegationSigner's but this is not the correct signature from the wallet contract // since the wallet owner is address(1) - ISignatureUtils.SignatureWithExpiry memory approverSignatureAndExpiry = _getApproverSignature( + ISignatureUtilsMixinTypes.SignatureWithExpiry memory approverSignatureAndExpiry = _getApproverSignature( delegationSignerPrivateKey, staker, defaultOperator, @@ -3001,7 +2894,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // try to delegate from the `staker` to the operator, and check reversion cheats.startPrank(staker); // Signature should fail as the wallet will not return EIP1271_MAGICVALUE - cheats.expectRevert(ISignatureUtils.InvalidSignature.selector); + cheats.expectRevert(ISignatureUtilsMixinErrors.InvalidSignature.selector); delegationManager.delegateTo(defaultOperator, approverSignatureAndExpiry, emptySalt); cheats.stopPrank(); } @@ -3016,7 +2909,9 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { * Reverts if the staker is already delegated (to the operator or to anyone else) * Reverts if the ‘operator’ is not actually registered as an operator */ - function testFuzz_OperatorWhoRequiresEIP1271Signature(Randomness r) public rand(r) { + function testFuzz_OperatorWhoRequiresEIP1271Signature( + Randomness r + ) public rand(r) { address staker = r.Address(); bytes32 salt = r.Bytes32(); uint256 expiry = r.Uint256(block.timestamp, type(uint256).max); @@ -3025,14 +2920,11 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // verify that the salt hasn't been used before assertFalse( - delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - salt - ), + delegationManager.delegationApproverSaltIsSpent(delegationManager.delegationApprover(defaultOperator), salt), "salt somehow spent too early?" ); // calculate the delegationSigner's signature - ISignatureUtils.SignatureWithExpiry memory approverSignatureAndExpiry = _getApproverSignature( + ISignatureUtilsMixinTypes.SignatureWithExpiry memory approverSignatureAndExpiry = _getApproverSignature( delegationSignerPrivateKey, staker, defaultOperator, @@ -3056,8 +2948,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // verify that the salt is still marked as unused (since it wasn't checked or used) assertFalse( delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - salt + delegationManager.delegationApprover(defaultOperator), salt ), "salt somehow spent too incorrectly?" ); @@ -3065,8 +2956,7 @@ contract DelegationManagerUnitTests_delegateTo is DelegationManagerUnitTests { // verify that the salt is marked as used assertTrue( delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(defaultOperator), - salt + delegationManager.delegationApprover(defaultOperator), salt ), "salt somehow spent not spent?" ); @@ -3080,7 +2970,9 @@ contract DelegationManagerUnitTests_increaseDelegatedShares is DelegationManager using Math for *; /// @notice Verifies that `DelegationManager.increaseDelegatedShares` reverts if not called by the StrategyManager nor EigenPodManager - function testFuzz_Revert_increaseDelegatedShares_invalidCaller(Randomness r) public rand(r) { + function testFuzz_Revert_increaseDelegatedShares_invalidCaller( + Randomness r + ) public rand(r) { address invalidCaller = r.Address(); uint256 shares = r.Uint256(1, MAX_STRATEGY_SHARES); cheats.expectRevert(IDelegationManagerErrors.OnlyStrategyManagerOrEigenPodManager.selector); @@ -3100,27 +2992,19 @@ contract DelegationManagerUnitTests_increaseDelegatedShares is DelegationManager // Register operator _registerOperatorWithBaseDetails(defaultOperator); // Set operator magnitude - _setOperatorMagnitude({ - operator: defaultOperator, - strategy: strategyMock, - magnitude: 0 - }); + _setOperatorMagnitude({operator: defaultOperator, strategy: strategyMock, magnitude: 0}); // delegate from the `staker` to the operator _delegateToOperatorWhoAcceptsAllStakers(staker, defaultOperator); - uint256 _delegatedSharesBefore = delegationManager.operatorShares( - delegationManager.delegatedTo(staker), - strategyMock - ); + uint256 _delegatedSharesBefore = + delegationManager.operatorShares(delegationManager.delegatedTo(staker), strategyMock); cheats.prank(address(strategyManagerMock)); cheats.expectRevert(FullySlashed.selector); delegationManager.increaseDelegatedShares(staker, strategyMock, 0, shares); - uint256 delegatedSharesAfter = delegationManager.operatorShares( - delegationManager.delegatedTo(staker), - strategyMock - ); + uint256 delegatedSharesAfter = + delegationManager.operatorShares(delegationManager.delegatedTo(staker), strategyMock); assertEq(delegatedSharesAfter, _delegatedSharesBefore, "delegated shares incremented incorrectly"); assertEq(_delegatedSharesBefore, 0, "nonzero shares delegated to zero address!"); @@ -3143,11 +3027,7 @@ contract DelegationManagerUnitTests_increaseDelegatedShares is DelegationManager // 1. Register operator with initial operator magnitude and delegate staker to operator _registerOperatorWithBaseDetails(defaultOperator); - _setOperatorMagnitude({ - operator: defaultOperator, - strategy: strategyMock, - magnitude: initialMagnitude - }); + _setOperatorMagnitude({operator: defaultOperator, strategy: strategyMock, magnitude: initialMagnitude}); _delegateToOperatorWhoAcceptsAllStakers(staker, defaultOperator); // 2. set staker initial shares and increase delegated shares IStrategy[] memory strategiesDeposited = strategyMock.toArray(); @@ -3167,18 +3047,14 @@ contract DelegationManagerUnitTests_increaseDelegatedShares is DelegationManager prevDsf: WAD, depositAmount: existingShares }); - (uint256[] memory withdrawableShares, ) = delegationManager.getWithdrawableShares(staker, strategiesDeposited); + (uint256[] memory withdrawableShares,) = delegationManager.getWithdrawableShares(staker, strategiesDeposited); _assertWithdrawableAndOperatorShares( withdrawableShares[0], delegationManager.operatorShares(defaultOperator, strategyMock), "Shares not increased correctly" ); // 3. Now set operator magnitude to 0 (100% slashed) - _setOperatorMagnitude({ - operator: defaultOperator, - strategy: strategyMock, - magnitude: 0 - }); + _setOperatorMagnitude({operator: defaultOperator, strategy: strategyMock, magnitude: 0}); // 4. Try to "redeposit" and expect a revert since strategy is 100% slashed // staker's withdrawable shares should also be 0 now @@ -3186,16 +3062,14 @@ contract DelegationManagerUnitTests_increaseDelegatedShares is DelegationManager cheats.expectRevert(FullySlashed.selector); delegationManager.increaseDelegatedShares(staker, strategyMock, existingShares, shares); - (withdrawableShares, ) = delegationManager.getWithdrawableShares(staker, strategiesDeposited); - assertEq( - withdrawableShares[0], - 0, - "All existing shares should be slashed" - ); + (withdrawableShares,) = delegationManager.getWithdrawableShares(staker, strategiesDeposited); + assertEq(withdrawableShares[0], 0, "All existing shares should be slashed"); } /// @notice Verifies that there is no change in operatorShares if the staker is not delegated - function testFuzz_increaseDelegatedShares_noop(Randomness r) public rand(r) { + function testFuzz_increaseDelegatedShares_noop( + Randomness r + ) public rand(r) { address staker = r.Address(); _registerOperatorWithBaseDetails(defaultOperator); assertFalse(delegationManager.isDelegated(staker), "bad test setup"); @@ -3211,10 +3085,12 @@ contract DelegationManagerUnitTests_increaseDelegatedShares is DelegationManager * Asserts: * - depositScalingFactor, depositShares, withdrawableShares, operatorShares after deposit * - correct operator shares after deposit - + * * @dev Checks that there is no change if the staker is not delegated */ - function testFuzz_increaseDelegatedShares(Randomness r) public rand(r) { + function testFuzz_increaseDelegatedShares( + Randomness r + ) public rand(r) { address staker = r.Address(); uint256 shares = r.Uint256(1, MAX_STRATEGY_SHARES); bool delegateFromStakerToOperator = r.Boolean(); @@ -3225,10 +3101,8 @@ contract DelegationManagerUnitTests_increaseDelegatedShares is DelegationManager if (delegateFromStakerToOperator) { _delegateToOperatorWhoAcceptsAllStakers(staker, defaultOperator); } - uint256 delegatedSharesBefore = delegationManager.operatorShares( - delegationManager.delegatedTo(staker), - strategyMock - ); + uint256 delegatedSharesBefore = + delegationManager.operatorShares(delegationManager.delegatedTo(staker), strategyMock); // deposit and increase delegated shares strategyManagerMock.addDeposit(staker, strategyMock, shares); @@ -3258,12 +3132,10 @@ contract DelegationManagerUnitTests_increaseDelegatedShares is DelegationManager // Assert correct end state values uint256 delegatedSharesAfter = delegationManager.operatorShares(defaultOperator, strategyMock); - (uint256[] memory withdrawableShares, ) = delegationManager.getWithdrawableShares(staker, strategyMock.toArray()); + (uint256[] memory withdrawableShares,) = delegationManager.getWithdrawableShares(staker, strategyMock.toArray()); if (delegationManager.isDelegated(staker)) { _assertWithdrawableAndOperatorShares( - withdrawableShares[0], - delegatedSharesAfter, - "Invalid withdrawable shares" + withdrawableShares[0], delegatedSharesAfter, "Invalid withdrawable shares" ); } else { assertEq(delegatedSharesAfter, delegatedSharesBefore, "delegated shares incremented incorrectly"); @@ -3271,7 +3143,9 @@ contract DelegationManagerUnitTests_increaseDelegatedShares is DelegationManager } } - function testFuzz_increaseDelegatedShares_beaconChainShares(Randomness r) public rand(r) { + function testFuzz_increaseDelegatedShares_beaconChainShares( + Randomness r + ) public rand(r) { address staker = r.Address(); uint256 shares = r.Uint256(1, MAX_ETH_SUPPLY); uint64 beaconChainSlashingFactor = r.Uint64(1, WAD); @@ -3280,10 +3154,8 @@ contract DelegationManagerUnitTests_increaseDelegatedShares is DelegationManager _registerOperatorWithBaseDetails(defaultOperator); // delegate from the `staker` to the operator *if `delegateFromStakerToOperator` is 'true'* _delegateToOperatorWhoAcceptsAllStakers(staker, defaultOperator); - uint256 delegatedSharesBefore = delegationManager.operatorShares( - delegationManager.delegatedTo(staker), - beaconChainETHStrategy - ); + uint256 delegatedSharesBefore = + delegationManager.operatorShares(delegationManager.delegatedTo(staker), beaconChainETHStrategy); // deposit and increase delegated shares eigenPodManagerMock.setPodOwnerShares(staker, int256(shares)); @@ -3312,12 +3184,9 @@ contract DelegationManagerUnitTests_increaseDelegatedShares is DelegationManager // Assert correct end state values uint256 delegatedSharesAfter = delegationManager.operatorShares(defaultOperator, beaconChainETHStrategy); - (uint256[] memory withdrawableShares, ) = delegationManager.getWithdrawableShares(staker, beaconChainETHStrategy.toArray()); - _assertWithdrawableAndOperatorShares( - withdrawableShares[0], - delegatedSharesAfter, - "Invalid withdrawable shares" - ); + (uint256[] memory withdrawableShares,) = + delegationManager.getWithdrawableShares(staker, beaconChainETHStrategy.toArray()); + _assertWithdrawableAndOperatorShares(withdrawableShares[0], delegatedSharesAfter, "Invalid withdrawable shares"); } /** @@ -3325,7 +3194,9 @@ contract DelegationManagerUnitTests_increaseDelegatedShares is DelegationManager * who the `staker` is delegated to has in the strategy * @dev Checks that there is no change if the staker is not delegated */ - function testFuzz_increaseDelegatedShares_slashedOperator(Randomness r) public rand(r) { + function testFuzz_increaseDelegatedShares_slashedOperator( + Randomness r + ) public rand(r) { address staker = r.Address(); uint256 shares = r.Uint256(1, MAX_STRATEGY_SHARES); uint64 magnitude = r.Uint64(1, WAD); @@ -3333,7 +3204,7 @@ contract DelegationManagerUnitTests_increaseDelegatedShares is DelegationManager // Register operator _registerOperatorWithBaseDetails(defaultOperator); - + // Set operator magnitude _setOperatorMagnitude(defaultOperator, strategyMock, magnitude); @@ -3341,10 +3212,8 @@ contract DelegationManagerUnitTests_increaseDelegatedShares is DelegationManager if (delegateFromStakerToOperator) { _delegateToOperatorWhoAcceptsAllStakers(staker, defaultOperator); } - uint256 delegatedSharesBefore = delegationManager.operatorShares( - delegationManager.delegatedTo(staker), - strategyMock - ); + uint256 delegatedSharesBefore = + delegationManager.operatorShares(delegationManager.delegatedTo(staker), strategyMock); strategyManagerMock.addDeposit(staker, strategyMock, shares); if (delegationManager.isDelegated(staker)) { @@ -3374,13 +3243,11 @@ contract DelegationManagerUnitTests_increaseDelegatedShares is DelegationManager // Assert correct values uint256 delegatedSharesAfter = delegationManager.operatorShares(defaultOperator, strategyMock); - (uint256[] memory withdrawableShares, ) = delegationManager.getWithdrawableShares(staker, strategyMock.toArray()); + (uint256[] memory withdrawableShares,) = delegationManager.getWithdrawableShares(staker, strategyMock.toArray()); if (delegationManager.isDelegated(staker)) { _assertWithdrawableAndOperatorShares( - withdrawableShares[0], - delegatedSharesAfter, - "Invalid withdrawable shares" + withdrawableShares[0], delegatedSharesAfter, "Invalid withdrawable shares" ); } else { assertEq(delegatedSharesAfter, delegatedSharesBefore, "delegated shares incremented incorrectly"); @@ -3390,10 +3257,12 @@ contract DelegationManagerUnitTests_increaseDelegatedShares is DelegationManager /** * @notice Verifies that `DelegationManager.increaseDelegatedShares` properly increases the delegated `shares` for the - * `defaultOperator` who the staker is delegated to. Asserts for proper events emitted and correct withdrawable shares, + * `defaultOperator` who the staker is delegated to. Asserts for proper events emitted and correct withdrawable shares, * despoitScalingFactor for the staker, and operator shares after deposit. */ - function testFuzz_increaseDelegatedShares_slashedOperatorAndBeaconChainShares(Randomness r) public rand(r) { + function testFuzz_increaseDelegatedShares_slashedOperatorAndBeaconChainShares( + Randomness r + ) public rand(r) { address staker = r.Address(); uint256 shares = r.Uint256(1, MAX_ETH_SUPPLY); uint64 maxMagnitude = r.Uint64(1, WAD); @@ -3405,10 +3274,8 @@ contract DelegationManagerUnitTests_increaseDelegatedShares is DelegationManager _setOperatorMagnitude(defaultOperator, beaconChainETHStrategy, maxMagnitude); // delegate from the `staker` to the operator *if `delegateFromStakerToOperator` is 'true'* _delegateToOperatorWhoAcceptsAllStakers(staker, defaultOperator); - uint256 delegatedSharesBefore = delegationManager.operatorShares( - delegationManager.delegatedTo(staker), - beaconChainETHStrategy - ); + uint256 delegatedSharesBefore = + delegationManager.operatorShares(delegationManager.delegatedTo(staker), beaconChainETHStrategy); // deposit and increase delegated shares eigenPodManagerMock.setPodOwnerShares(staker, int256(shares)); @@ -3437,12 +3304,9 @@ contract DelegationManagerUnitTests_increaseDelegatedShares is DelegationManager // Assert correct end state values uint256 delegatedSharesAfter = delegationManager.operatorShares(defaultOperator, beaconChainETHStrategy); - (uint256[] memory withdrawableShares, ) = delegationManager.getWithdrawableShares(staker, beaconChainETHStrategy.toArray()); - _assertWithdrawableAndOperatorShares( - withdrawableShares[0], - delegatedSharesAfter, - "Invalid withdrawable shares" - ); + (uint256[] memory withdrawableShares,) = + delegationManager.getWithdrawableShares(staker, beaconChainETHStrategy.toArray()); + _assertWithdrawableAndOperatorShares(withdrawableShares[0], delegatedSharesAfter, "Invalid withdrawable shares"); } /** @@ -3461,24 +3325,14 @@ contract DelegationManagerUnitTests_increaseDelegatedShares is DelegationManager // Register operator _registerOperatorWithBaseDetails(defaultOperator); // Set operator magnitude for 100% slashed strategy - _setOperatorMagnitude({ - operator: defaultOperator, - strategy: strategyMock, - magnitude: 0 - }); + _setOperatorMagnitude({operator: defaultOperator, strategy: strategyMock, magnitude: 0}); // Set operator magnitude for non-100% slashed strategy - _setOperatorMagnitude({ - operator: defaultOperator, - strategy: strategy, - magnitude: magnitude - }); + _setOperatorMagnitude({operator: defaultOperator, strategy: strategy, magnitude: magnitude}); // delegate from the `staker` to the operator _delegateToOperatorWhoAcceptsAllStakers(staker, defaultOperator); - uint256 delegatedSharesBefore = delegationManager.operatorShares( - delegationManager.delegatedTo(staker), - strategy - ); + uint256 delegatedSharesBefore = + delegationManager.operatorShares(delegationManager.delegatedTo(staker), strategy); // deposit and increaseDelegatedShares strategyManagerMock.addDeposit(staker, strategy, shares); @@ -3508,16 +3362,9 @@ contract DelegationManagerUnitTests_increaseDelegatedShares is DelegationManager }); // Assert correct end state values - (uint256[] memory withdrawableShares, ) = delegationManager.getWithdrawableShares(staker, strategyArray); - uint256 delegatedSharesAfter = delegationManager.operatorShares( - delegationManager.delegatedTo(staker), - strategy - ); - _assertWithdrawableAndOperatorShares( - withdrawableShares[0], - delegatedSharesAfter, - "Invalid withdrawable shares" - ); + (uint256[] memory withdrawableShares,) = delegationManager.getWithdrawableShares(staker, strategyArray); + uint256 delegatedSharesAfter = delegationManager.operatorShares(delegationManager.delegatedTo(staker), strategy); + _assertWithdrawableAndOperatorShares(withdrawableShares[0], delegatedSharesAfter, "Invalid withdrawable shares"); } /** @@ -3528,13 +3375,13 @@ contract DelegationManagerUnitTests_increaseDelegatedShares is DelegationManager * The test below results in a drift difference of 4.418e13 */ function test_increaseDelegatedShares_depositRepeatedly() public { - uint64 initialMagnitude = 999999999999990009; - uint256 shares = 44182209037560531097078597505; + uint64 initialMagnitude = 999_999_999_999_990_009; + uint256 shares = 44_182_209_037_560_531_097_078_597_505; // register *this contract* as an operator _registerOperatorWithBaseDetails(defaultOperator); _setOperatorMagnitude(defaultOperator, strategyMock, initialMagnitude); - + // Set the staker deposits in the strategies IStrategy[] memory strategies = strategyMock.toArray(); strategyManagerMock.addDeposit(defaultStaker, strategyMock, shares); @@ -3554,14 +3401,12 @@ contract DelegationManagerUnitTests_increaseDelegatedShares is DelegationManager } } - ( - uint256[] memory withdrawableShares, - uint256[] memory depositShares - ) = delegationManager.getWithdrawableShares(defaultStaker, strategies); + (uint256[] memory withdrawableShares, uint256[] memory depositShares) = + delegationManager.getWithdrawableShares(defaultStaker, strategies); assertEq(depositShares[0], shares, "staker deposit shares not reset correctly"); assertEq( delegationManager.operatorShares(defaultOperator, strategyMock) - withdrawableShares[0], - 44182209037566, + 44_182_209_037_566, "drift should be 4.418e13 from previous tests" ); } @@ -3572,7 +3417,9 @@ contract DelegationManagerUnitTests_decreaseDelegatedShares is DelegationManager using SlashingLib for *; using Math for *; - function testFuzz_Revert_decreaseDelegatedShares_invalidCaller(Randomness r) public rand(r) { + function testFuzz_Revert_decreaseDelegatedShares_invalidCaller( + Randomness r + ) public rand(r) { address invalidCaller = r.Address(); address staker = r.Address(); uint256 shares = r.Uint256(1, MAX_STRATEGY_SHARES); @@ -3583,7 +3430,9 @@ contract DelegationManagerUnitTests_decreaseDelegatedShares is DelegationManager } /// @notice Verifies that there is no change in operatorShares if the staker is not delegated - function testFuzz_decreaseDelegatedShares_noop(Randomness r) public rand(r) { + function testFuzz_decreaseDelegatedShares_noop( + Randomness r + ) public rand(r) { address staker = r.Address(); uint256 shares = r.Uint256(1, MAX_STRATEGY_SHARES); uint64 beaconChainSlashingFactorDecrease = uint64(r.Uint256(0, WAD)); @@ -3603,7 +3452,9 @@ contract DelegationManagerUnitTests_decreaseDelegatedShares is DelegationManager * Ensures that after the decrease, the staker's withdrawableShares <= operatorShares, * preventing any underflow for the operator's shares if they were all to be withdrawn. */ - function testFuzz_decreaseDelegatedShares_nonSlashedOperator(Randomness r) public rand(r) { + function testFuzz_decreaseDelegatedShares_nonSlashedOperator( + Randomness r + ) public rand(r) { int256 beaconShares = int256(r.Uint256(1, MAX_ETH_SUPPLY)); uint256 sharesDecrease = r.Uint256(0, uint256(beaconShares) - 1); uint64 beaconChainSlashingFactor = r.Uint64(1, WAD); @@ -3612,30 +3463,24 @@ contract DelegationManagerUnitTests_decreaseDelegatedShares is DelegationManager _registerOperatorWithBaseDetails(defaultOperator); eigenPodManagerMock.setPodOwnerShares(defaultStaker, beaconShares); eigenPodManagerMock.setBeaconChainSlashingFactor(defaultStaker, beaconChainSlashingFactor); + (uint256[] memory withdrawableShares,) = delegationManager.getWithdrawableShares(defaultStaker, beaconChainETHStrategy.toArray()); _delegateToOperatorWhoAcceptsAllStakers(defaultStaker, defaultOperator); - _assertDeposit({ + _assertDelegation({ staker: defaultStaker, operator: defaultOperator, strategy: beaconChainETHStrategy, operatorSharesBefore: 0, - withdrawableSharesBefore: 0, - depositSharesBefore: 0, - prevDsf: WAD, - depositAmount: uint256(beaconShares) + withdrawableSharesBefore: withdrawableShares[0], + depositSharesBefore: uint256(beaconShares), + prevDsf: WAD }); // 2. Perform beaconChain slash + decreaseDelegatedShares() - ( - uint64 prevBeaconSlashingFactor, - uint64 newBeaconSlashingFactor - ) = _setNewBeaconChainSlashingFactor(defaultStaker, beaconShares, sharesDecrease); + (uint64 prevBeaconSlashingFactor, uint64 newBeaconSlashingFactor) = + _setNewBeaconChainSlashingFactor(defaultStaker, beaconShares, sharesDecrease); uint64 beaconChainSlashingFactorDecrease = prevBeaconSlashingFactor - newBeaconSlashingFactor; - assertEq( - beaconChainSlashingFactor, - prevBeaconSlashingFactor, - "Bad test setup" - ); - uint256 depositScalingFactor = uint256(WAD).divWad(beaconChainSlashingFactor); + assertEq(beaconChainSlashingFactor, prevBeaconSlashingFactor, "Bad test setup"); + uint256 depositScalingFactor = uint256(WAD); // expected operatorShares decreased for event uint256 operatorSharesToDecrease = _calcWithdrawableShares({ depositShares: uint256(beaconShares), @@ -3651,7 +3496,9 @@ contract DelegationManagerUnitTests_decreaseDelegatedShares is DelegationManager }) ); cheats.prank(address(eigenPodManagerMock)); - delegationManager.decreaseDelegatedShares(defaultStaker, uint256(beaconShares), beaconChainSlashingFactorDecrease); + delegationManager.decreaseDelegatedShares( + defaultStaker, uint256(beaconShares), beaconChainSlashingFactorDecrease + ); // 3. Assert correct values uint256 expectedWithdrawableShares = _calcWithdrawableShares({ @@ -3661,16 +3508,17 @@ contract DelegationManagerUnitTests_decreaseDelegatedShares is DelegationManager }); _assertSharesAfterBeaconSlash({ staker: defaultStaker, - withdrawableSharesBefore: uint256(beaconShares), + withdrawableSharesBefore: withdrawableShares[0], expectedWithdrawableShares: expectedWithdrawableShares, prevBeaconSlashingFactor: prevBeaconSlashingFactor }); // Assert correct end state values - (uint256[] memory withdrawableSharesAfter, ) = delegationManager.getWithdrawableShares(defaultStaker, beaconChainETHStrategy.toArray()); + (uint256[] memory withdrawableSharesAfter,) = + delegationManager.getWithdrawableShares(defaultStaker, beaconChainETHStrategy.toArray()); assertEq( delegationManager.operatorShares(defaultOperator, beaconChainETHStrategy) + operatorSharesToDecrease, - uint256(beaconShares), + withdrawableShares[0], "operator shares not decreased correctly" ); @@ -3689,7 +3537,9 @@ contract DelegationManagerUnitTests_decreaseDelegatedShares is DelegationManager * Ensures that after the decrease, the staker's withdrawableShares <= operatorShares, * preventing any underflow for the operator's shares if they were all to be withdrawn. */ - function testFuzz_decreaseDelegatedShares_slashedOperator(Randomness r) public rand(r) { + function testFuzz_decreaseDelegatedShares_slashedOperator( + Randomness r + ) public rand(r) { int256 beaconShares = int256(r.Uint256(1, MAX_ETH_SUPPLY)); uint256 sharesDecrease = r.Uint256(0, uint256(beaconShares) - 1); uint64 maxMagnitude = r.Uint64(1, WAD - 1); @@ -3700,30 +3550,24 @@ contract DelegationManagerUnitTests_decreaseDelegatedShares is DelegationManager _setOperatorMagnitude(defaultOperator, beaconChainETHStrategy, maxMagnitude); eigenPodManagerMock.setPodOwnerShares(defaultStaker, beaconShares); eigenPodManagerMock.setBeaconChainSlashingFactor(defaultStaker, beaconChainSlashingFactor); + (uint256[] memory withdrawableShares,) = delegationManager.getWithdrawableShares(defaultStaker, beaconChainETHStrategy.toArray()); _delegateToOperatorWhoAcceptsAllStakers(defaultStaker, defaultOperator); - _assertDeposit({ + _assertDelegation({ staker: defaultStaker, operator: defaultOperator, strategy: beaconChainETHStrategy, operatorSharesBefore: 0, - withdrawableSharesBefore: 0, - depositSharesBefore: 0, - prevDsf: WAD, - depositAmount: uint256(beaconShares) + withdrawableSharesBefore: withdrawableShares[0], + depositSharesBefore: uint256(beaconShares), + prevDsf: WAD }); // 2. Perform beaconChain slash + decreaseDelegatedShares() - ( - uint64 prevBeaconSlashingFactor, - uint64 newBeaconSlashingFactor - ) = _setNewBeaconChainSlashingFactor(defaultStaker, beaconShares, sharesDecrease); + (uint64 prevBeaconSlashingFactor, uint64 newBeaconSlashingFactor) = + _setNewBeaconChainSlashingFactor(defaultStaker, beaconShares, sharesDecrease); uint64 beaconChainSlashingFactorDecrease = prevBeaconSlashingFactor - newBeaconSlashingFactor; - assertEq( - beaconChainSlashingFactor, - prevBeaconSlashingFactor, - "Bad test setup" - ); - uint256 depositScalingFactor = uint256(WAD).divWad(maxMagnitude.mulWad(beaconChainSlashingFactor)); + assertEq(beaconChainSlashingFactor, prevBeaconSlashingFactor, "Bad test setup"); + uint256 depositScalingFactor = uint256(WAD).divWad(maxMagnitude); // expected operatorShares decreased for event uint256 operatorSharesToDecrease = _calcWithdrawableShares({ depositShares: uint256(beaconShares), @@ -3739,7 +3583,9 @@ contract DelegationManagerUnitTests_decreaseDelegatedShares is DelegationManager }) ); cheats.prank(address(eigenPodManagerMock)); - delegationManager.decreaseDelegatedShares(defaultStaker, uint256(beaconShares), beaconChainSlashingFactorDecrease); + delegationManager.decreaseDelegatedShares( + defaultStaker, uint256(beaconShares), beaconChainSlashingFactorDecrease + ); // 3. Assert correct values uint256 expectedWithdrawableShares = _calcWithdrawableShares({ @@ -3749,16 +3595,17 @@ contract DelegationManagerUnitTests_decreaseDelegatedShares is DelegationManager }); _assertSharesAfterBeaconSlash({ staker: defaultStaker, - withdrawableSharesBefore: uint256(beaconShares), + withdrawableSharesBefore: withdrawableShares[0], expectedWithdrawableShares: expectedWithdrawableShares, prevBeaconSlashingFactor: prevBeaconSlashingFactor }); // Assert correct end state values - (uint256[] memory withdrawableSharesAfter, ) = delegationManager.getWithdrawableShares(defaultStaker, beaconChainETHStrategy.toArray()); + (uint256[] memory withdrawableSharesAfter,) = + delegationManager.getWithdrawableShares(defaultStaker, beaconChainETHStrategy.toArray()); assertEq( delegationManager.operatorShares(defaultOperator, beaconChainETHStrategy) + operatorSharesToDecrease, - uint256(beaconShares), + withdrawableShares[0], "operator shares not decreased correctly" ); @@ -3774,7 +3621,9 @@ contract DelegationManagerUnitTests_decreaseDelegatedShares is DelegationManager * is slashed. Their withdrawable shares should be 0 afterwards and decreasing operatorShares should * not underflow and revert either. */ - function testFuzz_decreaseDelegatedShares_entireBalance(Randomness r) public rand(r) { + function testFuzz_decreaseDelegatedShares_entireBalance( + Randomness r + ) public rand(r) { int256 beaconShares = int256(r.Uint256(1, MAX_ETH_SUPPLY)); uint64 maxMagnitude = r.Uint64(1, WAD); uint64 beaconChainSlashingFactor = r.Uint64(1, WAD); @@ -3784,30 +3633,24 @@ contract DelegationManagerUnitTests_decreaseDelegatedShares is DelegationManager _setOperatorMagnitude(defaultOperator, beaconChainETHStrategy, maxMagnitude); eigenPodManagerMock.setPodOwnerShares(defaultStaker, beaconShares); eigenPodManagerMock.setBeaconChainSlashingFactor(defaultStaker, beaconChainSlashingFactor); + (uint256[] memory withdrawableShares,) = delegationManager.getWithdrawableShares(defaultStaker, beaconChainETHStrategy.toArray()); _delegateToOperatorWhoAcceptsAllStakers(defaultStaker, defaultOperator); - _assertDeposit({ + _assertDelegation({ staker: defaultStaker, operator: defaultOperator, strategy: beaconChainETHStrategy, operatorSharesBefore: 0, - withdrawableSharesBefore: 0, - depositSharesBefore: 0, - prevDsf: WAD, - depositAmount: uint256(beaconShares) + withdrawableSharesBefore: withdrawableShares[0], + depositSharesBefore: uint256(beaconShares), + prevDsf: WAD }); // 2. Perform beaconChain slash + decreaseDelegatedShares() - ( - uint64 prevBeaconSlashingFactor, - uint64 newBeaconSlashingFactor - ) = _setNewBeaconChainSlashingFactor(defaultStaker, beaconShares, uint256(beaconShares)); - assertEq( - beaconChainSlashingFactor, - prevBeaconSlashingFactor, - "Bad test setup" - ); + (uint64 prevBeaconSlashingFactor, uint64 newBeaconSlashingFactor) = + _setNewBeaconChainSlashingFactor(defaultStaker, beaconShares, uint256(beaconShares)); + assertEq(beaconChainSlashingFactor, prevBeaconSlashingFactor, "Bad test setup"); uint64 beaconChainSlashingFactorDecrease = prevBeaconSlashingFactor - newBeaconSlashingFactor; - uint256 depositScalingFactor = uint256(WAD).divWad(maxMagnitude.mulWad(beaconChainSlashingFactor)); + uint256 depositScalingFactor = uint256(WAD).divWad(maxMagnitude); // expected operatorShares decreased for event uint256 operatorSharesToDecrease = _calcWithdrawableShares({ depositShares: uint256(beaconShares), @@ -3831,25 +3674,19 @@ contract DelegationManagerUnitTests_decreaseDelegatedShares is DelegationManager depositScalingFactor: depositScalingFactor, slashingFactor: maxMagnitude.mulWad(newBeaconSlashingFactor) }); + assertEq(expectedWithdrawableShares, 0, "All shares should be slashed"); assertEq( - expectedWithdrawableShares, - 0, - "All shares should be slashed" - ); - assertEq( - eigenPodManagerMock.beaconChainSlashingFactor(defaultStaker), - 0, - "beaconChainSlashingFactor should be 0" + eigenPodManagerMock.beaconChainSlashingFactor(defaultStaker), 0, "beaconChainSlashingFactor should be 0" ); _assertSharesAfterBeaconSlash({ staker: defaultStaker, - withdrawableSharesBefore: uint256(beaconShares), + withdrawableSharesBefore: withdrawableShares[0], expectedWithdrawableShares: expectedWithdrawableShares, prevBeaconSlashingFactor: prevBeaconSlashingFactor }); assertEq( delegationManager.operatorShares(defaultOperator, beaconChainETHStrategy) + operatorSharesToDecrease, - uint256(beaconShares), + withdrawableShares[0], "operator shares not decreased correctly" ); } @@ -3861,7 +3698,9 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { using Math for uint256; // @notice Verifies that undelegating is not possible when the "undelegation paused" switch is flipped - function testFuzz_Revert_undelegate_paused(Randomness r) public rand(r) { + function testFuzz_Revert_undelegate_paused( + Randomness r + ) public rand(r) { address staker = r.Address(); address operator = r.Address(); _registerOperatorWithBaseDetails(operator); @@ -3875,7 +3714,9 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { delegationManager.undelegate(staker); } - function testFuzz_Revert_undelegate_notDelegated(Randomness r) public rand(r) { + function testFuzz_Revert_undelegate_notDelegated( + Randomness r + ) public rand(r) { address undelegatedStaker = r.Address(); assertFalse(delegationManager.isDelegated(undelegatedStaker), "bad test setup"); @@ -3885,7 +3726,9 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { } // @notice Verifies that an operator cannot undelegate from themself (this should always be forbidden) - function testFuzz_Revert_undelegate_stakerIsOperator(Randomness r) public rand(r) { + function testFuzz_Revert_undelegate_stakerIsOperator( + Randomness r + ) public rand(r) { address operator = r.Address(); _registerOperatorWithBaseDetails(operator); @@ -3923,7 +3766,9 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { * @notice Verifies that the `undelegate` function has proper access controls (can only be called by the operator who the `staker` has delegated * to or the operator's `delegationApprover`), or the staker themselves */ - function testFuzz_Revert_undelegate_invalidCaller(Randomness r) public rand(r) { + function testFuzz_Revert_undelegate_invalidCaller( + Randomness r + ) public rand(r) { address invalidCaller = r.Address(); address staker = r.Address(); @@ -3942,9 +3787,11 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { * Properly undelegates the staker, i.e. the staker becomes “delegated to” the zero address, and `isDelegated(staker)` returns ‘false’ * Emits a `StakerUndelegated` event */ - function testFuzz_undelegate_noDelegateableShares(Randomness r) public rand(r) { + function testFuzz_undelegate_noDelegateableShares( + Randomness r + ) public rand(r) { address staker = r.Address(); - + // register *this contract* as an operator and delegate from the `staker` to them _registerOperatorWithBaseDetails(defaultOperator); _delegateToOperatorWhoAcceptsAllStakers(staker, defaultOperator); @@ -3956,9 +3803,7 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { assertEq(withdrawalRoots.length, 0, "withdrawalRoot should be an empty array"); assertEq( - delegationManager.delegatedTo(staker), - address(0), - "undelegated staker should be delegated to zero address" + delegationManager.delegatedTo(staker), address(0), "undelegated staker should be delegated to zero address" ); assertFalse(delegationManager.isDelegated(staker), "staker not undelegated"); } @@ -3966,7 +3811,9 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { /** * @notice Verifies that the `undelegate` function allows for a force undelegation */ - function testFuzz_undelegate_forceUndelegation_noDelegateableShares(Randomness r) public rand(r) { + function testFuzz_undelegate_forceUndelegation_noDelegateableShares( + Randomness r + ) public rand(r) { address staker = r.Address(); bytes32 salt = r.Bytes32(); bool callFromOperatorOrApprover = r.Boolean(); @@ -4000,9 +3847,7 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { assertEq(withdrawalRoots.length, 0, "withdrawalRoot should be an empty array"); assertEq( - delegationManager.delegatedTo(staker), - address(0), - "undelegated staker should be delegated to zero address" + delegationManager.delegatedTo(staker), address(0), "undelegated staker should be delegated to zero address" ); assertFalse(delegationManager.isDelegated(staker), "staker not undelegated"); } @@ -4010,7 +3855,9 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { /** * @notice Verifies that the `undelegate` function properly queues a withdrawal for all shares of the staker */ - function testFuzz_undelegate_nonSlashedOperator(Randomness r) public rand(r) { + function testFuzz_undelegate_nonSlashedOperator( + Randomness r + ) public rand(r) { uint256 shares = r.Uint256(1, MAX_STRATEGY_SHARES); IStrategy[] memory strategyArray = r.StrategyArray(1); IStrategy strategy = strategyArray[0]; @@ -4034,11 +3881,7 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { }); // Format queued withdrawal - ( - , - Withdrawal memory withdrawal, - bytes32 withdrawalRoot - ) = _setUpQueueWithdrawalsSingleStrat({ + (, Withdrawal memory withdrawal, bytes32 withdrawalRoot) = _setUpQueueWithdrawalsSingleStrat({ staker: defaultStaker, strategy: strategy, depositSharesToWithdraw: shares @@ -4085,15 +3928,17 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { * @notice Verifies that the `undelegate` function properly queues a withdrawal for all shares of the staker * @notice The operator should have its shares slashed prior to the staker's deposit */ - function testFuzz_undelegate_preSlashedOperator(Randomness r) public rand(r) { + function testFuzz_undelegate_preSlashedOperator( + Randomness r + ) public rand(r) { uint256 shares = r.Uint256(1, MAX_STRATEGY_SHARES); uint64 operatorMagnitude = r.Uint64(1, WAD); - IStrategy strategy = IStrategy(r.Address()); + IStrategy strategy = IStrategy(r.Address()); // register *this contract* as an operator & set its slashed magnitude _registerOperatorWithBaseDetails(defaultOperator); _setOperatorMagnitude(defaultOperator, strategy, operatorMagnitude); - + // Set the staker deposits in the strategies strategyManagerMock.addDeposit(defaultStaker, strategy, shares); @@ -4109,13 +3954,9 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { prevDsf: uint256(WAD).divWad(operatorMagnitude), depositAmount: shares }); - + // Format queued withdrawal - ( - , - Withdrawal memory withdrawal, - bytes32 withdrawalRoot - ) = _setUpQueueWithdrawalsSingleStrat({ + (, Withdrawal memory withdrawal, bytes32 withdrawalRoot) = _setUpQueueWithdrawalsSingleStrat({ staker: defaultStaker, strategy: strategy, depositSharesToWithdraw: shares @@ -4124,11 +3965,7 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { // Calculate operatorShares decreased, may be off of shares due to rounding uint256 depositScalingFactor = delegationManager.depositScalingFactor(defaultStaker, strategy); assertTrue(depositScalingFactor > WAD, "bad test setup"); - uint256 operatorSharesDecreased = _calcWithdrawableShares( - shares, - depositScalingFactor, - operatorMagnitude - ); + uint256 operatorSharesDecreased = _calcWithdrawableShares(shares, depositScalingFactor, operatorMagnitude); assertLe(operatorSharesDecreased, shares, "operatorSharesDecreased should be <= shares"); // Undelegate the staker @@ -4167,7 +4004,8 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { depositScalingFactor: uint256(WAD).divWad(operatorMagnitude), slashingFactor: uint256(operatorMagnitude) }); - (uint256[] memory stakerWithdrawableShares, ) = delegationManager.getWithdrawableShares(defaultStaker, strategy.toArray()); + (uint256[] memory stakerWithdrawableShares,) = + delegationManager.getWithdrawableShares(defaultStaker, strategy.toArray()); assertEq(stakerWithdrawableShares[0], 0, "staker withdrawable shares not calculated correctly"); } @@ -4175,7 +4013,9 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { * @notice Verifies that the `undelegate` function properly queues a withdrawal for all shares of the staker * @notice The operator should have its shares slashed prior to the staker's deposit */ - function testFuzz_undelegate_slashedWhileStaked(Randomness r) public rand(r) { + function testFuzz_undelegate_slashedWhileStaked( + Randomness r + ) public rand(r) { uint256 shares = r.Uint256(1, MAX_STRATEGY_SHARES); uint64 prevMaxMagnitude = r.Uint64(2, WAD); uint64 newMaxMagnitude = r.Uint64(1, prevMaxMagnitude - 1); @@ -4184,10 +4024,10 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { // register *this contract* as an operator _registerOperatorWithBaseDetails(defaultOperator); _setOperatorMagnitude(defaultOperator, strategy, prevMaxMagnitude); - + // Set the staker deposits in the strategies strategyManagerMock.addDeposit(defaultStaker, strategy, shares); - + // delegate from the `defaultStaker` to the operator _delegateToOperatorWhoAcceptsAllStakers(defaultStaker, defaultOperator); _assertDeposit({ @@ -4209,7 +4049,8 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { // Set operator magnitude { - (uint256[] memory withdrawableSharesBefore, ) = delegationManager.getWithdrawableShares(defaultStaker, strategy.toArray()); + (uint256[] memory withdrawableSharesBefore,) = + delegationManager.getWithdrawableShares(defaultStaker, strategy.toArray()); uint256 delegatedSharesBefore = delegationManager.operatorShares(defaultOperator, strategy); _setOperatorMagnitude(defaultOperator, strategy, newMaxMagnitude); cheats.prank(address(allocationManagerMock)); @@ -4223,7 +4064,7 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { }); uint256 expectedWithdrawable = _calcWithdrawableShares( - shares, + shares, uint256(WAD).divWad(prevMaxMagnitude), _getSlashingFactor(defaultStaker, strategy, newMaxMagnitude) ); @@ -4237,8 +4078,11 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { }); // Get withdrawable shares - (uint256[] memory withdrawableSharesAfter, uint256[] memory depositSharesAfter) = delegationManager.getWithdrawableShares(defaultStaker, strategy.toArray()); - _assertWithdrawableAndOperatorShares(withdrawableSharesAfter[0], operatorSharesAfterSlash, "Invalid withdrawable shares"); + (uint256[] memory withdrawableSharesAfter, uint256[] memory depositSharesAfter) = + delegationManager.getWithdrawableShares(defaultStaker, strategy.toArray()); + _assertWithdrawableAndOperatorShares( + withdrawableSharesAfter[0], operatorSharesAfterSlash, "Invalid withdrawable shares" + ); assertEq(depositSharesAfter[0], shares, "Invalid deposit shares"); assertEq( delegationManager.depositScalingFactor(defaultStaker, strategy), @@ -4248,14 +4092,11 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { } // Format queued withdrawal - (uint256[] memory withdrawableShares, uint256[] memory depositShares) = delegationManager.getWithdrawableShares(defaultStaker, strategy.toArray()); + (uint256[] memory withdrawableShares, uint256[] memory depositShares) = + delegationManager.getWithdrawableShares(defaultStaker, strategy.toArray()); uint256 operatorSharesBefore = delegationManager.operatorShares(defaultOperator, strategy); { - ( - , - Withdrawal memory withdrawal, - bytes32 withdrawalRoot - ) = _setUpQueueWithdrawalsSingleStrat({ + (, Withdrawal memory withdrawal, bytes32 withdrawalRoot) = _setUpQueueWithdrawalsSingleStrat({ staker: defaultStaker, strategy: strategy, depositSharesToWithdraw: shares @@ -4308,7 +4149,9 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { * @notice Verifies that the `undelegate` function properly undelegates a staker even though their shares * were slashed entirely. */ - function testFuzz_undelegate_slashedOperator100PercentWhileStaked(Randomness r) public rand(r) { + function testFuzz_undelegate_slashedOperator100PercentWhileStaked( + Randomness r + ) public rand(r) { uint256 shares = r.Uint256(1, MAX_STRATEGY_SHARES); IStrategy[] memory strategyArray = r.StrategyArray(1); IStrategy strategy = strategyArray[0]; @@ -4343,11 +4186,7 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { assertEq(operatorSharesAfterSlash, 0, "operator shares not fully slashed"); } - ( - , - Withdrawal memory withdrawal, - bytes32 withdrawalRoot - ) = _setUpQueueWithdrawalsSingleStrat({ + (, Withdrawal memory withdrawal, bytes32 withdrawalRoot) = _setUpQueueWithdrawalsSingleStrat({ staker: defaultStaker, strategy: strategy, depositSharesToWithdraw: shares @@ -4357,20 +4196,10 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { assertEq(depositScalingFactor, WAD, "bad test setup"); // Get withdrawable and deposit shares { - ( - uint256[] memory withdrawableSharesBefore, - uint256[] memory depositSharesBefore - ) = delegationManager.getWithdrawableShares(defaultStaker, strategyArray); - assertEq( - withdrawableSharesBefore[0], - 0, - "withdrawable shares should be 0 after being slashed fully" - ); - assertEq( - depositSharesBefore[0], - shares, - "deposit shares should be unchanged after being slashed fully" - ); + (uint256[] memory withdrawableSharesBefore, uint256[] memory depositSharesBefore) = + delegationManager.getWithdrawableShares(defaultStaker, strategyArray); + assertEq(withdrawableSharesBefore[0], 0, "withdrawable shares should be 0 after being slashed fully"); + assertEq(depositSharesBefore[0], shares, "deposit shares should be unchanged after being slashed fully"); } // Undelegate the staker @@ -4410,16 +4239,18 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { slashingFactor: 0 }); - assertEq(delegationManager.operatorShares(defaultOperator, strategy), 0, "operator shares not decreased correctly"); - ( - uint256[] memory stakerWithdrawableShares, - uint256[] memory depositShares - ) = delegationManager.getWithdrawableShares(defaultStaker, strategyArray); + assertEq( + delegationManager.operatorShares(defaultOperator, strategy), 0, "operator shares not decreased correctly" + ); + (uint256[] memory stakerWithdrawableShares, uint256[] memory depositShares) = + delegationManager.getWithdrawableShares(defaultStaker, strategyArray); assertEq(stakerWithdrawableShares[0], 0, "staker withdrawable shares not calculated correctly"); assertEq(depositShares[0], 0, "staker deposit shares not reset correctly"); } - function testFuzz_undelegate_slashedOperatorCloseTo100(Randomness r) public rand(r) { + function testFuzz_undelegate_slashedOperatorCloseTo100( + Randomness r + ) public rand(r) { address[] memory stakers = r.StakerArray(r.Uint32(1, 8)); uint64 prevMaxMagnitude = r.Uint64(2, WAD); uint64 newMaxMagnitude = 1; @@ -4427,16 +4258,12 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { // 1. register *this contract* as an operator _registerOperatorWithBaseDetails(defaultOperator); _setOperatorMagnitude(defaultOperator, strategyMock, prevMaxMagnitude); - + // 2. Stakers deposits in the strategyMock { for (uint256 i = 0; i < stakers.length; ++i) { uint256 shares = r.Uint256(1, MAX_STRATEGY_SHARES); - strategyManagerMock.addDeposit( - stakers[i], - strategyMock, - shares - ); + strategyManagerMock.addDeposit(stakers[i], strategyMock, shares); stakerDepositShares[stakers[i]] = shares; } } @@ -4460,11 +4287,14 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { }); } - (uint256[] memory withdrawableSharesBefore, ) = delegationManager.getWithdrawableShares(stakers[i], strategyMock.toArray()); + (uint256[] memory withdrawableSharesBefore,) = + delegationManager.getWithdrawableShares(stakers[i], strategyMock.toArray()); totalWithdrawable += withdrawableSharesBefore[0]; } assertLe( - totalWithdrawable, delegationManager.operatorShares(defaultOperator, strategyMock), "should be <= op shares due to rounding" + totalWithdrawable, + delegationManager.operatorShares(defaultOperator, strategyMock), + "should be <= op shares due to rounding" ); } @@ -4487,11 +4317,7 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { // 5. Undelegate the stakers with expected events uint256 totalOperatorSharesDecreased = 0; for (uint256 i = 0; i < stakers.length; ++i) { - ( - , - Withdrawal memory withdrawal, - bytes32 withdrawalRoot - ) = _setUpQueueWithdrawalsSingleStrat({ + (, Withdrawal memory withdrawal, bytes32 withdrawalRoot) = _setUpQueueWithdrawalsSingleStrat({ staker: stakers[i], strategy: strategyMock, depositSharesToWithdraw: stakerDepositShares[stakers[i]] @@ -4529,10 +4355,8 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { ); assertFalse(delegationManager.isDelegated(defaultStaker), "staker not undelegated"); for (uint256 i = 0; i < stakers.length; ++i) { - ( - uint256[] memory stakerWithdrawableShares, - uint256[] memory stakerDepositShares - ) = delegationManager.getWithdrawableShares(stakers[i], strategyMock.toArray()); + (uint256[] memory stakerWithdrawableShares, uint256[] memory stakerDepositShares) = + delegationManager.getWithdrawableShares(stakers[i], strategyMock.toArray()); assertEq(stakerWithdrawableShares[0], 0, "staker withdrawable shares not calculated correctly"); assertEq(stakerDepositShares[0], 0, "staker deposit shares not reset correctly"); } @@ -4542,10 +4366,12 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { * @notice Given an operator with slashed magnitude, delegate, undelegate, and then delegate back to the same operator with * completing withdrawals as shares. This should result in the operatorShares after the second delegation being <= the shares from the first delegation. */ - function testFuzz_undelegate_delegateAgainWithRounding(Randomness r) public rand(r) { + function testFuzz_undelegate_delegateAgainWithRounding( + Randomness r + ) public rand(r) { uint256 shares = r.Uint256(1, MAX_STRATEGY_SHARES); // set magnitude to 66% to ensure rounding when calculating `toShares` - uint64 operatorMagnitude = 333333333333333333; + uint64 operatorMagnitude = 333_333_333_333_333_333; // register *this contract* as an operator & set its slashed magnitude _registerOperatorWithBaseDetails(defaultOperator); @@ -4569,11 +4395,7 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { uint256 operatorSharesBefore = delegationManager.operatorShares(defaultOperator, strategyMock); // Format queued withdrawal - ( - , - Withdrawal memory withdrawal, - bytes32 withdrawalRoot - ) = _setUpQueueWithdrawalsSingleStrat({ + (, Withdrawal memory withdrawal, bytes32 withdrawalRoot) = _setUpQueueWithdrawalsSingleStrat({ staker: defaultStaker, strategy: strategyMock, depositSharesToWithdraw: shares @@ -4581,9 +4403,7 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { uint256 slashingFactor = _getSlashingFactor(defaultStaker, strategyMock, operatorMagnitude); uint256 operatorSharesDecreased = _calcWithdrawableShares( - shares, - delegationManager.depositScalingFactor(defaultStaker, strategyMock), - slashingFactor + shares, delegationManager.depositScalingFactor(defaultStaker, strategyMock), slashingFactor ); // Undelegate the staker @@ -4621,7 +4441,8 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { depositScalingFactor: uint256(WAD).divWad(operatorMagnitude), slashingFactor: operatorMagnitude }); - (uint256[] memory stakerWithdrawableShares, ) = delegationManager.getWithdrawableShares(defaultStaker, strategyMock.toArray()); + (uint256[] memory stakerWithdrawableShares,) = + delegationManager.getWithdrawableShares(defaultStaker, strategyMock.toArray()); assertEq(stakerWithdrawableShares[0], 0, "staker withdrawable shares not calculated correctly"); // // Re-delegate the staker to the operator again. The shares should have increased but may be less than from before due to rounding @@ -4634,15 +4455,21 @@ contract DelegationManagerUnitTests_undelegate is DelegationManagerUnitTests { delegationManager.completeQueuedWithdrawal(withdrawal, tokens, false); uint256 operatorSharesAfter = delegationManager.operatorShares(defaultOperator, strategyMock); - assertLe(operatorSharesAfter, operatorSharesBefore, "operator shares should be less than or equal to before due to potential rounding"); + assertLe( + operatorSharesAfter, + operatorSharesBefore, + "operator shares should be less than or equal to before due to potential rounding" + ); } } -contract DelegationManagerUnitTests_redelegate is DelegationManagerUnitTests { +contract DelegationManagerUnitTests_redelegate is DelegationManagerUnitTests { using ArrayLib for *; - + // @notice Verifies that redelegating is not possible when the "delegation paused" switch is flipped - function testFuzz_Revert_redelegate_delegatePaused(Randomness r) public { + function testFuzz_Revert_redelegate_delegatePaused( + Randomness r + ) public { address staker = r.Address(); address newOperator = r.Address(); @@ -4661,7 +4488,9 @@ contract DelegationManagerUnitTests_redelegate is DelegationManagerUnitTests { } // @notice Verifies that redelegating is not possible when the "undelegation paused" switch is flipped - function testFuzz_Revert_redelegate_undelegatePaused(Randomness r) public { + function testFuzz_Revert_redelegate_undelegatePaused( + Randomness r + ) public { address staker = r.Address(); address newOperator = r.Address(); @@ -4679,7 +4508,9 @@ contract DelegationManagerUnitTests_redelegate is DelegationManagerUnitTests { delegationManager.redelegate(newOperator, emptyApproverSignatureAndExpiry, emptySalt); } - function testFuzz_Revert_redelegate_notDelegated(Randomness r) public { + function testFuzz_Revert_redelegate_notDelegated( + Randomness r + ) public { address undelegatedStaker = r.Address(); assertFalse(delegationManager.isDelegated(undelegatedStaker), "bad test setup"); @@ -4691,7 +4522,9 @@ contract DelegationManagerUnitTests_redelegate is DelegationManagerUnitTests { } // @notice Verifies that an operator cannot undelegate from themself (this should always be forbidden) - function testFuzz_Revert_redelegate_stakerIsOperator(Randomness r) public { + function testFuzz_Revert_redelegate_stakerIsOperator( + Randomness r + ) public { address operator = r.Address(); _registerOperatorWithBaseDetails(operator); _registerOperatorWithBaseDetails(defaultOperator); @@ -4702,7 +4535,9 @@ contract DelegationManagerUnitTests_redelegate is DelegationManagerUnitTests { } /// @notice Verifies that `staker` cannot redelegate to an unregistered `operator` - function testFuzz_Revert_redelegateToUnregisteredOperator(Randomness r) public { + function testFuzz_Revert_redelegateToUnregisteredOperator( + Randomness r + ) public { address staker = r.Address(); address operator = r.Address(); assertFalse(delegationManager.isOperator(operator), "incorrect test input?"); @@ -4724,7 +4559,7 @@ contract DelegationManagerUnitTests_redelegate is DelegationManagerUnitTests { address staker = r.Address(); address newOperator = r.Address(); - uint expiry = r.Uint256(0, block.timestamp - 1); + uint256 expiry = r.Uint256(0, block.timestamp - 1); bytes32 salt = r.Bytes32(); _registerOperatorWithBaseDetails(defaultOperator); @@ -4733,7 +4568,7 @@ contract DelegationManagerUnitTests_redelegate is DelegationManagerUnitTests { _registerOperatorWithDelegationApprover(newOperator); // calculate the delegationSigner's signature - ISignatureUtils.SignatureWithExpiry memory approverSignatureAndExpiry = _getApproverSignature( + ISignatureUtilsMixinTypes.SignatureWithExpiry memory approverSignatureAndExpiry = _getApproverSignature( delegationSignerPrivateKey, staker, newOperator, @@ -4743,7 +4578,7 @@ contract DelegationManagerUnitTests_redelegate is DelegationManagerUnitTests { // delegate from the `staker` to the operator cheats.startPrank(staker); - cheats.expectRevert(ISignatureUtils.SignatureExpired.selector); + cheats.expectRevert(ISignatureUtilsMixinErrors.SignatureExpired.selector); delegationManager.redelegate(newOperator, approverSignatureAndExpiry, salt); cheats.stopPrank(); } @@ -4753,7 +4588,7 @@ contract DelegationManagerUnitTests_redelegate is DelegationManagerUnitTests { ) public { address staker = r.Address(); address newOperator = r.Address(); - uint expiry = r.Uint256(block.timestamp, block.timestamp + 100); + uint256 expiry = r.Uint256(block.timestamp, block.timestamp + 100); bytes32 salt = r.Bytes32(); _registerOperatorWithBaseDetails(defaultOperator); @@ -4761,14 +4596,11 @@ contract DelegationManagerUnitTests_redelegate is DelegationManagerUnitTests { // verify that the salt hasn't been used before assertFalse( - delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(newOperator), - salt - ), + delegationManager.delegationApproverSaltIsSpent(delegationManager.delegationApprover(newOperator), salt), "salt somehow spent too early?" ); // calculate the delegationSigner's signature - ISignatureUtils.SignatureWithExpiry memory approverSignatureAndExpiry = _getApproverSignature( + ISignatureUtilsMixinTypes.SignatureWithExpiry memory approverSignatureAndExpiry = _getApproverSignature( delegationSignerPrivateKey, staker, newOperator, @@ -4780,10 +4612,7 @@ contract DelegationManagerUnitTests_redelegate is DelegationManagerUnitTests { cheats.startPrank(staker); delegationManager.delegateTo(newOperator, approverSignatureAndExpiry, salt); assertTrue( - delegationManager.delegationApproverSaltIsSpent( - delegationManager.delegationApprover(newOperator), - salt - ), + delegationManager.delegationApproverSaltIsSpent(delegationManager.delegationApprover(newOperator), salt), "salt somehow spent not spent?" ); @@ -4800,7 +4629,9 @@ contract DelegationManagerUnitTests_redelegate is DelegationManagerUnitTests { * @notice Verifies that the `redelegate` function properly queues a withdrawal for all shares of the staker * ... and delegates to a new operator */ - function testFuzz_redelegate_noSlashing(Randomness r) public { + function testFuzz_redelegate_noSlashing( + Randomness r + ) public { uint256 shares = r.Uint256(1, MAX_STRATEGY_SHARES); IStrategy[] memory strategyArray = r.StrategyArray(1); IStrategy strategy = strategyArray[0]; @@ -4813,13 +4644,9 @@ contract DelegationManagerUnitTests_redelegate is DelegationManagerUnitTests { _registerOperatorWithBaseDetails(defaultOperator); _delegateToOperatorWhoAcceptsAllStakers(defaultStaker, defaultOperator); _registerOperatorWithBaseDetails(newOperator); - + // Format queued withdrawal - ( - , - Withdrawal memory withdrawal, - bytes32 withdrawalRoot - ) = _setUpQueueWithdrawalsSingleStrat({ + (, Withdrawal memory withdrawal, bytes32 withdrawalRoot) = _setUpQueueWithdrawalsSingleStrat({ staker: defaultStaker, strategy: strategy, depositSharesToWithdraw: shares @@ -4860,9 +4687,16 @@ contract DelegationManagerUnitTests_redelegate is DelegationManagerUnitTests { assertTrue(delegationManager.isDelegated(defaultStaker), "staker should still be delegated"); // Checks - operator & staker shares - assertEq(delegationManager.operatorShares(defaultOperator, strategyMock), 0, "operator shares not decreased correctly"); - assertEq(delegationManager.operatorShares(newOperator, strategyMock), 0, "operator shares should not have been added"); - (uint256[] memory stakerWithdrawableShares, ) = delegationManager.getWithdrawableShares(defaultStaker, strategyArray); + assertEq( + delegationManager.operatorShares(defaultOperator, strategyMock), + 0, + "operator shares not decreased correctly" + ); + assertEq( + delegationManager.operatorShares(newOperator, strategyMock), 0, "operator shares should not have been added" + ); + (uint256[] memory stakerWithdrawableShares,) = + delegationManager.getWithdrawableShares(defaultStaker, strategyArray); assertEq(stakerWithdrawableShares[0], 0, "staker withdrawable shares not calculated correctly"); } @@ -4870,7 +4704,9 @@ contract DelegationManagerUnitTests_redelegate is DelegationManagerUnitTests { * @notice This function tests to ensure that a delegator can re-delegate to an operator after undelegating. * Asserts the shares after re-delegating are the same as originally. No slashing is done in this test. */ - function testFuzz_undelegate_redelegateWithSharesBack(Randomness r) public rand(r) { + function testFuzz_undelegate_redelegateWithSharesBack( + Randomness r + ) public rand(r) { address staker = r.Address(); address operator = r.Address(); uint256 strategyShares = r.Uint256(1, MAX_STRATEGY_SHARES); @@ -4880,9 +4716,7 @@ contract DelegationManagerUnitTests_redelegate is DelegationManagerUnitTests { // 1. Set staker shares strategyManagerMock.addDeposit(staker, strategyMock, strategyShares); eigenPodManagerMock.setPodOwnerShares(staker, beaconShares); - ( - IStrategy[] memory strategiesToReturn, - ) = delegationManager.getDepositedShares(staker); + (IStrategy[] memory strategiesToReturn,) = delegationManager.getDepositedShares(staker); // 2. register operator and delegate staker to operator _registerOperatorWithBaseDetails(operator); _delegateToOperatorWhoAcceptsAllStakers(staker, operator); @@ -4909,18 +4743,12 @@ contract DelegationManagerUnitTests_redelegate is DelegationManagerUnitTests { // 3. Setup queued withdrawals from `undelegate` // queued withdrawals done for single strat as this is how undelegate queue withdraws - ( - , - Withdrawal memory strategyWithdrawal, - ) = _setUpQueueWithdrawalsSingleStrat({ + (, Withdrawal memory strategyWithdrawal,) = _setUpQueueWithdrawalsSingleStrat({ staker: staker, strategy: strategyMock, depositSharesToWithdraw: strategyShares }); - ( - , - Withdrawal memory beaconWithdrawal, - ) = _setUpQueueWithdrawalsSingleStrat({ + (, Withdrawal memory beaconWithdrawal,) = _setUpQueueWithdrawalsSingleStrat({ staker: staker, strategy: IStrategy(address(beaconChainETHStrategy)), depositSharesToWithdraw: uint256(beaconShares) @@ -4939,30 +4767,23 @@ contract DelegationManagerUnitTests_redelegate is DelegationManagerUnitTests { // delegate first and complete withdrawal _delegateToOperatorWhoAcceptsAllStakers(staker, operator); cheats.startPrank(staker); - delegationManager.completeQueuedWithdrawal(strategyWithdrawal, strategyTokens, false); - delegationManager.completeQueuedWithdrawal(beaconWithdrawal, beaconTokens, false); + delegationManager.completeQueuedWithdrawal(strategyWithdrawal, strategyTokens, false); + delegationManager.completeQueuedWithdrawal(beaconWithdrawal, beaconTokens, false); cheats.stopPrank(); } else { // complete withdrawal first and then delegate cheats.startPrank(staker); - delegationManager.completeQueuedWithdrawal(strategyWithdrawal, strategyTokens, false); - delegationManager.completeQueuedWithdrawal(beaconWithdrawal, beaconTokens, false); + delegationManager.completeQueuedWithdrawal(strategyWithdrawal, strategyTokens, false); + delegationManager.completeQueuedWithdrawal(beaconWithdrawal, beaconTokens, false); cheats.stopPrank(); _delegateToOperatorWhoAcceptsAllStakers(staker, operator); } } // 5. assert correct shares and delegation state - assertTrue( - delegationManager.isDelegated(staker), - "staker should be delegated" - ); - assertEq( - delegationManager.delegatedTo(staker), - operator, - "staker should be delegated to operator" - ); - (uint256[] memory stakerShares, ) = delegationManager.getWithdrawableShares(staker, strategiesToReturn); + assertTrue(delegationManager.isDelegated(staker), "staker should be delegated"); + assertEq(delegationManager.delegatedTo(staker), operator, "staker should be delegated to operator"); + (uint256[] memory stakerShares,) = delegationManager.getWithdrawableShares(staker, strategiesToReturn); assertEq( delegationManager.operatorShares(operator, strategyMock), stakerShares[0], @@ -4983,7 +4804,7 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes function test_Revert_WhenEnterQueueWithdrawalsPaused() public { cheats.prank(pauser); delegationManager.pause(2 ** PAUSED_ENTER_WITHDRAWAL_QUEUE); - (QueuedWithdrawalParams[] memory queuedWithdrawalParams, , ) = _setUpQueueWithdrawalsSingleStrat({ + (QueuedWithdrawalParams[] memory queuedWithdrawalParams,,) = _setUpQueueWithdrawalsSingleStrat({ staker: defaultStaker, strategy: strategyMock, depositSharesToWithdraw: 100 @@ -5009,9 +4830,11 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes delegationManager.queueWithdrawals(queuedWithdrawalParams); } - function testFuzz_IgnoresWithdrawerField(address withdrawer) public { - _depositIntoStrategies(defaultStaker, strategyMock.toArray(), uint(100).toArrayU256()); - (QueuedWithdrawalParams[] memory queuedWithdrawalParams, , ) = _setUpQueueWithdrawalsSingleStrat({ + function testFuzz_IgnoresWithdrawerField( + address withdrawer + ) public { + _depositIntoStrategies(defaultStaker, strategyMock.toArray(), uint256(100).toArrayU256()); + (QueuedWithdrawalParams[] memory queuedWithdrawalParams,,) = _setUpQueueWithdrawalsSingleStrat({ staker: defaultStaker, strategy: strategyMock, depositSharesToWithdraw: 100 @@ -5051,12 +4874,15 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes * - Asserts that staker cumulativeWithdrawalsQueued nonce is incremented * - Checks that event was emitted with correct withdrawalRoot and withdrawal */ - function testFuzz_queueWithdrawal_SingleStrat_nonSlashedOperator(Randomness r) public rand(r) { + function testFuzz_queueWithdrawal_SingleStrat_nonSlashedOperator( + Randomness r + ) public rand(r) { uint256 depositAmount = r.Uint256(1, MAX_STRATEGY_SHARES); uint256 withdrawalAmount = r.Uint256(1, depositAmount); bool depositBeaconChainShares = r.Boolean(); // sharesAmounts is single element so returns single strategy - IStrategy[] memory strategies = _deployAndDepositIntoStrategies(defaultStaker, depositAmount.toArrayU256(), depositBeaconChainShares); + IStrategy[] memory strategies = + _deployAndDepositIntoStrategies(defaultStaker, depositAmount.toArrayU256(), depositBeaconChainShares); _registerOperatorWithBaseDetails(defaultOperator); _delegateToOperatorWhoAcceptsAllStakers(defaultStaker, defaultOperator); _assertDeposit({ @@ -5069,16 +4895,15 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes prevDsf: uint256(WAD), depositAmount: depositAmount }); - ( - QueuedWithdrawalParams[] memory queuedWithdrawalParams, - Withdrawal memory withdrawal, - bytes32 withdrawalRoot - ) = _setUpQueueWithdrawalsSingleStrat({ + (QueuedWithdrawalParams[] memory queuedWithdrawalParams, Withdrawal memory withdrawal, bytes32 withdrawalRoot) = + _setUpQueueWithdrawalsSingleStrat({ staker: defaultStaker, strategy: strategies[0], depositSharesToWithdraw: withdrawalAmount }); - assertEq(delegationManager.delegatedTo(defaultStaker), defaultOperator, "staker should be delegated to operator"); + assertEq( + delegationManager.delegatedTo(defaultStaker), defaultOperator, "staker should be delegated to operator" + ); uint256 nonceBefore = delegationManager.cumulativeWithdrawalsQueued(defaultStaker); uint256 delegatedSharesBefore = delegationManager.operatorShares(defaultOperator, strategies[0]); @@ -5118,7 +4943,9 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes * - Asserts that staker cumulativeWithdrawalsQueued nonce is incremented * - Checks that event was emitted with correct withdrawalRoot and withdrawal */ - function testFuzz_queueWithdrawal_SingleStrat_preSlashedOperator(Randomness r) public rand(r) { + function testFuzz_queueWithdrawal_SingleStrat_preSlashedOperator( + Randomness r + ) public rand(r) { uint256 depositAmount = r.Uint256(1, MAX_STRATEGY_SHARES); uint256 withdrawalAmount = r.Uint256(1, depositAmount); uint64 maxMagnitude = r.Uint64(1, WAD); @@ -5141,17 +4968,16 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes depositAmount: depositAmount }); - ( - QueuedWithdrawalParams[] memory queuedWithdrawalParams, - Withdrawal memory withdrawal, - bytes32 withdrawalRoot - ) = _setUpQueueWithdrawalsSingleStrat({ + (QueuedWithdrawalParams[] memory queuedWithdrawalParams, Withdrawal memory withdrawal, bytes32 withdrawalRoot) = + _setUpQueueWithdrawalsSingleStrat({ staker: defaultStaker, strategy: strategyMock, depositSharesToWithdraw: withdrawalAmount }); - assertEq(delegationManager.delegatedTo(defaultStaker), defaultOperator, "staker should be delegated to operator"); + assertEq( + delegationManager.delegatedTo(defaultStaker), defaultOperator, "staker should be delegated to operator" + ); uint256 nonceBefore = delegationManager.cumulativeWithdrawalsQueued(defaultStaker); uint256 delegatedSharesBefore = delegationManager.operatorShares(defaultOperator, strategyMock); @@ -5192,7 +5018,9 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes * - Asserts that staker cumulativeWithdrawalsQueued nonce is incremented * - Checks that event was emitted with correct withdrawalRoot and withdrawal */ - function testFuzz_queueWithdrawal_SingleStrat_slashedWhileStaked(Randomness r) public rand(r) { + function testFuzz_queueWithdrawal_SingleStrat_slashedWhileStaked( + Randomness r + ) public rand(r) { uint256 depositAmount = r.Uint256(1, MAX_STRATEGY_SHARES); uint256 withdrawalAmount = r.Uint256(1, depositAmount); uint64 prevMaxMagnitude = r.Uint64(2, WAD); @@ -5222,7 +5050,7 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes cheats.prank(address(allocationManagerMock)); delegationManager.slashOperatorShares(defaultOperator, strategyMock, prevMaxMagnitude, newMaxMagnitude); // Assertions on amount burned - (uint256 operatorSharesSlashed, ) = _assertOperatorSharesAfterSlash({ + (uint256 operatorSharesSlashed,) = _assertOperatorSharesAfterSlash({ operator: defaultOperator, strategy: strategyMock, operatorSharesBefore: operatorSharesBefore, @@ -5286,7 +5114,7 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes Randomness r ) public rand(r) { uint256 depositAmount = r.Uint256(1, MAX_STRATEGY_SHARES); - + // Register operator, deposit for staker & delegate _registerOperatorWithBaseDetails(defaultOperator); strategyManagerMock.addDeposit(defaultStaker, strategyMock, depositAmount); @@ -5302,11 +5130,8 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes depositAmount: depositAmount }); - ( - QueuedWithdrawalParams[] memory queuedWithdrawalParams, - Withdrawal memory withdrawal, - bytes32 withdrawalRoot - ) = _setUpQueueWithdrawalsSingleStrat({ + (QueuedWithdrawalParams[] memory queuedWithdrawalParams, Withdrawal memory withdrawal, bytes32 withdrawalRoot) = + _setUpQueueWithdrawalsSingleStrat({ staker: defaultStaker, strategy: strategyMock, depositSharesToWithdraw: 0 // expected 0 since slashed 100% @@ -5324,7 +5149,9 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes prevMaxMagnitude: WAD, newMaxMagnitude: operatorMagnitude }); - assertEq(delegationManager.delegatedTo(defaultStaker), defaultOperator, "staker should be delegated to operator"); + assertEq( + delegationManager.delegatedTo(defaultStaker), defaultOperator, "staker should be delegated to operator" + ); // queueWithdrawals should result in an empty withdrawal _queueWithdrawals_expectEmit( @@ -5339,12 +5166,9 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes cheats.prank(defaultStaker); delegationManager.queueWithdrawals(queuedWithdrawalParams); - (uint256[] memory withdrawableShares, ) = delegationManager.getWithdrawableShares(defaultStaker, strategyMock.toArray()); - assertEq( - withdrawableShares[0], - 0, - "withdrawable shares should be 0 after being slashed fully" - ); + (uint256[] memory withdrawableShares,) = + delegationManager.getWithdrawableShares(defaultStaker, strategyMock.toArray()); + assertEq(withdrawableShares[0], 0, "withdrawable shares should be 0 after being slashed fully"); _assertWithdrawal({ staker: defaultStaker, operator: defaultOperator, @@ -5374,12 +5198,10 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes uint32 numStrategies = r.Uint32(1, 32); bool depositBeaconChainShares = r.Boolean(); - ( - uint256[] memory depositAmounts, - uint256[] memory withdrawalAmounts, - , - ) = _fuzzDepositWithdrawalAmounts({ r: r, numStrategies: numStrategies }); - IStrategy[] memory strategies = _deployAndDepositIntoStrategies(defaultStaker, depositAmounts, depositBeaconChainShares); + (uint256[] memory depositAmounts, uint256[] memory withdrawalAmounts,,) = + _fuzzDepositWithdrawalAmounts({r: r, numStrategies: numStrategies}); + IStrategy[] memory strategies = + _deployAndDepositIntoStrategies(defaultStaker, depositAmounts, depositBeaconChainShares); _registerOperatorWithBaseDetails(defaultOperator); _delegateToOperatorWhoAcceptsAllStakers(defaultStaker, defaultOperator); @@ -5396,18 +5218,17 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes }); } - ( - QueuedWithdrawalParams[] memory queuedWithdrawalParams, - Withdrawal memory withdrawal, - bytes32 withdrawalRoot - ) = _setUpQueueWithdrawals({ + (QueuedWithdrawalParams[] memory queuedWithdrawalParams, Withdrawal memory withdrawal, bytes32 withdrawalRoot) = + _setUpQueueWithdrawals({ staker: defaultStaker, strategies: strategies, depositWithdrawalAmounts: withdrawalAmounts }); // Before queueWithdrawal state values uint256 nonceBefore = delegationManager.cumulativeWithdrawalsQueued(defaultStaker); - assertEq(delegationManager.delegatedTo(defaultStaker), defaultOperator, "staker should be delegated to operator"); + assertEq( + delegationManager.delegatedTo(defaultStaker), defaultOperator, "staker should be delegated to operator" + ); uint256[] memory delegatedSharesBefore = new uint256[](strategies.length); for (uint256 i = 0; i < strategies.length; i++) { delegatedSharesBefore[i] = delegationManager.operatorShares(defaultOperator, strategies[i]); @@ -5440,9 +5261,7 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes }); } assertEq( - delegationManager.delegatedTo(defaultStaker), - defaultOperator, - "staker should be delegated to operator" + delegationManager.delegatedTo(defaultStaker), defaultOperator, "staker should be delegated to operator" ); uint256 nonceAfter = delegationManager.cumulativeWithdrawalsQueued(defaultStaker); assertEq(nonceBefore + 1, nonceAfter, "staker nonce should have incremented"); @@ -5464,18 +5283,15 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes ) public rand(r) { // 1. Setup // - fuzz numbers of strategies, deposit and withdraw amounts, and prev/new magnitudes for each strategy respectively - // - deposit into strategies, delegate to operator + // - deposit into strategies, delegate to operator bool depositBeaconChainShares = r.Boolean(); IStrategy[] memory strategies = r.StrategyArray(r.Uint32(1, 32)); if (depositBeaconChainShares) { strategies[strategies.length - 1] = beaconChainETHStrategy; } - ( - uint256[] memory depositAmounts, - uint256[] memory withdrawalAmounts, - uint64[] memory prevMaxMagnitudes, - ) = _fuzzDepositWithdrawalAmounts({ r: r, numStrategies: uint32(strategies.length) }); + (uint256[] memory depositAmounts, uint256[] memory withdrawalAmounts, uint64[] memory prevMaxMagnitudes,) = + _fuzzDepositWithdrawalAmounts({r: r, numStrategies: uint32(strategies.length)}); _registerOperatorWithBaseDetails(defaultOperator); allocationManagerMock.setMaxMagnitudes(defaultOperator, strategies, prevMaxMagnitudes); _depositIntoStrategies(defaultStaker, strategies, depositAmounts); @@ -5535,9 +5351,7 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes }); } assertEq( - delegationManager.delegatedTo(defaultStaker), - defaultOperator, - "staker should be delegated to operator" + delegationManager.delegatedTo(defaultStaker), defaultOperator, "staker should be delegated to operator" ); assertEq( nonceBefore + 1, @@ -5552,7 +5366,7 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes * with multiple strategies and sharesAmounts. Operator has random maxMagnitudes for each strategy. * Depending on number of strategies randomized, deposits sharesAmounts into each strategy for the staker and delegates to operator. * After depositing, the operator gets slashed for each of the strategies and has new maxMagnitudes set. - * For each strategy, + * For each strategy, * - Asserts that staker is delegated to the operator * - Asserts that shares for delegatedTo operator are decreased by `depositAmount` * - Asserts that staker cumulativeWithdrawalsQueued nonce is incremented @@ -5563,7 +5377,7 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes ) public rand(r) { // 1. Setup // - fuzz numbers of strategies, deposit and withdraw amounts, and prev/new magnitudes for each strategy respectively - // - deposit into strategies, delegate to operator + // - deposit into strategies, delegate to operator IStrategy[] memory strategies = r.StrategyArray(r.Uint32(1, 32)); bool depositBeaconChainShares = r.Boolean(); if (depositBeaconChainShares) { @@ -5574,7 +5388,7 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes uint256[] memory withdrawalAmounts, uint64[] memory prevMaxMagnitudes, uint64[] memory newMaxMagnitudes - ) = _fuzzDepositWithdrawalAmounts({ r: r, numStrategies: uint32(strategies.length) }); + ) = _fuzzDepositWithdrawalAmounts({r: r, numStrategies: uint32(strategies.length)}); _registerOperatorWithBaseDetails(defaultOperator); allocationManagerMock.setMaxMagnitudes(defaultOperator, strategies, prevMaxMagnitudes); _depositIntoStrategies(defaultStaker, strategies, depositAmounts); @@ -5600,9 +5414,11 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes uint256[] memory slashedOperatorShares = new uint256[](strategies.length); for (uint256 i = 0; i < strategies.length; i++) { uint256 operatorSharesBefore = delegationManager.operatorShares(defaultOperator, strategies[i]); - delegationManager.slashOperatorShares(defaultOperator, strategies[i], prevMaxMagnitudes[i], newMaxMagnitudes[i]); + delegationManager.slashOperatorShares( + defaultOperator, strategies[i], prevMaxMagnitudes[i], newMaxMagnitudes[i] + ); // Assert correct amount of shares slashed from operator - (slashedOperatorShares[i], ) = _assertOperatorSharesAfterSlash({ + (slashedOperatorShares[i],) = _assertOperatorSharesAfterSlash({ operator: defaultOperator, strategy: strategies[i], operatorSharesBefore: operatorSharesBefore, @@ -5652,9 +5468,7 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes }); } assertEq( - delegationManager.delegatedTo(defaultStaker), - defaultOperator, - "staker should be delegated to operator" + delegationManager.delegatedTo(defaultStaker), defaultOperator, "staker should be delegated to operator" ); assertEq( nonceBefore + 1, @@ -5673,7 +5487,7 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes ) public rand(r) { // 1. Setup // - fuzz numbers of strategies, deposit and withdraw amounts, and prev/new magnitudes for each strategy respectively - // - deposit into strategies, delegate to operator + // - deposit into strategies, delegate to operator uint32 numStrats = r.Uint32(1, 32); IStrategy[] memory strategies = r.StrategyArray(numStrats); bool depositBeaconChainShares = r.Boolean(); @@ -5685,7 +5499,7 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes uint256[] memory withdrawalAmounts, uint64[] memory prevMaxMagnitudes, uint64[] memory newMaxMagnitudes - ) = _fuzzDepositWithdrawalAmounts({ r: r, numStrategies: numStrats }); + ) = _fuzzDepositWithdrawalAmounts({r: r, numStrategies: numStrats}); // randomly choose strategy to have 0 newMaxMagnitude uint256 zeroMagnitudeIndex = r.Uint256(0, numStrats - 1); newMaxMagnitudes[zeroMagnitudeIndex] = 0; @@ -5715,10 +5529,12 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes cheats.startPrank(address(allocationManagerMock)); for (uint256 i = 0; i < strategies.length; i++) { uint256 operatorSharesBefore = delegationManager.operatorShares(defaultOperator, strategies[i]); - delegationManager.slashOperatorShares(defaultOperator, strategies[i], prevMaxMagnitudes[i], newMaxMagnitudes[i]); - + delegationManager.slashOperatorShares( + defaultOperator, strategies[i], prevMaxMagnitudes[i], newMaxMagnitudes[i] + ); + // Assertions on amount burned - (slashedOperatorShares[i], ) = _assertOperatorSharesAfterSlash({ + (slashedOperatorShares[i],) = _assertOperatorSharesAfterSlash({ operator: defaultOperator, strategy: strategies[i], operatorSharesBefore: operatorSharesBefore, @@ -5728,9 +5544,7 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes // additional assertion checks for strategy that was slashed 100% if (zeroMagnitudeIndex == i) { assertEq( - slashedOperatorShares[i], - operatorSharesBefore, - "expected slashed operator shares to be full amount" + slashedOperatorShares[i], operatorSharesBefore, "expected slashed operator shares to be full amount" ); assertEq( delegationManager.operatorShares(defaultOperator, strategies[i]), @@ -5770,11 +5584,7 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes // 5. Post queueWithdrawal state values for (uint256 i = 0; i < strategies.length; i++) { if (zeroMagnitudeIndex == i) { - assertEq( - newMaxMagnitudes[i], - 0, - "expected new max magnitude to be 0" - ); + assertEq(newMaxMagnitudes[i], 0, "expected new max magnitude to be 0"); } _assertWithdrawal({ staker: defaultStaker, @@ -5788,9 +5598,7 @@ contract DelegationManagerUnitTests_queueWithdrawals is DelegationManagerUnitTes }); } assertEq( - delegationManager.delegatedTo(defaultStaker), - defaultOperator, - "staker should be delegated to operator" + delegationManager.delegatedTo(defaultStaker), defaultOperator, "staker should be delegated to operator" ); assertEq( nonceBefore + 1, @@ -5823,7 +5631,7 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage // single withdrawal interface cheats.expectRevert(IPausable.CurrentlyPaused.selector); - delegationManager.completeQueuedWithdrawal(withdrawal, tokens, false); + delegationManager.completeQueuedWithdrawal(withdrawal, tokens, false); IERC20[][] memory tokensArray = new IERC20[][](1); tokensArray[0] = tokens; @@ -5836,7 +5644,7 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage // multiple Withdrawal interface cheats.expectRevert(IPausable.CurrentlyPaused.selector); - delegationManager.completeQueuedWithdrawals(withdrawals, tokensArray, receiveAsTokens); + delegationManager.completeQueuedWithdrawals(withdrawals, tokensArray, receiveAsTokens); } function test_Revert_WhenInputArrayLengthMismatch() public { @@ -5861,21 +5669,20 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage cheats.prank(defaultStaker); cheats.expectRevert(InputArrayLengthMismatch.selector); - delegationManager.completeQueuedWithdrawal(withdrawal, newTokens, false); + delegationManager.completeQueuedWithdrawal(withdrawal, newTokens, false); // check that the withdrawal completes otherwise cheats.prank(defaultStaker); - delegationManager.completeQueuedWithdrawal(withdrawal, tokens, true); + delegationManager.completeQueuedWithdrawal(withdrawal, tokens, true); } - function test_Revert_WhenWithdrawerNotCaller(Randomness r) rand(r) public { + function test_Revert_WhenWithdrawerNotCaller( + Randomness r + ) public rand(r) { address invalidCaller = r.Address(); _registerOperatorWithBaseDetails(defaultOperator); - ( - Withdrawal memory withdrawal, - IERC20[] memory tokens, - ) = _setUpCompleteQueuedWithdrawalSingleStrat({ + (Withdrawal memory withdrawal, IERC20[] memory tokens,) = _setUpCompleteQueuedWithdrawalSingleStrat({ staker: defaultStaker, depositAmount: 100, withdrawalAmount: 100, @@ -5885,16 +5692,13 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage cheats.expectRevert(WithdrawerNotCaller.selector); cheats.prank(invalidCaller); - delegationManager.completeQueuedWithdrawal(withdrawal, tokens, false); + delegationManager.completeQueuedWithdrawal(withdrawal, tokens, false); } function test_Revert_WhenInvalidWithdrawalRoot() public { _registerOperatorWithBaseDetails(defaultOperator); - ( - Withdrawal memory withdrawal, - IERC20[] memory tokens, - bytes32 withdrawalRoot - ) = _setUpCompleteQueuedWithdrawalSingleStrat({ + (Withdrawal memory withdrawal, IERC20[] memory tokens, bytes32 withdrawalRoot) = + _setUpCompleteQueuedWithdrawalSingleStrat({ staker: defaultStaker, depositAmount: 100, withdrawalAmount: 100, @@ -5905,12 +5709,15 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage assertTrue(delegationManager.pendingWithdrawals(withdrawalRoot), "withdrawalRoot should be pending"); cheats.roll(withdrawal.startBlock + delegationManager.minWithdrawalDelayBlocks() + 1); cheats.prank(defaultStaker); - delegationManager.completeQueuedWithdrawal(withdrawal, tokens, true); - assertFalse(delegationManager.pendingWithdrawals(withdrawalRoot), "withdrawalRoot should be completed and marked false now"); + delegationManager.completeQueuedWithdrawal(withdrawal, tokens, true); + assertFalse( + delegationManager.pendingWithdrawals(withdrawalRoot), + "withdrawalRoot should be completed and marked false now" + ); cheats.expectRevert(WithdrawalNotQueued.selector); cheats.prank(defaultStaker); - delegationManager.completeQueuedWithdrawal(withdrawal, tokens, false); + delegationManager.completeQueuedWithdrawal(withdrawal, tokens, false); } /** @@ -5918,15 +5725,14 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage * delegationManager.getCompletableTimestamp returns a value greater than MIN_WITHDRAWAL_DELAY_BLOCKS * then it should revert if the validBlockNumber has not passed either. */ - function test_Revert_WhenWithdrawalDelayNotPassed(Randomness r) rand(r) public { + function test_Revert_WhenWithdrawalDelayNotPassed( + Randomness r + ) public rand(r) { uint32 numStrategies = r.Uint32(1, 32); bool receiveAsTokens = r.Boolean(); - ( - uint256[] memory depositAmounts, - uint256[] memory withdrawalAmounts, - , - ) = _fuzzDepositWithdrawalAmounts(r, numStrategies); - + (uint256[] memory depositAmounts, uint256[] memory withdrawalAmounts,,) = + _fuzzDepositWithdrawalAmounts(r, numStrategies); + _registerOperatorWithBaseDetails(defaultOperator); ( Withdrawal memory withdrawal, @@ -5946,8 +5752,8 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage delegationManager.completeQueuedWithdrawal(withdrawal, tokens, receiveAsTokens); } - /// @notice Verifies that when we complete a withdrawal as shares after a full slash, we revert - function test_revert_fullySlashed() public { + /// @notice Verifies that when we complete a withdrawal as shares after a full slash, we clear the withdrawal + function test_clearWithdrawal_fullySlashed() public { // Register operator _registerOperatorWithBaseDetails(defaultOperator); _setOperatorMagnitude(defaultOperator, strategyMock, WAD); @@ -5959,10 +5765,8 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage // Queue withdrawal uint256 withdrawalAmount = depositAmount; - ( - QueuedWithdrawalParams[] memory queuedWithdrawalParams, - Withdrawal memory withdrawal, - ) = _setUpQueueWithdrawalsSingleStrat({ + (QueuedWithdrawalParams[] memory queuedWithdrawalParams, Withdrawal memory withdrawal,) = + _setUpQueueWithdrawalsSingleStrat({ staker: defaultStaker, strategy: strategyMock, depositSharesToWithdraw: withdrawalAmount @@ -5978,28 +5782,42 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage cheats.prank(address(allocationManagerMock)); delegationManager.slashOperatorShares(defaultOperator, strategyMock, WAD, 0); - // Complete withdrawal as shares and assert that operator has no shares increased + // Complete withdrawal as shares and check that withdrawal was cleared cheats.roll(block.number + 1); IERC20[] memory tokens = strategyMock.underlyingToken().toArray(); - cheats.expectRevert(FullySlashed.selector); + + bytes32 withdrawalRoot = delegationManager.calculateWithdrawalRoot(withdrawal); + assertTrue( + delegationManager.pendingWithdrawals(withdrawalRoot), "withdrawal should be pending before completion" + ); + cheats.prank(defaultStaker); delegationManager.completeQueuedWithdrawal(withdrawal, tokens, false); + + assertFalse( + delegationManager.pendingWithdrawals(withdrawalRoot), "withdrawal should be cleared after completion" + ); + + // Assert that no shares were added back + assertEq(delegationManager.operatorShares(defaultOperator, strategyMock), 0, "operator shares should remain 0"); + (uint256[] memory withdrawableShares,) = + delegationManager.getWithdrawableShares(defaultStaker, strategyMock.toArray()); + assertEq(withdrawableShares[0], 0, "withdrawable shares should be 0"); } /** * Test completing multiple queued withdrawals for a single strategy by passing in the withdrawals */ - function test_completeQueuedWithdrawals_MultipleWithdrawals(Randomness r) public rand(r) { + function test_completeQueuedWithdrawals_MultipleWithdrawals( + Randomness r + ) public rand(r) { address staker = r.Address(); uint256 depositAmount = r.Uint256(1, MAX_STRATEGY_SHARES); uint256 numWithdrawals = r.Uint256(2, 20); bool receiveAsTokens = r.Boolean(); - ( - Withdrawal[] memory withdrawals, - IERC20[][] memory tokens, - bytes32[] memory withdrawalRoots - ) = _setUpCompleteQueuedWithdrawalsSingleStrat({ + (Withdrawal[] memory withdrawals, IERC20[][] memory tokens, bytes32[] memory withdrawalRoots) = + _setUpCompleteQueuedWithdrawalsSingleStrat({ staker: staker, depositAmount: depositAmount, numWithdrawals: numWithdrawals @@ -6009,7 +5827,7 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage _delegateToOperatorWhoAcceptsAllStakers(staker, defaultOperator); uint256 operatorSharesBefore = delegationManager.operatorShares(defaultOperator, withdrawals[0].strategies[0]); - for (uint i = 0; i < withdrawalRoots.length; i++) { + for (uint256 i = 0; i < withdrawalRoots.length; i++) { assertTrue(delegationManager.pendingWithdrawals(withdrawalRoots[i]), "withdrawalRoots should be pending"); } bool[] memory receiveAsTokensArray = receiveAsTokens.toArray(numWithdrawals); @@ -6027,22 +5845,12 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage delegationManager.completeQueuedWithdrawals(withdrawals, tokens, receiveAsTokensArray); // assertion checks - ( - uint256[] memory withdrawableShares, - uint256[] memory depositShares - ) = delegationManager.getWithdrawableShares(staker, withdrawals[0].strategies); + (uint256[] memory withdrawableShares, uint256[] memory depositShares) = + delegationManager.getWithdrawableShares(staker, withdrawals[0].strategies); uint256 operatorSharesAfter = delegationManager.operatorShares(defaultOperator, withdrawals[0].strategies[0]); if (receiveAsTokens) { - assertEq( - withdrawableShares[0], - 0, - "withdrawable shares should be 0 from withdrawing all" - ); - assertEq( - depositShares[0], - 0, - "deposit shares should be 0 from withdrawing all" - ); + assertEq(withdrawableShares[0], 0, "withdrawable shares should be 0 from withdrawing all"); + assertEq(depositShares[0], 0, "deposit shares should be 0 from withdrawing all"); assertEq(operatorSharesAfter, operatorSharesBefore, "operator shares should be unchanged"); } else { assertEq( @@ -6050,11 +5858,7 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage depositAmount * numWithdrawals, "withdrawable shares should be added back as shares" ); - assertEq( - depositShares[0], - depositAmount * numWithdrawals, - "deposit shares should be added back as shares" - ); + assertEq(depositShares[0], depositAmount * numWithdrawals, "deposit shares should be added back as shares"); assertEq( operatorSharesAfter, operatorSharesBefore + depositAmount * numWithdrawals, @@ -6083,17 +5887,14 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage */ function test_completeQueuedWithdrawal_SingleStrat( Randomness r - ) public rand(r) { + ) public rand(r) { uint256 depositAmount = r.Uint256(1, MAX_STRATEGY_SHARES); uint256 withdrawalAmount = r.Uint256(1, depositAmount); bool receiveAsTokens = r.Boolean(); _registerOperatorWithBaseDetails(defaultOperator); - ( - Withdrawal memory withdrawal, - IERC20[] memory tokens, - bytes32 withdrawalRoot - ) = _setUpCompleteQueuedWithdrawalSingleStrat({ + (Withdrawal memory withdrawal, IERC20[] memory tokens, bytes32 withdrawalRoot) = + _setUpCompleteQueuedWithdrawalSingleStrat({ staker: defaultStaker, depositAmount: depositAmount, withdrawalAmount: withdrawalAmount, @@ -6113,7 +5914,7 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage }) ); cheats.prank(defaultStaker); - delegationManager.completeQueuedWithdrawal(withdrawal, tokens, receiveAsTokens); + delegationManager.completeQueuedWithdrawal(withdrawal, tokens, receiveAsTokens); _assertCompletedWithdrawal( AssertCompletedWithdrawalStruct({ @@ -6157,11 +5958,8 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage _delegateToOperatorWhoAcceptsAllStakers(defaultStaker, defaultOperator); // Queue withdrawal - ( - QueuedWithdrawalParams[] memory queuedWithdrawalParams, - Withdrawal memory withdrawal, - bytes32 withdrawalRoot - ) = _setUpQueueWithdrawalsSingleStrat({ + (QueuedWithdrawalParams[] memory queuedWithdrawalParams, Withdrawal memory withdrawal, bytes32 withdrawalRoot) = + _setUpQueueWithdrawalsSingleStrat({ staker: defaultStaker, strategy: strategyMock, depositSharesToWithdraw: withdrawalAmount @@ -6188,14 +5986,16 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage // Slash operator while staker has queued withdrawal { uint256 operatorSharesAfterQueue = delegationManager.operatorShares(defaultOperator, strategyMock); - (uint256 sharesToDecrement, ) = _calcSlashedAmount({ + (uint256 sharesToDecrement,) = _calcSlashedAmount({ operatorShares: operatorSharesAfterQueue, prevMaxMagnitude: prevMaxMagnitude, newMaxMagnitude: newMaxMagnitude }); _setOperatorMagnitude(defaultOperator, strategyMock, newMaxMagnitude); cheats.prank(address(allocationManagerMock)); - delegationManager.slashOperatorShares(defaultOperator, withdrawal.strategies[0], prevMaxMagnitude, newMaxMagnitude); + delegationManager.slashOperatorShares( + defaultOperator, withdrawal.strategies[0], prevMaxMagnitude, newMaxMagnitude + ); uint256 operatorSharesAfterSlash = delegationManager.operatorShares(defaultOperator, strategyMock); assertEq( operatorSharesAfterSlash, @@ -6205,10 +6005,8 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage } // Complete queue withdrawal - ( - uint256[] memory withdrawableShares, - uint256[] memory depositShares - ) = delegationManager.getWithdrawableShares(defaultStaker, withdrawal.strategies); + (uint256[] memory withdrawableShares, uint256[] memory depositShares) = + delegationManager.getWithdrawableShares(defaultStaker, withdrawal.strategies); uint256 operatorSharesBefore = delegationManager.operatorShares(defaultOperator, strategyMock); { IERC20[] memory tokens = new IERC20[](1); @@ -6222,7 +6020,7 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage }) ); cheats.prank(defaultStaker); - delegationManager.completeQueuedWithdrawal(withdrawal, tokens, receiveAsTokens); + delegationManager.completeQueuedWithdrawal(withdrawal, tokens, receiveAsTokens); } _assertCompletedWithdrawal( @@ -6267,11 +6065,8 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage _delegateToOperatorWhoAcceptsAllStakers(defaultStaker, defaultOperator); // Queue withdrawal - ( - QueuedWithdrawalParams[] memory queuedWithdrawalParams, - Withdrawal memory withdrawal, - bytes32 withdrawalRoot - ) = _setUpQueueWithdrawalsSingleStrat({ + (QueuedWithdrawalParams[] memory queuedWithdrawalParams, Withdrawal memory withdrawal, bytes32 withdrawalRoot) = + _setUpQueueWithdrawalsSingleStrat({ staker: defaultStaker, strategy: beaconChainETHStrategy, depositSharesToWithdraw: withdrawalAmount @@ -6281,19 +6076,25 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage { uint256 sharesToDecrement = _calcWithdrawableShares({ depositShares: withdrawalAmount, - depositScalingFactor: uint256(WAD).divWad(initialBCSF), + depositScalingFactor: uint256(WAD), slashingFactor: uint256(initialBCSF) }); - uint256 operatorSharesBeforeQueue = delegationManager.operatorShares(defaultOperator, beaconChainETHStrategy); + uint256 operatorSharesBeforeQueue = + delegationManager.operatorShares(defaultOperator, beaconChainETHStrategy); cheats.prank(defaultStaker); delegationManager.queueWithdrawals(queuedWithdrawalParams); assertTrue(delegationManager.pendingWithdrawals(withdrawalRoot), "withdrawalRoot should be pending"); uint256 operatorSharesAfterQueue = delegationManager.operatorShares(defaultOperator, beaconChainETHStrategy); - assertEq(operatorSharesAfterQueue, operatorSharesBeforeQueue - sharesToDecrement, "operator shares should be decreased after queue"); + assertEq( + operatorSharesAfterQueue, + operatorSharesBeforeQueue - sharesToDecrement, + "operator shares should be decreased after queue" + ); // Slash the staker for beacon chain shares while it has queued a withdrawal // simulate the operations done in EigenPodManager._reduceSlashingFactor - (uint256[] memory withdrawableSharesBefore, ) = delegationManager.getWithdrawableShares(defaultStaker, beaconChainETHStrategy.toArray()); + (uint256[] memory withdrawableSharesBefore,) = + delegationManager.getWithdrawableShares(defaultStaker, beaconChainETHStrategy.toArray()); uint256 currentPodShares = uint256(depositAmount) - withdrawalAmount; (prevBeaconSlashingFactor, newBeaconSlashingFactor) = _decreaseBeaconChainShares({ @@ -6304,17 +6105,17 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage uint256 expectedWithdrawableShares = _calcWithdrawableShares({ depositShares: uint256(currentPodShares), - depositScalingFactor: uint256(WAD).divWad(prevBeaconSlashingFactor), + depositScalingFactor: uint256(WAD), slashingFactor: uint256(newBeaconSlashingFactor) }); - _assertSharesAfterBeaconSlash(defaultStaker, withdrawableSharesBefore[0], expectedWithdrawableShares, prevBeaconSlashingFactor); + _assertSharesAfterBeaconSlash( + defaultStaker, withdrawableSharesBefore[0], expectedWithdrawableShares, prevBeaconSlashingFactor + ); } // Complete queue withdrawal - ( - uint256[] memory withdrawableShares, - uint256[] memory depositShares - ) = delegationManager.getWithdrawableShares(defaultStaker, beaconChainETHStrategy.toArray()); + (uint256[] memory withdrawableShares, uint256[] memory depositShares) = + delegationManager.getWithdrawableShares(defaultStaker, beaconChainETHStrategy.toArray()); uint256 operatorSharesBefore = delegationManager.operatorShares(defaultOperator, beaconChainETHStrategy); { @@ -6328,7 +6129,7 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage }) ); cheats.prank(defaultStaker); - delegationManager.completeQueuedWithdrawal(withdrawal, tokens, receiveAsTokens); + delegationManager.completeQueuedWithdrawal(withdrawal, tokens, receiveAsTokens); } _assertCompletedWithdrawal( @@ -6340,7 +6141,7 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage operatorSharesBefore: operatorSharesBefore.toArrayU256(), withdrawableSharesBefore: withdrawableShares, depositSharesBefore: depositShares, - prevDepositScalingFactors: uint256(WAD).divWad(initialBCSF).toArrayU256(), + prevDepositScalingFactors: uint256(WAD).toArrayU256(), slashingFactors: uint256(WAD).toArrayU256(), // beaconChainSlashingFactor is separate from slashingFactors input beaconChainSlashingFactor: newBeaconSlashingFactor }) @@ -6371,11 +6172,8 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage uint256 operatorSharesBeforeQueue = delegationManager.operatorShares(defaultOperator, beaconChainETHStrategy); // Queue withdrawal - ( - QueuedWithdrawalParams[] memory queuedWithdrawalParams, - Withdrawal memory withdrawal, - bytes32 withdrawalRoot - ) = _setUpQueueWithdrawalsSingleStrat({ + (QueuedWithdrawalParams[] memory queuedWithdrawalParams, Withdrawal memory withdrawal, bytes32 withdrawalRoot) = + _setUpQueueWithdrawalsSingleStrat({ staker: defaultStaker, strategy: beaconChainETHStrategy, depositSharesToWithdraw: withdrawalAmount @@ -6387,7 +6185,11 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage delegationManager.queueWithdrawals(queuedWithdrawalParams); assertTrue(delegationManager.pendingWithdrawals(withdrawalRoot), "withdrawalRoot should be pending"); uint256 operatorSharesAfterQueue = delegationManager.operatorShares(defaultOperator, beaconChainETHStrategy); - assertEq(operatorSharesAfterQueue, operatorSharesBeforeQueue - withdrawalAmount, "operator shares should be decreased after queue"); + assertEq( + operatorSharesAfterQueue, + operatorSharesBeforeQueue - withdrawalAmount, + "operator shares should be decreased after queue" + ); // Slash the staker for beacon chain shares while it has queued a withdrawal // simulate the operations done in EigenPodManager._reduceSlashingFactor @@ -6396,23 +6198,32 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage beaconShares: depositAmount - int256(withdrawalAmount), sharesDecrease: (uint256(depositAmount) - withdrawalAmount) / 2 }); - uint256 operatorSharesAfterBeaconSlash = delegationManager.operatorShares(defaultOperator, beaconChainETHStrategy); - assertEq(operatorSharesAfterBeaconSlash, operatorSharesAfterQueue.ceilDiv(2), "operator shares should be decreased after beaconChain slash"); + uint256 operatorSharesAfterBeaconSlash = + delegationManager.operatorShares(defaultOperator, beaconChainETHStrategy); + assertEq( + operatorSharesAfterBeaconSlash, + operatorSharesAfterQueue.ceilDiv(2), + "operator shares should be decreased after beaconChain slash" + ); // Slash the operator for beacon chain shares uint64 operatorMagnitude = 5e17; _setOperatorMagnitude(defaultOperator, withdrawal.strategies[0], operatorMagnitude); cheats.prank(address(allocationManagerMock)); delegationManager.slashOperatorShares(defaultOperator, withdrawal.strategies[0], WAD, operatorMagnitude); - uint256 operatorSharesAfterAVSSlash = delegationManager.operatorShares(defaultOperator, beaconChainETHStrategy); - assertApproxEqAbs(operatorSharesAfterAVSSlash, operatorSharesAfterBeaconSlash / 2, 1, "operator shares should be decreased after AVS slash"); + uint256 operatorSharesAfterAVSSlash = + delegationManager.operatorShares(defaultOperator, beaconChainETHStrategy); + assertApproxEqAbs( + operatorSharesAfterAVSSlash, + operatorSharesAfterBeaconSlash / 2, + 1, + "operator shares should be decreased after AVS slash" + ); } // Complete queue withdrawal - ( - uint256[] memory withdrawableShares, - uint256[] memory depositShares - ) = delegationManager.getWithdrawableShares(defaultStaker, beaconChainETHStrategy.toArray()); + (uint256[] memory withdrawableShares, uint256[] memory depositShares) = + delegationManager.getWithdrawableShares(defaultStaker, beaconChainETHStrategy.toArray()); uint256 operatorSharesBefore = delegationManager.operatorShares(defaultOperator, beaconChainETHStrategy); IERC20[] memory tokens = new IERC20[](1); cheats.roll(withdrawal.startBlock + delegationManager.minWithdrawalDelayBlocks() + 1); @@ -6424,7 +6235,7 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage }) ); cheats.prank(defaultStaker); - delegationManager.completeQueuedWithdrawal(withdrawal, tokens, receiveAsTokens); + delegationManager.completeQueuedWithdrawal(withdrawal, tokens, receiveAsTokens); _assertCompletedWithdrawal( AssertCompletedWithdrawalStruct({ @@ -6442,7 +6253,6 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage ); } - /** * @notice Verifies that `DelegationManager.completeQueuedWithdrawal` properly completes a queued withdrawal for the `withdrawer` * for a single strategy. Withdraws as shares so if the withdrawer is delegated, operator shares increase. In the test case, this only @@ -6457,14 +6267,11 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage address staker = r.Address(); uint128 depositAmount = r.Uint128(); uint128 withdrawalAmount = r.Uint128(1, depositAmount); - + _registerOperatorWithBaseDetails(defaultOperator); - ( - Withdrawal memory withdrawal, - IERC20[] memory tokens, - bytes32 withdrawalRoot - ) = _setUpCompleteQueuedWithdrawalSingleStrat({ + (Withdrawal memory withdrawal, IERC20[] memory tokens, bytes32 withdrawalRoot) = + _setUpCompleteQueuedWithdrawalSingleStrat({ staker: staker, depositAmount: depositAmount, withdrawalAmount: withdrawalAmount, @@ -6480,22 +6287,25 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage // completeQueuedWithdrawal cheats.roll(withdrawal.startBlock + delegationManager.minWithdrawalDelayBlocks() + 1); _completeQueuedWithdrawal_expectEmit( - CompleteQueuedWithdrawalEmitStruct({ - withdrawal: withdrawal, - tokens: tokens, - receiveAsTokens: false - }) + CompleteQueuedWithdrawalEmitStruct({withdrawal: withdrawal, tokens: tokens, receiveAsTokens: false}) ); cheats.prank(staker); - delegationManager.completeQueuedWithdrawal(withdrawal, tokens, false); + delegationManager.completeQueuedWithdrawal(withdrawal, tokens, false); uint256 operatorSharesAfter = delegationManager.operatorShares(defaultOperator, withdrawal.strategies[0]); // Since staker is delegated, operatorShares get incremented - assertEq(operatorSharesAfter, operatorSharesBefore + withdrawalAmount, "operator shares not increased correctly"); - assertFalse(delegationManager.pendingWithdrawals(withdrawalRoot), "withdrawalRoot should be completed and marked false now"); + assertEq( + operatorSharesAfter, operatorSharesBefore + withdrawalAmount, "operator shares not increased correctly" + ); + assertFalse( + delegationManager.pendingWithdrawals(withdrawalRoot), + "withdrawalRoot should be completed and marked false now" + ); } - function testFuzz_completeQueuedWithdrawals_OutOfOrderBlocking(Randomness r) public { + function testFuzz_completeQueuedWithdrawals_OutOfOrderBlocking( + Randomness r + ) public { uint256 totalDepositShares = r.Uint256(4, 100 ether); uint256 depositSharesPerWithdrawal = totalDepositShares / 4; @@ -6505,20 +6315,14 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage QueuedWithdrawalParams[] memory queuedParams = new QueuedWithdrawalParams[](4); Withdrawal[] memory withdrawals = new Withdrawal[](4); - + uint256 startBlock = block.number; uint256 nonce = delegationManager.cumulativeWithdrawalsQueued(defaultStaker); for (uint256 i; i < 4; ++i) { cheats.roll(startBlock + i); - ( - QueuedWithdrawalParams[] memory params, - Withdrawal memory withdrawal, - ) = _setUpQueueWithdrawalsSingleStrat( - defaultStaker, - strategyMock, - depositSharesPerWithdrawal - ); + (QueuedWithdrawalParams[] memory params, Withdrawal memory withdrawal,) = + _setUpQueueWithdrawalsSingleStrat(defaultStaker, strategyMock, depositSharesPerWithdrawal); withdrawal.nonce = nonce; nonce += 1; @@ -6529,12 +6333,12 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage cheats.startPrank(defaultStaker); cheats.roll(startBlock); - + delegationManager.queueWithdrawals(queuedParams[0].toArray()); cheats.roll(startBlock + 1); delegationManager.queueWithdrawals(queuedParams[1].toArray()); - - (Withdrawal[] memory firstWithdrawals, ) = delegationManager.getQueuedWithdrawals(defaultStaker); + + (Withdrawal[] memory firstWithdrawals,) = delegationManager.getQueuedWithdrawals(defaultStaker); cheats.roll(startBlock + 2); delegationManager.queueWithdrawals(queuedParams[2].toArray()); @@ -6548,23 +6352,17 @@ contract DelegationManagerUnitTests_completeQueuedWithdrawal is DelegationManage bytes32 root1 = delegationManager.calculateWithdrawalRoot(withdrawals[0]); bytes32 root2 = delegationManager.calculateWithdrawalRoot(withdrawals[1]); - + bytes32 root1_view = delegationManager.calculateWithdrawalRoot(firstWithdrawals[0]); bytes32 root2_view = delegationManager.calculateWithdrawalRoot(firstWithdrawals[1]); - assertEq( - root1, root1_view, - "withdrawal root should be the same" - ); + assertEq(root1, root1_view, "withdrawal root should be the same"); - assertEq( - root2, root2_view, - "withdrawal root should be the same" - ); + assertEq(root2, root2_view, "withdrawal root should be the same"); cheats.roll(startBlock + delay + 2); delegationManager.completeQueuedWithdrawals(firstWithdrawals, tokens, true.toArray(2)); - + // Throws `WithdrawalNotQueued`. cheats.roll(startBlock + delay + 3); delegationManager.completeQueuedWithdrawals(withdrawals[2].toArray(), tokens, true.toArray()); @@ -6578,7 +6376,9 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests using Math for *; /// @notice Verifies that `DelegationManager.slashOperatorShares` reverts if not called by the AllocationManager - function testFuzz_Revert_slashOperatorShares_invalidCaller(Randomness r) public rand(r) { + function testFuzz_Revert_slashOperatorShares_invalidCaller( + Randomness r + ) public rand(r) { address invalidCaller = r.Address(); cheats.startPrank(invalidCaller); @@ -6591,7 +6391,7 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests _registerOperatorWithBaseDetails(defaultOperator); cheats.prank(address(allocationManagerMock)); - delegationManager.slashOperatorShares(defaultOperator, strategyMock, WAD, WAD/2); + delegationManager.slashOperatorShares(defaultOperator, strategyMock, WAD, WAD / 2); assertEq(delegationManager.operatorShares(defaultOperator, strategyMock), 0, "shares should not have changed"); } @@ -6608,10 +6408,8 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests // Queue withdrawal uint256 withdrawalAmount = depositAmount; - ( - QueuedWithdrawalParams[] memory queuedWithdrawalParams, - Withdrawal memory withdrawal, - ) = _setUpQueueWithdrawalsSingleStrat({ + (QueuedWithdrawalParams[] memory queuedWithdrawalParams, Withdrawal memory withdrawal,) = + _setUpQueueWithdrawalsSingleStrat({ staker: defaultStaker, strategy: strategyMock, depositSharesToWithdraw: withdrawalAmount @@ -6631,32 +6429,28 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests uint256 slashableSharesInQueueAfter = delegationManager.getSlashableSharesInQueue(defaultOperator, strategyMock); - // Complete withdrawal as tokens and assert that nothing is returned + // Complete withdrawal as tokens and assert that nothing is returned and withdrawal is cleared cheats.roll(block.number + 1); IERC20[] memory tokens = strategyMock.underlyingToken().toArray(); - cheats.expectCall( - address(strategyManagerMock), - abi.encodeWithSelector( - IShareManager.withdrawSharesAsTokens.selector, - defaultStaker, - strategyMock, - strategyMock.underlyingToken(), - 0 - ) + + bytes32 withdrawalRoot = delegationManager.calculateWithdrawalRoot(withdrawal); + assertTrue( + delegationManager.pendingWithdrawals(withdrawalRoot), "withdrawal should be pending before completion" ); + cheats.prank(defaultStaker); delegationManager.completeQueuedWithdrawal(withdrawal, tokens, true); + assertFalse( + delegationManager.pendingWithdrawals(withdrawalRoot), "withdrawal should be cleared after completion" + ); + assertEq( slashableSharesInQueue, depositAmount, "the withdrawal in queue from block.number - minWithdrawalDelayBlocks should still be included" ); - assertEq( - slashableSharesInQueueAfter, - 0, - "slashable shares in queue should be 0 after burning" - ); + assertEq(slashableSharesInQueueAfter, 0, "slashable shares in queue should be 0 after burning"); } /// @notice Verifies that shares are NOT burnable for a withdrawal queued just before the MIN_WITHDRAWAL_DELAY_BLOCKS @@ -6672,10 +6466,8 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests // Queue withdrawal uint256 withdrawalAmount = depositAmount; - ( - QueuedWithdrawalParams[] memory queuedWithdrawalParams, - Withdrawal memory withdrawal, - ) = _setUpQueueWithdrawalsSingleStrat({ + (QueuedWithdrawalParams[] memory queuedWithdrawalParams, Withdrawal memory withdrawal,) = + _setUpQueueWithdrawalsSingleStrat({ staker: defaultStaker, strategy: strategyMock, depositSharesToWithdraw: withdrawalAmount @@ -6706,7 +6498,7 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests ) ); cheats.prank(defaultStaker); - delegationManager.completeQueuedWithdrawal(withdrawal, tokens, true); + delegationManager.completeQueuedWithdrawal(withdrawal, tokens, true); } /** @@ -6725,10 +6517,8 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests // Queue 5 withdrawals uint256 startBlock = block.number; uint256 withdrawalAmount = depositAmount / 6; - for(uint256 i = 0; i < 5; i++) { - ( - QueuedWithdrawalParams[] memory queuedWithdrawalParams,, - ) = _setUpQueueWithdrawalsSingleStrat({ + for (uint256 i = 0; i < 5; i++) { + (QueuedWithdrawalParams[] memory queuedWithdrawalParams,,) = _setUpQueueWithdrawalsSingleStrat({ staker: defaultStaker, strategy: strategyMock, depositSharesToWithdraw: withdrawalAmount @@ -6744,7 +6534,11 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests // Get slashable shares uint256 slashableSharesInQueue = delegationManager.getSlashableSharesInQueue(defaultOperator, strategyMock); - assertEq(slashableSharesInQueue, depositAmount/6 * 3, "slashable shares in queue should be 3/6 of the deposit amount"); + assertEq( + slashableSharesInQueue, + depositAmount / 6 * 3, + "slashable shares in queue should be 3/6 of the deposit amount" + ); // Slash all of operator's shares _setOperatorMagnitude(defaultOperator, strategyMock, 0); @@ -6757,7 +6551,7 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests depositAmount / 6 // 1 withdrawal not queued so decreased ); delegationManager.slashOperatorShares(defaultOperator, strategyMock, WAD, 0); - + // Assert slashable shares slashableSharesInQueue = delegationManager.getSlashableSharesInQueue(defaultOperator, strategyMock); assertEq(slashableSharesInQueue, 0); @@ -6767,7 +6561,9 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests * @notice Verifies that `DelegationManager.slashOperatorShares` properly decreases the delegated `shares` that the operator * who the `defaultStaker` is delegated to has in the strategies */ - function testFuzz_slashOperatorShares_slashedOperator(Randomness r) public rand(r) { + function testFuzz_slashOperatorShares_slashedOperator( + Randomness r + ) public rand(r) { // sanity-filtering on fuzzed input length & staker IStrategy[] memory strategies = r.StrategyArray(16); uint256 shares = r.Uint256(1, MAX_STRATEGY_SHARES); @@ -6785,7 +6581,7 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests // Set the staker deposits in the strategies uint256[] memory sharesToSet = new uint256[](strategies.length); uint256[] memory depositScalingFactors = new uint256[](strategies.length); - for(uint256 i = 0; i < strategies.length; i++) { + for (uint256 i = 0; i < strategies.length; i++) { strategies[i] = IStrategy(random().Address()); sharesToSet[i] = shares; depositScalingFactors[i] = uint256(WAD).divWad(uint256(prevMaxMagnitude)); @@ -6832,12 +6628,7 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests }); cheats.expectEmit(true, true, true, true, address(delegationManager)); - emit OperatorSharesDecreased( - defaultOperator, - address(0), - strategies[i], - sharesToDecrease - ); + emit OperatorSharesDecreased(defaultOperator, address(0), strategies[i], sharesToDecrease); delegationManager.slashOperatorShares(defaultOperator, strategies[i], prevMaxMagnitude, newMaxMagnitude); // Also update maxMagnitude in ALM mock @@ -6849,7 +6640,7 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests } // check shares after call to `slashOperatorShares` - (uint256[] memory withdrawableShares, ) = delegationManager.getWithdrawableShares(defaultStaker, strategies); + (uint256[] memory withdrawableShares,) = delegationManager.getWithdrawableShares(defaultStaker, strategies); for (uint256 i = 0; i < strategies.length; ++i) { uint256 delegatedSharesAfter = delegationManager.operatorShares(delegatedTo, strategies[i]); assertEq( @@ -6893,7 +6684,7 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests uint256 queuedSlashableSharesBefore = delegationManager.getSlashableSharesInQueue(operator, strategyMock); // calculate burned shares, should be halved - uint256 sharesToBurn = shares/2; + uint256 sharesToBurn = shares / 2; // Burn shares _slashOperatorShares_expectEmit( @@ -6904,6 +6695,11 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests sharesToBurn: sharesToBurn }) ); + + // Assert OperatorSharesSlashed event was emitted with correct params + cheats.expectEmit(true, true, true, true, address(delegationManager)); + emit OperatorSharesSlashed(operator, strategyMock, sharesToBurn); + cheats.prank(address(allocationManagerMock)); delegationManager.slashOperatorShares({ operator: operator, @@ -6916,7 +6712,11 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests uint256 operatorSharesAfter = delegationManager.operatorShares(operator, strategyMock); assertEq(queuedSlashableSharesBefore, 0, "there should be no slashable shares in queue"); assertEq(queuedSlashableSharesAfter, 0, "there should be no slashable shares in queue"); - assertEq(operatorSharesAfter, operatorSharesBefore - sharesToBurn, "operator shares should be decreased by sharesToBurn"); + assertEq( + operatorSharesAfter, + operatorSharesBefore - sharesToBurn, + "operator shares should be decreased by sharesToBurn" + ); } /** @@ -6951,10 +6751,8 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests // 3. Queue withdrawal for staker2 and roll blocks forward so that the withdrawal is not slashable { - ( - QueuedWithdrawalParams[] memory queuedWithdrawalParams, - Withdrawal memory withdrawal, - ) = _setUpQueueWithdrawalsSingleStrat({ + (QueuedWithdrawalParams[] memory queuedWithdrawalParams, Withdrawal memory withdrawal,) = + _setUpQueueWithdrawalsSingleStrat({ staker: staker2, strategy: strategyMock, depositSharesToWithdraw: withdrawAmount @@ -6988,6 +6786,11 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests sharesToBurn: sharesToBurn }) ); + + // Assert OperatorSharesSlashed event was emitted with correct params + cheats.expectEmit(true, true, true, true, address(delegationManager)); + emit OperatorSharesSlashed(operator, strategyMock, sharesToBurn); + cheats.prank(address(allocationManagerMock)); delegationManager.slashOperatorShares({ operator: operator, @@ -7001,14 +6804,20 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests uint256 operatorSharesAfter = delegationManager.operatorShares(operator, strategyMock); assertEq(queuedSlashableSharesBefore, 0, "there should be no slashable shares in queue"); assertEq(queuedSlashableSharesAfter, 0, "there should be no slashable shares in queue"); - assertEq(operatorSharesAfter, operatorSharesBefore - sharesToBurn, "operator shares should be decreased by sharesToBurn"); + assertEq( + operatorSharesAfter, + operatorSharesBefore - sharesToBurn, + "operator shares should be decreased by sharesToBurn" + ); } /** * @notice Test burning shares for an operator with slashable queued withdrawals in past MIN_WITHDRAWAL_DELAY_BLOCKS window. * There exists a single withdrawal that is slashable. */ - function testFuzz_slashOperatorShares_SingleSlashableWithdrawal(Randomness r) public rand(r) { + function testFuzz_slashOperatorShares_SingleSlashableWithdrawal( + Randomness r + ) public rand(r) { // 1. Randomize operator and staker info // Operator info address operator = r.Address(); @@ -7030,9 +6839,7 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests // 3. Queue withdrawal for staker2 so that the withdrawal is slashable { - ( - QueuedWithdrawalParams[] memory queuedWithdrawalParams,, - ) = _setUpQueueWithdrawalsSingleStrat({ + (QueuedWithdrawalParams[] memory queuedWithdrawalParams,,) = _setUpQueueWithdrawalsSingleStrat({ staker: staker2, strategy: strategyMock, depositSharesToWithdraw: withdrawAmount @@ -7066,6 +6873,11 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests sharesToBurn: sharesToBurn }) ); + + // Assert OperatorSharesSlashed event was emitted with correct params + cheats.expectEmit(true, true, true, true, address(delegationManager)); + emit OperatorSharesSlashed(operator, strategyMock, sharesToBurn); + cheats.prank(address(allocationManagerMock)); delegationManager.slashOperatorShares({ operator: operator, @@ -7077,9 +6889,19 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests // 5. Assert expected values uint256 queuedSlashableSharesAfter = delegationManager.getSlashableSharesInQueue(operator, strategyMock); uint256 operatorSharesAfter = delegationManager.operatorShares(operator, strategyMock); - assertEq(queuedSlashableSharesBefore, withdrawAmount, "Slashable shares in queue should be full withdraw amount"); - assertEq(queuedSlashableSharesAfter, withdrawAmount / 4, "Slashable shares in queue should be 1/4 withdraw amount after slashing"); - assertEq(operatorSharesAfter, operatorSharesBefore - sharesToDecrease, "operator shares should be decreased by sharesToBurn"); + assertEq( + queuedSlashableSharesBefore, withdrawAmount, "Slashable shares in queue should be full withdraw amount" + ); + assertEq( + queuedSlashableSharesAfter, + withdrawAmount / 4, + "Slashable shares in queue should be 1/4 withdraw amount after slashing" + ); + assertEq( + operatorSharesAfter, + operatorSharesBefore - sharesToDecrease, + "operator shares should be decreased by sharesToBurn" + ); } /** @@ -7106,10 +6928,8 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests // 3. Queue withdrawal for staker and roll blocks forward so that the withdrawal is not slashable { - ( - QueuedWithdrawalParams[] memory queuedWithdrawalParams, - Withdrawal memory withdrawal, - ) = _setUpQueueWithdrawalsSingleStrat({ + (QueuedWithdrawalParams[] memory queuedWithdrawalParams, Withdrawal memory withdrawal,) = + _setUpQueueWithdrawalsSingleStrat({ staker: staker, strategy: strategyMock, depositSharesToWithdraw: withdrawAmount1 @@ -7122,10 +6942,7 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests "there should be withdrawAmount slashable shares in queue" ); - ( - queuedWithdrawalParams, - withdrawal, - ) = _setUpQueueWithdrawalsSingleStrat({ + (queuedWithdrawalParams, withdrawal,) = _setUpQueueWithdrawalsSingleStrat({ staker: staker, strategy: strategyMock, depositSharesToWithdraw: withdrawAmount2 @@ -7145,7 +6962,8 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests // calculate burned shares, should be halved for both operatorShares and slashable shares in queue // staker queue withdraws shares twice and both withdrawals should be slashed 75%. uint256 sharesToDecrease = (depositAmount - withdrawAmount1 - withdrawAmount2) * 3 / 4; - uint256 sharesToBurn = sharesToDecrease + (delegationManager.getSlashableSharesInQueue(operator, strategyMock) * 3 / 4); + uint256 sharesToBurn = + sharesToDecrease + (delegationManager.getSlashableSharesInQueue(operator, strategyMock) * 3 / 4); // 4. Burn shares _setOperatorMagnitude(operator, strategyMock, newMagnitude); @@ -7157,6 +6975,11 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests sharesToBurn: sharesToBurn }) ); + + // Assert OperatorSharesSlashed event was emitted with correct params + cheats.expectEmit(true, true, true, true, address(delegationManager)); + emit OperatorSharesSlashed(operator, strategyMock, sharesToBurn); + cheats.prank(address(allocationManagerMock)); delegationManager.slashOperatorShares({ operator: operator, @@ -7168,9 +6991,21 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests // 5. Assert expected values uint256 queuedSlashableSharesAfter = delegationManager.getSlashableSharesInQueue(operator, strategyMock); uint256 operatorSharesAfter = delegationManager.operatorShares(operator, strategyMock); - assertEq(queuedSlashableSharesBefore, (withdrawAmount1 + withdrawAmount2), "Slashable shares in queue should be full withdraw amount"); - assertEq(queuedSlashableSharesAfter, (withdrawAmount1 + withdrawAmount2) / 4, "Slashable shares in queue should be 1/4 withdraw amount after slashing"); - assertEq(operatorSharesAfter, operatorSharesBefore - sharesToDecrease, "operator shares should be decreased by sharesToBurn"); + assertEq( + queuedSlashableSharesBefore, + (withdrawAmount1 + withdrawAmount2), + "Slashable shares in queue should be full withdraw amount" + ); + assertEq( + queuedSlashableSharesAfter, + (withdrawAmount1 + withdrawAmount2) / 4, + "Slashable shares in queue should be 1/4 withdraw amount after slashing" + ); + assertEq( + operatorSharesAfter, + operatorSharesBefore - sharesToDecrease, + "operator shares should be decreased by sharesToBurn" + ); } /** @@ -7178,9 +7013,9 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests * There exists multiple withdrawals that are slashable but queued with different maxMagnitudes at * time of queuing. * - * Test Setup: + * Test Setup: * - staker1 deposits, queues withdrawal for some amount, - * - operator slashed 50% + * - operator slashed 50% * - staker 2 deposits, queues withdrawal for some amount * - operator is then slashed another 50% * slashed amount for staker 1 should be 75% and staker 2 should be 50% where the total @@ -7204,9 +7039,7 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests // 3. Queue withdrawal for staker and slash operator for 50% { - ( - QueuedWithdrawalParams[] memory queuedWithdrawalParams,, - ) = _setUpQueueWithdrawalsSingleStrat({ + (QueuedWithdrawalParams[] memory queuedWithdrawalParams,,) = _setUpQueueWithdrawalsSingleStrat({ staker: staker, strategy: strategyMock, depositSharesToWithdraw: depositSharesToWithdraw1 @@ -7219,7 +7052,7 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests uint256 queuedSlashableSharesBefore = delegationManager.getSlashableSharesInQueue(operator, strategyMock); uint256 sharesToDecrease = (depositAmount - depositSharesToWithdraw1) / 2; - uint256 sharesToBurn = sharesToDecrease + depositSharesToWithdraw1/2; + uint256 sharesToBurn = sharesToDecrease + depositSharesToWithdraw1 / 2; // 3.2 Burn shares _setOperatorMagnitude(operator, strategyMock, newMagnitude); @@ -7231,6 +7064,11 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests sharesToBurn: sharesToBurn }) ); + + // Assert OperatorSharesSlashed event was emitted with correct params + cheats.expectEmit(true, true, true, true, address(delegationManager)); + emit OperatorSharesSlashed(operator, strategyMock, sharesToBurn); + cheats.prank(address(allocationManagerMock)); delegationManager.slashOperatorShares({ operator: operator, @@ -7260,15 +7098,12 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests // 4. Queue withdrawal for staker and slash operator for 60% again newMagnitude = 25e16; { - ( - QueuedWithdrawalParams[] memory queuedWithdrawalParams,, - ) = _setUpQueueWithdrawalsSingleStrat({ + (QueuedWithdrawalParams[] memory queuedWithdrawalParams,,) = _setUpQueueWithdrawalsSingleStrat({ staker: staker, strategy: strategyMock, depositSharesToWithdraw: depositSharesToWithdraw2 }); - // 4.1 queue a withdrawal for the staker cheats.prank(staker); delegationManager.queueWithdrawals(queuedWithdrawalParams); @@ -7288,18 +7123,23 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests sharesToBurn: sharesToBurn }) ); + + // Assert OperatorSharesSlashed event was emitted with correct params + cheats.expectEmit(true, true, true, true, address(delegationManager)); + emit OperatorSharesSlashed(operator, strategyMock, sharesToBurn); + cheats.prank(address(allocationManagerMock)); delegationManager.slashOperatorShares({ operator: operator, strategy: strategyMock, - prevMaxMagnitude: newMagnitude*2, + prevMaxMagnitude: newMagnitude * 2, newMaxMagnitude: newMagnitude }); // 4.3 Assert slashable shares and operator shares assertEq( queuedSlashableSharesBefore, - (depositSharesToWithdraw1 + depositSharesToWithdraw2)/2, + (depositSharesToWithdraw1 + depositSharesToWithdraw2) / 2, "Slashable shares in queue before should be both queued withdrawal amounts halved" ); assertEq( @@ -7320,7 +7160,9 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests * However if the withdrawal is not completable and the withdrawal delay hasn't elapsed, then the withdrawal * should be counted as slashable. */ - function testFuzz_slashOperatorShares_Timings(Randomness r) public rand(r) { + function testFuzz_slashOperatorShares_Timings( + Randomness r + ) public rand(r) { // 1. Randomize operator and staker info // Operator info address operator = r.Address(); @@ -7337,10 +7179,8 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests // 3. Queue withdrawal for staker and roll blocks forward so that the withdrawal is completable uint256 completableBlock; { - ( - QueuedWithdrawalParams[] memory queuedWithdrawalParams, - Withdrawal memory withdrawal, - ) = _setUpQueueWithdrawalsSingleStrat({ + (QueuedWithdrawalParams[] memory queuedWithdrawalParams, Withdrawal memory withdrawal,) = + _setUpQueueWithdrawalsSingleStrat({ staker: staker, strategy: strategyMock, depositSharesToWithdraw: depositAmount @@ -7378,7 +7218,6 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests ); cheats.stopPrank(); - } uint256 operatorSharesBefore = delegationManager.operatorShares(operator, strategyMock); @@ -7393,6 +7232,11 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests sharesToBurn: 0 }) ); + + // Assert OperatorSharesSlashed event was emitted with correct params + cheats.expectEmit(true, true, true, true, address(delegationManager)); + emit OperatorSharesSlashed(operator, strategyMock, 0); + cheats.prank(address(allocationManagerMock)); delegationManager.slashOperatorShares({ operator: operator, @@ -7417,7 +7261,9 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests * and there are no slashable shares in the queue. Note: this will be implemented in a future release with * consideration of the Pectra upgrade. */ - function testFuzz_slashOperatorShares_BeaconChainStrategy(Randomness r) public rand(r) { + function testFuzz_slashOperatorShares_BeaconChainStrategy( + Randomness r + ) public rand(r) { // 1. Randomize operator and staker info // Operator info address operator = r.Address(); @@ -7439,9 +7285,7 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests // 3. Queue withdrawal for staker2 so that the withdrawal is slashable { - ( - QueuedWithdrawalParams[] memory queuedWithdrawalParams,, - ) = _setUpQueueWithdrawalsSingleStrat({ + (QueuedWithdrawalParams[] memory queuedWithdrawalParams,,) = _setUpQueueWithdrawalsSingleStrat({ staker: staker2, strategy: beaconChainETHStrategy, depositSharesToWithdraw: withdrawAmount @@ -7450,24 +7294,31 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests delegationManager.queueWithdrawals(queuedWithdrawalParams); assertEq( delegationManager.getSlashableSharesInQueue(operator, beaconChainETHStrategy), - 0, - "there should be 0 withdrawAmount slashable shares in queue since this is beaconChainETHStrategy" + withdrawAmount, + "there should be withdrawAmount slashable shares in queue" ); } uint256 operatorSharesBefore = delegationManager.operatorShares(operator, beaconChainETHStrategy); - uint256 queuedSlashableSharesBefore = delegationManager.getSlashableSharesInQueue(operator, beaconChainETHStrategy); + uint256 queuedSlashableSharesBefore = + delegationManager.getSlashableSharesInQueue(operator, beaconChainETHStrategy); // calculate burned shares, should be 3/4 of the original shares // staker2 queue withdraws shares // Therefore amount of shares to burn should be what the staker still has remaining + staker1 shares and then // divided by 2 since the operator was slashed 50% uint256 sharesToDecrease = (shares + depositAmount - withdrawAmount) * 3 / 4; + uint256 sharesToBurn = sharesToDecrease + (delegationManager.getSlashableSharesInQueue(operator, beaconChainETHStrategy) * 3 / 4); // 4. Burn shares _setOperatorMagnitude(operator, beaconChainETHStrategy, newMagnitude); cheats.expectEmit(true, true, true, true, address(delegationManager)); emit OperatorSharesDecreased(operator, address(0), beaconChainETHStrategy, sharesToDecrease); + + // Assert OperatorSharesSlashed event was emitted with correct params + cheats.expectEmit(true, true, true, true, address(delegationManager)); + emit OperatorSharesSlashed(operator, beaconChainETHStrategy, sharesToBurn); + cheats.prank(address(allocationManagerMock)); delegationManager.slashOperatorShares({ operator: operator, @@ -7477,27 +7328,28 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests }); // 5. Assert expected values - uint256 queuedSlashableSharesAfter = delegationManager.getSlashableSharesInQueue(operator, beaconChainETHStrategy); + uint256 queuedSlashableSharesAfter = + delegationManager.getSlashableSharesInQueue(operator, beaconChainETHStrategy); uint256 operatorSharesAfter = delegationManager.operatorShares(operator, beaconChainETHStrategy); - assertEq(queuedSlashableSharesBefore, 0, "Slashable shares in queue should be 0 for beaconChainStrategy"); - assertEq(queuedSlashableSharesAfter, 0, "Slashable shares in queue should be 0 for beaconChainStrategy"); + assertEq(queuedSlashableSharesBefore, withdrawAmount, "Slashable shares in queue should be full withdraw amount"); + assertEq(queuedSlashableSharesAfter, withdrawAmount / 4, "Slashable shares in queue should be 1/4 withdraw amount after slashing"); assertEq(operatorSharesAfter, operatorSharesBefore - sharesToDecrease, "operator shares should be decreased by sharesToDecrease"); } /** * @notice This test demonstrates that the rate that withdrawable shares decrease from slashing is at LEAST - * greater than or equal to the rate that the operator shares decrease from slashing. + * greater than or equal to the rate that the operator shares decrease from slashing. * We want this property otherwise undelegating/queue withdrawing all shares as a staker could lead to a underflow revert. * Note: If the SlashingLib.calcSlashedAmount function were to round down (overslash) then this test would fail. */ function test_slashOperatorShares_slashedRepeatedly() public { - uint64 initialMagnitude = 90009; - uint256 shares = 40000000004182209037560531097078597505; + uint64 initialMagnitude = 90_009; + uint256 shares = 40_000_000_004_182_209_037_560_531_097_078_597_505; // register *this contract* as an operator _registerOperatorWithBaseDetails(defaultOperator); _setOperatorMagnitude(defaultOperator, strategyMock, initialMagnitude); - + // Set the staker deposits in the strategies strategyManagerMock.addDeposit(defaultStaker, strategyMock, shares); @@ -7512,19 +7364,18 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests newOperatorMagnitude -= slashMagnitude; _setOperatorMagnitude(defaultOperator, strategyMock, newOperatorMagnitude); + // Assert OperatorSharesSlashed event was emitted with correct params + cheats.expectEmit(true, true, true, true, address(delegationManager)); + emit OperatorSharesSlashed(defaultOperator, strategyMock, 44440000449046438731194137360795695); + cheats.prank(address(allocationManagerMock)); delegationManager.slashOperatorShares( - defaultOperator, - strategyMock, - newOperatorMagnitude + slashMagnitude, - newOperatorMagnitude + defaultOperator, strategyMock, newOperatorMagnitude + slashMagnitude, newOperatorMagnitude ); uint256 operatorSharesAfterSlash = delegationManager.operatorShares(defaultOperator, strategyMock); - ( - uint256[] memory withdrawableShares, - uint256[] memory depositShares - ) = delegationManager.getWithdrawableShares(defaultStaker, strategyMock.toArray()); + (uint256[] memory withdrawableShares, uint256[] memory depositShares) = + delegationManager.getWithdrawableShares(defaultStaker, strategyMock.toArray()); assertEq(depositShares[0], shares, "staker deposit shares not reset correctly"); assertLe( withdrawableShares[0], @@ -7539,7 +7390,9 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests * and also on the beaconChain. This test ensures that the order of slashing does not matter and nets * the same withdrawableShares for the staker whether slashing occurred on the beaconChain, or on EigenLayer first. */ - function testFuzz_beaconSlashAndAVSSlash(Randomness r) public rand(r) { + function testFuzz_beaconSlashAndAVSSlash( + Randomness r + ) public rand(r) { uint64 initialMagnitude = r.Uint64(2, WAD); uint64 newMaxMagnitude = r.Uint64(1, initialMagnitude); // note: beaconShares only goes negative when performing withdrawal -- and this will change post-migration @@ -7587,15 +7440,13 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests { // Slash beaconChain first { - (withdrawableShares,) = delegationManager.getWithdrawableShares(defaultStaker, beaconChainETHStrategy.toArray()); + (withdrawableShares,) = + delegationManager.getWithdrawableShares(defaultStaker, beaconChainETHStrategy.toArray()); uint256 beaconSharesBeforeSlash = withdrawableShares[0]; uint64 prevBeaconChainSlashingFactor; - (prevBeaconChainSlashingFactor, newBeaconSlashingFactor) = _decreaseBeaconChainShares( - defaultStaker, - beaconShares, - sharesDecrease - ); + (prevBeaconChainSlashingFactor, newBeaconSlashingFactor) = + _decreaseBeaconChainShares(defaultStaker, beaconShares, sharesDecrease); uint256 expectedWithdrawableShares = _calcWithdrawableShares({ depositShares: uint256(beaconShares), @@ -7611,19 +7462,23 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests } // Slash on EigenLayer second { - (withdrawableShares,) = delegationManager.getWithdrawableShares(defaultStaker, beaconChainETHStrategy.toArray()); + (withdrawableShares,) = + delegationManager.getWithdrawableShares(defaultStaker, beaconChainETHStrategy.toArray()); uint256 beaconSharesBeforeSlash = withdrawableShares[0]; // do a slash via an AVS _setOperatorMagnitude(defaultOperator, beaconChainETHStrategy, newMaxMagnitude); cheats.prank(address(allocationManagerMock)); - delegationManager.slashOperatorShares(defaultOperator, beaconChainETHStrategy, initialMagnitude, newMaxMagnitude); + delegationManager.slashOperatorShares( + defaultOperator, beaconChainETHStrategy, initialMagnitude, newMaxMagnitude + ); // save the outcome - (withdrawableShares,) = delegationManager.getWithdrawableShares(defaultStaker, beaconChainETHStrategy.toArray()); + (withdrawableShares,) = + delegationManager.getWithdrawableShares(defaultStaker, beaconChainETHStrategy.toArray()); uint256 beaconSharesAfterSecondSlash = withdrawableShares[0]; uint256 expectedWithdrawable = _calcWithdrawableShares( - uint256(beaconShares), + uint256(beaconShares), uint256(WAD).divWad(initialMagnitude), _getSlashingFactor(defaultStaker, beaconChainETHStrategy, newMaxMagnitude) ); @@ -7645,16 +7500,15 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests // 2. do AVS slash then beacon chain slash //////////////////////////// - // restore the staker and operator to their original state - // Reset operator's magnitude, beaconChainSlashingFactor + // initialize new staker and operator with same initial conditions delegationManager.undelegate(defaultStaker); _registerOperatorWithBaseDetails(defaultOperator2); _setOperatorMagnitude(defaultOperator2, beaconChainETHStrategy, initialMagnitude); - eigenPodManagerMock.setPodOwnerShares(defaultStaker, beaconShares); - eigenPodManagerMock.setBeaconChainSlashingFactor(defaultStaker, WAD); - _delegateToOperatorWhoAcceptsAllStakers(defaultStaker, defaultOperator2); + eigenPodManagerMock.setPodOwnerShares(defaultStaker2, beaconShares); + eigenPodManagerMock.setBeaconChainSlashingFactor(defaultStaker2, WAD); + _delegateToOperatorWhoAcceptsAllStakers(defaultStaker2, defaultOperator2); _assertDeposit({ - staker: defaultStaker, + staker: defaultStaker2, operator: defaultOperator2, strategy: beaconChainETHStrategy, operatorSharesBefore: 0, @@ -7667,21 +7521,24 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests { // Slash on EigenLayer first { - (withdrawableShares,) = delegationManager.getWithdrawableShares(defaultStaker, beaconChainETHStrategy.toArray()); + (withdrawableShares,) = + delegationManager.getWithdrawableShares(defaultStaker2, beaconChainETHStrategy.toArray()); uint256 beaconSharesBeforeSlash = withdrawableShares[0]; _setOperatorMagnitude(defaultOperator2, beaconChainETHStrategy, newMaxMagnitude); cheats.prank(address(allocationManagerMock)); - delegationManager.slashOperatorShares(defaultOperator2, beaconChainETHStrategy, initialMagnitude, newMaxMagnitude); + delegationManager.slashOperatorShares( + defaultOperator2, beaconChainETHStrategy, initialMagnitude, newMaxMagnitude + ); uint256 expectedWithdrawable = _calcWithdrawableShares( - uint256(beaconShares), + uint256(beaconShares), uint256(WAD).divWad(initialMagnitude), - _getSlashingFactor(defaultStaker, beaconChainETHStrategy, newMaxMagnitude) + _getSlashingFactor(defaultStaker2, beaconChainETHStrategy, newMaxMagnitude) ); _assertSharesAfterSlash({ - staker: defaultStaker, + staker: defaultStaker2, strategy: beaconChainETHStrategy, withdrawableSharesBefore: beaconSharesBeforeSlash, expectedWithdrawableShares: expectedWithdrawable, @@ -7692,15 +7549,13 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests // Slash beaconChain second { - (withdrawableShares,) = delegationManager.getWithdrawableShares(defaultStaker, beaconChainETHStrategy.toArray()); + (withdrawableShares,) = + delegationManager.getWithdrawableShares(defaultStaker2, beaconChainETHStrategy.toArray()); uint256 beaconSharesBeforeSlash = withdrawableShares[0]; uint64 prevBeaconChainSlashingFactor; - (prevBeaconChainSlashingFactor, newBeaconSlashingFactor) = _decreaseBeaconChainShares( - defaultStaker, - beaconShares, - sharesDecrease - ); + (prevBeaconChainSlashingFactor, newBeaconSlashingFactor) = + _decreaseBeaconChainShares(defaultStaker2, beaconShares, sharesDecrease); uint256 expectedWithdrawableShares = _calcWithdrawableShares({ depositShares: uint256(beaconShares), @@ -7708,7 +7563,7 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests slashingFactor: newMaxMagnitude.mulWad(newBeaconSlashingFactor) }); _assertSharesAfterBeaconSlash({ - staker: defaultStaker, + staker: defaultStaker2, withdrawableSharesBefore: beaconSharesBeforeSlash, expectedWithdrawableShares: expectedWithdrawableShares, prevBeaconSlashingFactor: prevBeaconChainSlashingFactor @@ -7719,12 +7574,9 @@ contract DelegationManagerUnitTests_slashingShares is DelegationManagerUnitTests //////////////////////////// // 3. Confirm withdrawable shares are the same regardless of order of operations in Test 1 or Test 2 //////////////////////////// - (withdrawableShares,) = delegationManager.getWithdrawableShares(defaultStaker, beaconChainETHStrategy.toArray()); - assertEq( - withdrawableShares[0], - sharesAfterAllSlashing, - "shares after all slashing should be the same" - ); + (withdrawableShares,) = + delegationManager.getWithdrawableShares(defaultStaker2, beaconChainETHStrategy.toArray()); + assertEq(withdrawableShares[0], sharesAfterAllSlashing, "shares after all slashing should be the same"); } } @@ -7743,7 +7595,7 @@ contract DelegationManagerUnitTests_SharesUnderflowChecks is DelegationManagerUn function testFuzz_slashDepositRepeatedly( Randomness r ) public rand(r) { - uint64 initMagnitude = r.Uint64(10000, WAD); + uint64 initMagnitude = r.Uint64(10_000, WAD); uint256 shares = r.Uint256(1, MAX_STRATEGY_SHARES); cheats.assume(initMagnitude % 2 != 0); cheats.assume(shares % 2 != 0); @@ -7751,7 +7603,7 @@ contract DelegationManagerUnitTests_SharesUnderflowChecks is DelegationManagerUn // register *this contract* as an operator _registerOperatorWithBaseDetails(defaultOperator); _setOperatorMagnitude(defaultOperator, strategyMock, initMagnitude); - + // Set the staker deposits in the strategies IStrategy[] memory strategies = strategyMock.toArray(); { @@ -7764,13 +7616,11 @@ contract DelegationManagerUnitTests_SharesUnderflowChecks is DelegationManagerUn // delegate from the `defaultStaker` to the operator _delegateToOperatorWhoAcceptsAllStakers(defaultStaker, defaultOperator); - // Slash and deposit more for each iteration uint64 currMagnitude = initMagnitude; { uint256 newDepositShares = shares; for (uint256 i = 0; i < 100; ++i) { - // 1. slash operator for 100 magnitude uint64 slashMagnitude = 100; currMagnitude -= slashMagnitude; @@ -7796,7 +7646,7 @@ contract DelegationManagerUnitTests_SharesUnderflowChecks is DelegationManagerUn } } - (uint256[] memory withdrawableShares, ) = delegationManager.getWithdrawableShares(defaultStaker, strategies); + (uint256[] memory withdrawableShares,) = delegationManager.getWithdrawableShares(defaultStaker, strategies); assertLe( withdrawableShares[0], delegationManager.operatorShares(defaultOperator, strategyMock), @@ -7806,13 +7656,23 @@ contract DelegationManagerUnitTests_SharesUnderflowChecks is DelegationManagerUn if (cheats.envOr("WRITE_CSV_TESTS", false)) { cheats.writeLine( "./test.csv", - string(abi.encodePacked( - cheats.toString(initMagnitude), ", ", - cheats.toString(shares), ", ", - cheats.toString(delegationManager.operatorShares(defaultOperator, strategyMock)), ", ", - cheats.toString(withdrawableShares[0]), ", ", - cheats.toString(stdMath.delta(delegationManager.operatorShares(defaultOperator, strategyMock), withdrawableShares[0])) - )) + string( + abi.encodePacked( + cheats.toString(initMagnitude), + ", ", + cheats.toString(shares), + ", ", + cheats.toString(delegationManager.operatorShares(defaultOperator, strategyMock)), + ", ", + cheats.toString(withdrawableShares[0]), + ", ", + cheats.toString( + stdMath.delta( + delegationManager.operatorShares(defaultOperator, strategyMock), withdrawableShares[0] + ) + ) + ) + ) ); } } @@ -7822,11 +7682,11 @@ contract DelegationManagerUnitTests_SharesUnderflowChecks is DelegationManagerUn * Single staker with fuzzed starting shares and magnitude. * Slash 100 magnitude and fuzz deposit amount for 100 iterations. */ - /// forge-config: default.fuzz.runs = 50 + /// forge-config: default.fuzz.runs = 50 function testFuzz_slashDepositRepeatedly_randDeposits( Randomness r ) public rand(r) { - uint64 initMagnitude = r.Uint64(10000, WAD); + uint64 initMagnitude = r.Uint64(10_000, WAD); uint256 depositAmount = r.Uint256(1, 1e34); uint256 shares = r.Uint256(1, MAX_STRATEGY_SHARES / 1e4); cheats.assume(initMagnitude % 2 != 0); @@ -7835,7 +7695,7 @@ contract DelegationManagerUnitTests_SharesUnderflowChecks is DelegationManagerUn // register *this contract* as an operator _registerOperatorWithBaseDetails(defaultOperator); _setOperatorMagnitude(defaultOperator, strategyMock, initMagnitude); - + // Set the staker deposits in the strategies IStrategy[] memory strategies = strategyMock.toArray(); { @@ -7848,13 +7708,11 @@ contract DelegationManagerUnitTests_SharesUnderflowChecks is DelegationManagerUn // delegate from the `defaultStaker` to the operator _delegateToOperatorWhoAcceptsAllStakers(defaultStaker, defaultOperator); - // Slash and deposit more for each iteration uint64 currMagnitude = initMagnitude; { uint256 newDepositShares = shares; for (uint256 i = 0; i < 100; ++i) { - // 1. slash operator for 100 magnitude uint64 slashMagnitude = 100; currMagnitude -= slashMagnitude; @@ -7879,7 +7737,7 @@ contract DelegationManagerUnitTests_SharesUnderflowChecks is DelegationManagerUn } } - (uint256[] memory withdrawableShares, ) = delegationManager.getWithdrawableShares(defaultStaker, strategies); + (uint256[] memory withdrawableShares,) = delegationManager.getWithdrawableShares(defaultStaker, strategies); assertLe( withdrawableShares[0], delegationManager.operatorShares(defaultOperator, strategyMock), @@ -7889,29 +7747,39 @@ contract DelegationManagerUnitTests_SharesUnderflowChecks is DelegationManagerUn if (cheats.envOr("WRITE_CSV_TESTS", false)) { cheats.writeLine( "./test2.csv", - string(abi.encodePacked( - cheats.toString(initMagnitude), ", ", - cheats.toString(shares), ", ", - cheats.toString(depositAmount), ", ", - cheats.toString(delegationManager.operatorShares(defaultOperator, strategyMock)), ", ", - cheats.toString(withdrawableShares[0]), ", ", - cheats.toString(stdMath.delta(delegationManager.operatorShares(defaultOperator, strategyMock), withdrawableShares[0])) - )) + string( + abi.encodePacked( + cheats.toString(initMagnitude), + ", ", + cheats.toString(shares), + ", ", + cheats.toString(depositAmount), + ", ", + cheats.toString(delegationManager.operatorShares(defaultOperator, strategyMock)), + ", ", + cheats.toString(withdrawableShares[0]), + ", ", + cheats.toString( + stdMath.delta( + delegationManager.operatorShares(defaultOperator, strategyMock), withdrawableShares[0] + ) + ) + ) + ) ); } } - /** * @notice Fuzzed tests * For 500 stakers, deposit `shares` amount and delegate to the operator. After each staker delegates, * slash 100 magnitude. */ - /// forge-config: default.fuzz.runs = 50 + /// forge-config: default.fuzz.runs = 50 function testFuzz_depositMultipleStakers_slash_repeatedly( Randomness r ) public rand(r) { - uint64 initMagnitude = r.Uint64(50000, WAD); + uint64 initMagnitude = r.Uint64(50_000, WAD); uint256 shares = r.Uint256(MAX_STRATEGY_SHARES / 1e7, MAX_STRATEGY_SHARES / 1e4); cheats.assume(initMagnitude % 2 != 0); cheats.assume(shares % 2 != 0); @@ -7919,7 +7787,7 @@ contract DelegationManagerUnitTests_SharesUnderflowChecks is DelegationManagerUn // register *this contract* as an operator _registerOperatorWithBaseDetails(defaultOperator); _setOperatorMagnitude(defaultOperator, strategyMock, initMagnitude); - + // Set the staker deposits in the strategies IStrategy[] memory strategies = strategyMock.toArray(); uint256[] memory sharesToSet = new uint256[](1); @@ -7954,7 +7822,7 @@ contract DelegationManagerUnitTests_SharesUnderflowChecks is DelegationManagerUn uint256 operatorSharesAfter = delegationManager.operatorShares(defaultOperator, strategyMock); uint256 totalWithdrawableShares = 0; for (uint256 i = 0; i < numStakers; ++i) { - (uint256[] memory withdrawableShares, ) = delegationManager.getWithdrawableShares(stakers[i], strategies); + (uint256[] memory withdrawableShares,) = delegationManager.getWithdrawableShares(stakers[i], strategies); totalWithdrawableShares += withdrawableShares[0]; } assertLe( @@ -7963,17 +7831,22 @@ contract DelegationManagerUnitTests_SharesUnderflowChecks is DelegationManagerUn "withdrawableShares should be less than or equal to operatorShares" ); - if (cheats.envOr("WRITE_CSV_TESTS", false)) { cheats.writeLine( "./test3.csv", - string(abi.encodePacked( - cheats.toString(initMagnitude), ", ", // initial magnitude - cheats.toString(shares), ", ", // amount each staker deposits - cheats.toString(operatorSharesAfter), ", ", // operator shares after all slashing and deposits - cheats.toString(totalWithdrawableShares), ", ", // total withdrawable shares from all stakers - cheats.toString(stdMath.delta(operatorSharesAfter, totalWithdrawableShares)) // delta difference between opShares and total withdrawable - )) + string( + abi.encodePacked( + cheats.toString(initMagnitude), + ", ", // initial magnitude + cheats.toString(shares), + ", ", // amount each staker deposits + cheats.toString(operatorSharesAfter), + ", ", // operator shares after all slashing and deposits + cheats.toString(totalWithdrawableShares), + ", ", // total withdrawable shares from all stakers + cheats.toString(stdMath.delta(operatorSharesAfter, totalWithdrawableShares)) // delta difference between opShares and total withdrawable + ) + ) ); } } @@ -7987,7 +7860,7 @@ contract DelegationManagerUnitTests_SharesUnderflowChecks is DelegationManagerUn function testFuzz_depositMultipleStakers_slashLargeMagnitudes( Randomness r ) public rand(r) { - uint64 initMagnitude = r.Uint64(50000, WAD); + uint64 initMagnitude = r.Uint64(50_000, WAD); uint256 shares = r.Uint256(MAX_STRATEGY_SHARES / 1e7, MAX_STRATEGY_SHARES / 1e4); cheats.assume(initMagnitude % 2 != 0); cheats.assume(shares % 2 != 0); @@ -7995,7 +7868,7 @@ contract DelegationManagerUnitTests_SharesUnderflowChecks is DelegationManagerUn // register *this contract* as an operator _registerOperatorWithBaseDetails(defaultOperator); _setOperatorMagnitude(defaultOperator, strategyMock, initMagnitude); - + // Set the staker deposits in the strategies IStrategy[] memory strategies = strategyMock.toArray(); uint256[] memory sharesToSet = new uint256[](1); @@ -8008,7 +7881,6 @@ contract DelegationManagerUnitTests_SharesUnderflowChecks is DelegationManagerUn uint64 currMagnitude = initMagnitude; { for (uint256 i = 0; i < numStakers; ++i) { - // 1. deposit and delegate new staker stakers[i] = random().Address(); strategyManagerMock.setDeposits(stakers[i], strategies, sharesToSet); @@ -8031,7 +7903,7 @@ contract DelegationManagerUnitTests_SharesUnderflowChecks is DelegationManagerUn uint256 operatorSharesAfter = delegationManager.operatorShares(defaultOperator, strategyMock); uint256 totalWithdrawableShares = 0; for (uint256 i = 0; i < numStakers; ++i) { - (uint256[] memory withdrawableShares, ) = delegationManager.getWithdrawableShares(stakers[i], strategies); + (uint256[] memory withdrawableShares,) = delegationManager.getWithdrawableShares(stakers[i], strategies); totalWithdrawableShares += withdrawableShares[0]; } assertLe( @@ -8043,13 +7915,19 @@ contract DelegationManagerUnitTests_SharesUnderflowChecks is DelegationManagerUn if (cheats.envOr("WRITE_CSV_TESTS", false)) { cheats.writeLine( "./test4.csv", - string(abi.encodePacked( - cheats.toString(initMagnitude), ", ", // initial magnitude - cheats.toString(shares), ", ", // amount each staker deposits - cheats.toString(operatorSharesAfter), ", ", // operator shares after all slashing and deposits - cheats.toString(totalWithdrawableShares), ", ", // total withdrawable shares from all stakers - cheats.toString(stdMath.delta(operatorSharesAfter, totalWithdrawableShares)) // delta difference between opShares and total withdrawable - )) + string( + abi.encodePacked( + cheats.toString(initMagnitude), + ", ", // initial magnitude + cheats.toString(shares), + ", ", // amount each staker deposits + cheats.toString(operatorSharesAfter), + ", ", // operator shares after all slashing and deposits + cheats.toString(totalWithdrawableShares), + ", ", // total withdrawable shares from all stakers + cheats.toString(stdMath.delta(operatorSharesAfter, totalWithdrawableShares)) // delta difference between opShares and total withdrawable + ) + ) ); } } @@ -8070,7 +7948,7 @@ contract DelegationManagerUnitTests_SharesUnderflowChecks is DelegationManagerUn // register *this contract* as an operator _registerOperatorWithBaseDetails(defaultOperator); _setOperatorMagnitude(defaultOperator, strategyMock, initMagnitude); - + // Set the staker deposits in the strategies IStrategy[] memory strategies = strategyMock.toArray(); uint256[] memory sharesToSet = new uint256[](1); @@ -8083,7 +7961,6 @@ contract DelegationManagerUnitTests_SharesUnderflowChecks is DelegationManagerUn uint64 currMagnitude = initMagnitude; { for (uint256 i = 0; i < numStakers; ++i) { - // 1. deposit and delegate new staker stakers[i] = random().Address(); strategyManagerMock.setDeposits(stakers[i], strategies, sharesToSet); @@ -8106,7 +7983,7 @@ contract DelegationManagerUnitTests_SharesUnderflowChecks is DelegationManagerUn uint256 operatorSharesAfter = delegationManager.operatorShares(defaultOperator, strategyMock); uint256 totalWithdrawableShares = 0; for (uint256 i = 0; i < numStakers; ++i) { - (uint256[] memory withdrawableShares, ) = delegationManager.getWithdrawableShares(stakers[i], strategies); + (uint256[] memory withdrawableShares,) = delegationManager.getWithdrawableShares(stakers[i], strategies); totalWithdrawableShares += withdrawableShares[0]; } assertLe( @@ -8114,17 +7991,23 @@ contract DelegationManagerUnitTests_SharesUnderflowChecks is DelegationManagerUn operatorSharesAfter, "withdrawableShares should be less than or equal to operatorShares" ); - + if (cheats.envOr("WRITE_CSV_TESTS", false)) { cheats.writeLine( "./test5.csv", - string(abi.encodePacked( - cheats.toString(initMagnitude), ", ", // initial magnitude - cheats.toString(shares), ", ", // amount each staker deposits - cheats.toString(operatorSharesAfter), ", ", // operator shares after all slashing and deposits - cheats.toString(totalWithdrawableShares), ", ", // total withdrawable shares from all stakers - cheats.toString(stdMath.delta(operatorSharesAfter, totalWithdrawableShares)) // delta difference between opShares and total withdrawable - )) + string( + abi.encodePacked( + cheats.toString(initMagnitude), + ", ", // initial magnitude + cheats.toString(shares), + ", ", // amount each staker deposits + cheats.toString(operatorSharesAfter), + ", ", // operator shares after all slashing and deposits + cheats.toString(totalWithdrawableShares), + ", ", // total withdrawable shares from all stakers + cheats.toString(stdMath.delta(operatorSharesAfter, totalWithdrawableShares)) // delta difference between opShares and total withdrawable + ) + ) ); } } @@ -8145,7 +8028,7 @@ contract DelegationManagerUnitTests_SharesUnderflowChecks is DelegationManagerUn // register *this contract* as an operator _registerOperatorWithBaseDetails(defaultOperator); _setOperatorMagnitude(defaultOperator, strategyMock, initMagnitude); - + // Set the staker deposits in the strategies IStrategy[] memory strategies = strategyMock.toArray(); uint256[] memory sharesToSet = new uint256[](1); @@ -8156,7 +8039,6 @@ contract DelegationManagerUnitTests_SharesUnderflowChecks is DelegationManagerUn address[] memory stakers = new address[](numStakers); // deposit all stakers one time for (uint256 i = 0; i < numStakers; ++i) { - // 1. deposit and delegate new staker stakers[i] = random().Address(); strategyManagerMock.setDeposits(stakers[i], strategies, sharesToSet); @@ -8167,7 +8049,6 @@ contract DelegationManagerUnitTests_SharesUnderflowChecks is DelegationManagerUn uint64 currMagnitude = initMagnitude; { for (uint256 i = 0; i < numStakers; ++i) { - // 2. slash operator for 100 magnitude uint64 slashMagnitude = 1; currMagnitude -= slashMagnitude; @@ -8185,7 +8066,7 @@ contract DelegationManagerUnitTests_SharesUnderflowChecks is DelegationManagerUn uint256 operatorSharesAfter = delegationManager.operatorShares(defaultOperator, strategyMock); uint256 totalWithdrawableShares = 0; for (uint256 i = 0; i < numStakers; ++i) { - (uint256[] memory withdrawableShares, ) = delegationManager.getWithdrawableShares(stakers[i], strategies); + (uint256[] memory withdrawableShares,) = delegationManager.getWithdrawableShares(stakers[i], strategies); totalWithdrawableShares += withdrawableShares[0]; } assertLe( @@ -8197,13 +8078,19 @@ contract DelegationManagerUnitTests_SharesUnderflowChecks is DelegationManagerUn if (cheats.envOr("WRITE_CSV_TESTS", false)) { cheats.writeLine( "./test6.csv", - string(abi.encodePacked( - cheats.toString(initMagnitude), ", ", // initial magnitude - cheats.toString(shares), ", ", // amount each staker deposits - cheats.toString(operatorSharesAfter), ", ", // operator shares after all slashing and deposits - cheats.toString(totalWithdrawableShares), ", ", // total withdrawable shares from all stakers - cheats.toString(stdMath.delta(operatorSharesAfter, totalWithdrawableShares)) // delta difference between opShares and total withdrawable - )) + string( + abi.encodePacked( + cheats.toString(initMagnitude), + ", ", // initial magnitude + cheats.toString(shares), + ", ", // amount each staker deposits + cheats.toString(operatorSharesAfter), + ", ", // operator shares after all slashing and deposits + cheats.toString(totalWithdrawableShares), + ", ", // total withdrawable shares from all stakers + cheats.toString(stdMath.delta(operatorSharesAfter, totalWithdrawableShares)) // delta difference between opShares and total withdrawable + ) + ) ); } } @@ -8213,25 +8100,26 @@ contract DelegationManagerUnitTests_Rounding is DelegationManagerUnitTests {} /** * @notice TODO Lifecycle tests - These tests combine multiple functionalities of the DelegationManager - 1. Old SigP test - registerAsOperator, separate staker delegate to operator, as operator undelegate (reverts), - checks that staker is still delegated and operator still registered, staker undelegates, checks staker not delegated and operator - is still registered - 2. RegisterOperator, Deposit, Delegate, Queue, Complete - 3. RegisterOperator, Mock Slash(set maxMagnitudes), Deposit/Delegate, Queue, Complete - 4. RegisterOperator, Deposit/Delegate, Mock Slash(set maxMagnitudes), Queue, Complete - 5. RegisterOperator, Mock Slash(set maxMagnitudes), Deposit/Delegate, Queue, Mock Slash(set maxMagnitudes), Complete - 7. RegisterOperator, Deposit/Delegate, Mock Slash 100% (set maxMagnitudes), Undelegate, Complete non 100% slashed strategies - 8. RegisterOperator, Deposit/Delegate, Undelegate, Re delegate to another operator, Mock Slash 100% (set maxMagnitudes), Complete as shares - (withdrawals should have been slashed even though delegated to a new operator) - 9. Invariant check getWithdrawableShares = sum(deposits), Multiple deposits with operator who has never been slashed - 10. Invariant check getWithdrawableShares = sum(deposits), Multiple deposits with operator who HAS been been slashed + * 1. Old SigP test - registerAsOperator, separate staker delegate to operator, as operator undelegate (reverts), + * checks that staker is still delegated and operator still registered, staker undelegates, checks staker not delegated and operator + * is still registered + * 2. RegisterOperator, Deposit, Delegate, Queue, Complete + * 3. RegisterOperator, Mock Slash(set maxMagnitudes), Deposit/Delegate, Queue, Complete + * 4. RegisterOperator, Deposit/Delegate, Mock Slash(set maxMagnitudes), Queue, Complete + * 5. RegisterOperator, Mock Slash(set maxMagnitudes), Deposit/Delegate, Queue, Mock Slash(set maxMagnitudes), Complete + * 7. RegisterOperator, Deposit/Delegate, Mock Slash 100% (set maxMagnitudes), Undelegate, Complete non 100% slashed strategies + * 8. RegisterOperator, Deposit/Delegate, Undelegate, Re delegate to another operator, Mock Slash 100% (set maxMagnitudes), Complete as shares + * (withdrawals should have been slashed even though delegated to a new operator) + * 9. Invariant check getWithdrawableShares = sum(deposits), Multiple deposits with operator who has never been slashed + * 10. Invariant check getWithdrawableShares = sum(deposits), Multiple deposits with operator who HAS been been slashed */ - contract DelegationManagerUnitTests_Lifecycle is DelegationManagerUnitTests { using ArrayLib for *; // 2. RegisterOperator, Deposit, Delegate, Queue, Complete - function test_register_operator_deposit_delegate_queue_complete(Randomness r) public rand(r) { + function test_register_operator_deposit_delegate_queue_complete( + Randomness r + ) public rand(r) { address operator = r.Address(); address staker = r.Address(); IStrategy[] memory strategies = strategyMock.toArray(); @@ -8242,10 +8130,10 @@ contract DelegationManagerUnitTests_Lifecycle is DelegationManagerUnitTests { // 2) Mock deposit into SM. strategyManagerMock.setDeposits(staker, strategies, depositShares); - + // 3) Staker delegates to operator. _delegateToOperatorWhoAcceptsAllStakers(staker, operator); - + // 3) Staker queues withdrawals. QueuedWithdrawalParams[] memory queuedWithdrawalParams = new QueuedWithdrawalParams[](1); queuedWithdrawalParams[0] = QueuedWithdrawalParams({ @@ -8272,13 +8160,17 @@ contract DelegationManagerUnitTests_Lifecycle is DelegationManagerUnitTests { cheats.roll(block.number + delegationManager.minWithdrawalDelayBlocks() + 1); cheats.prank(staker); - delegationManager.completeQueuedWithdrawal(withdrawal, tokenMock.toArray(), false); + delegationManager.completeQueuedWithdrawal(withdrawal, tokenMock.toArray(), false); assertFalse(delegationManager.pendingWithdrawals(withdrawalRoot), "withdrawalRoot should not be pending"); // Checks - assertEq(delegationManager.cumulativeWithdrawalsQueued(staker), 1, "staker nonce should have incremented"); - assertEq(delegationManager.operatorShares(operator, strategies[0]), 100 ether, "operator shares should be 0 after withdrawal"); + assertEq(delegationManager.cumulativeWithdrawalsQueued(staker), 1, "staker nonce should have incremented"); + assertEq( + delegationManager.operatorShares(operator, strategies[0]), + 100 ether, + "operator shares should be 0 after withdrawal" + ); } /** @@ -8315,11 +8207,7 @@ contract DelegationManagerUnitTests_Lifecycle is DelegationManagerUnitTests { assertEq(operatorSharesAfterSlash, 0, "operator shares not fully slashed"); } - ( - , - Withdrawal memory withdrawal, - bytes32 withdrawalRoot - ) = _setUpQueueWithdrawalsSingleStrat({ + (, Withdrawal memory withdrawal, bytes32 withdrawalRoot) = _setUpQueueWithdrawalsSingleStrat({ staker: defaultStaker, strategy: strategy, depositSharesToWithdraw: shares @@ -8329,20 +8217,10 @@ contract DelegationManagerUnitTests_Lifecycle is DelegationManagerUnitTests { assertEq(depositScalingFactor, WAD, "bad test setup"); // Get withdrawable and deposit shares { - ( - uint256[] memory withdrawableSharesBefore, - uint256[] memory depositSharesBefore - ) = delegationManager.getWithdrawableShares(defaultStaker, strategyArray); - assertEq( - withdrawableSharesBefore[0], - 0, - "withdrawable shares should be 0 after being slashed fully" - ); - assertEq( - depositSharesBefore[0], - shares, - "deposit shares should be unchanged after being slashed fully" - ); + (uint256[] memory withdrawableSharesBefore, uint256[] memory depositSharesBefore) = + delegationManager.getWithdrawableShares(defaultStaker, strategyArray); + assertEq(withdrawableSharesBefore[0], 0, "withdrawable shares should be 0 after being slashed fully"); + assertEq(depositSharesBefore[0], shares, "deposit shares should be unchanged after being slashed fully"); } // Undelegate the staker @@ -8371,11 +8249,11 @@ contract DelegationManagerUnitTests_Lifecycle is DelegationManagerUnitTests { assertFalse(delegationManager.isDelegated(defaultStaker), "staker not undelegated"); // Checks - operator & staker shares - assertEq(delegationManager.operatorShares(defaultOperator, strategy), 0, "operator shares not decreased correctly"); - ( - uint256[] memory stakerWithdrawableShares, - uint256[] memory depositShares - ) = delegationManager.getWithdrawableShares(defaultStaker, strategyArray); + assertEq( + delegationManager.operatorShares(defaultOperator, strategy), 0, "operator shares not decreased correctly" + ); + (uint256[] memory stakerWithdrawableShares, uint256[] memory depositShares) = + delegationManager.getWithdrawableShares(defaultStaker, strategyArray); assertEq(stakerWithdrawableShares[0], 0, "staker withdrawable shares not calculated correctly"); assertEq(depositShares[0], 0, "staker deposit shares not reset correctly"); @@ -8384,7 +8262,8 @@ contract DelegationManagerUnitTests_Lifecycle is DelegationManagerUnitTests { _registerOperatorWithBaseDetails(newOperator); _delegateToOperatorWhoAcceptsAllStakers(defaultStaker, newOperator); - (stakerWithdrawableShares, depositShares) = delegationManager.getWithdrawableShares(defaultStaker, strategyArray); + (stakerWithdrawableShares, depositShares) = + delegationManager.getWithdrawableShares(defaultStaker, strategyArray); assertEq(stakerWithdrawableShares[0], 0, "staker withdrawable shares not calculated correctly"); assertEq(depositShares[0], 0, "staker deposit shares not reset correctly"); @@ -8392,7 +8271,8 @@ contract DelegationManagerUnitTests_Lifecycle is DelegationManagerUnitTests { cheats.prank(defaultStaker); delegationManager.completeQueuedWithdrawal(withdrawal, tokenMock.toArray(), false); - (stakerWithdrawableShares, depositShares) = delegationManager.getWithdrawableShares(defaultStaker, strategyArray); + (stakerWithdrawableShares, depositShares) = + delegationManager.getWithdrawableShares(defaultStaker, strategyArray); assertEq(stakerWithdrawableShares[0], 0, "staker withdrawable shares not calculated correctly"); assertEq(depositShares[0], 0, "staker deposit shares not reset correctly"); assertEq(delegationManager.operatorShares(newOperator, strategy), 0, "new operator shares should be unchanged"); @@ -8403,7 +8283,7 @@ contract DelegationManagerUnitTests_ConvertToDepositShares is DelegationManagerU using ArrayLib for *; function test_convertToDepositShares_noSlashing() public { - uint shares = 100 ether; + uint256 shares = 100 ether; // Set the staker deposits in the strategies strategyManagerMock.addDeposit(defaultStaker, strategyMock, shares); @@ -8420,9 +8300,9 @@ contract DelegationManagerUnitTests_ConvertToDepositShares is DelegationManagerU // register *this contract* as an operator _registerOperatorWithBaseDetails(defaultOperator); _delegateToOperatorWhoAcceptsAllStakers(defaultStaker, defaultOperator); - _setOperatorMagnitude(defaultOperator, strategyMock, WAD/3); + _setOperatorMagnitude(defaultOperator, strategyMock, WAD / 3); - _checkDepositSharesConvertCorrectly(strategies, shares); + _checkDepositSharesConvertCorrectly(strategies, shares); // queue and complete a withdrawal for half the deposit shares (uint256[] memory withdrawableShares,) = delegationManager.getWithdrawableShares(defaultStaker, strategies); @@ -8446,12 +8326,12 @@ contract DelegationManagerUnitTests_ConvertToDepositShares is DelegationManagerU // delegate to an operator and slash _registerOperatorWithBaseDetails(defaultOperator); _delegateToOperatorWhoAcceptsAllStakers(defaultStaker, defaultOperator); - _setOperatorMagnitude(defaultOperator, beaconChainETHStrategy, WAD/3); + _setOperatorMagnitude(defaultOperator, beaconChainETHStrategy, WAD / 3); _checkDepositSharesConvertCorrectly(strategies, shares); // slash on beacon chain by 1/3 - _decreaseBeaconChainShares(defaultStaker, int256(shares[0]), shares[0]/3); + _decreaseBeaconChainShares(defaultStaker, int256(shares[0]), shares[0] / 3); _checkDepositSharesConvertCorrectly(strategies, shares); @@ -8464,20 +8344,21 @@ contract DelegationManagerUnitTests_ConvertToDepositShares is DelegationManagerU _checkDepositSharesConvertCorrectly(strategies, shares); } - function _checkDepositSharesConvertCorrectly(IStrategy[] memory strategies, uint256[] memory expectedDepositShares) public view { + function _checkDepositSharesConvertCorrectly( + IStrategy[] memory strategies, + uint256[] memory expectedDepositShares + ) public view { (uint256[] memory withdrawableShares,) = delegationManager.getWithdrawableShares(defaultStaker, strategies); // get the deposit shares - uint256[] memory depositShares = delegationManager.convertToDepositShares(defaultStaker, strategies, withdrawableShares); + uint256[] memory depositShares = + delegationManager.convertToDepositShares(defaultStaker, strategies, withdrawableShares); for (uint256 i = 0; i < strategies.length; i++) { assertApproxEqRel( - expectedDepositShares[i], - depositShares[i], - APPROX_REL_DIFF, - "deposit shares not converted correctly" + expectedDepositShares[i], depositShares[i], APPROX_REL_DIFF, "deposit shares not converted correctly" ); - // make sure that the deposit shares are less than or equal to the shares, + // make sure that the deposit shares are less than or equal to the shares, // so this value is sane to input into `completeQueuedWithdrawals` assertLe( depositShares[i], @@ -8489,12 +8370,13 @@ contract DelegationManagerUnitTests_ConvertToDepositShares is DelegationManagerU // get the deposit shares uint256[] memory oneThirdWithdrawableShares = new uint256[](strategies.length); for (uint256 i = 0; i < strategies.length; i++) { - oneThirdWithdrawableShares[i] = withdrawableShares[i]/3; + oneThirdWithdrawableShares[i] = withdrawableShares[i] / 3; } - uint256[] memory oneThirdDepositShares = delegationManager.convertToDepositShares(defaultStaker, strategies, oneThirdWithdrawableShares); + uint256[] memory oneThirdDepositShares = + delegationManager.convertToDepositShares(defaultStaker, strategies, oneThirdWithdrawableShares); for (uint256 i = 0; i < strategies.length; i++) { assertApproxEqRel( - expectedDepositShares[i]/3, + expectedDepositShares[i] / 3, oneThirdDepositShares[i], APPROX_REL_DIFF, "deposit shares not converted correctly" @@ -8503,11 +8385,8 @@ contract DelegationManagerUnitTests_ConvertToDepositShares is DelegationManagerU } function _queueAndCompleteWithdrawalForSingleStrategy(IStrategy strategy, uint256 shares) public { - (QueuedWithdrawalParams[] memory queuedWithdrawalParams, Withdrawal memory withdrawal,) = _setUpQueueWithdrawalsSingleStrat({ - staker: defaultStaker, - strategy: strategy, - depositSharesToWithdraw: shares - }); + (QueuedWithdrawalParams[] memory queuedWithdrawalParams, Withdrawal memory withdrawal,) = + _setUpQueueWithdrawalsSingleStrat({staker: defaultStaker, strategy: strategy, depositSharesToWithdraw: shares}); cheats.prank(defaultStaker); delegationManager.queueWithdrawals(queuedWithdrawalParams); @@ -8522,17 +8401,17 @@ contract DelegationManagerUnitTests_getQueuedWithdrawals is DelegationManagerUni using ArrayLib for *; using SlashingLib for *; - function _withdrawalRoot(Withdrawal memory withdrawal) internal pure returns (bytes32) { + function _withdrawalRoot( + Withdrawal memory withdrawal + ) internal pure returns (bytes32) { return keccak256(abi.encode(withdrawal)); } - function test_getQueuedWithdrawals_Correctness(Randomness r) public rand(r) { + function test_getQueuedWithdrawals_Correctness( + Randomness r + ) public rand(r) { uint256 numStrategies = r.Uint256(2, 8); - uint256[] memory depositShares = r.Uint256Array({ - len: numStrategies, - min: 2, - max: 100 ether - }); + uint256[] memory depositShares = r.Uint256Array({len: numStrategies, min: 2, max: 100 ether}); IStrategy[] memory strategies = _deployAndDepositIntoStrategies(defaultStaker, depositShares, false); _registerOperatorWithBaseDetails(defaultOperator); @@ -8548,28 +8427,26 @@ contract DelegationManagerUnitTests_getQueuedWithdrawals is DelegationManagerUni } // Queue withdrawals. - ( - QueuedWithdrawalParams[] memory queuedWithdrawalParams, - Withdrawal memory withdrawal, - bytes32 withdrawalRoot - ) = _setUpQueueWithdrawals({ - staker: defaultStaker, - strategies: strategies, - depositWithdrawalAmounts: depositShares - }); + (QueuedWithdrawalParams[] memory queuedWithdrawalParams, Withdrawal memory withdrawal, bytes32 withdrawalRoot) = + _setUpQueueWithdrawals({staker: defaultStaker, strategies: strategies, depositWithdrawalAmounts: depositShares}); cheats.prank(defaultStaker); delegationManager.queueWithdrawals(queuedWithdrawalParams); - + // Get queued withdrawals. - (Withdrawal[] memory withdrawals, uint256[][] memory shares) = delegationManager.getQueuedWithdrawals(defaultStaker); + (Withdrawal[] memory withdrawals, uint256[][] memory shares) = + delegationManager.getQueuedWithdrawals(defaultStaker); // Checks for (uint256 i; i < strategies.length; ++i) { uint256 newStakerShares = depositShares[i] / 2; assertApproxEqAbs(shares[0][i], newStakerShares, 1, "staker shares should be decreased by half +- 1"); } - - assertEq(_withdrawalRoot(withdrawal), _withdrawalRoot(withdrawals[0]), "_withdrawalRoot(withdrawal) != _withdrawalRoot(withdrawals[0])"); + + assertEq( + _withdrawalRoot(withdrawal), + _withdrawalRoot(withdrawals[0]), + "_withdrawalRoot(withdrawal) != _withdrawalRoot(withdrawals[0])" + ); assertEq(_withdrawalRoot(withdrawal), withdrawalRoot, "_withdrawalRoot(withdrawal) != withdrawalRoot"); } @@ -8581,7 +8458,7 @@ contract DelegationManagerUnitTests_getQueuedWithdrawals is DelegationManagerUni _registerOperatorWithBaseDetails(defaultOperator); strategyManagerMock.addDeposit(defaultStaker, strategyMock, totalDepositShares); _delegateToOperatorWhoAcceptsAllStakers(defaultStaker, defaultOperator); - + uint256 newStakerShares = totalDepositShares / 2; _setOperatorMagnitude(defaultOperator, strategyMock, 0.5 ether); cheats.prank(address(allocationManagerMock)); @@ -8610,14 +8487,15 @@ contract DelegationManagerUnitTests_getQueuedWithdrawals is DelegationManagerUni ) = _setUpQueueWithdrawalsSingleStrat({ staker: defaultStaker, strategy: strategyMock, - depositSharesToWithdraw: totalDepositShares / 2 + depositSharesToWithdraw: totalDepositShares / 2 }); cheats.prank(defaultStaker); delegationManager.queueWithdrawals(queuedWithdrawalParams1); // Get queued withdrawals. - (Withdrawal[] memory withdrawals, uint256[][] memory shares) = delegationManager.getQueuedWithdrawals(defaultStaker); + (Withdrawal[] memory withdrawals, uint256[][] memory shares) = + delegationManager.getQueuedWithdrawals(defaultStaker); // Sanity assertEq(withdrawals.length, 2, "withdrawal.length != 2"); @@ -8639,7 +8517,9 @@ contract DelegationManagerUnitTests_getQueuedWithdrawals is DelegationManagerUni * expected withdrawn shares from the view function. * Slashing on the completableBlock of the withdrawal should have no affect on the withdrawn shares. */ - function test_getQueuedWithdrawals_SlashAfterWithdrawalCompletion(Randomness r) public rand(r) { + function test_getQueuedWithdrawals_SlashAfterWithdrawalCompletion( + Randomness r + ) public rand(r) { uint256 depositAmount = r.Uint256(1, MAX_STRATEGY_SHARES); // Deposit Staker @@ -8650,11 +8530,8 @@ contract DelegationManagerUnitTests_getQueuedWithdrawals is DelegationManagerUni _delegateToOperatorWhoAcceptsAllStakers(defaultStaker, defaultOperator); // Queue withdrawal - ( - QueuedWithdrawalParams[] memory queuedWithdrawalParams, - Withdrawal memory withdrawal, - bytes32 withdrawalRoot - ) = _setUpQueueWithdrawalsSingleStrat({ + (QueuedWithdrawalParams[] memory queuedWithdrawalParams, Withdrawal memory withdrawal, bytes32 withdrawalRoot) = + _setUpQueueWithdrawalsSingleStrat({ staker: defaultStaker, strategy: strategyMock, depositSharesToWithdraw: depositAmount @@ -8681,7 +8558,7 @@ contract DelegationManagerUnitTests_getQueuedWithdrawals is DelegationManagerUni // Slash operator 50% while staker has queued withdrawal { uint256 operatorSharesAfterQueue = delegationManager.operatorShares(defaultOperator, strategyMock); - (uint256 sharesToDecrement, ) = _calcSlashedAmount({ + (uint256 sharesToDecrement,) = _calcSlashedAmount({ operatorShares: operatorSharesAfterQueue, prevMaxMagnitude: uint64(WAD), newMaxMagnitude: 50e16 @@ -8699,7 +8576,8 @@ contract DelegationManagerUnitTests_getQueuedWithdrawals is DelegationManagerUni // Assert that the getQueuedWithdrawals returns shares that are halved as a result of being slashed 50% { - (Withdrawal[] memory withdrawals, uint256[][] memory shares) = delegationManager.getQueuedWithdrawals(defaultStaker); + (Withdrawal[] memory withdrawals, uint256[][] memory shares) = + delegationManager.getQueuedWithdrawals(defaultStaker); assertEq(withdrawals.length, 1, "withdrawals.length != 1"); assertEq(withdrawals[0].strategies.length, 1, "withdrawals[0].strategies.length != 1"); assertEq(shares[0][0], depositAmount / 2, "shares[0][0] != depositAmount / 2"); @@ -8712,11 +8590,8 @@ contract DelegationManagerUnitTests_getQueuedWithdrawals is DelegationManagerUni // slash operator 50% again { uint256 operatorShares = delegationManager.operatorShares(defaultOperator, strategyMock); - (uint256 sharesToDecrement, ) = _calcSlashedAmount({ - operatorShares: operatorShares, - prevMaxMagnitude: 50e16, - newMaxMagnitude: 25e16 - }); + (uint256 sharesToDecrement,) = + _calcSlashedAmount({operatorShares: operatorShares, prevMaxMagnitude: 50e16, newMaxMagnitude: 25e16}); _setOperatorMagnitude(defaultOperator, strategyMock, 25e16); cheats.prank(address(allocationManagerMock)); delegationManager.slashOperatorShares(defaultOperator, withdrawal.strategies[0], 50e16, 25e16); @@ -8733,7 +8608,8 @@ contract DelegationManagerUnitTests_getQueuedWithdrawals is DelegationManagerUni uint256 expectedSharesIncrease = depositAmount / 2; uint256 queuedWithdrawableShares; { - (Withdrawal[] memory withdrawals, uint256[][] memory shares) = delegationManager.getQueuedWithdrawals(defaultStaker); + (Withdrawal[] memory withdrawals, uint256[][] memory shares) = + delegationManager.getQueuedWithdrawals(defaultStaker); queuedWithdrawableShares = shares[0][0]; assertEq(withdrawals.length, 1, "withdrawals.length != 1"); assertEq(withdrawals[0].strategies.length, 1, "withdrawals[0].strategies.length != 1"); @@ -8741,10 +8617,12 @@ contract DelegationManagerUnitTests_getQueuedWithdrawals is DelegationManagerUni } // Complete queued Withdrawal with shares added back. Since total deposit slashed by 50% and not 75% - (uint256[] memory withdrawableSharesBefore, ) = delegationManager.getWithdrawableShares(defaultStaker, withdrawal.strategies); + (uint256[] memory withdrawableSharesBefore,) = + delegationManager.getWithdrawableShares(defaultStaker, withdrawal.strategies); cheats.prank(defaultStaker); delegationManager.completeQueuedWithdrawal(withdrawal, tokenMock.toArray(), false); - (uint256[] memory withdrawableSharesAfter, ) = delegationManager.getWithdrawableShares(defaultStaker, withdrawal.strategies); + (uint256[] memory withdrawableSharesAfter,) = + delegationManager.getWithdrawableShares(defaultStaker, withdrawal.strategies); // Added shares assertEq( @@ -8757,10 +8635,164 @@ contract DelegationManagerUnitTests_getQueuedWithdrawals is DelegationManagerUni queuedWithdrawableShares, "expectedSharesIncrease should be equal to queuedWithdrawableShares" ); - assertEq( - block.number, - completableBlock, - "block.number should be the completableBlock" - ); + assertEq(block.number, completableBlock, "block.number should be the completableBlock"); + } + + function test_getQueuedWithdrawals_UsesCorrectOperatorMagnitude() public { + // Alice deposits 100 shares into strategy + uint256 depositAmount = 100e18; + _depositIntoStrategies(defaultStaker, strategyMock.toArray(), depositAmount.toArrayU256()); + + // Register operator with magnitude of 0.5 and delegate Alice to them + _registerOperatorWithBaseDetails(defaultOperator); + _delegateToOperatorWhoAcceptsAllStakers(defaultStaker, defaultOperator); + _setOperatorMagnitude(defaultOperator, strategyMock, 0.5 ether); + + // Alice queues withdrawal of all 100 shares while operator magnitude is 0.5 + // This means she should get back 50 shares (100 * 0.5) + ( + QueuedWithdrawalParams[] memory queuedWithdrawalParams, + Withdrawal memory withdrawal, + bytes32 withdrawalRoot + ) = _setUpQueueWithdrawalsSingleStrat({ + staker: defaultStaker, + strategy: strategyMock, + depositSharesToWithdraw: depositAmount + }); + + cheats.prank(defaultStaker); + delegationManager.queueWithdrawals(queuedWithdrawalParams); + + // Alice undelegates, which would normally update operator's magnitude to 1.0 + // This tests that the withdrawal still uses the original 0.5 magnitude from when it was queued + cheats.prank(defaultStaker); + delegationManager.undelegate(defaultStaker); + + // Get shares from withdrawal - should return 50 shares (100 * 0.5) using original magnitude + // rather than incorrectly returning 100 shares (100 * 1.0) using new magnitude + (, uint256[] memory shares) = delegationManager.getQueuedWithdrawalFromRoot(withdrawalRoot); + assertEq(shares[0], 50e18, "shares should be 50e18 (100e18 * 0.5) using original magnitude"); + } +} + +contract DelegationManagerUnitTests_getQueuedWithdrawalFromRoot is DelegationManagerUnitTests { + using ArrayLib for *; + using SlashingLib for *; + + function test_getQueuedWithdrawalFromRoot_Correctness(Randomness r) public rand(r) { + // Set up initial deposit + uint256 depositAmount = r.Uint256(1 ether, 100 ether); + _depositIntoStrategies(defaultStaker, strategyMock.toArray(), depositAmount.toArrayU256()); + + // Register operator and delegate + _registerOperatorWithBaseDetails(defaultOperator); + _delegateToOperatorWhoAcceptsAllStakers(defaultStaker, defaultOperator); + + // Queue withdrawal + ( + QueuedWithdrawalParams[] memory queuedWithdrawalParams, + Withdrawal memory withdrawal, + bytes32 withdrawalRoot + ) = _setUpQueueWithdrawalsSingleStrat({ + staker: defaultStaker, + strategy: strategyMock, + depositSharesToWithdraw: depositAmount + }); + + cheats.prank(defaultStaker); + delegationManager.queueWithdrawals(queuedWithdrawalParams); + + // Get shares from queued withdrawal + (, uint256[] memory shares) = delegationManager.getQueuedWithdrawalFromRoot(withdrawalRoot); + + // Verify withdrawal details match + assertEq(shares.length, 1, "incorrect shares array length"); + assertEq(shares[0], depositAmount, "incorrect shares amount"); + } + + function test_getQueuedWithdrawalFromRoot_AfterSlashing(Randomness r) public rand(r) { + // Set up initial deposit + uint256 depositAmount = r.Uint256(1 ether, 100 ether); + _depositIntoStrategies(defaultStaker, strategyMock.toArray(), depositAmount.toArrayU256()); + + // Register operator and delegate + _registerOperatorWithBaseDetails(defaultOperator); + _delegateToOperatorWhoAcceptsAllStakers(defaultStaker, defaultOperator); + + // Queue withdrawal + ( + QueuedWithdrawalParams[] memory queuedWithdrawalParams, + Withdrawal memory withdrawal, + bytes32 withdrawalRoot + ) = _setUpQueueWithdrawalsSingleStrat({ + staker: defaultStaker, + strategy: strategyMock, + depositSharesToWithdraw: depositAmount + }); + + cheats.prank(defaultStaker); + delegationManager.queueWithdrawals(queuedWithdrawalParams); + + // Slash operator by 50% + _setOperatorMagnitude(defaultOperator, strategyMock, 0.5 ether); + cheats.prank(address(allocationManagerMock)); + delegationManager.slashOperatorShares(defaultOperator, strategyMock, WAD, 0.5 ether); + + // Get shares from queued withdrawal + (, uint256[] memory shares) = delegationManager.getQueuedWithdrawalFromRoot(withdrawalRoot); + + // Verify withdrawal details match and shares are slashed + assertEq(shares.length, 1, "incorrect shares array length"); + assertEq(shares[0], depositAmount / 2, "shares not properly slashed"); + } + + function test_getQueuedWithdrawalFromRoot_NonexistentWithdrawal() public { + bytes32 nonexistentRoot = bytes32(uint256(1)); + (, uint256[] memory shares) = delegationManager.getQueuedWithdrawalFromRoot(nonexistentRoot); + assertEq(shares.length, 0, "shares array should be empty"); + } + + function test_getQueuedWithdrawalFromRoot_MultipleStrategies(Randomness r) public rand(r) { + // Set up multiple strategies with deposits + uint256 numStrategies = r.Uint256(2, 5); + uint256[] memory depositShares = r.Uint256Array({ + len: numStrategies, + min: 1 ether, + max: 100 ether + }); + + IStrategy[] memory strategies = _deployAndDepositIntoStrategies(defaultStaker, depositShares, false); + + // Register operator and delegate + _registerOperatorWithBaseDetails(defaultOperator); + _delegateToOperatorWhoAcceptsAllStakers(defaultStaker, defaultOperator); + + // Queue withdrawals for multiple strategies + ( + QueuedWithdrawalParams[] memory queuedWithdrawalParams, + Withdrawal memory withdrawal, + bytes32 withdrawalRoot + ) = _setUpQueueWithdrawals({ + staker: defaultStaker, + strategies: strategies, + depositWithdrawalAmounts: depositShares + }); + + cheats.prank(defaultStaker); + delegationManager.queueWithdrawals(queuedWithdrawalParams); + + // Get shares from queued withdrawal + (, uint256[] memory shares) = delegationManager.getQueuedWithdrawalFromRoot(withdrawalRoot); + + // Verify withdrawal details and shares for each strategy + assertEq(shares.length, numStrategies, "incorrect shares array length"); + for (uint256 i = 0; i < numStrategies; i++) { + assertEq(shares[i], depositShares[i], "incorrect shares amount for strategy"); + } + } + + function testFuzz_getQueuedWithdrawalFromRoot_EmptyWithdrawal(bytes32 withdrawalRoot) public { + (, uint256[] memory shares) = delegationManager.getQueuedWithdrawalFromRoot(withdrawalRoot); + assertEq(shares.length, 0, "sanity check"); } } diff --git a/src/test/unit/EigenPodManagerUnit.t.sol b/src/test/unit/EigenPodManagerUnit.t.sol index f1286f0316..3cf02d6ba8 100644 --- a/src/test/unit/EigenPodManagerUnit.t.sol +++ b/src/test/unit/EigenPodManagerUnit.t.sol @@ -44,7 +44,8 @@ contract EigenPodManagerUnitTests is EigenLayerUnitTestSetup, IEigenPodManagerEv ethPOSMock, eigenPodBeacon, IDelegationManager(address(delegationManagerMock)), - pauserRegistry + pauserRegistry, + "v9.9.9" ); eigenPodManager = EigenPodManager( address( @@ -78,7 +79,7 @@ contract EigenPodManagerUnitTests is EigenLayerUnitTestSetup, IEigenPodManagerEv if (shares >= 0) { cheats.prank(address(delegationManagerMock)); - eigenPodManager.addShares(podOwner, beaconChainETHStrategy, IERC20(address(0)), uint256(shares)); + eigenPodManager.addShares(podOwner, beaconChainETHStrategy, uint256(shares)); } else { EigenPodManagerWrapper(address(eigenPodManager)).setPodOwnerShares(podOwner, shares); } @@ -185,6 +186,23 @@ contract EigenPodManagerUnitTests_StakeTests is EigenPodManagerUnitTests { contract EigenPodManagerUnitTests_ShareUpdateTests is EigenPodManagerUnitTests { + // Wrapper contract that exposes the internal `_calculateChangeInDelegatableShares` function + EigenPodManagerWrapper public eigenPodManagerWrapper; + + function setUp() virtual override public { + super.setUp(); + + // Upgrade eigenPodManager to wrapper + eigenPodManagerWrapper = new EigenPodManagerWrapper( + ethPOSMock, + eigenPodBeacon, + IDelegationManager(address(delegationManagerMock)), + pauserRegistry, + "v9.9.9" + ); + eigenLayerProxyAdmin.upgrade(ITransparentUpgradeableProxy(payable(address(eigenPodManager))), address(eigenPodManagerWrapper)); + } + /******************************************************************************* Add Shares Tests *******************************************************************************/ @@ -193,20 +211,20 @@ contract EigenPodManagerUnitTests_ShareUpdateTests is EigenPodManagerUnitTests { cheats.assume(notDelegationManager != address(delegationManagerMock)); cheats.prank(notDelegationManager); cheats.expectRevert(IEigenPodManagerErrors.OnlyDelegationManager.selector); - eigenPodManager.addShares(defaultStaker, IStrategy(address(0)), IERC20(address(0)), 0); + eigenPodManager.addShares(defaultStaker, IStrategy(address(0)), 0); } function test_addShares_revert_podOwnerZeroAddress() public { cheats.prank(address(delegationManagerMock)); cheats.expectRevert(IEigenPodErrors.InputAddressZero.selector); - eigenPodManager.addShares(address(0), beaconChainETHStrategy, IERC20(address(0)), 0); + eigenPodManager.addShares(address(0), beaconChainETHStrategy, 0); } function testFuzz_addShares_revert_sharesNegative(int256 shares) public { cheats.assume(shares < 0); cheats.prank(address(delegationManagerMock)); cheats.expectRevert(IEigenPodManagerErrors.SharesNegative.selector); - eigenPodManager.addShares(defaultStaker, beaconChainETHStrategy, IERC20(address(0)), uint256(shares)); + eigenPodManager.addShares(defaultStaker, beaconChainETHStrategy, uint256(shares)); } function testFuzz_addShares(uint256 shares) public { @@ -217,12 +235,60 @@ contract EigenPodManagerUnitTests_ShareUpdateTests is EigenPodManagerUnitTests { // Add shares cheats.prank(address(delegationManagerMock)); - eigenPodManager.addShares(defaultStaker, beaconChainETHStrategy, IERC20(address(0)), shares); + eigenPodManager.addShares(defaultStaker, beaconChainETHStrategy, shares); // Check storage update assertEq(eigenPodManager.podOwnerDepositShares(defaultStaker), int256(shares), "Incorrect number of shares added"); } + function test_addShares_negativeInitial() public { + _initializePodWithShares(defaultStaker, -1); + + cheats.prank(address(delegationManagerMock)); + + (uint256 prevDepositShares, uint256 addedShares) = eigenPodManager.addShares( + defaultStaker, + beaconChainETHStrategy, + 5 + ); + + assertEq(prevDepositShares, 0); + assertEq(addedShares, 4); + } + + function testFuzz_addShares_negativeSharesInitial(int256 sharesToStart, int256 sharesToAdd) public { + cheats.assume(sharesToStart < 0); + cheats.assume(sharesToAdd >= 0); + + _initializePodWithShares(defaultStaker, sharesToStart); + int256 expectedDepositShares = sharesToStart + sharesToAdd; + + cheats.prank(address(delegationManagerMock)); + + cheats.expectEmit(true, true, true, true, address(eigenPodManager)); + emit PodSharesUpdated(defaultStaker, sharesToAdd); + cheats.expectEmit(true, true, true, true, address(eigenPodManager)); + emit NewTotalShares(defaultStaker, expectedDepositShares); + + (uint256 prevDepositShares, uint256 addedShares) = eigenPodManager.addShares( + defaultStaker, + beaconChainETHStrategy, + uint256(sharesToAdd) + ); + + // validate that prev shares return 0 since we started from a negative balance + assertEq(prevDepositShares, 0); + + // If we now have positive shares, expect return + if (expectedDepositShares > 0) { + assertEq(addedShares, uint256(expectedDepositShares)); + } + // We still have negative shares, return 0 + else { + assertEq(addedShares, 0); + } + } + /******************************************************************************* Remove Shares Tests ******************************************************************************/ @@ -304,7 +370,8 @@ contract EigenPodManagerUnitTests_WithdrawSharesAsTokensTests is EigenPodManager ethPOSMock, eigenPodBeacon, IDelegationManager(address(delegationManagerMock)), - pauserRegistry + pauserRegistry, + "v9.9.9" ); eigenLayerProxyAdmin.upgrade(ITransparentUpgradeableProxy(payable(address(eigenPodManager))), address(eigenPodManagerWrapper)); } @@ -426,7 +493,8 @@ contract EigenPodManagerUnitTests_BeaconChainETHBalanceUpdateTests is EigenPodMa ethPOSMock, eigenPodBeacon, IDelegationManager(address(delegationManagerMock)), - pauserRegistry + pauserRegistry, + "v9.9.9" ); eigenLayerProxyAdmin.upgrade(ITransparentUpgradeableProxy(payable(address(eigenPodManager))), address(eigenPodManagerWrapper)); } diff --git a/src/test/unit/EigenPodUnit.t.sol b/src/test/unit/EigenPodUnit.t.sol index 002ff9419f..eb098cfa94 100644 --- a/src/test/unit/EigenPodUnit.t.sol +++ b/src/test/unit/EigenPodUnit.t.sol @@ -59,7 +59,8 @@ contract EigenPodUnitTests is EigenLayerUnitTestSetup, EigenPodPausingConstants, podImplementation = new EigenPod( ethPOSDepositMock, IEigenPodManager(address(eigenPodManagerMock)), - GENESIS_TIME_LOCAL + GENESIS_TIME_LOCAL, + "v9.9.9" ); // Deploy Beacon @@ -324,7 +325,7 @@ contract EigenPodUnitTests is EigenLayerUnitTestSetup, EigenPodPausingConstants, contract EigenPodUnitTests_Initialization is EigenPodUnitTests { function test_constructor() public { - EigenPod pod = new EigenPod(ethPOSDepositMock, IEigenPodManager(address(eigenPodManagerMock)), GENESIS_TIME_LOCAL); + EigenPod pod = new EigenPod(ethPOSDepositMock, IEigenPodManager(address(eigenPodManagerMock)), GENESIS_TIME_LOCAL, "v9.9.9"); assertTrue(pod.ethPOS() == ethPOSDepositMock, "should have set ethPOS correctly"); assertTrue(address(pod.eigenPodManager()) == address(eigenPodManagerMock), "should have set eigenpodmanager correctly"); @@ -352,7 +353,7 @@ contract EigenPodUnitTests_Initialization is EigenPodUnitTests { } function test_initialize_revert_emptyPodOwner() public { - EigenPod pod = new EigenPod(ethPOSDepositMock, IEigenPodManager(address(eigenPodManagerMock)), GENESIS_TIME_LOCAL); + EigenPod pod = new EigenPod(ethPOSDepositMock, IEigenPodManager(address(eigenPodManagerMock)), GENESIS_TIME_LOCAL, "v9.9.9"); // un-initialize pod cheats.store(address(pod), 0, 0); @@ -1726,7 +1727,8 @@ contract EigenPodHarnessSetup is EigenPodUnitTests { eigenPodHarnessImplementation = new EigenPodHarness( ethPOSDepositMock, IEigenPodManager(address(eigenPodManagerMock)), - GENESIS_TIME_LOCAL + GENESIS_TIME_LOCAL, + "v9.9.9" ); // Upgrade eigenPod to harness diff --git a/src/test/unit/RewardsCoordinatorUnit.t.sol b/src/test/unit/RewardsCoordinatorUnit.t.sol index 899d5c0a02..0a86e9e8b4 100644 --- a/src/test/unit/RewardsCoordinatorUnit.t.sol +++ b/src/test/unit/RewardsCoordinatorUnit.t.sol @@ -102,17 +102,21 @@ contract RewardsCoordinatorUnitTests is EigenLayerUnitTestSetup, IRewardsCoordin // Deploy RewardsCoordinator proxy and implementation rewardsCoordinatorImplementation = new RewardsCoordinator( - IDelegationManager(address(delegationManagerMock)), - IStrategyManager(address(strategyManagerMock)), - IAllocationManager(address(allocationManagerMock)), - pauserRegistry, - IPermissionController(address(permissionController)), - CALCULATION_INTERVAL_SECONDS, - MAX_REWARDS_DURATION, - MAX_RETROACTIVE_LENGTH, - MAX_FUTURE_LENGTH, - GENESIS_REWARDS_TIMESTAMP - ); + IRewardsCoordinatorTypes.RewardsCoordinatorConstructorParams({ + delegationManager: IDelegationManager(address(delegationManagerMock)), + strategyManager: IStrategyManager(address(strategyManagerMock)), + allocationManager: IAllocationManager(address(allocationManagerMock)), + pauserRegistry: pauserRegistry, + permissionController: IPermissionController(address(permissionController)), + CALCULATION_INTERVAL_SECONDS: CALCULATION_INTERVAL_SECONDS, + MAX_REWARDS_DURATION: MAX_REWARDS_DURATION, + MAX_RETROACTIVE_LENGTH: MAX_RETROACTIVE_LENGTH, + MAX_FUTURE_LENGTH: MAX_FUTURE_LENGTH, + GENESIS_REWARDS_TIMESTAMP: GENESIS_REWARDS_TIMESTAMP, + version: "v9.9.9" + }) + ); + rewardsCoordinator = RewardsCoordinator( address( new TransparentUpgradeableProxy( @@ -135,7 +139,7 @@ contract RewardsCoordinatorUnitTests is EigenLayerUnitTestSetup, IRewardsCoordin token2 = new ERC20PresetFixedSupply("jeo boden", "MOCK2", mockTokenInitialSupply, address(this)); token3 = new ERC20PresetFixedSupply("pepe wif avs", "MOCK3", mockTokenInitialSupply, address(this)); - strategyImplementation = new StrategyBase(IStrategyManager(address(strategyManagerMock)), pauserRegistry); + strategyImplementation = new StrategyBase(IStrategyManager(address(strategyManagerMock)), pauserRegistry, "v9.9.9"); strategyMock1 = StrategyBase( address( new TransparentUpgradeableProxy( diff --git a/src/test/unit/StrategyBaseTVLLimitsUnit.sol b/src/test/unit/StrategyBaseTVLLimitsUnit.sol index 797621b681..531be01dae 100644 --- a/src/test/unit/StrategyBaseTVLLimitsUnit.sol +++ b/src/test/unit/StrategyBaseTVLLimitsUnit.sol @@ -24,7 +24,7 @@ contract StrategyBaseTVLLimitsUnitTests is StrategyBaseUnitTests { StrategyBaseUnitTests.setUp(); // depoloy the TVL-limited strategy - strategyBaseTVLLimitsImplementation = new StrategyBaseTVLLimits(strategyManager, pauserRegistry); + strategyBaseTVLLimitsImplementation = new StrategyBaseTVLLimits(strategyManager, pauserRegistry, "v9.9.9"); strategyWithTVLLimits = StrategyBaseTVLLimits( address( new TransparentUpgradeableProxy( diff --git a/src/test/unit/StrategyBaseUnit.t.sol b/src/test/unit/StrategyBaseUnit.t.sol index 13a80673b3..60caa46201 100644 --- a/src/test/unit/StrategyBaseUnit.t.sol +++ b/src/test/unit/StrategyBaseUnit.t.sol @@ -55,7 +55,7 @@ contract StrategyBaseUnitTests is Test { underlyingToken = new ERC20PresetFixedSupply("Test Token", "TEST", initialSupply, initialOwner); - strategyImplementation = new StrategyBase(strategyManager, pauserRegistry); + strategyImplementation = new StrategyBase(strategyManager, pauserRegistry, "v9.9.9"); strategy = StrategyBase( address( @@ -161,7 +161,7 @@ contract StrategyBaseUnitTests is Test { // Deploy token with 1e39 total supply underlyingToken = new ERC20PresetFixedSupply("Test Token", "TEST", 1e39, initialOwner); - strategyImplementation = new StrategyBase(strategyManager, pauserRegistry); + strategyImplementation = new StrategyBase(strategyManager, pauserRegistry, "v9.9.9"); strategy = StrategyBase( address( diff --git a/src/test/unit/StrategyFactoryUnit.t.sol b/src/test/unit/StrategyFactoryUnit.t.sol index 5775851163..6843c39d20 100644 --- a/src/test/unit/StrategyFactoryUnit.t.sol +++ b/src/test/unit/StrategyFactoryUnit.t.sol @@ -46,12 +46,12 @@ contract StrategyFactoryUnitTests is EigenLayerUnitTestSetup { underlyingToken = new ERC20PresetFixedSupply("Test Token", "TEST", initialSupply, initialOwner); - strategyImplementation = new StrategyBase(IStrategyManager(address(strategyManagerMock)), pauserRegistry); + strategyImplementation = new StrategyBase(IStrategyManager(address(strategyManagerMock)), pauserRegistry, "v9.9.9"); strategyBeacon = new UpgradeableBeacon(address(strategyImplementation)); strategyBeacon.transferOwnership(beaconProxyOwner); - strategyFactoryImplementation = new StrategyFactory(IStrategyManager(address(strategyManagerMock)), pauserRegistry); + strategyFactoryImplementation = new StrategyFactory(IStrategyManager(address(strategyManagerMock)), pauserRegistry, "v9.9.9"); strategyFactory = StrategyFactory( address( diff --git a/src/test/unit/StrategyManagerUnit.t.sol b/src/test/unit/StrategyManagerUnit.t.sol index d5ba4146ee..9e58282aaa 100644 --- a/src/test/unit/StrategyManagerUnit.t.sol +++ b/src/test/unit/StrategyManagerUnit.t.sol @@ -38,7 +38,7 @@ contract StrategyManagerUnitTests is EigenLayerUnitTestSetup, IStrategyManagerEv function setUp() public override { EigenLayerUnitTestSetup.setUp(); strategyManagerImplementation = new StrategyManager( - IDelegationManager(address(delegationManagerMock)), pauserRegistry + IDelegationManager(address(delegationManagerMock)), pauserRegistry, "v9.9.9" ); strategyManager = StrategyManager( address( @@ -88,7 +88,7 @@ contract StrategyManagerUnitTests is EigenLayerUnitTestSetup, IStrategyManagerEv IPauserRegistry _pauserRegistry, address admin ) public returns (StrategyBase) { - StrategyBase newStrategyImplementation = new StrategyBase(_strategyManager, _pauserRegistry); + StrategyBase newStrategyImplementation = new StrategyBase(_strategyManager, _pauserRegistry, "v9.9.9"); StrategyBase newStrategy = StrategyBase(address(new TransparentUpgradeableProxy(address(newStrategyImplementation), address(admin), ""))); newStrategy.initialize(_token); return newStrategy; @@ -120,7 +120,7 @@ contract StrategyManagerUnitTests is EigenLayerUnitTestSetup, IStrategyManagerEv token.approve(address(strategyManager), amount); cheats.expectEmit(true, true, true, true, address(strategyManager)); - emit Deposit(staker, token, strategy, expectedDepositShares); + emit Deposit(staker, strategy, expectedDepositShares); uint256 shares = strategyManager.depositIntoStrategy(strategy, token, amount); cheats.stopPrank(); @@ -177,12 +177,12 @@ contract StrategyManagerUnitTests is EigenLayerUnitTestSetup, IStrategyManagerEv if (!expectedRevertMessageIsempty) { cheats.expectRevert(expectedRevertMessage); } else if (expiry < block.timestamp) { - cheats.expectRevert(ISignatureUtils.SignatureExpired.selector); + cheats.expectRevert(ISignatureUtilsMixinErrors.SignatureExpired.selector); } else { // needed for expecting an event with the right parameters uint256 expectedDepositShares = amount; cheats.expectEmit(true, true, true, true, address(strategyManager)); - emit Deposit(staker, dummyToken, dummyStrat, expectedDepositShares); + emit Deposit(staker, dummyStrat, expectedDepositShares); } uint256 shares = strategyManager.depositIntoStrategyWithSignature( dummyStrat, @@ -263,6 +263,20 @@ contract StrategyManagerUnitTests_initialize is StrategyManagerUnitTests { address(pauserRegistry), "strategyManager.pauserRegistry() != pauserRegistry" ); + + bytes memory v = bytes(strategyManager.version()); + + bytes32 expectedDomainSeparator = keccak256( + abi.encode( + EIP712_DOMAIN_TYPEHASH, + keccak256(bytes("EigenLayer")), + keccak256(bytes(bytes.concat(v[0], v[1]))), + block.chainid, + address(strategyManager) + ) + ); + + assertEq(strategyManager.domainSeparator(), expectedDomainSeparator, "sanity check"); } } @@ -297,7 +311,7 @@ contract StrategyManagerUnitTests_depositIntoStrategy is StrategyManagerUnitTest token.approve(address(strategyManager), amount); cheats.expectEmit(true, true, true, true, address(strategyManager)); - emit Deposit(staker, token, strategy, expectedDepositShares); + emit Deposit(staker, strategy, expectedDepositShares); uint256 depositedShares = strategyManager.depositIntoStrategy(strategy, token, amount); cheats.stopPrank(); @@ -836,7 +850,7 @@ contract StrategyManagerUnitTests_depositIntoStrategyWithSignature is StrategyMa uint256 depositSharesBefore = strategyManager.stakerDepositShares(staker, strategy); - cheats.expectRevert(ISignatureUtils.InvalidSignature.selector); + cheats.expectRevert(ISignatureUtilsMixinErrors.InvalidSignature.selector); // call with `notStaker` as input instead of `staker` address address notStaker = address(3333); strategyManager.depositIntoStrategyWithSignature(strategy, token, amount, notStaker, expiry, signature); @@ -866,7 +880,7 @@ contract StrategyManagerUnitTests_depositIntoStrategyWithSignature is StrategyMa // not expecting a revert, so input an empty string bytes memory signature = _depositIntoStrategyWithSignature(staker, amount, expiry, ""); - cheats.expectRevert(ISignatureUtils.InvalidSignature.selector); + cheats.expectRevert(ISignatureUtilsMixinErrors.InvalidSignature.selector); strategyManager.depositIntoStrategyWithSignature(dummyStrat, dummyToken, amount, staker, expiry, signature); } @@ -906,7 +920,7 @@ contract StrategyManagerUnitTests_depositIntoStrategyWithSignature is StrategyMa signature = abi.encodePacked(r, s, v); } - cheats.expectRevert(ISignatureUtils.InvalidSignature.selector); + cheats.expectRevert(ISignatureUtilsMixinErrors.InvalidSignature.selector); strategyManager.depositIntoStrategyWithSignature(strategy, token, amount, staker, expiry, signature); } @@ -1074,7 +1088,7 @@ contract StrategyManagerUnitTests_depositIntoStrategyWithSignature is StrategyMa uint256 depositSharesBefore = strategyManager.stakerDepositShares(staker, strategy); - cheats.expectRevert(ISignatureUtils.SignatureExpired.selector); + cheats.expectRevert(ISignatureUtilsMixinErrors.SignatureExpired.selector); strategyManager.depositIntoStrategyWithSignature(strategy, token, amount, staker, expiry, signature); uint256 depositSharesAfter = strategyManager.stakerDepositShares(staker, strategy); @@ -1300,18 +1314,18 @@ contract StrategyManagerUnitTests_addShares is StrategyManagerUnitTests { function test_Revert_DelegationManagerModifier() external { DelegationManagerMock invalidDelegationManager = new DelegationManagerMock(); cheats.expectRevert(IStrategyManagerErrors.OnlyDelegationManager.selector); - invalidDelegationManager.addShares(strategyManager, address(this), dummyToken, dummyStrat, 1); + invalidDelegationManager.addShares(strategyManager, address(this), dummyStrat, 1); } function testFuzz_Revert_StakerZeroAddress(uint256 amount) external { cheats.expectRevert(IStrategyManagerErrors.StakerAddressZero.selector); - delegationManagerMock.addShares(strategyManager, address(0), dummyToken, dummyStrat, amount); + delegationManagerMock.addShares(strategyManager, address(0), dummyStrat, amount); } function testFuzz_Revert_ZeroShares(address staker) external filterFuzzedAddressInputs(staker) { cheats.assume(staker != address(0)); cheats.expectRevert(IStrategyManagerErrors.SharesAmountZero.selector); - delegationManagerMock.addShares(strategyManager, staker, dummyToken, dummyStrat, 0); + delegationManagerMock.addShares(strategyManager, staker, dummyStrat, 0); } function testFuzz_AppendsStakerStrategyList( @@ -1324,7 +1338,7 @@ contract StrategyManagerUnitTests_addShares is StrategyManagerUnitTests { assertEq(depositSharesBefore, 0, "Staker has already deposited into this strategy"); assertFalse(_isDepositedStrategy(staker, dummyStrat), "strategy should not be deposited"); - delegationManagerMock.addShares(strategyManager, staker, dummyToken, dummyStrat, amount); + delegationManagerMock.addShares(strategyManager, staker, dummyStrat, amount); uint256 stakerStrategyListLengthAfter = strategyManager.stakerStrategyListLength(staker); uint256 depositSharesAfter = strategyManager.stakerDepositShares(staker, dummyStrat); assertEq( @@ -1349,7 +1363,7 @@ contract StrategyManagerUnitTests_addShares is StrategyManagerUnitTests { assertEq(depositSharesBefore, initialAmount, "Staker has not deposited amount into strategy"); assertTrue(_isDepositedStrategy(staker, strategy), "strategy should be deposited"); - delegationManagerMock.addShares(strategyManager, staker, dummyToken, dummyStrat, sharesAmount); + delegationManagerMock.addShares(strategyManager, staker, dummyStrat, sharesAmount); uint256 stakerStrategyListLengthAfter = strategyManager.stakerStrategyListLength(staker); uint256 depositSharesAfter = strategyManager.stakerDepositShares(staker, dummyStrat); assertEq( @@ -1397,7 +1411,7 @@ contract StrategyManagerUnitTests_addShares is StrategyManagerUnitTests { cheats.prank(staker); cheats.expectRevert(IStrategyManagerErrors.MaxStrategiesExceeded.selector); - delegationManagerMock.addShares(strategyManager, staker, dummyToken, strategy, amount); + delegationManagerMock.addShares(strategyManager, staker, strategy, amount); cheats.expectRevert(IStrategyManagerErrors.MaxStrategiesExceeded.selector); strategyManager.depositIntoStrategy(strategy, token, amount); @@ -1466,7 +1480,7 @@ contract StrategyManagerUnitTests_increaseBurnableShares is StrategyManagerUnitT cheats.prank(address(delegationManagerMock)); strategyManager.increaseBurnableShares(strategy, addedSharesToBurn); assertEq( - strategyManager.burnableShares(strategy), + strategyManager.getBurnableShares(strategy), addedSharesToBurn, "strategyManager.burnableShares(strategy) != addedSharesToBurn" ); @@ -1487,7 +1501,7 @@ contract StrategyManagerUnitTests_increaseBurnableShares is StrategyManagerUnitT emit BurnableSharesIncreased(strategy, existingBurnableShares); strategyManager.increaseBurnableShares(strategy, existingBurnableShares); assertEq( - strategyManager.burnableShares(strategy), + strategyManager.getBurnableShares(strategy), existingBurnableShares, "strategyManager.burnableShares(strategy) != existingBurnableShares" ); @@ -1498,7 +1512,7 @@ contract StrategyManagerUnitTests_increaseBurnableShares is StrategyManagerUnitT strategyManager.increaseBurnableShares(strategy, addedSharesToBurn); assertEq( - strategyManager.burnableShares(strategy), + strategyManager.getBurnableShares(strategy), existingBurnableShares + addedSharesToBurn, "strategyManager.burnableShares(strategy) != existingBurnableShares + addedSharesToBurn" ); @@ -1543,6 +1557,11 @@ contract StrategyManagerUnitTests_burnShares is StrategyManagerUnitTests { burnAddressBalanceBefore + sharesToBurn, "balanceAfter != balanceBefore + sharesAmount" ); + + // Verify strategy was removed from burnable shares + (address[] memory strategiesAfterBurn, uint256[] memory sharesAfterBurn) = strategyManager.getStrategiesWithBurnableShares(); + assertEq(strategiesAfterBurn.length, 0, "Should have no strategies after burning"); + assertEq(strategyManager.getBurnableShares(strategy), 0, "getBurnableShares should return 0 after burning"); } /// @notice check that balances are unchanged with a reverting token but burnShares doesn't revert @@ -1572,7 +1591,7 @@ contract StrategyManagerUnitTests_burnShares is StrategyManagerUnitTests { strategyManager.burnShares(strategy); assertEq( - strategyManager.burnableShares(strategy), + strategyManager.getBurnableShares(strategy), sharesToBurn, "burnable shares should be unchanged" ); @@ -1751,4 +1770,78 @@ contract StrategyManagerUnitTests_removeStrategiesFromDepositWhitelist is Strate } } } +} + +contract StrategyManagerUnitTests_getStrategiesWithBurnableShares is StrategyManagerUnitTests { + + function test_getStrategiesWithBurnableShares_Empty() public { + (address[] memory strategies, uint256[] memory shares) = strategyManager.getStrategiesWithBurnableShares(); + assertEq(strategies.length, 0, "Should have no strategies when empty"); + assertEq(shares.length, 0, "Should have no shares when empty"); + } + + function testFuzz_getStrategiesWithBurnableShares_Single(uint256 sharesToAdd) public { + //ensure non-zero + cheats.assume(sharesToAdd > 0); + + // Add burnable shares + cheats.prank(address(delegationManagerMock)); + strategyManager.increaseBurnableShares(dummyStrat, sharesToAdd); + + // Get strategies with burnable shares + (address[] memory strategies, uint256[] memory shares) = strategyManager.getStrategiesWithBurnableShares(); + + // Verify results + assertEq(strategies.length, 1, "Should have one strategy"); + assertEq(shares.length, 1, "Should have one share amount"); + assertEq(strategies[0], address(dummyStrat), "Wrong strategy address"); + assertEq(shares[0], sharesToAdd, "Wrong shares amount"); + } + + function testFuzz_getStrategiesWithBurnableShares_Multiple( + uint256[3] calldata sharesToAdd + ) public { + IStrategy[] memory strategies = new IStrategy[](3); + strategies[0] = dummyStrat; + strategies[1] = dummyStrat2; + strategies[2] = dummyStrat3; + uint256[3] memory expectedShares; + uint256 expectedLength = 0; + + // Add non-zero shares to strategies + for (uint256 i = 0; i < 3; i++) { + expectedShares[i] = sharesToAdd[i]; + if (sharesToAdd[i] > 0) { + expectedLength++; + cheats.prank(address(delegationManagerMock)); + strategyManager.increaseBurnableShares(strategies[i], sharesToAdd[i]); + } + } + + // Get strategies with burnable shares + (address[] memory returnedStrategies, uint256[] memory returnedShares) = + strategyManager.getStrategiesWithBurnableShares(); + + // Verify lengths match + assertEq(returnedStrategies.length, expectedLength, "Wrong number of strategies returned"); + assertEq(returnedShares.length, expectedLength, "Wrong number of share amounts returned"); + + // For all strategies with non-zero shares, verify they are in the returned arrays + uint256 foundCount = 0; + for (uint256 i = 0; i < 3; i++) { + if (expectedShares[i] > 0) { + bool found = false; + for (uint256 j = 0; j < returnedStrategies.length; j++) { + if (returnedStrategies[j] == address(strategies[i])) { + assertEq(returnedShares[j], expectedShares[i], "Wrong share amount"); + found = true; + foundCount++; + break; + } + } + assertTrue(found, "Strategy with non-zero shares not found in returned array"); + } + } + assertEq(foundCount, expectedLength, "Number of found strategies doesn't match expected length"); + } } \ No newline at end of file diff --git a/src/test/unit/libraries/SnapshotsUnit.t.sol b/src/test/unit/libraries/SnapshotsUnit.t.sol index 804bdb4e71..1851a73959 100644 --- a/src/test/unit/libraries/SnapshotsUnit.t.sol +++ b/src/test/unit/libraries/SnapshotsUnit.t.sol @@ -9,6 +9,7 @@ contract SnapshotsUnitTests is Test { Snapshots.DefaultWadHistory history; + /// forge-config: default.allow_internal_expect_revert = true function test_Revert_InvalidSnapshotOrdering(uint256 r) public { uint32 key = uint32(bound(r, 1, type(uint32).max)); uint32 smallerKey = uint32(bound(r, 0, key - 1)); diff --git a/src/test/unit/mixins/SemVerMixin.t.sol b/src/test/unit/mixins/SemVerMixin.t.sol new file mode 100644 index 0000000000..bd217fd1d3 --- /dev/null +++ b/src/test/unit/mixins/SemVerMixin.t.sol @@ -0,0 +1,29 @@ +// SPDX-License-Identifier: BUSL-1.1 +pragma solidity ^0.8.0; + +import {Test} from "forge-std/Test.sol"; +import {SemVerMixin} from "src/contracts/mixins/SemVerMixin.sol"; + +// Helper contract to test the abstract SemVerMixin +contract SemVerMixinMock is SemVerMixin { + constructor(string memory version) SemVerMixin(version) {} + + // Expose internal function for testing + function majorVersion() public view returns (string memory) { + return _majorVersion(); + } +} + +contract SemVerMixinTest is Test { + SemVerMixinMock public semVer; + + function test_version_returnsCorrectVersion() public { + semVer = new SemVerMixinMock("v1.2.3"); + assertEq(semVer.version(), "v1.2.3"); + } + + function test_majorVersion_returnsCorrectMajorVersion() public { + semVer = new SemVerMixinMock("v1.2.3"); + assertEq(semVer.majorVersion(), "v1"); + } +} \ No newline at end of file diff --git a/src/test/unit/mixins/SignatureUtilsUnit.t.sol b/src/test/unit/mixins/SignatureUtilsUnit.t.sol index b6dffecfda..c2b959b39a 100644 --- a/src/test/unit/mixins/SignatureUtilsUnit.t.sol +++ b/src/test/unit/mixins/SignatureUtilsUnit.t.sol @@ -2,7 +2,7 @@ pragma solidity ^0.8.27; import "forge-std/Test.sol"; -import "src/contracts/mixins/SignatureUtils.sol"; +import "src/contracts/mixins/SignatureUtilsMixin.sol"; contract MockSigner { mapping(bytes32 => mapping(bytes => bool)) public validSignatures; @@ -16,7 +16,7 @@ contract MockSigner { } } -contract SignatureUtilsUnit is Test, SignatureUtils { +contract SignatureUtilsMixinUnit is Test, SignatureUtilsMixin("v0.0.0") { uint256 signerPk; address signer; bytes32 hash; @@ -34,8 +34,9 @@ contract SignatureUtilsUnit is Test, SignatureUtils { expectedDomainSeparator = keccak256( abi.encode( - keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)"), + keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"), keccak256(bytes("EigenLayer")), + keccak256(bytes(_majorVersion())), block.chainid, address(this) ) @@ -43,7 +44,6 @@ contract SignatureUtilsUnit is Test, SignatureUtils { } function test_domainSeparator_NonZero() public { - assertTrue(_INITIAL_DOMAIN_SEPARATOR != 0, "The initial domain separator should be non-zero"); assertTrue(domainSeparator() != 0, "The domain separator should be non-zero"); assertTrue(domainSeparator() == expectedDomainSeparator, "The domain separator should be as expected"); } @@ -63,14 +63,15 @@ contract SignatureUtilsUnit is Test, SignatureUtils { ); } + /// forge-config: default.allow_internal_expect_revert = true function test_checkIsValidSignatureNow_Expired() public { (uint8 v, bytes32 r, bytes32 s) = vm.sign(signerPk, digest); - vm.expectRevert(ISignatureUtils.SignatureExpired.selector); + vm.expectRevert(ISignatureUtilsMixinErrors.SignatureExpired.selector); _checkIsValidSignatureNow(signer, digest, abi.encode(r, s, v), block.timestamp - 1); } - function testFail_checkIsValidSignatureNow_InvalidSignature() public { - _checkIsValidSignatureNow(signer, digest, "", block.timestamp); - } + // function testFail_checkIsValidSignatureNow_InvalidSignature() public { + // _checkIsValidSignatureNow(signer, digest, "", block.timestamp); + // } } \ No newline at end of file diff --git a/src/test/utils/EigenLayerUnitTestSetup.sol b/src/test/utils/EigenLayerUnitTestSetup.sol index a8ac0e187f..80d48dc3d4 100644 --- a/src/test/utils/EigenLayerUnitTestSetup.sol +++ b/src/test/utils/EigenLayerUnitTestSetup.sol @@ -71,7 +71,7 @@ abstract contract EigenLayerUnitTestSetup is Test { eigenLayerProxyAdmin = new ProxyAdmin(); // Deploy permission controller - permissionControllerImplementation = new PermissionController(); + permissionControllerImplementation = new PermissionController("v9.9.9"); permissionController = PermissionController(address(new TransparentUpgradeableProxy( address(permissionControllerImplementation), address(eigenLayerProxyAdmin), diff --git a/src/test/utils/Logger.t.sol b/src/test/utils/Logger.t.sol index c3fd148c25..7a5aab8f99 100644 --- a/src/test/utils/Logger.t.sol +++ b/src/test/utils/Logger.t.sol @@ -46,10 +46,30 @@ abstract contract Logger is Test { /// Modifiers /// ----------------------------------------------------------------------- + // Address used to store a trace counter to allow us to use noTracing + // across any contract that inherits Logger + address constant LOG_STATE_ADDR = address(0xDEADBEEF); + bytes32 constant LOG_STATE_SLOT = bytes32(0); + modifier noTracing() { - cheats.pauseTracing(); + uint traceCounter = _getTraceCounter(); + if (traceCounter == 0) { + cheats.pauseTracing(); + } + + traceCounter++; + _setTraceCounter(traceCounter); + _; - cheats.resumeTracing(); + + traceCounter = _getTraceCounter(); + traceCounter--; + _setTraceCounter(traceCounter); + + if (traceCounter == 0) { + cheats.resumeTracing(); + } + } modifier noLogging() { @@ -77,7 +97,7 @@ abstract contract Logger is Test { /// @dev Returns `name` colored based logging its role. function colorByRole( string memory name - ) public view noTracing returns (string memory colored) { + ) public view returns (string memory colored) { bool isOperator = _contains(name, "operator"); bool isStaker = _contains(name, "staker"); bool isAVS = _contains(name, "avs"); @@ -105,8 +125,15 @@ abstract contract Logger is Test { function rollForward( uint256 blocks ) internal { - cheats.roll(block.timestamp + blocks); - console.log("%s.roll(%d)", colorByRole("cheats"), block.timestamp); + cheats.roll(block.number + blocks); + console.log("%s.roll(+ %d blocks)", colorByRole("cheats"), blocks); + } + + function rollBackward( + uint256 blocks + ) internal { + cheats.roll(block.number - blocks); + console.log("%s.roll(- %d blocks)", colorByRole("cheats"), blocks); } /// ----------------------------------------------------------------------- @@ -117,6 +144,18 @@ abstract contract Logger is Test { logging = !logging; console.log("\n%s logging %s...", NAME_COLORED(), logging ? "enabled" : "disabled"); } + + /// ----------------------------------------------------------------------- + /// Trace Counter get/set + /// ----------------------------------------------------------------------- + + function _getTraceCounter() internal view returns (uint) { + return uint(cheats.load(LOG_STATE_ADDR, LOG_STATE_SLOT)); + } + + function _setTraceCounter(uint _newValue) internal { + cheats.store(LOG_STATE_ADDR, LOG_STATE_SLOT, bytes32(_newValue)); + } } /// @dev Assumes the user is a `Logger`.