Merge branch 'master' into client-v2-get

contracts/script/MockRollupDeployer.s.sol

@@ -3,7 +3,7 @@
 pragma solidity ^0.8.9;
 
 import "forge-std/Script.sol";
-import "../test/rollup/MockRollup.sol";
+import "../test/rollupV1/MockRollup.sol";
 import {IEigenDAServiceManager} from "../src/interfaces/IEigenDAServiceManager.sol";
 
 contract MockRollupDeployer is Script {

contracts/src/core/EigenDABlobVerifier.sol

@@ -96,7 +96,7 @@ contract EigenDABlobVerifier is IEigenDABlobVerifier {
             blobVerificationProof,
             nonSignerStakesAndSignature,
             getDefaultSecurityThresholdsV2(),
-            quorumNumbersRequired()
+            blobVerificationProof.blobCertificate.blobHeader.quorumNumbers
         );
     }
 
@@ -118,7 +118,7 @@ contract EigenDABlobVerifier is IEigenDABlobVerifier {
             signedBatch,
             blobVerificationProof,
             getDefaultSecurityThresholdsV2(),
-            quorumNumbersRequired()
+            blobVerificationProof.blobCertificate.blobHeader.quorumNumbers
         );
     }
 

contracts/src/core/EigenDAThresholdRegistry.sol

@@ -37,26 +37,6 @@ contract EigenDAThresholdRegistry is EigenDAThresholdRegistryStorage, OwnableUpg
         }
     }
 
-    function updateQuorumAdversaryThresholdPercentages(bytes memory _quorumAdversaryThresholdPercentages) external onlyOwner {
-        emit QuorumAdversaryThresholdPercentagesUpdated(quorumAdversaryThresholdPercentages, _quorumAdversaryThresholdPercentages);
-        quorumAdversaryThresholdPercentages = _quorumAdversaryThresholdPercentages;
-    }
-
-    function updateQuorumConfirmationThresholdPercentages(bytes memory _quorumConfirmationThresholdPercentages) external onlyOwner {
-        emit QuorumConfirmationThresholdPercentagesUpdated(quorumConfirmationThresholdPercentages, _quorumConfirmationThresholdPercentages);
-        quorumConfirmationThresholdPercentages = _quorumConfirmationThresholdPercentages;
-    }
-
-    function updateQuorumNumbersRequired(bytes memory _quorumNumbersRequired) external onlyOwner {
-        emit QuorumNumbersRequiredUpdated(quorumNumbersRequired, _quorumNumbersRequired);
-        quorumNumbersRequired = _quorumNumbersRequired;
-    }
-
-    function updateDefaultSecurityThresholdsV2(SecurityThresholds memory _defaultSecurityThresholdsV2) external onlyOwner {
-        emit DefaultSecurityThresholdsV2Updated(defaultSecurityThresholdsV2, _defaultSecurityThresholdsV2);
-        defaultSecurityThresholdsV2 = _defaultSecurityThresholdsV2;
-    }
-
     function addVersionedBlobParams(VersionedBlobParams memory _versionedBlobParams) external onlyOwner returns (uint16) {
         return _addVersionedBlobParams(_versionedBlobParams);
     }

contracts/src/core/EigenDAThresholdRegistryStorage.sol

@@ -11,17 +11,25 @@ import "../interfaces/IEigenDAStructs.sol";
  */
 abstract contract EigenDAThresholdRegistryStorage is IEigenDAThresholdRegistry {
 
+    /// @notice The adversary threshold percentage for the quorum at position `quorumNumber`
     bytes public quorumAdversaryThresholdPercentages;
 
+    /// @notice The confirmation threshold percentage for the quorum at position `quorumNumber`
     bytes public quorumConfirmationThresholdPercentages;
 
+    /// @notice The set of quorum numbers that are required
     bytes public quorumNumbersRequired;
 
+    /// @notice The next blob version id to be added
     uint16 public nextBlobVersion;
 
+    /// @notice mapping of blob version id to the params of the blob version
     mapping(uint16 => VersionedBlobParams) public versionedBlobParams;
 
+    /// @notice Default security thresholds for quorums
     SecurityThresholds public defaultSecurityThresholdsV2;
 
+    // storage gap for upgradeability
+    // slither-disable-next-line shadowing-state
     uint256[44] private __GAP;
 }

