test_set_code_to_contract_creator()

Documentation for tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_contract_creator@e9958ed2.

Generate fixtures for these test cases for Osaka with:

fill -v tests/prague/eip7702_set_code_tx/test_set_code_txs.py::test_set_code_to_contract_creator --fork Osaka

Test the executing a contract-creating opcode in a set-code transaction.

Source code in tests/prague/eip7702_set_code_tx/test_set_code_txs.py

@pytest.mark.with_all_create_opcodes
@pytest.mark.slow()
def test_set_code_to_contract_creator(
    state_test: StateTestFiller,
    pre: Alloc,
    create_opcode: Op,
    evm_code_type: EVMCodeType,
) -> None:
    """
    Test the executing a contract-creating opcode in a set-code transaction.
    """
    storage = Storage()
    auth_signer = pre.fund_eoa(auth_account_start_balance)

    deployed_code: Bytecode | Container = Op.STOP
    initcode: Bytecode | Container

    if evm_code_type == EVMCodeType.LEGACY:
        initcode = Initcode(deploy_code=deployed_code)
    elif evm_code_type == EVMCodeType.EOF_V1:
        deployed_code = Container.Code(deployed_code)
        initcode = Container.Init(deploy_container=deployed_code)
    else:
        raise ValueError(f"Unsupported EVM code type: {evm_code_type}")

    deployed_contract_address = compute_create_address(
        address=auth_signer,
        nonce=1,
        initcode=initcode,
        opcode=create_opcode,
    )

    creator_code: Bytecode | Container
    if evm_code_type == EVMCodeType.LEGACY:
        creator_code = Op.CALLDATACOPY(0, 0, Op.CALLDATASIZE) + Op.SSTORE(
            storage.store_next(deployed_contract_address),
            create_opcode(value=0, offset=0, size=Op.CALLDATASIZE),
        )
    elif evm_code_type == EVMCodeType.EOF_V1:
        creator_code = Container(
            sections=[
                Section.Code(
                    code=Op.EOFCREATE[0](0, 0, 0, 0) + Op.STOP(),
                ),
                Section.Container(
                    container=initcode,
                ),
            ]
        )
    else:
        raise ValueError(f"Unsupported EVM code type: {evm_code_type}")

    creator_code_address = pre.deploy_contract(creator_code)

    tx = Transaction(
        gas_limit=10_000_000,
        to=auth_signer,
        value=0,
        data=initcode if evm_code_type == EVMCodeType.LEGACY else b"",
        authorization_list=[
            AuthorizationTuple(
                address=creator_code_address,
                nonce=0,
                signer=auth_signer,
            ),
        ],
        sender=pre.fund_eoa(),
    )

    state_test(
        env=Environment(),
        pre=pre,
        tx=tx,
        post={
            creator_code_address: Account(storage={}),
            auth_signer: Account(
                nonce=2,
                code=Spec.delegation_designation(creator_code_address),
                storage=storage,
            ),
            deployed_contract_address: Account(
                code=deployed_code,
                storage={},
            ),
        },
    )

Parametrized Test Cases

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

Fork All Forks Prague Osaka

Fixture Type All Fixture Types state_test blockchain_test

Test ID (Abbreviated)	create_opcode	evm_code_type
...fork_Prague-create_opcode_CREATE2-evm_code_type_LEGACY-state_test	CREATE2	LEGACY
...fork_Prague-create_opcode_CREATE2-evm_code_type_LEGACY-blockchain_test_from_state_test	CREATE2	LEGACY
...fork_Prague-create_opcode_CREATE-evm_code_type_LEGACY-state_test	CREATE	LEGACY
...fork_Prague-create_opcode_CREATE-evm_code_type_LEGACY-blockchain_test_from_state_test	CREATE	LEGACY
...fork_Osaka-create_opcode_CREATE2-evm_code_type_LEGACY-state_test	CREATE2	LEGACY
...fork_Osaka-create_opcode_CREATE2-evm_code_type_LEGACY-blockchain_test_from_state_test	CREATE2	LEGACY
...fork_Osaka-create_opcode_CREATE-evm_code_type_LEGACY-state_test	CREATE	LEGACY
...fork_Osaka-create_opcode_CREATE-evm_code_type_LEGACY-blockchain_test_from_state_test	CREATE	LEGACY