Add CustomDA proof validation interface

src/osp/ICustomDAProofValidator.sol

@@ -0,0 +1,20 @@
+// Copyright 2021-2024, Offchain Labs, Inc.
+// For license information, see https://github.com/OffchainLabs/nitro-contracts/blob/main/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title ICustomDAProofValidator
+ * @notice Interface for custom data availability proof validators
+ */
+interface ICustomDAProofValidator {
+    /**
+     * @notice Validates a custom DA proof and returns the preimage chunk
+     * @param proof The complete proof data (format determined by implementation)
+     * @return preimageChunk The 32-byte chunk of preimage data
+     */
+    function validateReadPreimage(
+        bytes calldata proof
+    ) external view returns (bytes memory preimageChunk);
+}

src/osp/OneStepProverHostIo.sol

@@ -11,6 +11,7 @@ import "../state/MultiStack.sol";
 import "../state/Deserialize.sol";
 import "../state/ModuleMemory.sol";
 import "./IOneStepProver.sol";
+import "./ICustomDAProofValidator.sol";
 import "../bridge/Messages.sol";
 import "../bridge/IBridge.sol";
 
@@ -29,6 +30,15 @@ contract OneStepProverHostIo is IOneStepProver {
     uint64 private constant INBOX_HEADER_LEN = 40;
     uint64 private constant DELAYED_HEADER_LEN = 112 + 1;
 
+    ICustomDAProofValidator public customDAValidator;
+
+    function setCustomDAValidator(
+        ICustomDAProofValidator _validator
+    ) external {
+        // TODO: Add appropriate access control
+        customDAValidator = _validator;
+    }
+
     function setLeafByte(bytes32 oldLeaf, uint256 idx, uint8 val) internal pure returns (bytes32) {
         require(idx < LEAF_SIZE, "BAD_SET_LEAF_BYTE_IDX");
         // Take into account that we are casting the leaf to a big-endian integer
@@ -220,6 +230,20 @@ contract OneStepProverHostIo is IOneStepProver {
 
                 extracted = kzgProof[64:96];
             }
+        } else if (inst.argumentData == 3) {
+            // The machine is asking for a CustomDA preimage
+            require(proofType == 0, "UNKNOWN_PREIMAGE_PROOF");
+            require(address(customDAValidator) != address(0), "CUSTOM_DA_VALIDATOR_NOT_SET");
+
+            // The OSP is completely agnostic to CustomDA proof format
+            // Just forward all remaining proof bytes to the validator
+            bytes calldata customProof = proof[proofOffset:];
+
+            // Delegate entirely to the custom validator
+            extracted = customDAValidator.validateReadPreimage(customProof);
+
+            // Ensure we got a valid response
+            require(extracted.length > 0 && extracted.length <= 32, "INVALID_CUSTOM_DA_RESPONSE");
         } else {
             revert("UNKNOWN_PREIMAGE_TYPE");
         }

src/osp/ReferenceDAProofValidator.sol

@@ -0,0 +1,66 @@
+// Copyright 2021-2024, Offchain Labs, Inc.
+// For license information, see https://github.com/OffchainLabs/nitro-contracts/blob/main/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import "./ICustomDAProofValidator.sol";
+
+/**
+ * @title ReferenceDAProofValidator
+ * @notice Reference implementation of a CustomDA proof validator
+ */
+contract ReferenceDAProofValidator is ICustomDAProofValidator {
+    /**
+     * @notice Validates a ReferenceDA proof and returns the preimage chunk
+     * @param proof ReferenceDA proof format: [hash(32), offset(8), Version(1), PreimageSize(8), PreimageData]
+     * @return preimageChunk The 32-byte chunk at the specified offset
+     */
+    function validateReadPreimage(
+        bytes calldata proof
+    ) external pure override returns (bytes memory preimageChunk) {
+        // ReferenceDA proof format: [hash(32), offset(8), Version(1), PreimageSize(8), PreimageData]
+        require(proof.length >= 49, "Proof too short"); // 32 + 8 + 1 + 8
+
+        // Extract hash and offset that were included by the off-chain enhancer
+        bytes32 hash;
+        uint256 offset;
+        assembly {
+            hash := calldataload(add(proof.offset, 0))
+            offset := shr(192, calldataload(add(proof.offset, 32))) // Read 8 bytes as uint256
+        }
+
+        // Decode the actual proof data
+        require(proof[40] == 0x01, "Unsupported proof version");
+
+        uint256 preimageSize;
+        assembly {
+            preimageSize := shr(192, calldataload(add(proof.offset, 41))) // Read 8 bytes as uint256
+        }
+        require(proof.length == 49 + preimageSize, "Invalid proof length");
+
+        // Extract preimage data
+        bytes memory preimage = proof[49:];
+
+        // Verify hash
+        require(keccak256(preimage) == hash, "Invalid preimage");
+
+        // Extract chunk at offset
+        uint256 chunkStart = offset;
+        uint256 chunkEnd = offset + 32;
+        if (chunkEnd > preimage.length) {
+            chunkEnd = preimage.length;
+        }
+
+        uint256 chunkSize = chunkEnd - chunkStart;
+        preimageChunk = new bytes(32);
+
+        if (chunkSize > 0) {
+            for (uint256 i = 0; i < chunkSize; i++) {
+                preimageChunk[i] = preimage[chunkStart + i];
+            }
+        }
+
+        return preimageChunk;
+    }
+}

test/osp/ReferenceDAProofValidator.t.sol

@@ -0,0 +1,166 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+import "forge-std/Test.sol";
+import "../../src/osp/ReferenceDAProofValidator.sol";
+
+contract ReferenceDAProofValidatorTest is Test {
+    ReferenceDAProofValidator validator;
+
+    function setUp() public {
+        validator = new ReferenceDAProofValidator();
+    }
+
+    function testValidateReadPreimage() public {
+        // Test preimage data
+        bytes memory preimage = "This is a test preimage that is longer than 32 bytes for testing chunk extraction";
+        bytes32 hash = keccak256(preimage);
+        uint256 offset = 16; // Read from byte 16
+
+        // Build proof: [hash(32), offset(8), Version(1), PreimageSize(8), PreimageData]
+        bytes memory proof = new bytes(49 + preimage.length);
+
+        // Copy hash
+        assembly {
+            mstore(add(proof, 32), hash)
+        }
+
+        // Copy offset (8 bytes)
+        assembly {
+            let offsetData := shl(192, offset) // Shift to make it 8 bytes at the beginning
+            mstore(add(proof, 64), offsetData)
+        }
+
+        // Set version
+        proof[40] = 1;
+
+        // Set preimage size (8 bytes)
+        uint256 preimageSize = preimage.length;
+        assembly {
+            let sizeData := shl(192, preimageSize) // Shift to make it 8 bytes at the beginning
+            mstore(add(proof, 73), sizeData)
+        }
+
+        // Copy preimage data
+        for (uint256 i = 0; i < preimage.length; i++) {
+            proof[49 + i] = preimage[i];
+        }
+
+        // Call validateReadPreimage
+        bytes memory chunk = validator.validateReadPreimage(proof);
+
+        // Verify the chunk
+        assertEq(chunk.length, 32, "Chunk should be 32 bytes");
+
+        // Verify chunk contents match the expected slice of preimage
+        for (uint256 i = 0; i < 32; i++) {
+            if (offset + i < preimage.length) {
+                assertEq(chunk[i], preimage[offset + i], "Chunk byte mismatch");
+            } else {
+                assertEq(chunk[i], 0, "Chunk padding should be zero");
+            }
+        }
+    }
+
+    function testValidateReadPreimageAtEnd() public {
+        // Test reading at the end of preimage (less than 32 bytes available)
+        bytes memory preimage = "Short preimage";
+        bytes32 hash = keccak256(preimage);
+        uint256 offset = 8; // Only 6 bytes available from offset 8
+
+        // Build proof
+        bytes memory proof = new bytes(49 + preimage.length);
+
+        // Copy hash
+        assembly {
+            mstore(add(proof, 32), hash)
+        }
+
+        // Copy offset
+        assembly {
+            let offsetData := shl(192, offset)
+            mstore(add(proof, 64), offsetData)
+        }
+
+        // Set version
+        proof[40] = 1;
+
+        // Set preimage size
+        assembly {
+            let sizeData := shl(192, 14) // "Short preimage" is 14 bytes
+            mstore(add(proof, 73), sizeData)
+        }
+
+        // Copy preimage
+        for (uint256 i = 0; i < preimage.length; i++) {
+            proof[49 + i] = preimage[i];
+        }
+
+        // Validate
+        bytes memory chunk = validator.validateReadPreimage(proof);
+
+        // Should get "eimage" (6 bytes) padded with zeros
+        assertEq(chunk.length, 32);
+        assertEq(chunk[0], bytes1("e"));
+        assertEq(chunk[1], bytes1("i"));
+        assertEq(chunk[2], bytes1("m"));
+        assertEq(chunk[3], bytes1("a"));
+        assertEq(chunk[4], bytes1("g"));
+        assertEq(chunk[5], bytes1("e"));
+
+        // Rest should be zeros
+        for (uint256 i = 6; i < 32; i++) {
+            assertEq(chunk[i], 0);
+        }
+    }
+
+    function testInvalidHash() public {
+        bytes memory preimage = "Test preimage";
+        bytes32 wrongHash = keccak256("Wrong data");
+        uint256 offset = 0;
+
+        // Build proof with wrong hash
+        bytes memory proof = new bytes(49 + preimage.length);
+
+        assembly {
+            mstore(add(proof, 32), wrongHash)
+        }
+        assembly {
+            let offsetData := shl(192, offset)
+            mstore(add(proof, 64), offsetData)
+        }
+        proof[40] = 1;
+        assembly {
+            let sizeData := shl(192, 13)
+            mstore(add(proof, 73), sizeData)
+        }
+        for (uint256 i = 0; i < preimage.length; i++) {
+            proof[49 + i] = preimage[i];
+        }
+
+        // Should revert
+        vm.expectRevert("Invalid preimage");
+        validator.validateReadPreimage(proof);
+    }
+
+    function testInvalidVersion() public {
+        bytes memory preimage = "Test";
+        bytes32 hash = keccak256(preimage);
+
+        bytes memory proof = new bytes(49 + preimage.length);
+        assembly {
+            mstore(add(proof, 32), hash)
+        }
+        proof[40] = 2; // Wrong version
+
+        vm.expectRevert("Unsupported proof version");
+        validator.validateReadPreimage(proof);
+    }
+
+    function testProofTooShort() public {
+        bytes memory proof = new bytes(48); // Too short
+
+        vm.expectRevert("Proof too short");
+        validator.validateReadPreimage(proof);
+    }
+}