test_invalid_container_deployment()

Documentation for tests/osaka/eip7692_eof_v1/eip7698_eof_creation_tx/test_eof_creation_tx.py::test_invalid_container_deployment@01f496f4.

Generate fixtures for these test cases for Osaka with:

fill -v tests/osaka/eip7692_eof_v1/eip7698_eof_creation_tx/test_eof_creation_tx.py::test_invalid_container_deployment --fork Osaka

Verify nonce is not incremented when an invalid container deployment is attempted.

Source code in tests/osaka/eip7692_eof_v1/eip7698_eof_creation_tx/test_eof_creation_tx.py

@pytest.mark.parametrize(
    "reason",
    [
        "valid",
        "invalid_deploy_container",
        "invalid_initcode",
        "invalid_opcode_during_initcode",
        "invalid_opcode_with_sstore_during_initcode",
        "revert_opcode_during_initcode",
        "out_of_gas_during_initcode",
        "out_of_gas_when_returning_contract",
        "out_of_gas_when_returning_contract_due_to_memory_expansion",
    ],
)
def test_invalid_container_deployment(
    state_test: StateTestFiller,
    fork: Fork,
    pre: Alloc,
    reason: str,
):
    """Verify nonce is not incremented when an invalid container deployment is attempted."""
    env = Environment()
    sender = pre.fund_eoa()

    # Valid defaults
    deployed_container = Container(
        sections=[
            Section.Code(code=Op.CALLF[1](Op.PUSH0, Op.PUSH0) + Op.STOP),
            Section.Code(code=Op.ADD + Op.RETF, code_inputs=2, code_outputs=1),
        ]
    )
    init_container: Container = Container(
        sections=[
            Section.Code(code=Op.RETURNCODE[0](0, 0)),
            Section.Container(deployed_container),
        ],
        kind=ContainerKind.INITCODE,
    )
    tx_gas_limit = 1_000_000
    fork_intrinsic_gas_calculator = fork.transaction_intrinsic_cost_calculator()
    fork_gas_costs = fork.gas_costs()

    # Modify defaults based on invalidity reason
    if reason == "invalid_deploy_container":
        deployed_container = Container(
            sections=[
                Section.Code(code=Op.CALLF[1](Op.PUSH0, Op.PUSH0) + Op.STOP),
                Section.Code(code=Op.ADD + Op.RETF, code_outputs=0),
            ]
        )
        init_container = Container(
            sections=[
                Section.Code(code=Op.RETURNCODE[0](0, 0)),
                Section.Container(deployed_container),
            ],
        )
    elif reason == "invalid_initcode":
        init_container = Container(
            sections=[
                Section.Code(code=Op.RETURNCODE[1](0, 0)),
                Section.Container(deployed_container),
            ],
        )
    elif (
        reason == "invalid_opcode_during_initcode"
        or reason == "invalid_opcode_with_sstore_during_initcode"
        or reason == "revert_opcode_during_initcode"
        or reason == "out_of_gas_during_initcode"
    ):
        invalid_code_path: Bytecode
        if reason == "invalid_opcode_during_initcode":
            invalid_code_path = Op.SSTORE(0, 1) + Op.INVALID
        elif reason == "revert_opcode_during_initcode":
            invalid_code_path = Op.REVERT(0, 0)
        elif reason == "out_of_gas_during_initcode":
            invalid_code_path = Op.MSTORE(0xFFFFFFFFFFFFFFFFFFFFFFFFFFF, 1)
        else:
            invalid_code_path = Op.INVALID
        init_container = Container(
            sections=[
                Section.Code(
                    code=Op.RJUMPI[len(invalid_code_path)](Op.PUSH0)
                    + invalid_code_path
                    + Op.RETURNCODE[0](0, 0)
                ),
                Section.Container(deployed_container),
            ],
        )
    elif reason == "out_of_gas_when_returning_contract":
        gas_cost = (
            # Transaction intrinsic gas cost
            fork_intrinsic_gas_calculator(calldata=init_container, contract_creation=True)
            # Code deposit gas cost
            + len(deployed_container) * fork_gas_costs.G_CODE_DEPOSIT_BYTE
            # Two push opcodes
            + 2 * fork_gas_costs.G_VERY_LOW
        )
        tx_gas_limit = gas_cost - 1
    elif reason == "out_of_gas_when_returning_contract_due_to_memory_expansion":
        gas_cost = (
            # Transaction intrinsic gas cost
            fork_intrinsic_gas_calculator(calldata=init_container, contract_creation=True)
            # Code deposit gas cost
            + (len(deployed_container) + 1) * fork_gas_costs.G_CODE_DEPOSIT_BYTE
            # Two push opcodes
            + 2 * fork_gas_costs.G_VERY_LOW
        )
        tx_gas_limit = gas_cost
        init_container = Container(
            sections=[
                Section.Code(code=Op.RETURNCODE[0](0, 1)),
                Section.Container(deployed_container),
            ],
        )
    elif reason == "valid":
        pass
    else:
        raise TypeError("Unexpected reason", reason)

    tx = Transaction(
        sender=sender,
        to=None,
        gas_limit=tx_gas_limit,
        data=init_container,
    )

    destination_contract_address = tx.created_contract

    post = {
        destination_contract_address: Account.NONEXISTENT
        if reason != "valid"
        else Account(nonce=1, code=deployed_container),
        sender: Account(
            nonce=sender.nonce,
        ),
    }

    state_test(
        env=env,
        pre=pre,
        post=post,
        tx=tx,
    )

