ethereum-augur-temp

This is the Python core library of the Ethereum project.

For the python based command line client see: https://github.com/ethereum/pyethapp

Installation:

sudo apt-get install libssl-dev build-essential automake pkg-config libtool libffi-dev libgmp-dev

git clone https://github.com/ethereum/pyethereum/

cd pyethereum

python setup.py install

Components

ethereum.pow.chain

Contains the Chain class, which can be used to manage a blockchain. Main
methods are:

-  ``__init__(genesis=None, env=None, new_head_cb=None, reset_genesis=False, localtime=None)``
   - initializes with the given genesis. ``env`` specifies the
   *environment* (including chain config and database), ``new_head_cb``
   is a callback called when a new head is added, and ``localtime`` is
   what the chain assumes is the current timestamp. The genesis can be:

   -  None - in which case it assumes ``env`` is given, and creates a
      Chain object with the data saved in ``env.db``. If
      ``reset_genesis`` is set, it re-initializes the chain.
   -  A ``State`` object
   -  A genesis declaration
   -  A state snapshot (``State.snapshot()``)
   -  An allocation (ie. dict
      ``{address: {balance: 1, nonce: 2, code: b'\x03\x04\x05', storage: {"0x06": "0x07"}}}``)

-  ``add_block(block)`` - adds a block to the chain
-  ``process_time_queue(timestamp)`` - tells the chain that the current
   time has increased to the new timestamp. The chain will then process
   any blocks that were unprocessed because they appeared too "early"
-  ``get_blockhash_by_number(num)`` - get the block hash of a block at
   the given block number
-  ``get_block(hash)`` - gets the block with the given blockhash
-  ``get_block_by_number(num)`` - equivalent to
   ``get_block(get_blockhash_by_number(num))``
-  ``get_parent(block)`` - gets the parent of a block
-  ``get_children(block)`` - gets the children of a block
-  ``head`` (property) - gets the block at the head of the chain
-  ``state`` (property) - gets the state at the head of the chain
-  ``mk_poststate_of_blockhash(hash)`` - creates a state object after a
   given block
-  ``has_block(block)`` - is that block in the chain? Returns True/False
-  ``get_chain(from, to)`` - roughly equivalent to
   ``[get_block_by_number(i) for i in range(from, to)]``, though
   automatically stops if it reaches the head. ``from`` can be elided to
   start from genesis, ``to`` can be elided to go up to the head.
-  ``get_tx_position(tx)`` - if the transaction is in the chain, returns
   ``(blknum, index)`` where ``blknum`` is the block number of the block
   that contains the transaction and ``index`` is its position in the
   block

ethereum.state
~~~~~~~~~~~~~~

Contains the State class, which is used to manage a state. Main methods
are:

-  ``__init__(root_hash, env, **kwargs)`` - initializes a state with the
   given root hash, the given env (which includes a config and database)
   and the given auxiliary arguments. These include:

   -  ``txindex`` - the transaction index
   -  ``gas_used`` - amount of gas used
   -  ``gas_limit`` - block gas limit
   -  ``block_number`` - block number
   -  ``block_coinbase`` - block coinbase address
   -  ``block_difficulty`` - block difficulty
   -  ``timestamp`` - timestamp
   -  ``logs`` - logs created so far
   -  ``receipts`` - receipts created so far (from previous transactions
      in the current block)
   -  ``bloom`` - the bloom filter
   -  ``suicides`` - suicides (or selfdestructs, the newer more
      politically correct synonym)
   -  ``recent_uncles`` - recent uncle blocks in the chain
   -  ``prev_headers`` - previous block headers
   -  ``refunds`` - suicide/selfdestruct refund counter

Pyethereum follows a **maximally state-centric model**; the ONLY
information needed to process a transaction or a block is located within
the state itself, allowing the actual state transition logic to be a
very clean ``apply_transaction(state, tx)`` and
``apply_block(state, block)``.

-  ``get_balance``- gets the balance of an account
-  ``get_code`` - gets the code of an account
-  ``get_storage_data(addr, k)`` - gets the storage at the given key of
   the given address. Expects a key in **numerical** form (eg. b"cow" or
   "0x636f77" is represented as 6516599).
-  ``to_snapshot(root_only=False, no_prevblocks=False)`` - creates a
   snapshot for the current state. If ``root_only`` is set, only adds
   the state root, not the entire state. If ``no_prevblocks`` is set,
   does not add previous headers and uncles. Setting either of those
   flags means that the same database would be required to recover from
   the snapshot.
-  ``from_snapshot(snapshot, env)`` (classmethod) - creates a state from
   the given snapshot with the given ``env``.