contracts/src/payments/PaymentVault.sol

@@ -106,8 +106,8 @@ contract PaymentVault is OwnableUpgradeable, PaymentVaultStorage {
         require(success);
     }
 
-    function withdrawERC20(address _token, uint256 _amount) external onlyOwner {
-        IERC20(_token).transfer(owner(), _amount);
+    function withdrawERC20(IERC20 _token, uint256 _amount) external onlyOwner {
+        _token.transfer(owner(), _amount);
     }
 
     function _checkQuorumSplit(bytes memory _quorumNumbers, bytes memory _quorumSplits) internal pure {

contracts/test/MockEigenDADeployer.sol

@@ -0,0 +1,279 @@
+// SPDX-License-Identifier: MIT
+pragma solidity =0.8.12;
+
+import "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "../lib/eigenlayer-middleware/test/utils/BLSMockAVSDeployer.sol";
+import {EigenDAHasher} from "../src/libraries/EigenDAHasher.sol";
+import {EigenDAServiceManager, IRewardsCoordinator} from "../src/core/EigenDAServiceManager.sol";
+import {EigenDABlobVerificationUtils} from "../src/libraries/EigenDABlobVerificationUtils.sol";
+import {EigenDAHasher} from "../src/libraries/EigenDAHasher.sol";
+import {EigenDAServiceManager} from "../src/core/EigenDAServiceManager.sol";
+import {IEigenDAServiceManager} from "../src/interfaces/IEigenDAServiceManager.sol";
+import {EigenDABlobVerifier} from "../src/core/EigenDABlobVerifier.sol";
+import {EigenDAThresholdRegistry, IEigenDAThresholdRegistry} from "../src/core/EigenDAThresholdRegistry.sol";
+import {IEigenDABatchMetadataStorage} from "../src/interfaces/IEigenDABatchMetadataStorage.sol";
+import {IEigenDASignatureVerifier} from "../src/interfaces/IEigenDASignatureVerifier.sol";
+import {IRegistryCoordinator} from "../lib/eigenlayer-middleware/src/interfaces/IRegistryCoordinator.sol";
+import {IEigenDARelayRegistry} from "../src/interfaces/IEigenDARelayRegistry.sol";
+import {EigenDARelayRegistry} from "../src/core/EigenDARelayRegistry.sol";
+import {IPaymentVault} from "../src/interfaces/IPaymentVault.sol";
+import {PaymentVault} from "../src/payments/PaymentVault.sol";
+import {IEigenDADisperserRegistry} from "../src/interfaces/IEigenDADisperserRegistry.sol";
+import {EigenDADisperserRegistry} from "../src/core/EigenDADisperserRegistry.sol";
+import "../src/interfaces/IEigenDAStructs.sol";
+import "forge-std/StdStorage.sol";
+
+contract MockEigenDADeployer is BLSMockAVSDeployer {
+    using stdStorage for StdStorage;
+    using BN254 for BN254.G1Point;
+    using EigenDAHasher for BatchHeader;
+    using EigenDAHasher for ReducedBatchHeader;
+    using EigenDAHasher for BlobHeader;
+    using EigenDAHasher for BatchMetadata;
+
+    address confirmer = address(uint160(uint256(keccak256(abi.encodePacked("confirmer")))));
+    address notConfirmer = address(uint160(uint256(keccak256(abi.encodePacked("notConfirmer")))));
+    address rewardsInitiator = address(uint160(uint256(keccak256(abi.encodePacked("rewardsInitiator")))));
+
+    EigenDAServiceManager eigenDAServiceManager;
+    EigenDAServiceManager eigenDAServiceManagerImplementation;
+    EigenDARelayRegistry eigenDARelayRegistry;
+    EigenDARelayRegistry eigenDARelayRegistryImplementation;
+    EigenDAThresholdRegistry eigenDAThresholdRegistry;
+    EigenDAThresholdRegistry eigenDAThresholdRegistryImplementation;
+    EigenDADisperserRegistry eigenDADisperserRegistry;
+    EigenDADisperserRegistry eigenDADisperserRegistryImplementation;
+    PaymentVault paymentVault;
+    PaymentVault paymentVaultImplementation;
+    EigenDABlobVerifier eigenDABlobVerifier;
+
+    ERC20 mockToken;
+
+    bytes quorumAdversaryThresholdPercentages = hex"212121";
+    bytes quorumConfirmationThresholdPercentages = hex"373737";
+    bytes quorumNumbersRequired = hex"0001";
+    SecurityThresholds defaultSecurityThresholds = SecurityThresholds(55, 33);
+
+    uint32 defaultReferenceBlockNumber = 100;
+    uint32 defaultConfirmationBlockNumber = 1000;
+    uint32 defaultBatchId = 0;
+
+    uint64 minNumSymbols = 1;
+    uint64 pricePerSymbol = 3;
+    uint64 priceUpdateCooldown = 6 days;
+    uint64 globalSymbolsPerPeriod = 2;
+    uint64 reservationPeriodInterval = 4;
+    uint64 globalRatePeriodInterval = 5;
+
+    mapping(uint8 => bool) public quorumNumbersUsed;
+
+    function _deployDA() public {
+        _setUpBLSMockAVSDeployer();
+
+        eigenDAServiceManager = EigenDAServiceManager(
+            address(
+                new TransparentUpgradeableProxy(address(emptyContract), address(proxyAdmin), "")
+            )
+        );
+
+        eigenDAThresholdRegistry = EigenDAThresholdRegistry(
+            address(
+                new TransparentUpgradeableProxy(address(emptyContract), address(proxyAdmin), "")
+            )
+        );
+
+        eigenDARelayRegistry = EigenDARelayRegistry(
+            address(
+                new TransparentUpgradeableProxy(address(emptyContract), address(proxyAdmin), "")
+            )
+        );
+
+        paymentVault = PaymentVault(
+            payable(
+                address(
+                    new TransparentUpgradeableProxy(address(emptyContract), address(proxyAdmin), "")
+                )
+            )
+        );
+
+        eigenDADisperserRegistry = EigenDADisperserRegistry(
+            address(
+                new TransparentUpgradeableProxy(address(emptyContract), address(proxyAdmin), "")
+            )
+        );
+
+        eigenDAServiceManagerImplementation = new EigenDAServiceManager(
+            avsDirectory,
+            rewardsCoordinator,
+            registryCoordinator,
+            stakeRegistry,
+            eigenDAThresholdRegistry,
+            eigenDARelayRegistry,
+            paymentVault,
+            eigenDADisperserRegistry
+        );
+
+        address[] memory confirmers = new address[](1);
+        confirmers[0] = confirmer;
+
+        cheats.prank(proxyAdminOwner);
+        proxyAdmin.upgradeAndCall(
+            TransparentUpgradeableProxy(payable(address(eigenDAServiceManager))),
+            address(eigenDAServiceManagerImplementation),
+            abi.encodeWithSelector(
+                EigenDAServiceManager.initialize.selector,
+                pauserRegistry,
+                0,
+                registryCoordinatorOwner,
+                confirmers,
+                registryCoordinatorOwner
+            )
+        );
+
+        eigenDAThresholdRegistryImplementation = new EigenDAThresholdRegistry();
+
+        VersionedBlobParams[] memory versionedBlobParams = new VersionedBlobParams[](1);
+        versionedBlobParams[0] = VersionedBlobParams({
+            maxNumOperators: 3537,
+            numChunks: 8192,
+            codingRate: 8
+        });
+
+        cheats.prank(proxyAdminOwner);
+        proxyAdmin.upgradeAndCall(
+            TransparentUpgradeableProxy(payable(address(eigenDAThresholdRegistry))),
+            address(eigenDAThresholdRegistryImplementation),
+            abi.encodeWithSelector(
+                EigenDAThresholdRegistry.initialize.selector,
+                registryCoordinatorOwner,
+                quorumAdversaryThresholdPercentages,
+                quorumConfirmationThresholdPercentages,
+                quorumNumbersRequired,
+                versionedBlobParams,
+                defaultSecurityThresholds
+            )
+        );
+
+        eigenDARelayRegistryImplementation = new EigenDARelayRegistry();
+
+        cheats.prank(proxyAdminOwner);
+        proxyAdmin.upgradeAndCall(
+            TransparentUpgradeableProxy(payable(address(eigenDARelayRegistry))),
+            address(eigenDARelayRegistryImplementation),
+            abi.encodeWithSelector(EigenDARelayRegistry.initialize.selector, registryCoordinatorOwner)
+        );
+
+        eigenDADisperserRegistryImplementation = new EigenDADisperserRegistry();
+
+        cheats.prank(proxyAdminOwner);
+        proxyAdmin.upgradeAndCall(
+            TransparentUpgradeableProxy(payable(address(eigenDADisperserRegistry))),
+            address(eigenDADisperserRegistryImplementation),
+            abi.encodeWithSelector(EigenDADisperserRegistry.initialize.selector, registryCoordinatorOwner)
+        );
+
+        paymentVaultImplementation = PaymentVault(payable(address(new PaymentVault())));
+
+        paymentVault = PaymentVault(
+            payable(
+                address(
+                    new TransparentUpgradeableProxy(
+                        address(paymentVaultImplementation),
+                        address(proxyAdmin),
+                        abi.encodeWithSelector(
+                            PaymentVault.initialize.selector,
+                            registryCoordinatorOwner,
+                            minNumSymbols,
+                            pricePerSymbol,
+                            priceUpdateCooldown,
+                            globalSymbolsPerPeriod,
+                            reservationPeriodInterval,
+                            globalRatePeriodInterval
+                        )
+                    )
+                )
+            )
+        );
+
+        mockToken = new ERC20("Mock Token", "MOCK");
+
+        eigenDABlobVerifier = new EigenDABlobVerifier(
+            IEigenDAThresholdRegistry(address(eigenDAThresholdRegistry)),
+            IEigenDABatchMetadataStorage(address(eigenDAServiceManager)),
+            IEigenDASignatureVerifier(address(eigenDAServiceManager)),
+            IEigenDARelayRegistry(address(eigenDARelayRegistry)),
+            OperatorStateRetriever(address(operatorStateRetriever)),
+            IRegistryCoordinator(address(registryCoordinator))
+        );
+    }
+
+    function _getHeaderandNonSigners(uint256 _nonSigners, uint256 _pseudoRandomNumber, uint8 _threshold) internal returns (BatchHeader memory, BLSSignatureChecker.NonSignerStakesAndSignature memory) {
+        // register a bunch of operators
+        uint256 quorumBitmap = 1;
+        bytes memory quorumNumbers = BitmapUtils.bitmapToBytesArray(quorumBitmap);
+
+        // 0 nonSigners
+        (uint32 referenceBlockNumber, BLSSignatureChecker.NonSignerStakesAndSignature memory nonSignerStakesAndSignature) = 
+            _registerSignatoriesAndGetNonSignerStakeAndSignatureRandom(_pseudoRandomNumber, _nonSigners, quorumBitmap);
+
+        // get a random batch header
+        BatchHeader memory batchHeader = _getRandomBatchHeader(_pseudoRandomNumber, quorumNumbers, referenceBlockNumber, _threshold);
+
+        // set batch specific signature
+        bytes32 reducedBatchHeaderHash = batchHeader.hashBatchHeaderToReducedBatchHeader();
+        nonSignerStakesAndSignature.sigma = BN254.hashToG1(reducedBatchHeaderHash).scalar_mul(aggSignerPrivKey);
+
+        return (batchHeader, nonSignerStakesAndSignature);
+    }
+
+    function _getRandomBatchHeader(uint256 pseudoRandomNumber, bytes memory quorumNumbers, uint32 referenceBlockNumber, uint8 threshold) internal pure returns(BatchHeader memory) {
+        BatchHeader memory batchHeader;
+        batchHeader.blobHeadersRoot = keccak256(abi.encodePacked("blobHeadersRoot", pseudoRandomNumber));
+        batchHeader.quorumNumbers = quorumNumbers;
+        batchHeader.signedStakeForQuorums = new bytes(quorumNumbers.length);
+        for (uint256 i = 0; i < quorumNumbers.length; i++) {
+            batchHeader.signedStakeForQuorums[i] = bytes1(threshold);
+        }
+        batchHeader.referenceBlockNumber = referenceBlockNumber;
+        return batchHeader;
+    }
+
+    function _generateRandomBlobHeader(uint256 pseudoRandomNumber, uint256 numQuorumsBlobParams) internal returns (BlobHeader memory) {
+        if(pseudoRandomNumber == 0) {
+            pseudoRandomNumber = 1;
+        }
+
+        BlobHeader memory blobHeader;
+        blobHeader.commitment.X = uint256(keccak256(abi.encodePacked(pseudoRandomNumber, "blobHeader.commitment.X"))) % BN254.FP_MODULUS;
+        blobHeader.commitment.Y = uint256(keccak256(abi.encodePacked(pseudoRandomNumber, "blobHeader.commitment.Y"))) % BN254.FP_MODULUS;
+
+        blobHeader.dataLength = uint32(uint256(keccak256(abi.encodePacked(pseudoRandomNumber, "blobHeader.dataLength"))));
+
+        blobHeader.quorumBlobParams = new QuorumBlobParam[](numQuorumsBlobParams);
+        blobHeader.dataLength = uint32(uint256(keccak256(abi.encodePacked(pseudoRandomNumber, "blobHeader.dataLength"))));
+        for (uint i = 0; i < numQuorumsBlobParams; i++) {
+            if(i < 2){
+                blobHeader.quorumBlobParams[i].quorumNumber = uint8(i);
+            } else {
+                blobHeader.quorumBlobParams[i].quorumNumber = uint8(uint256(keccak256(abi.encodePacked(pseudoRandomNumber, "blobHeader.quorumBlobParams[i].quorumNumber", i)))) % 192;
+
+                // make sure it isn't already used
+                while(quorumNumbersUsed[blobHeader.quorumBlobParams[i].quorumNumber]) {
+                    blobHeader.quorumBlobParams[i].quorumNumber = uint8(uint256(blobHeader.quorumBlobParams[i].quorumNumber) + 1) % 192;
+                }
+                quorumNumbersUsed[blobHeader.quorumBlobParams[i].quorumNumber] = true;
+            }
+
+            blobHeader.quorumBlobParams[i].adversaryThresholdPercentage = eigenDABlobVerifier.getQuorumAdversaryThresholdPercentage(blobHeader.quorumBlobParams[i].quorumNumber);
+            blobHeader.quorumBlobParams[i].chunkLength = uint32(uint256(keccak256(abi.encodePacked(pseudoRandomNumber, "blobHeader.quorumBlobParams[i].chunkLength", i))));
+            blobHeader.quorumBlobParams[i].confirmationThresholdPercentage = eigenDABlobVerifier.getQuorumConfirmationThresholdPercentage(blobHeader.quorumBlobParams[i].quorumNumber);
+        }
+        // mark all quorum numbers as unused
+        for (uint i = 0; i < numQuorumsBlobParams; i++) {
+            quorumNumbersUsed[blobHeader.quorumBlobParams[i].quorumNumber] = false;
+        }
+
+        return blobHeader;
+    }
+}