def __init__(self, shard_id=0, expected_period_number=0, period_start_prevhash=utils.sha3rlp([]), parent_collation_hash=utils.sha3rlp([]), tx_list_root=trie.BLANK_ROOT, coinbase=sharding_config['GENESIS_COINBASE'], post_state_root=trie.BLANK_ROOT, receipts_root=trie.BLANK_ROOT, sig=''): fields = {k: v for k, v in locals().items() if k != 'self'} if len(fields['coinbase']) == 40: fields['coinbase'] = decode_hex(fields['coinbase']) assert len(fields['coinbase']) == 20 super(CollationHeader, self).__init__(**fields)
def __init__(self, prevhash=default_config['GENESIS_PREVHASH'], uncles_hash=utils.sha3rlp([]), coinbase=default_config['GENESIS_COINBASE'], state_root=trie.BLANK_ROOT, tx_list_root=trie.BLANK_ROOT, receipts_root=trie.BLANK_ROOT, bloom=0, difficulty=default_config['GENESIS_DIFFICULTY'], number=0, gas_limit=default_config['GENESIS_GAS_LIMIT'], gas_used=0, timestamp=0, extra_data=b'', mixhash=default_config['GENESIS_MIXHASH'], nonce=b''): # at the beginning of a method, locals() is a dict of all arguments fields = { k: v for k, v in locals().items() if k not in ['self', '__class__'] } if len(fields['coinbase']) == 40: fields['coinbase'] = decode_hex(fields['coinbase']) assert len(fields['coinbase']) == 20 self.block = None super(BlockHeader, self).__init__(**fields)
def __init__(self, shard_id=int_to_big_endian(0), prev_state_root=trie.BLANK_ROOT, tx_list_root=trie.BLANK_ROOT, coinbase=sharding_config['GENESIS_COINBASE'], post_state_root=trie.BLANK_ROOT, receipt_root=trie.BLANK_ROOT, children=[], state_branch_node=utils.sha3rlp([]), signatures=[], mixhash='', nonce='', source_block_numeber=int_to_big_endian(0), source_block_hash=utils.sha3rlp([])): fields = {k: v for k, v in locals().items() if k != 'self'} if len(fields['coinbase']) == 40: fields['coinbase'] = decode_hex(fields['coinbase']) assert len(fields['coinbase']) == 20 super(CollationHeader, self).__init__(**fields)
def generate_transaction_hash() -> str: (private_key, public_key, sender) = generate_eth_account() recipient = generate_eth_account(only_address=True) transaction = { 'to': '0x%s' % recipient, 'value': 0, 'gas': 1000000, 'gasPrice': 1000000000, 'nonce': 0, 'chainId': 1 } signature = utils.ecdsa_raw_sign(utils.sha3(transaction), private_key) return utils.sha3rlp(signature).hex()
def run_block_test(params): b = blocks.genesis(env, start_alloc=params["pre"]) gbh = params["genesisBlockHeader"] b.bloom = utils.scanners['int256b'](gbh["bloom"]) b.timestamp = utils.scanners['int'](gbh["timestamp"]) b.nonce = utils.scanners['bin'](gbh["nonce"]) b.extra_data = utils.scanners['bin'](gbh["extraData"]) b.gas_limit = utils.scanners['int'](gbh["gasLimit"]) b.gas_used = utils.scanners['int'](gbh["gasUsed"]) b.coinbase = utils.scanners['addr'](decode_hex(gbh["coinbase"])) b.difficulty = utils.parse_int_or_hex(gbh["difficulty"]) b.prevhash = utils.scanners['bin'](gbh["parentHash"]) b.mixhash = utils.scanners['bin'](gbh["mixHash"]) assert b.receipts.root_hash == \ utils.scanners['bin'](gbh["receiptTrie"]) assert b.transactions.root_hash == \ utils.scanners['bin'](gbh["transactionsTrie"]) assert utils.sha3rlp(b.uncles) == \ utils.scanners['bin'](gbh["uncleHash"]) h = encode_hex(b.state.root_hash) if h != str_to_bytes(gbh["stateRoot"]): raise Exception("state root mismatch") if b.hash != utils.scanners['bin'](gbh["hash"]): raise Exception("header hash mismatch") assert b.header.check_pow() blockmap = {b.hash: b} env.db.put(b.hash, rlp.encode(b)) for blk in params["blocks"]: if 'blockHeader' not in blk: try: rlpdata = decode_hex(blk["rlp"][2:]) blkparent = rlp.decode( rlp.encode(rlp.decode(rlpdata)[0]), blocks.BlockHeader).prevhash b2 = rlp.decode(rlpdata, blocks.Block, parent=blockmap[blkparent], env=env) success = b2.validate_uncles() except (ValueError, TypeError, AttributeError, VerificationFailed, DecodingError, DeserializationError, InvalidTransaction, KeyError): success = False assert not success else: rlpdata = decode_hex(blk["rlp"][2:]) blkparent = rlp.decode(rlp.encode(rlp.decode(rlpdata)[0]), blocks.BlockHeader).prevhash b2 = rlp.decode(rlpdata, blocks.Block, parent=blockmap[blkparent], env=env) assert b2.validate_uncles() blockmap[b2.hash] = b2 env.db.put(b2.hash, rlp.encode(b2))
def __init__(self, prevhash=GENESIS_PREVHASH, uncles_hash=utils.sha3rlp([]), coinbase=GENESIS_COINBASE, state_root=trie.BLANK_ROOT, tx_list_root=trie.BLANK_ROOT, receipts_root=trie.BLANK_ROOT, bloom=0, difficulty=GENESIS_DIFFICULTY, number=0, gas_limit=GENESIS_GAS_LIMIT, gas_used=0, timestamp=0, extra_data='', mixhash=GENESIS_MIXHASH, nonce=''): # at the beginning of a method, locals() is a dict of all arguments fields = {k: v for k, v in locals().items() if k != 'self'} if len(fields['coinbase']) == 40: fields['coinbase'] = decode_hex(fields['coinbase']) assert len(fields['coinbase']) == 20 self.block = None super(BlockHeader, self).__init__(**fields)
import logging import warnings import numpy as np import pandas as pd import rlp from eth_utils import (encode_hex, to_canonical_address, decode_hex) from ethereum import utils from ethereum.trie import Trie BLANK_ROOT = encode_hex(utils.sha3rlp(b'')) BLANK_CODE = encode_hex(utils.sha3(b'')) BLANK_RLP = rlp.encode(b'') ACCOUNT_LENGTH = 42 class Account: def __init__(self, address, nonce=0, balance=0, storage_root=BLANK_ROOT, contract_code=BLANK_CODE, is_in_db=False, is_address_in_db=False): """ :type nonce: int :type address: str :type balance: int :type storage_root: str :type contract_code: str :type is_in_db: bool """ self.address = address self.nonce = nonce self.balance = balance self.storage_root = storage_root
from ethereum.trie import Trie from ethereum.securetrie import SecureTrie from ethereum.config import default_config, Env from ethereum.block import FakeHeader from ethereum.db import BaseDB, EphemDB, OverlayDB, RefcountDB from ethereum.specials import specials as default_specials import copy import sys if sys.version_info.major == 2: from repoze.lru import lru_cache else: from functools import lru_cache BLANK_HASH = utils.sha3(b'') BLANK_ROOT = utils.sha3rlp(b'') THREE = b'\x00' * 19 + b'\x03' def snapshot_form(val): if is_numeric(val): return str(val) elif is_string(val): return '0x' + encode_hex(val) STATE_DEFAULTS = { "txindex": 0, "gas_used": 0, "gas_limit": 3141592,
( NODE_TYPE_BLANK, NODE_TYPE_LEAF, NODE_TYPE_EXTENSION, NODE_TYPE_BRANCH ) = tuple(range(4)) def is_key_value_type(node_type): return node_type in [NODE_TYPE_LEAF, NODE_TYPE_EXTENSION] BLANK_NODE = b'' BLANK_ROOT = utils.sha3rlp(b'') def transient_trie_exception(*args): raise Exception("Transient trie") class Trie(object): def __init__(self, db, root_hash=BLANK_ROOT, transient=False): '''it also present a dictionary like interface :param db key value database :root: blank or trie node in form of [key, value] or [v0,v1..v15,v] ''' self.db = db # Pass in a database object directly
def run_block_test(params, config_overrides={}): b = blocks.genesis(env, start_alloc=params["pre"]) gbh = params["genesisBlockHeader"] b.bloom = utils.scanners['int256b'](gbh["bloom"]) b.timestamp = utils.scanners['int'](gbh["timestamp"]) b.nonce = utils.scanners['bin'](gbh["nonce"]) b.extra_data = utils.scanners['bin'](gbh["extraData"]) b.gas_limit = utils.scanners['int'](gbh["gasLimit"]) b.gas_used = utils.scanners['int'](gbh["gasUsed"]) b.coinbase = utils.scanners['addr'](decode_hex(gbh["coinbase"])) b.difficulty = utils.parse_int_or_hex(gbh["difficulty"]) b.prevhash = utils.scanners['bin'](gbh["parentHash"]) b.mixhash = utils.scanners['bin'](gbh["mixHash"]) assert b.receipts.root_hash == \ utils.scanners['bin'](gbh["receiptTrie"]) assert b.transactions.root_hash == \ utils.scanners['bin'](gbh["transactionsTrie"]) assert utils.sha3rlp(b.uncles) == \ utils.scanners['bin'](gbh["uncleHash"]) h = encode_hex(b.state.root_hash) if h != str_to_bytes(gbh["stateRoot"]): raise Exception("state root mismatch") if b.hash != utils.scanners['bin'](gbh["hash"]): raise Exception("header hash mismatch") # assert b.header.check_pow() blockmap = {b.hash: b} env.db.put(b.hash, rlp.encode(b)) old_config = copy.deepcopy(env.config) try: for k, v in config_overrides.items(): env.config[k] = v b2 = None for blk in params["blocks"]: if 'blockHeader' not in blk: try: rlpdata = decode_hex(blk["rlp"][2:]) blkparent = rlp.decode(rlp.encode(rlp.decode(rlpdata)[0]), blocks.BlockHeader).prevhash b2 = rlp.decode(rlpdata, blocks.Block, parent=blockmap[blkparent], env=env) success = b2.validate_uncles() except (ValueError, TypeError, AttributeError, VerificationFailed, DecodingError, DeserializationError, InvalidTransaction, KeyError): success = False assert not success else: rlpdata = decode_hex(blk["rlp"][2:]) blkparent = rlp.decode(rlp.encode(rlp.decode(rlpdata)[0]), blocks.BlockHeader).prevhash b2 = rlp.decode(rlpdata, blocks.Block, parent=blockmap[blkparent], env=env) assert b2.validate_uncles() blockmap[b2.hash] = b2 env.db.put(b2.hash, rlp.encode(b2)) if b2: print('Block %d with state root %s' % (b2.number, encode_hex(b2.state.root_hash))) # blkdict = b.to_dict(False, True, False, True) # assert blk["blockHeader"] == \ # translate_keys(blkdict["header"], translator_list, lambda y, x: x, []) # assert blk["transactions"] == \ # [translate_keys(t, translator_list, valueconv, ['hash']) # for t in blkdict["transactions"]] # assert blk["uncleHeader"] == \ # [translate_keys(u, translator_list, lambda x: x, []) # for u in blkdict["uncles"]] finally: env.config = old_config
def run_block_test(params, config_overrides = {}): b = blocks.genesis(env, start_alloc=params["pre"]) gbh = params["genesisBlockHeader"] b.bloom = utils.scanners['int256b'](gbh["bloom"]) b.timestamp = utils.scanners['int'](gbh["timestamp"]) b.nonce = utils.scanners['bin'](gbh["nonce"]) b.extra_data = utils.scanners['bin'](gbh["extraData"]) b.gas_limit = utils.scanners['int'](gbh["gasLimit"]) b.gas_used = utils.scanners['int'](gbh["gasUsed"]) b.coinbase = utils.scanners['addr'](decode_hex(gbh["coinbase"])) b.difficulty = utils.parse_int_or_hex(gbh["difficulty"]) b.prevhash = utils.scanners['bin'](gbh["parentHash"]) b.mixhash = utils.scanners['bin'](gbh["mixHash"]) assert b.receipts.root_hash == \ utils.scanners['bin'](gbh["receiptTrie"]) assert b.transactions.root_hash == \ utils.scanners['bin'](gbh["transactionsTrie"]) assert utils.sha3rlp(b.uncles) == \ utils.scanners['bin'](gbh["uncleHash"]) h = encode_hex(b.state.root_hash) if h != str_to_bytes(gbh["stateRoot"]): raise Exception("state root mismatch") if b.hash != utils.scanners['bin'](gbh["hash"]): raise Exception("header hash mismatch") # assert b.header.check_pow() blockmap = {b.hash: b} env.db.put(b.hash, rlp.encode(b)) old_config = copy.deepcopy(env.config) for k, v in config_overrides.items(): env.config[k] = v b2 = None for blk in params["blocks"]: if 'blockHeader' not in blk: try: rlpdata = decode_hex(blk["rlp"][2:]) blkparent = rlp.decode( rlp.encode(rlp.decode(rlpdata)[0]), blocks.BlockHeader).prevhash b2 = rlp.decode(rlpdata, blocks.Block, parent=blockmap[blkparent], env=env) success = b2.validate_uncles() except (ValueError, TypeError, AttributeError, VerificationFailed, DecodingError, DeserializationError, InvalidTransaction, KeyError): success = False assert not success else: rlpdata = decode_hex(blk["rlp"][2:]) blkparent = rlp.decode(rlp.encode(rlp.decode(rlpdata)[0]), blocks.BlockHeader).prevhash b2 = rlp.decode(rlpdata, blocks.Block, parent=blockmap[blkparent], env=env) assert b2.validate_uncles() blockmap[b2.hash] = b2 env.db.put(b2.hash, rlp.encode(b2)) if b2: print('Block %d with state root %s' % (b2.number, encode_hex(b2.state.root_hash))) # blkdict = b.to_dict(False, True, False, True) # assert blk["blockHeader"] == \ # translate_keys(blkdict["header"], translator_list, lambda y, x: x, []) # assert blk["transactions"] == \ # [translate_keys(t, translator_list, valueconv, ['hash']) # for t in blkdict["transactions"]] # assert blk["uncleHeader"] == \ # [translate_keys(u, translator_list, lambda x: x, []) # for u in blkdict["uncles"]] env.config = old_config
def un_hash(self, key): return utils.sha3rlp(rlp.decode(key))