New Compounding Staking Strategy post Pectra upgrade

contracts/README.md

@@ -341,9 +341,7 @@ export DEFENDER_TEAM_SECRET=
 # set -o allexport && source ../../.env && set +o allexport
 
 # Set the DEBUG environment variable to oeth* for the Defender Action
-npx hardhat setActionVars --id 38e44420-f38b-4d4a-86b0-6012a8897ad9
 npx hardhat setActionVars --id f4b5b8d4-82ff-483f-bfae-9fef015790ca
-npx hardhat setActionVars --id 191d9631-70b9-43c5-9db4-1dd985fde05c
 npx hardhat setActionVars --id e2929f53-db56-49b2-b054-35f7df7fc4fb
 npx hardhat setActionVars --id 12c153c8-c5ca-420b-9696-e80c827996d1
 npx hardhat setActionVars --id 6e4f764d-4126-45a5-b7d9-1ab90cd3ffd6
@@ -354,9 +352,6 @@ npx hardhat setActionVars --id b1d831f1-29d4-4943-bb2e-8e625b76e82c
 # The Defender autotask client uses generic env var names so we'll set them first from the values in the .env file
 export API_KEY=${DEFENDER_TEAM_KEY}
 export API_SECRET=${DEFENDER_TEAM_SECRET}
-# Holesky
-npx defender-autotask update-code 38e44420-f38b-4d4a-86b0-6012a8897ad9 ./dist/registerValidators
-npx defender-autotask update-code 191d9631-70b9-43c5-9db4-1dd985fde05c ./dist/doAccounting
 # Mainnet
 npx defender-autotask update-code f4b5b8d4-82ff-483f-bfae-9fef015790ca ./dist/registerValidators
 npx defender-autotask update-code 12c153c8-c5ca-420b-9696-e80c827996d1 ./dist/stakeValidators

contracts/contracts/beacon/BeaconConsolidation.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+/**
+ * @title Library to request validator consolidation on the beacon chain.
+ * @author Origin Protocol Inc
+ */
+library BeaconConsolidation {
+    /// @notice The address the validator consolidation requests are sent
+    /// See https://eips.ethereum.org/EIPS/eip-7251
+    address internal constant CONSOLIDATION_REQUEST_ADDRESS =
+        0x0000BBdDc7CE488642fb579F8B00f3a590007251;
+
+    function request(bytes calldata source, bytes calldata target)
+        internal
+        returns (uint256 fee_)
+    {
+        require(source.length == 48, "Invalid source byte length");
+        require(target.length == 48, "Invalid target byte length");
+
+        fee_ = fee();
+
+        // Call the Consolidation Request contract with the public keys of the source and target
+        // validators packed together.
+        // This does not have a function signature, so we use a call
+        (bool success, ) = CONSOLIDATION_REQUEST_ADDRESS.call{ value: fee_ }(
+            abi.encodePacked(source, target)
+        );
+
+        require(success, "Consolidation request failed");
+    }
+
+    function fee() internal view returns (uint256) {
+        // Get fee from the consolidation request contract
+        (bool success, bytes memory result) = CONSOLIDATION_REQUEST_ADDRESS
+            .staticcall("");
+
+        require(success && result.length > 0, "Failed to get fee");
+        return abi.decode(result, (uint256));
+    }
+}

contracts/contracts/beacon/BeaconProofs.sol

