<snip>

    genesis_path = f"assets/{genesis_file}"

    genesis_bytes = pkgutil.get_data("ethereum", genesis_path)

    if genesis_bytes is None:

        raise Exception(f"Unable to read genesis from `{genesis_path}`")

    genesis_data = json.loads(genesis_bytes.decode())

    return GenesisConfiguration(

        chain_id=U64(genesis_data["config"]["chainId"]),

        difficulty=hex_to_uint(genesis_data["difficulty"]),

        extra_data=hex_to_bytes(genesis_data["extraData"]),

        gas_limit=hex_to_uint(genesis_data["gasLimit"]),

        nonce=hex_to_bytes8(genesis_data["nonce"]),

        timestamp=hex_or_base_10_str_to_u256(genesis_data["timestamp"]),

        initial_accounts=genesis_data["alloc"],

    )

    <snip>

    if balance.startswith("0x"):

        return hex_to_u256(balance)

    else:

        return U256(int(balance))

    <snip>

    Address: Type[FixedBytes] = hardfork.Address  # noqa N806

    assert issubclass(Address, FixedBytes)

    for hex_address, account in genesis.initial_accounts.items():

        address = hardfork.hex_to_address(hex_address)

        code = hex_to_bytes(account.get("code", "0x"))

        code_hash = hardfork.store_code(chain.state, code)

        hardfork.set_account(

            chain.state,

            address,

            hardfork.Account(

                Uint(int(account.get("nonce", "0"))),

                hex_or_base_10_str_to_u256(account.get("balance", 0)),

                code_hash,

            ),

        )

        for key, value in account.get("storage", {}).items():

            hardfork.set_storage(

                chain.state, address, hex_to_bytes32(key), hex_to_u256(value)

            )

    fields = {

        "parent_hash": Hash32(b"\0" * 32),

        "ommers_hash": keccak256(rlp.encode(())),

        "coinbase": Address(b"\0" * Address.LENGTH),

        "state_root": hardfork.state_root(chain.state),

        "transactions_root": hardfork.root(hardfork.Trie(False, None)),

        "receipt_root": hardfork.root(hardfork.Trie(False, None)),

        "bloom": hardfork.Bloom(b"\0" * 256),

        "difficulty": genesis.difficulty,

        "number": Uint(0),

        "gas_limit": genesis.gas_limit,

        "gas_used": Uint(0),

        "timestamp": genesis.timestamp,

        "extra_data": genesis.extra_data,

        "nonce": genesis.nonce,

    }

    if has_field(hardfork.Header, "mix_digest"):

        fields["mix_digest"] = Hash32(b"\0" * 32)

    else:

        fields["prev_randao"] = Hash32(b"\0" * 32)

    if has_field(hardfork.Header, "base_fee_per_gas"):

        fields["base_fee_per_gas"] = Uint(10**9)

    if has_field(hardfork.Header, "withdrawals_root"):

        fields["withdrawals_root"] = hardfork.root(hardfork.Trie(False, None))

    if has_field(hardfork.Header, "blob_gas_used"):

        fields["blob_gas_used"] = U64(0)

    if has_field(hardfork.Header, "excess_blob_gas"):

        fields["excess_blob_gas"] = U64(0)

    if has_field(hardfork.Header, "parent_beacon_block_root"):

        fields["parent_beacon_block_root"] = Hash32(b"\0" * 32)

    if has_field(hardfork.Header, "requests_hash"):

        fields["requests_hash"] = Hash32(b"\0" * 32)

    if has_field(hardfork.Header, "block_access_list_hash"):

        fields["block_access_list_hash"] = keccak256(rlp.encode([]))

    if has_field(hardfork.Header, "slot_number"):

        fields["slot_number"] = U64(0)

    genesis_header = hardfork.Header(**fields)

    block_fields = {

        "header": genesis_header,

        "transactions": (),

        "ommers": (),

    }

    if has_field(hardfork.Block, "withdrawals"):

        block_fields["withdrawals"] = ()

    if has_field(hardfork.Block, "requests"):

        block_fields["requests"] = ()

    genesis_block = hardfork.Block(**block_fields)

    chain.blocks.append(genesis_block)

    chain.chain_id = genesis.chain_id