-  ``ephemeral_clone()`` - creates a clone of the state that you can
   work with without affecting the original

There are also many methods that modify the state, eg. ``set_code``,
``set_storage_data``, but it is generally recommended to avoid using
these, and instead modify the state ONLY through ``apply_transaction``
and ``apply_block``.

ethereum.meta
~~~~~~~~~~~~~

This file contains two functions:

-  ``apply_block(state, block)`` - takes a state and processes a block
   onto that state
-  ``make_head_candidate(chain, txqueue=None, parent=None, timestamp, coinbase, extra_data, min_gasprice=0)``
   - creates a candidate block for the chain on top of the given parent
   block (default: head of the chain). Gets transactions from the given
   ``txqueue`` object with the given ``mingasprice`` (otherwise does not
   add transactions). ``timestamp``, ``coinbase`` and ``extra_data`` can
   be used to specify those parameters in the block; otherwise defaults
   are used

ethereum.messages
~~~~~~~~~~~~~~~~~

The main function that should be called from here is
``apply_transaction(state, tx)``.

ethereum.utils
~~~~~~~~~~~~~~

Contains a bunch of utility functions, including:

Numerical and hex conversions
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

-  ``encode_int(i)`` - converts an integer into big-endian binary
   representation
-  ``zpad(data, length)`` - pads the data up to the desired length by
   adding zero bytes on the left
-  ``encode_int32(i)`` - equivalent to ``zpad(encode_int(i), 32)`` but
   faster
-  ``big_endian_to_int(d)`` - converts binary data into an integer
-  ``encode_hex(b)`` - converts bytes to hex
-  ``decode_hex(h)`` - converts hex to bytes
-  ``int_to_addr(i)`` - converts integer to address
-  ``is_numeric(i)`` - returns True if the value is int or long,
   otherwise False

Cryptography
^^^^^^^^^^^^

-  ``sha3(data)`` - computes the SHA3 (or more precisely, keccak256)
   hash
-  ``ecrecover_to_pub(hash, v, r, s)`` - recovers the public key that
   made the signature as a 64-byte binary blob of
   ``encode_int32(x) + encode_int32(y)``. Hashing this and taking the
   last 20 bytes gives the *address* that signed a message.
-  ``ecsign(hash, key)`` - returns the v, r, s values of a signature
-  ``normalize_key(key)`` - converts a key from many formats into
   32-byte binary
-  ``privtoaddr(key)`` - converts a key to an address

Addresses
^^^^^^^^^

-  ``normalize_address(addr)`` - converts an address into 20-byte binary
   form
-  ``check_checksum(addr)`` - returns True if the address checksum
   passes, otherwise False
-  ``checksum_encode(addr)`` - converts an address into hex form with a
   checksum
-  ``mk_contract_address(addr, nonce)`` - creates the address of a
   contract created by the given address with the given nonce

Miscellaneous
^^^^^^^^^^^^^

-  ``denoms`` - contains the denominations of ether, eg.
   ``denoms.finney = 10**15``, ``denoms.shannon = 10**9``,
   ``denoms.gwei = 10**9``

ethereum.block
~~~~~~~~~~~~~~

Contains the ``Block`` and ``BlockHeader`` classes. Generally
recommended to avoid creating blocks and block headers directly, instead
using ``mk_head_candidate``. The member variables are straightforward:

-  ``block.transactions`` - transactions in a block
-  ``block.uncles`` - uncles in a block
-  ``block.header`` - header of a block

And in the header:

-  ``header.hash`` - the hash (also the block hash)
-  ``header.mining_hash`` - the hash used for proof of work mining
-  ``header.to_dict()`` - serializes into a human-readable dict
-  ``header.prevhash`` - previous block hash
-  ``header.uncles_hash`` - hash of the uncle list
-  ``header.coinbase`` - coinbase (miner) address
-  ``header.state_root`` - root hash of the post-state
-  ``header.tx_list_root`` - hash of the transactions in the block
-  ``header.receipts_root`` - hash of the receipt trie
-  ``header.bloom`` - bloom filter
-  ``header.difficulty`` - block difficulty
-  ``header.number`` - block number
-  ``header.gas_limit`` - gas limit
-  ``header.gas_used`` - gas used
-  ``header.timestamp`` - timestamp
-  ``header.extra_data`` - block extra data
-  ``header.mixhash`` and ``header.nonce`` - Ethash proof of work values

ethereum.transactions

Contains the Transaction class, with the following methods and values:

• __init__(nonce, gasprice, startgas, to, value, data, (v, r, s optional))
  • constructor
