EigenDA M1

da-contracts/contracts/da-layers/eigenda/DummyEigenDARegistry.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.24;
+
+contract DummyEigenDARegistry {
+    mapping(bytes => bytes32) public hashes;
+    function isVerified(bytes calldata inclusion_data) external view returns (bool, bytes32) {
+        return (true, hashes[inclusion_data]);
+    }
+
+    function verify(bytes calldata inclusion_data, bytes32 eigenDAHash) external {
+        hashes[inclusion_data] = eigenDAHash;
+    }
+}

da-contracts/contracts/da-layers/eigenda/EigenDAL1Validator.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.24;
+
+import {IL1DAValidator, L1DAValidatorOutput} from "../../IL1DAValidator.sol";
+import {OperatorDAInputTooSmall} from "../../DAContractsErrors.sol";
+
+interface IEigenDABlobProofRegistry {
+    function isVerified(bytes calldata inclusion_data) external view returns (bool, bytes32);
+}
+
+contract EigenDAL1Validator is IL1DAValidator {
+    error InvalidValidatorOutputHash();
+    error ProofNotVerified();
+
+    IEigenDABlobProofRegistry public eigenDARegistry;
+
+    constructor(address eigendaRegistryAddress) {
+        eigenDARegistry = IEigenDABlobProofRegistry(eigendaRegistryAddress);
+    }
+
+    function checkDA(
+        uint256, // _chainId
+        uint256, // _batchNumber,
+        bytes32 l2DAValidatorOutputHash,
+        bytes calldata operatorDAInput,
+        uint256 maxBlobsSupported
+    ) external override returns (L1DAValidatorOutput memory output) {
+        if (operatorDAInput.length < 32) {
+            revert OperatorDAInputTooSmall(operatorDAInput.length, 32);
+        }
+        bytes32 stateDiffHash = abi.decode(operatorDAInput[:32], (bytes32));
+
+        (bool isVerified, bytes32 eigenDAHash) = eigenDARegistry.isVerified(operatorDAInput[32:]);
+
+        if (!isVerified) revert ProofNotVerified();
+
+        if (l2DAValidatorOutputHash != keccak256(abi.encodePacked(stateDiffHash, eigenDAHash)))
+            revert InvalidValidatorOutputHash();
+
+        output.stateDiffHash = stateDiffHash;
+
+        output.blobsLinearHashes = new bytes32[](maxBlobsSupported);
+        output.blobsOpeningCommitments = new bytes32[](maxBlobsSupported);
+    }
+}

l1-contracts/deploy-scripts/DeployL1.s.sol

@@ -222,6 +222,15 @@ contract DeployL1Script is Script, DeployUtils {
             );
     }
 
