<snip>

    return rlp.encode(

        (

            raw_account_data.nonce,

            raw_account_data.balance,

            storage_root,

            raw_account_data.code_hash,

        )

    )

    <snip>

    unencoded: Extended

    if node is None:

        unencoded = b""

    elif isinstance(node, LeafNode):

        unencoded = (

            nibble_list_to_compact(node.rest_of_key, True),

            node.value,

        )

    elif isinstance(node, ExtensionNode):

        unencoded = (

            nibble_list_to_compact(node.key_segment, False),

            node.subnode,

        )

    elif isinstance(node, BranchNode):

        unencoded = list(node.subnodes) + [node.value]

    else:

        raise AssertionError(f"Invalid internal node type {type(node)}!")

    encoded = rlp.encode(unencoded)

    if len(encoded) < 32:

        return unencoded

    else:

        return keccak256(encoded)

    <snip>

    from ethereum.state import Account

    if isinstance(node, Account):

        assert storage_root is not None

        return encode_account(node, storage_root)

    elif isinstance(node, Bytes):

        return node

    else:

        return rlp.encode(node)

    <snip>

    return Trie(trie.secured, trie.default, copy.copy(trie._data))

    <snip>

    if value == trie.default:

        if key in trie._data:

            del trie._data[key]

    else:

        trie._data[key] = value

    <snip>

    return trie._data.get(key, trie.default)

    <snip>

    for i in range(len(a)):

        if i >= len(b) or a[i] != b[i]:

            return i

    return len(a)

    <snip>

    compact = bytearray()

    if len(x) % 2 == 0:  # ie even length

        compact.append(16 * (2 * is_leaf))

        for i in range(0, len(x), 2):

            compact.append(16 * x[i] + x[i + 1])

    else:

        compact.append(16 * ((2 * is_leaf) + 1) + x[0])

        for i in range(1, len(x), 2):

            compact.append(16 * x[i] + x[i + 1])

    return Bytes(compact)

    <snip>

    nibble_list = bytearray(2 * len(bytes_))

    for byte_index, byte in enumerate(bytes_):

        nibble_list[byte_index * 2] = (byte & 0xF0) >> 4

        nibble_list[byte_index * 2 + 1] = byte & 0x0F

    return Bytes(nibble_list)

    <snip>

    from ethereum.state import Account, Address

    mapped: MutableMapping[Bytes, Bytes] = {}

    for preimage, value in trie._data.items():

        if isinstance(value, Account):

            assert get_storage_root is not None

            address = Address(preimage)

            encoded_value = encode_node(value, get_storage_root(address))

        elif value is None:

            raise AssertionError("cannot encode `None`")

        else:

            encoded_value = encode_node(value)

        if encoded_value == b"":

            raise AssertionError

        key: Bytes

        if trie.secured:

            # "secure" tries hash keys once before construction

            key = keccak256(preimage)

        else:

            key = preimage

        mapped[bytes_to_nibble_list(key)] = encoded_value

    return mapped

    <snip>

    from ethereum.state import Root

    obj = _prepare_trie(trie, get_storage_root)

    root_node = encode_internal_node(patricialize(obj, Uint(0)))

    if len(rlp.encode(root_node)) < 32:

        return keccak256(rlp.encode(root_node))

    else:

        assert isinstance(root_node, Bytes)

        return Root(root_node)

    <snip>

    if len(obj) == 0:

        return None

    arbitrary_key = next(iter(obj))

    # if leaf node

    if len(obj) == 1:

        leaf = LeafNode(arbitrary_key[level:], obj[arbitrary_key])

        return leaf

    # prepare for extension node check by finding max j such that all keys in

    # obj have the same key[i:j]

    substring = arbitrary_key[level:]

    prefix_length = len(substring)

    for key in obj:

        prefix_length = min(

            prefix_length, common_prefix_length(substring, key[level:])

        )

        # finished searching, found another key at the current level

        if prefix_length == 0:

            break

    # if extension node

    if prefix_length > 0:

        prefix = arbitrary_key[int(level) : int(level) + prefix_length]

        return ExtensionNode(

            prefix,

            encode_internal_node(

                patricialize(obj, level + Uint(prefix_length))

            ),

        )

    branches: List[MutableMapping[Bytes, Bytes]] = []

    for _ in range(16):

        branches.append({})

    value = b""

    for key in obj:

        if len(key) == level:

            value = obj[key]

        else:

            branches[key[level]][key] = obj[key]

    subnodes = tuple(

        encode_internal_node(patricialize(branches[k], level + Uint(1)))

        for k in range(16)

    )

    return BranchNode(

        cast(BranchSubnodes, assert_type(subnodes, Tuple[Extended, ...])),

        value,

    )