New Compounding Staking Strategy post Pectra upgrade

contracts/.eslintrc.js

@@ -1,6 +1,6 @@
 module.exports = {
   env: {
-    es6: true,
+    es2020: true,
     node: true,
     browser: true,
     amd: true,

contracts/contracts/beacon/BeaconConsolidation.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+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/BeaconOracle.sol

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import { BeaconProofsLib } from "./BeaconProofsLib.sol";
+import { BeaconRoots } from "./BeaconRoots.sol";
+
+/// @title Beacon Chain Oracle
+/// @notice An Oracle for mapping execution layer block numbers to beacon chain slots.
+/// @author Origin Protocol Inc
+contract BeaconOracle {
+    /// @notice Maps a block number to slot
+    mapping(uint64 => uint64) private _blockToSlot;
+    /// @notice Maps a slot to a number
+    mapping(uint64 => uint64) private _slotToBlock;
+    /// @notice Maps a slot to a beacon block root
+    mapping(uint64 => bytes32) private _slotToRoot;
+
+    event BlockToSlot(
+        bytes32 indexed blockRoot,
+        uint64 indexed blockNumber,
+        uint64 indexed slot
+    );
+
+    /// @notice Uses merkle a proof against the beacon block root to link
+    /// an execution layer block number to a beacon chain slot.
+    /// @param nextBlockTimestamp The timestamp of the block after the one being proven.
+    /// @param blockNumber The execution layer block number.
+    /// @param slot The beacon chain slot.
+    /// @param slotProof The merkle proof witnesses for the slot against the beacon block root.
+    /// @param blockProof The merkle proof witnesses for the block number against the beacon block root.
+    function verifySlot(
+        uint64 nextBlockTimestamp,
+        uint64 blockNumber,
+        uint64 slot,
+        bytes calldata slotProof,
+        bytes calldata blockProof
+    ) external returns (bytes32 blockRoot) {
+        require(_blockToSlot[blockNumber] == 0, "Block already mapped");
+
+        // Get the parent beacon block root for the given timestamp.
+        // This is the beacon block root of the previous slot.
+        blockRoot = BeaconRoots.parentBlockRoot(nextBlockTimestamp);
+
+        // Verify the slot to the beacon block root
+        BeaconProofsLib.verifySlot(blockRoot, slot, slotProof);
+
+        // Verify the block number to the beacon block root
+        BeaconProofsLib.verifyBlockNumber(blockRoot, blockNumber, blockProof);
+
+        // Store mappings
+        _blockToSlot[blockNumber] = slot;
+        _slotToBlock[slot] = blockNumber;
+        _slotToRoot[slot] = blockRoot;
+
+        emit BlockToSlot(blockRoot, blockNumber, slot);
+    }
+
+    /// @notice Returns the beacon chain slot for a given execution layer block number.
+    function blockToSlot(uint64 blockNumber)
+        external
+        view
+        returns (uint64 slot)
+    {
+        slot = _blockToSlot[blockNumber];
+
+        require(slot != 0, "Block not mapped");
+    }
+
+    /// @notice Returns the execution layer block number for a given beacon chain slot.
+    function slotToBlock(uint64 slot)
+        external
+        view
+        returns (uint64 blockNumber)
+    {
+        blockNumber = _slotToBlock[slot];
+
+        require(blockNumber != 0, "Slot not mapped");
+    }
+
+    /// @notice Returns the beacon block root for a given beacon chain slot.
+    function slotToRoot(uint64 slot) external view returns (bytes32 blockRoot) {
+        blockRoot = _slotToRoot[slot];
+
+        require(blockRoot != 0, "Slot not mapped");
+    }
+
+    /// @notice Returns true if an execution layer block number has been mapped to a beacon chain slot.
+    function isBlockMapped(uint64 blockNumber) external view returns (bool) {
+        return _blockToSlot[blockNumber] != 0;
+    }
+
+    /// @notice Returns true if a beacon chain slot has been mapped to an execution layer block number.
+    function isSlotMapped(uint64 slot) external view returns (bool) {
+        return _slotToBlock[slot] != 0;
+    }
+}

contracts/contracts/beacon/BeaconProofs.sol

@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+import { BeaconProofsLib } from "./BeaconProofsLib.sol";
+
+contract BeaconProofs {
+    /// @notice Verifies the validator public key against the beacon block root
+    /// BeaconBlock.state.validators[validatorIndex].pubkey
+    /// @param beaconBlockRoot The root of the beacon block
+    /// @param pubKeyHash The beacon chain hash of the validator public key
+    /// @param validatorPubKeyProof The merkle proof for the validator public key to the beacon block root.
+    /// This is the witness hashes concatenated together starting from the leaf node.
+    /// @param validatorIndex The validator index
+    function verifyValidatorPubkey(
+        bytes32 beaconBlockRoot,
+        bytes32 pubKeyHash,
+        bytes calldata validatorPubKeyProof,
+        uint64 validatorIndex
+    ) external view {
+        BeaconProofsLib.verifyValidatorPubkey(
+            beaconBlockRoot,
+            pubKeyHash,
+            validatorPubKeyProof,
+            validatorIndex
+        );
+    }
+
+    /// @notice Verifies the balances container against the beacon block root
+    /// BeaconBlock.state.balances
+    /// @param beaconBlockRoot The root of the beacon block
+    /// @param balancesContainerLeaf The leaf node containing the balances container
+    /// @param balancesContainerProof The merkle proof for the balances container to the beacon block root.
+    /// This is the witness hashes concatenated together starting from the leaf node.
+    function verifyBalancesContainer(
+        bytes32 beaconBlockRoot,
+        bytes32 balancesContainerLeaf,
+        bytes calldata balancesContainerProof
+    ) external view {
+        BeaconProofsLib.verifyBalancesContainer(
+            beaconBlockRoot,
+            balancesContainerLeaf,
+            balancesContainerProof
+        );
+    }
+
+    /// @notice Verifies the validator balance against the root of the Balances container
+    /// or the beacon block root
+    /// @param root The root of the Balances container or the beacon block root
+    /// @param validatorBalanceLeaf The leaf node containing the validator balance with three other balances
+    /// @param balanceProof The merkle proof for the validator balance against the root.
+    /// This is the witness hashes concatenated together starting from the leaf node.
+    /// @param validatorIndex The validator index to verify the balance for
+    /// @param level The level of the balance proof, either Container or BeaconBlock
+    function verifyValidatorBalance(
+        bytes32 root,
+        bytes32 validatorBalanceLeaf,
+        bytes calldata balanceProof,
+        uint64 validatorIndex,
+        BeaconProofsLib.BalanceProofLevel level
+    ) external view returns (uint256 validatorBalance) {
+        validatorBalance = BeaconProofsLib.verifyValidatorBalance(
+            root,
+            validatorBalanceLeaf,
+            balanceProof,
+            validatorIndex,
+            level
+        );
+    }
+
+    /// @notice Verifies the slot of the first pending deposit against the beacon block root
+    /// BeaconBlock.state.PendingDeposits[0].slot
+    /// @param beaconBlockRoot The root of the beacon block
+    /// @param slot The beacon chain slot to verify
+    /// @param firstPendingDepositSlotProof The merkle proof for the first pending deposit's slot
+    /// against the beacon block root.
+    /// This is the witness hashes concatenated together starting from the leaf node.
+    function verifyFirstPendingDepositSlot(
+        bytes32 beaconBlockRoot,
+        uint64 slot,
+        bytes calldata firstPendingDepositSlotProof
+    ) external view {
+        BeaconProofsLib.verifyFirstPendingDepositSlot(
+            beaconBlockRoot,
+            slot,
+            firstPendingDepositSlotProof
+        );
+    }
+
+    /// @notice Verifies the block number to the the beacon block root
+    /// BeaconBlock.body.executionPayload.blockNumber
+    /// @param beaconBlockRoot The root of the beacon block
+    /// @param blockNumber The execution layer block number to verify
+    /// @param blockNumberProof The merkle proof for the block number against the beacon block
+    /// This is the witness hashes concatenated together starting from the leaf node.
+    function verifyBlockNumber(
+        bytes32 beaconBlockRoot,
+        uint256 blockNumber,
+        bytes calldata blockNumberProof
+    ) external view {
+        BeaconProofsLib.verifyBlockNumber(
+            beaconBlockRoot,
+            blockNumber,
+            blockNumberProof
+        );
+    }
+
+    /// @notice Verifies the slot number against the beacon block root.
+    /// BeaconBlock.slot
+    /// @param beaconBlockRoot The root of the beacon block
+    /// @param slot The beacon chain slot to verify
+    /// @param slotProof The merkle proof for the slot against the beacon block root.
+    /// This is the witness hashes concatenated together starting from the leaf node.
+    function verifySlot(
+        bytes32 beaconBlockRoot,
+        uint256 slot,
+        bytes calldata slotProof
+    ) external view {
+        BeaconProofsLib.verifySlot(beaconBlockRoot, slot, slotProof);
+    }
+}