• sign(key, network_id=None) - signs the transaction with the given key, and with the given EIP155 chain ID (leaving as None will create a pre-EIP155 tx, be warned of replay attacks if you do this!)
• sender - the sender address of the transaction
• network_id - the EIP155 chain ID of the transaction
• hash - the hash of the transaction
• to_dict() - serializes into a human-readable dict
• intrinsic_gas_used - the amount of gas consumed by the transaction, including the cost of the tx data
• creates - if the transaction creates a contract, returns the contract address
• nonce, gasprice, startgas, to, value, data, v, r, s - parameters in the transaction

ethereum.tools.keys

Creates encrypted private key storaes

-  ``decode_keystore_json(jsondata, password)`` - returns the private
   key from an encrypted keystore object. NOTE: if you are loading from
   a file, the most convenient way to do this is
   ``import json; key = decode_keystore_json(json.load(open('filename.json')), 'password')``
-  ``make_keystore_json(key, pw, kdf='pbkdf2', cipher='aes-128-ctr')`` -
   creates an encrypted keystore object for the key. Keeping ``kdf`` and
   ``cipher`` at their default values is recommended.

ethereum.abi
~~~~~~~~~~~~

Most compilers for HLLs (solidity, serpent, viper, etc) on top of
Ethereum have the option to output an ABI declaration for a program.
This is a json object that looks something like this:

::

    [{"name": "ecrecover(uint256,uint256,uint256,uint256)", "type": "function", "constant": false,
     "inputs": [{"name": "h", "type": "uint256"}, {"name": "v", "type": "uint256"}, {"name": "r", "type": "uint256"}, {"name": "s", "type": "uint256"}],
     "outputs": [{"name": "out", "type": "int256[]"}]},
     {"name": "PubkeyTripleLogEvent(uint256,uint256,uint256)", "type": "event",
     "inputs": [{"name": "x", "type": "uint256", "indexed": false}, {"name": "y", "type": "uint256", "indexed": false}, {"name": "z", "type": "uint256", "indexed": false}]}]

You can initialize an ``abi.ContractTranslator`` object to encode and
decode data for contracts as follows:

::

    true, false = True, False  
    ct = abi.ContractTranslator(<json here>)  
    txdata = ct.encode('function_name', [arg1, arg2, arg3])  

You can also call ``ct.decode_event([topic1, topic2...], logdata)`` to
decode a log.

RLP encoding and decoding

For any transaction or block, you can simply do:

::

import rlp  
bindata = rlp.encode(<tx or block>)  

To decode:

::

import rlp  
from ethereum.transactions import Transaction  
rlp.decode(blob, Transaction)  

Or:

::

import rlp  
from ethereum.blocks import Block  
rlp.decode(blob, Block)  

Consensus abstraction

The pyethereum codebase is designed to be maximally friendly for use
across many different consensus algorithms. If you want to add a new
consensus algo, you'll need to take the following steps:

-  Add a directory alongside ``pow``, and in it create a ``chain.py``
   class that implements a ``Chain`` module. This may have a totally
   different fork choice rule for proof of work (GHOST, signature
   counting, Casper, etc).
-  Add an entry to ``consensus_strategy.py``. You will need to
   implement:

   -  ``check_seal`` - check that a block is correctly "sealed" (mined,
      signed, etc)
   -  ``validate_uncles(state, block)`` - check that uncles are valid
   -  ``initialize(state, block)`` - called in ``apply_block`` before
      transactions are processed
   -  ``finalize(state, block)`` - called in ``apply_block`` after
      transactions are processed
   -  ``get_uncle_candidates(chain, state)`` - called in
      ``mk_head_candidate`` to include uncles in a block

-  Create a chain config with the ``CONSENSUS_STRATEGY`` set to whatever
   you named your new consensus strategy

Tester module
-------------

See https://github.com/ethereum/pyethereum/wiki/Using-pyethereum.tester

Tests
-----

Run ``python3.6 -m pytest ethereum/tests/<filename>`` for any .py file
in that directory. Currently all tests are passing except for a few
Metropolis-specific state tests and block tests.

To make your own state tests, use the tester module as follows:

::

    from ethereum.tools import tester as t  
    import json  
    c = t.Chain()  
    x = c.contract(<code>, language=<language>)  
    pre = t.mk_state_test_prefill(c)  
    x.foo(<args>)  
    post = t.mk_state_test_postfill(c, pre)  
    open('output.json', 'w').write(json.dumps(post, indent=4))  

To make a test filler file instead, do
``post = t.mk_state_test_postfill(c, pre, True)``.

License
-------

See `LICENSE <LICENSE>`_