+    function getEigenDAL2ValidatorAddress() internal returns (address) {
+        return
+            Utils.getL2AddressViaCreate2Factory(
+                bytes32(0),
+                L2ContractHelper.hashL2Bytecode(L2ContractsBytecodesLib.readEigenDAL2ValidatorBytecode()),
+                hex""
+            );
+    }
+
     function deployVerifiers() internal {
         (addresses.stateTransition.verifierFflonk) = deploySimpleContract("VerifierFflonk");
         (addresses.stateTransition.verifierPlonk) = deploySimpleContract("VerifierPlonk");
@@ -243,6 +252,18 @@ contract DeployL1Script is Script, DeployUtils {
         } else {
             addresses.daAddresses.availL1DAValidator = config.contracts.availL1DAValidator;
         }
+
+        if (config.contracts.eigenDAL1Validator == address(0)) {
+            if (config.contracts.eigenDARegistry == address(0)) {
+                addresses.daAddresses.eigenDARegistry = deploySimpleContract("DummyEigenDARegistry");
+            } else {
+                addresses.daAddresses.eigenDARegistry = config.contracts.eigenDARegistry;
+            }
+            addresses.daAddresses.eigenDAL1Validator = deploySimpleContract("EigenDAL1Validator");
+        } else {
+            addresses.daAddresses.eigenDAL1Validator = config.contracts.eigenDAL1Validator;
+        }
+
         vm.startBroadcast(msg.sender);
         IRollupDAManager rollupDAManager = IRollupDAManager(addresses.daAddresses.rollupDAManager);
         rollupDAManager.updateDAPair(addresses.daAddresses.l1RollupDAValidator, getRollupL2ValidatorAddress(), true);
@@ -534,6 +555,13 @@ contract DeployL1Script is Script, DeployUtils {
             "avail_l1_da_validator_addr",
             addresses.daAddresses.availL1DAValidator
         );
+        vm.serializeAddress(
+            "deployed_addresses",
+            "eigenda_l1_validator_addr",
+            addresses.daAddresses.eigenDAL1Validator
+        );
+
+        vm.serializeAddress("deployed_addresses", "eigenda_registry_addr", addresses.daAddresses.eigenDARegistry);
 
         string memory deployedAddresses = vm.serializeAddress(
             "deployed_addresses",
@@ -552,6 +580,7 @@ contract DeployL1Script is Script, DeployUtils {
         vm.serializeAddress("root", "expected_rollup_l2_da_validator_addr", getRollupL2ValidatorAddress());
         vm.serializeAddress("root", "expected_no_da_validium_l2_validator_addr", getNoDAValidiumL2ValidatorAddress());
         vm.serializeAddress("root", "expected_avail_l2_da_validator_addr", getAvailL2ValidatorAddress());
+        vm.serializeAddress("root", "expected_eigenda_l2_validator_addr", getEigenDAL2ValidatorAddress());
         string memory toml = vm.serializeAddress("root", "owner_address", config.ownerAddress);
 
         vm.writeToml(toml, outputPath);
@@ -717,6 +746,10 @@ contract DeployL1Script is Script, DeployUtils {
             return Utils.readAvailL1DAValidatorBytecode();
         } else if (compareStrings(contractName, "DummyAvailBridge")) {
             return Utils.readDummyAvailBridgeBytecode();
+        } else if (compareStrings(contractName, "DummyEigenDARegistry")) {
+            return Utils.readDummyEigenDARegistryBytecode();
+        } else if (compareStrings(contractName, "EigenDAL1Validator")) {
+            return Utils.readEigenDAL1ValidatorBytecode();
         } else if (compareStrings(contractName, "Verifier")) {
             if (config.testnetVerifier) {
                 return type(TestnetVerifier).creationCode;

l1-contracts/deploy-scripts/DeployL2Contracts.sol

@@ -24,7 +24,8 @@ contract DeployL2Script is Script {
     enum DAValidatorType {
         Rollup,
         NoDA,
-        Avail
+        Avail,
+        EigenDA
     }
 
     // solhint-disable-next-line gas-struct-packing
@@ -143,7 +144,7 @@ contract DeployL2Script is Script {
         config.eraChainId = toml.readUint("$.era_chain_id");
 
         uint256 validatorTypeUint = toml.readUint("$.da_validator_type");
-        require(validatorTypeUint < 3, "Invalid DA validator type");
+        require(validatorTypeUint < 4, "Invalid DA validator type");
         config.validatorType = DAValidatorType(validatorTypeUint);
     }
 
@@ -168,6 +169,8 @@ contract DeployL2Script is Script {
             bytecode = L2ContractsBytecodesLib.readNoDAL2DAValidatorBytecode();
         } else if (config.validatorType == DAValidatorType.Avail) {
             bytecode = L2ContractsBytecodesLib.readAvailL2DAValidatorBytecode();
+        } else if (config.validatorType == DAValidatorType.EigenDA) {
+            bytecode = L2ContractsBytecodesLib.readEigenDAL2ValidatorBytecode();
         } else {
             revert("Invalid DA validator type");
         }

l1-contracts/deploy-scripts/DeployUtils.s.sol

@@ -62,6 +62,8 @@ struct DataAvailabilityDeployedAddresses {
     address noDAValidiumL1DAValidator;
     address availBridge;
     address availL1DAValidator;
+    address eigenDAL1Validator;
+    address eigenDARegistry;
 }
 
 // solhint-disable-next-line gas-struct-packing
@@ -126,6 +128,8 @@ struct ContractsConfig {
     bytes32 defaultAAHash;
     bytes32 evmEmulatorHash;
     address availL1DAValidator;
+    address eigenDAL1Validator;
+    address eigenDARegistry;
 }
 
 struct TokensConfig {
@@ -202,6 +206,14 @@ abstract contract DeployUtils is Script {
             config.contracts.availL1DAValidator = toml.readAddress("$.contracts.avail_l1_da_validator");
         }
 
+        if (vm.keyExistsToml(toml, "$.contracts.eigenda_l1_validator")) {
+            config.contracts.eigenDAL1Validator = toml.readAddress("$.contracts.eigenda_l1_validator");
+        }
+
+        if (vm.keyExistsToml(toml, "$.contracts.eigenda_registry_addr")) {
+            config.contracts.eigenDARegistry = toml.readAddress("$.contracts.eigenda_registry_addr");
+        }
+
         config.tokens.tokenWethAddress = toml.readAddress("$.tokens.token_weth_address");
     }
 
@@ -428,6 +440,10 @@ abstract contract DeployUtils is Script {
             return abi.encode(addresses.daAddresses.availBridge);
         } else if (compareStrings(contractName, "DummyAvailBridge")) {
             return abi.encode();
+        } else if (compareStrings(contractName, "DummyEigenDARegistry")) {
+            return abi.encode();
+        } else if (compareStrings(contractName, "EigenDAL1Validator")) {
+            return abi.encode(addresses.daAddresses.eigenDARegistry);
         } else if (compareStrings(contractName, "Verifier")) {
             return abi.encode(addresses.stateTransition.verifierFflonk, addresses.stateTransition.verifierPlonk);
         } else if (compareStrings(contractName, "VerifierFflonk")) {

l1-contracts/deploy-scripts/L2ContractsBytecodesLib.sol

@@ -82,6 +82,12 @@ library L2ContractsBytecodesLib {
         return Utils.readZKFoundryBytecodeL2("AvailL2DAValidator.sol", "AvailL2DAValidator");
     }
 
+    /// @notice Reads the bytecode of the ValidiumL2DAValidator contract for EigenDA.
+    /// @return The bytecode of the ValidiumL2DAValidator contract.
+    function readEigenDAL2ValidatorBytecode() internal view returns (bytes memory) {
+        return Utils.readZKFoundryBytecodeL2("EigenDAL2Validator.sol", "EigenDAL2Validator");
+    }
+
     /// @notice Reads the bytecode of the ValidiumL2DAValidator contract for NoDA validium.
     /// @return The bytecode of the ValidiumL2DAValidator contract.
     function readNoDAL2DAValidatorBytecode() internal view returns (bytes memory) {

l1-contracts/deploy-scripts/Utils.sol

@@ -1132,6 +1132,14 @@ library Utils {
         bytecode = readFoundryBytecode("/../da-contracts/out/DummyAvailBridge.sol/DummyAvailBridge.json");
     }
 
+    function readEigenDAL1ValidatorBytecode() internal view returns (bytes memory bytecode) {
+        bytecode = readFoundryBytecode("/../da-contracts/out/EigenDAL1Validator.sol/EigenDAL1Validator.json");
+    }
+
+    function readDummyEigenDARegistryBytecode() internal view returns (bytes memory bytecode) {
+        bytecode = readFoundryBytecode("/../da-contracts/out/DummyEigenDARegistry.sol/DummyEigenDARegistry.json");
+    }
+
     // add this to be excluded from coverage report
     function test() internal {}
 }

l2-contracts/contracts/data-availability/EigenDAL2Validator.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.24;
+
+import {IL2DAValidator} from "../interfaces/IL2DAValidator.sol";
+
+import {StateDiffL2DAValidator} from "./StateDiffL2DAValidator.sol";
+
+/// Rollup DA validator. It will publish data that would allow to use either calldata or blobs.
+contract EigenDAL2Validator is IL2DAValidator, StateDiffL2DAValidator {
+    function validatePubdata(
+        // The rolling hash of the user L2->L1 logs.
+        bytes32,
+        // The root hash of the user L2->L1 logs.
+        bytes32,
+        // The chained hash of the L2->L1 messages
+        bytes32 _chainedMessagesHash,
+        // The chained hash of uncompressed bytecodes sent to L1
+        bytes32 _chainedBytecodesHash,
+        // Operator data, that is related to the DA itself
+        bytes calldata _totalL2ToL1PubdataAndStateDiffs
+    ) external returns (bytes32 outputHash) {
+        (bytes32 stateDiffHash, bytes calldata _totalPubdata, ) = _produceStateDiffPubdata(
+            _chainedMessagesHash,
+            _chainedBytecodesHash,
+            _totalL2ToL1PubdataAndStateDiffs
+        );
+
+        bytes32 fullPubdataHash = keccak256(_totalPubdata);
+        outputHash = keccak256(abi.encodePacked(stateDiffHash, fullPubdataHash));
+    }
+}