@@ -0,0 +1,187 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+import { BeaconProofsLib } from "./BeaconProofsLib.sol";
+import { IBeaconProofs } from "../interfaces/IBeaconProofs.sol";
+
+/**
+ * @title Verifies merkle proofs of beacon chain data.
+ * @author Origin Protocol Inc
+ */
+contract BeaconProofs is IBeaconProofs {
+    /// @notice Verifies the validator index is for the given validator public key.
+    /// Also verify the validator's withdrawal credential points to the withdrawal address.
+    /// BeaconBlock.state.validators[validatorIndex].pubkey
+    /// @param beaconBlockRoot The root of the beacon block
+    /// @param pubKeyHash Hash of validator's public key using the Beacon Chain's format
+    /// @param proof The merkle proof for the validator public key to the beacon block root.
+    /// This is 53 witness hashes of 32 bytes each concatenated together starting from the leaf node.
+    /// @param validatorIndex The validator index
+    /// @param withdrawalCredentials a value containing the validator type and withdrawal address.
+    function verifyValidator(
+        bytes32 beaconBlockRoot,
+        bytes32 pubKeyHash,
+        bytes calldata proof,
+        uint40 validatorIndex,
+        bytes32 withdrawalCredentials
+    ) external view {
+        BeaconProofsLib.verifyValidator(
+            beaconBlockRoot,
+            pubKeyHash,
+            proof,
+            validatorIndex,
+            withdrawalCredentials
+        );
+    }
+
+    function verifyValidatorWithdrawable(
+        bytes32 beaconBlockRoot,
+        uint40 validatorIndex,
+        uint64 withdrawableEpoch,
+        bytes calldata withdrawableEpochProof
+    ) external view {
+        BeaconProofsLib.verifyValidatorWithdrawableEpoch(
+            beaconBlockRoot,
+            validatorIndex,
+            withdrawableEpoch,
+            withdrawableEpochProof
+        );
+    }
+
+    /// @notice Verifies the balances container to the beacon block root
+    /// BeaconBlock.state.balances
+    /// @param beaconBlockRoot The root of the beacon block
+    /// @param balancesContainerRoot The merkle root of the the balances container
+    /// @param balancesContainerProof The merkle proof for the balances container to the beacon block root.
+    /// This is 9 witness hashes of 32 bytes each concatenated together starting from the leaf node.
+    function verifyBalancesContainer(
+        bytes32 beaconBlockRoot,
+        bytes32 balancesContainerRoot,
+        bytes calldata balancesContainerProof
+    ) external view {
+        BeaconProofsLib.verifyBalancesContainer(
+            beaconBlockRoot,
+            balancesContainerRoot,
+            balancesContainerProof
+        );
+    }
+
+    /// @notice Verifies the validator balance to the root of the Balances container.
+    /// @param balancesContainerRoot The merkle root of the Balances container.
+    /// @param validatorBalanceLeaf The leaf node containing the validator balance with three other balances.
+    /// @param balanceProof The merkle proof for the validator balance to the Balances container root.
+    /// This is 39 witness hashes of 32 bytes each concatenated together starting from the leaf node.
+    /// @param validatorIndex The validator index to verify the balance for
+    /// @return validatorBalanceGwei The balance in Gwei of the validator at the given index
+    function verifyValidatorBalance(
+        bytes32 balancesContainerRoot,
+        bytes32 validatorBalanceLeaf,
+        bytes calldata balanceProof,
+        uint40 validatorIndex
+    ) external view returns (uint256 validatorBalanceGwei) {
+        validatorBalanceGwei = BeaconProofsLib.verifyValidatorBalance(
+            balancesContainerRoot,
+            validatorBalanceLeaf,
+            balanceProof,
+            validatorIndex
+        );
+    }
+
+    /// @notice Verifies the pending deposits container to the beacon block root.
+    /// BeaconBlock.state.pendingDeposits
+    /// @param beaconBlockRoot The root of the beacon block.
+    /// @param pendingDepositsContainerRoot The merkle root of the the pending deposits container.
+    /// @param proof The merkle proof for the pending deposits container to the beacon block root.
+    /// This is 9 witness hashes of 32 bytes each concatenated together starting from the leaf node.
+    function verifyPendingDepositsContainer(
+        bytes32 beaconBlockRoot,
+        bytes32 pendingDepositsContainerRoot,
+        bytes calldata proof
+    ) external view {
+        BeaconProofsLib.verifyPendingDepositsContainer(
+            beaconBlockRoot,
+            pendingDepositsContainerRoot,
+            proof
+        );
+    }
+
+    /// @notice Verified a pending deposit to the root of the Pending Deposits container.
+    /// @param pendingDepositsContainerRoot The merkle root of the Pending Deposits container.
+    /// @param pendingDepositRoot The leaf node containing the validator balance with three other balances.
+    /// @param proof The merkle proof for the pending deposit root to the Pending Deposits container root.
+    /// This is 28 witness hashes of 32 bytes each concatenated together starting from the leaf node.
+    /// @param pendingDepositIndex The pending deposit index in the Pending Deposits container
+    function verifyPendingDeposit(
+        bytes32 pendingDepositsContainerRoot,
+        bytes32 pendingDepositRoot,
+        bytes calldata proof,
+        uint32 pendingDepositIndex
+    ) external view {
+        BeaconProofsLib.verifyPendingDeposit(
+            pendingDepositsContainerRoot,
+            pendingDepositRoot,
+            proof,
+            pendingDepositIndex
+        );
+    }
+
+    /// @notice If the deposit queue is not empty,
+    /// verify the slot of the first pending deposit to the beacon block root.
+    /// BeaconBlock.state.pendingDeposits[0].slot
+    /// If the deposit queue is empty, verify the root of the first pending deposit is empty
+    /// BeaconBlock.state.PendingDeposits[0]
+    /// @param beaconBlockRoot The root of the beacon block.
+    /// @param slot The beacon chain slot of the first deposit in the beacon chain's deposit queue.
+    /// Can be anything if the deposit queue is empty.
+    /// @param firstPendingDepositSlotProof The merkle proof to the beacon block root. Can be either:
+    /// - 40 witness hashes for BeaconBlock.state.PendingDeposits[0].slot when the deposit queue is not empty.
+    /// - 37 witness hashes for BeaconBlock.state.PendingDeposits[0] when the deposit queue is empty.
+    /// The 32 byte witness hashes are concatenated together starting from the leaf node.
+    /// @return isEmptyDepositQueue True if the deposit queue is empty, false otherwise.
+    function verifyFirstPendingDeposit(
+        bytes32 beaconBlockRoot,
+        uint64 slot,
+        bytes calldata firstPendingDepositSlotProof
+    ) external view returns (bool isEmptyDepositQueue) {
+        isEmptyDepositQueue = BeaconProofsLib.verifyFirstPendingDeposit(
+            beaconBlockRoot,
+            slot,
+            firstPendingDepositSlotProof
+        );
+    }
+
+    /// @notice Merkleizes a beacon chain pending deposit.
+    /// @param pubKeyHash Hash of validator's public key using the Beacon Chain's format
+    /// @param withdrawalCredentials The 32 byte withdrawal credentials.
+    /// @param amountGwei The amount of the deposit in Gwei.
+    /// @param signature The 96 byte BLS signature.
+    /// @param slot The beacon chain slot the deposit was made in.
+    /// @return root The merkle root of the pending deposit.
+    function merkleizePendingDeposit(
+        bytes32 pubKeyHash,
+        bytes calldata withdrawalCredentials,
+        uint64 amountGwei,
+        bytes calldata signature,
+        uint64 slot
+    ) external pure returns (bytes32) {
+        return
+            BeaconProofsLib.merkleizePendingDeposit(
+                pubKeyHash,
+                withdrawalCredentials,
+                amountGwei,
+                signature,
+                slot
+            );
+    }
+
+    /// @notice Merkleizes a BLS signature used for validator deposits.
+    /// @param signature The 96 byte BLS signature.
+    /// @return root The merkle root of the signature.
+    function merkleizeSignature(bytes calldata signature)
+        external
+        pure
+        returns (bytes32 root)
+    {
+        return BeaconProofsLib.merkleizeSignature(signature);
+    }
+}