Skip to content

Test Container Size

Documentation for tests/prague/eip7692_eof_v1/eip3540_eof_v1/test_container_size.py.

Generate fixtures for these test cases for Prague with:

Prague only: 

fill -v tests/prague/eip7692_eof_v1/eip3540_eof_v1/test_container_size.py --fork=Prague --evm-bin=/path/to/evm-tool-dev-version
For all forks up to and including Prague: 
fill -v tests/prague/eip7692_eof_v1/eip3540_eof_v1/test_container_size.py --until=Prague --evm-bin=/path/to/evm-tool-dev-version

EOF validation tests for EIP-3540 container size

test_max_size(eof_test, over_limit)

Verify EOF container valid at maximum size, invalid above

Source code in tests/prague/eip7692_eof_v1/eip3540_eof_v1/test_container_size.py 
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
@pytest.mark.parametrize(
    "over_limit",
    [0, 1, 2, 2**16 - MAX_INITCODE_SIZE],
)
def test_max_size(
    eof_test: EOFTestFiller,
    over_limit: int,
):
    """
    Verify EOF container valid at maximum size, invalid above
    """
    # Expand the minimal EOF code by more noop code, reaching the desired target container size.
    code = Container(
        sections=[
            Section.Code(
                code=Op.JUMPDEST * (MAX_INITCODE_SIZE - len(VALID_CONTAINER) + over_limit)
                + Op.STOP
            )
        ]
    )
    assert len(code) == MAX_INITCODE_SIZE + over_limit
    eof_test(
        data=bytes(code),
        expect_exception=None if over_limit == 0 else EOFException.CONTAINER_SIZE_ABOVE_LIMIT,
    )

test_above_max_size_raw(eof_test, size)

Verify EOF container invalid above maximum size, regardless of header contents

Source code in tests/prague/eip7692_eof_v1/eip3540_eof_v1/test_container_size.py 
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
@pytest.mark.parametrize(
    "size",
    [MAX_INITCODE_SIZE + 1, MAX_INITCODE_SIZE * 2],
)
def test_above_max_size_raw(
    eof_test: EOFTestFiller,
    size: int,
):
    """
    Verify EOF container invalid above maximum size, regardless of header contents
    """
    code = Op.INVALID * size
    eof_test(
        data=bytes(code),
        expect_exception=EOFException.CONTAINER_SIZE_ABOVE_LIMIT,
    )

test_section_after_end_of_container(eof_test, code)

Verify EOF container is invalid if any of sections declares above container size

Source code in tests/prague/eip7692_eof_v1/eip3540_eof_v1/test_container_size.py 
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
@pytest.mark.parametrize(
    "code",
    [
        pytest.param(
            Container(sections=[Section.Code(code=Op.STOP, custom_size=MAX_INITCODE_SIZE)]),
            id="1st_code_section",
        ),
        pytest.param(
            Container(
                sections=[
                    Section.Code(code=Op.STOP),
                    Section.Code(code=Op.STOP, custom_size=MAX_INITCODE_SIZE),
                ]
            ),
            id="2nd_code_section",
        ),
        pytest.param(
            Container(
                sections=[
                    Section.Code(code=Op.STOP),
                    Section.Container(container=Op.STOP, custom_size=MAX_INITCODE_SIZE),
                ]
            ),
            id="1st_container_section",
        ),
        pytest.param(
            Container(
                sections=[
                    Section.Code(code=Op.STOP),
                    Section.Container(container=Op.STOP),
                    Section.Container(container=Op.STOP, custom_size=MAX_INITCODE_SIZE),
                ]
            ),
            id="2nd_container_section",
        ),
    ],
)
def test_section_after_end_of_container(
    eof_test: EOFTestFiller,
    code: Container,
):
    """
    Verify EOF container is invalid if any of sections declares above container size
    """
    eof_test(
        data=bytes(code),
        expect_exception=EOFException.INVALID_SECTION_BODIES_SIZE,
    )