quilt / eth1.0-specs Goto Github PK

mload
sload
mload8
calldatacopy
calldataload
calldatasize

should be done in coordination with #10

Currently commented out. We need to ensure the values have no leading 0 bytes. I believe the keys should be padded to 32 bytes though.

Ideally we want every line of the spec tested in a format that is compatible with real world clients (like the ethereum/tests tests.)

To get a good idea of how much of the spec is covered by reusable tests, we should separate out the coverage reports for the pytest runs and the ethereum/tests runs.

• LT
• GT
• SLT
• SGT
• EQ
• ISZERO
• AND
• OR
• XOR
• NOT
• BYTE
• U256 tests for and, or, xor, rxor, ixor, invert

I'd like to implement EVM tracing, but not have that code show in the docs.

Should also verify the trie root matches the block being processed.

We should formalize any coding or style decisions not covered by black into a document somewhere in the repository.

For now, this issue can be a temporary place to collect these kind of decisions:

• Name functions with short imperative phrases, avoiding extra words which don't add information (choose fetch instead of do_fetch).
• Use exceptions for errors which are handled in-protocol (ex. OutOfGas), and assert for everything else.
• Never use type: ignore unless absolutely necessary.

ethereum#219 (comment)

^

This would make @djrtwo happy and would be neat.

https://github.com/ethereum/eth2.0-specs/blob/dev/specs/merge/beacon-chain.md#protocols
https://pypi.org/project/eth2spec/1.1.0a7/

Once #34 is merged, someone needs to go through every use of Uint and U256 and decide if it's using the correct type by comparing against the yellowpaper and/or client code.

Currently, the trie implementation uses a bytes type for the sequence of nibbles, with the stated validation rules that each byte may be no larger than 15. This requirement doesn't appear to actually be enforced and it would be ideal if the type definitions actually constrained the inputs via the type system rather than runtime validation.

I would suggest using an enum.IntEnum for this:

class Nibble(enum.IntEnum):
    NIBBLE_0 = 0x0
    NIBBLE_1 = 0x1
    ...
    NIBBLE_F = 0xf

Nibbles = List[Nibble]

Not only will this give you strong guarantees on anything that needs to take a Nibbles type as an input, but it also lets you have runtime validation for free

def bytes_to_nibbles(value: bytes) -> Nibbles:
    return [Nibble(v) for v in value]  # will raise a TypeError if the value isn't part of the Enum)

The current trie code has inherited the language from the yellow paper. It's pretty opaque, it would be useful to go through and rewrite/clean up.

This is an important task that should be done before we get too deep in implementing all the opcodes. The goal should be readability.

The RLP code has inherited the naming scheme of the yellow paper. It would be good to rewrite for clarity.

• DUPN
• SWAPN

^

^

I think it would be nice to just build the docs on push to ensure we never merge a broken change.

I'm thinking this can be done as a sphinx extension that subclasses literalinclude and somehow adjusts the line filter to skip the docstring.

The documentation currently has snippets like:

def BE_inverse(b: Bytes) -> Uint:
    """
    Converts a sequence of bytes into an arbitrarily sized unsigned integer `x`
    from its big endian representation.

    Parameters
    ----------
    b : `eth1spec.eth_types.Bytes`
        Bytes to decode.

    Returns
    -------
    x : `eth1spec.number.Uint`
        The byte sequence `b`, interpreted as a big endian unsigned integer.
    """
    if verbose:
        print("BE_inverse(", b.hex(), ")")
    x = 0
    for n in range(len(b)):
        # x+=b[n]*2**(len(b)-1-n)
        x += b[n] * 2 ** (8 * (len(b) - 1 - n))
    return Uint(x)

But we want them to look like:

def BE_inverse(b: Bytes) -> Uint:
    if verbose:
        print("BE_inverse(", b.hex(), ")")
    x = 0
    for n in range(len(b)):
        # x+=b[n]*2**(len(b)-1-n)
        x += b[n] * 2 ** (8 * (len(b) - 1 - n))
    return Uint(x)

A bit lower priority since we have access to all the ethereum/tests now.

^

Maybe this is already possible, but it would be help get a simple command setup that will host the docs as you live edit.

What was missing?

We need to implementEthHash, the proof of work algorithm.

How can this be fixed?

• Refer to this link for details and test cases.
• Refer to this implementation to see if some code can be borrowed.

I'd like to see a tool that sits above the eth1spec packages which can handle syncing mainnet, including the transitions between hardforks.

This, perhaps obviously, requires some kind of knowledge of hardforks and transition code. We've been thinking that we can put each hardfork on its own git branch, and tie them all together in a descendant package.

Can we deploy the docs to some github.io page once it's merged into pyspec?

Static header checks. See stubbed function verify_header.

SUB, MUL, DIV, SDIV, MOD, SMOD, ADDMOD, MULMOD, EXP, SIGNEXTEND

Since Uint is arbitrarily sized, we should create a U256 type which is capped.