Parametrized Test Cases

The interactive table below is also available as a standalone page.

Fork All Forks Osaka

Fixture Type All Fixture Types state_test blockchain_test

Test ID (Abbreviated)	reason
...fork_Osaka-state_test-reason_valid	valid
...fork_Osaka-state_test-reason_invalid_deploy_container	invalid_deploy_container
...fork_Osaka-state_test-reason_invalid_initcode	invalid_initcode
...fork_Osaka-state_test-reason_invalid_opcode_during_initcode	invalid_opcode_during_initcode
...fork_Osaka-state_test-reason_invalid_opcode_with_sstore_during_initcode	invalid_opcode_with_sstore_during_initcode
...fork_Osaka-state_test-reason_revert_opcode_during_initcode	revert_opcode_during_initcode
...fork_Osaka-state_test-reason_out_of_gas_during_initcode	out_of_gas_during_initcode
...fork_Osaka-state_test-reason_out_of_gas_when_returning_contract	out_of_gas_when_returning_contract
...fork_Osaka-state_test-reason_out_of_gas_when_returning_contract_due_to_memory_expansion	out_of_gas_when_returning_contract_due_to_memory_expansion
...fork_Osaka-blockchain_test_from_state_test-reason_valid	valid
...fork_Osaka-blockchain_test_from_state_test-reason_invalid_deploy_container	invalid_deploy_container
...fork_Osaka-blockchain_test_from_state_test-reason_invalid_initcode	invalid_initcode
...fork_Osaka-blockchain_test_from_state_test-reason_invalid_opcode_during_initcode	invalid_opcode_during_initcode
...fork_Osaka-blockchain_test_from_state_test-reason_invalid_opcode_with_sstore_during_initcode	invalid_opcode_with_sstore_during_initcode
...fork_Osaka-blockchain_test_from_state_test-reason_revert_opcode_during_initcode	revert_opcode_during_initcode
...fork_Osaka-blockchain_test_from_state_test-reason_out_of_gas_during_initcode	out_of_gas_during_initcode
...fork_Osaka-blockchain_test_from_state_test-reason_out_of_gas_when_returning_contract	out_of_gas_when_returning_contract
...fork_Osaka-blockchain_test_from_state_test-reason_out_of_gas_when_returning_contract_due_to_memory_expansion	out_of_gas_when_returning_contract_due_to_memory_expansion