def configure(self, config):
     self.config = config
     logger.info('Opening chain @ %s', utils.get_db_path())
     self.blockchain = DB(utils.get_db_path())
     logger.debug('Chain @ #%d %s', self.head.number, self.head.hex_hash())
     self.log_chain()
     self.new_miner()

 def configure(self, config, genesis=None):
     self.config = config
     logger.info('Opening chain @ %s', utils.get_db_path())
     db = self.blockchain = DB(utils.get_db_path())
     self.index = Index(db)
     if genesis:
         self._initialize_blockchain(genesis)
     logger.debug('Chain @ #%d %s', self.head.number, self.head.hex_hash())
     self.new_miner()

    def __init__(self,
                 prevhash='',
                 uncles_hash=block_structure_rev['uncles_hash'][2],
                 coinbase=block_structure_rev['coinbase'][2],
                 state_root='',
                 tx_list_root='',
                 difficulty=block_structure_rev['difficulty'][2],
                 number=0,
                 min_gas_price=block_structure_rev['min_gas_price'][2],
                 gas_limit=block_structure_rev['gas_limit'][2],
                 gas_used=0, timestamp=0, extra_data='', nonce='',
                 transaction_list=[],
                 uncles=[]):

        self.prevhash = prevhash
        self.uncles_hash = uncles_hash
        self.coinbase = coinbase
        self.state_root = state_root
        self.tx_list_root = tx_list_root
        self.difficulty = difficulty
        self.number = number
        self.min_gas_price = min_gas_price
        self.gas_limit = gas_limit
        self.gas_used = gas_used
        self.timestamp = timestamp
        self.extra_data = extra_data
        self.nonce = nonce
        self.transaction_list = transaction_list
        self.uncles = uncles

        self.transactions = Trie(get_db_path())
        self.transaction_count = 0

        # Fill in nodes for transaction trie
        for tx in transaction_list:
            self.add_transaction_to_list(tx)

        self.state = Trie(get_db_path(), self.state_root)

        # Basic consistency verifications
        if self.state.root != '' and self.state.db.get(self.state.root) == '':
            raise Exception("State Merkle root not found in database!")
        if self.tx_list_root != self.transactions.root:
            raise Exception("Transaction list root hash does not match!")
        if sha3(rlp.encode(self.uncles)) != self.uncles_hash:
            raise Exception("Uncle root hash does not match!")
        if len(self.extra_data) > 1024:
            raise Exception("Extra data cannot exceed 1024 bytes")
        if self.coinbase == '':
            raise Exception("Coinbase cannot be empty address")

 def _initialize_blockchain(self, genesis=None):
     logger.info('Initializing new chain @ %s', utils.get_db_path())
     if not genesis:
         genesis = blocks.genesis()
         self.index.add_block(genesis)
     self._store_block(genesis)
     self._update_head(genesis)

 def account_to_dict(self, address, with_storage_root=False):
     if with_storage_root:
         assert len(self.journal) == 0
     med_dict = {}
     for i, val in enumerate(self.get_acct(address)):
         name, typ, default = acct_structure[i]
         key = acct_structure[i][0]
         if name == 'storage':
             strie = trie.Trie(utils.get_db_path(), val)
             if with_storage_root:
                 med_dict['storage_root'] = strie.get_root_hash().encode('hex')
         else:
             med_dict[key] = self.caches[key].get(address, utils.printers[typ](val))
     med_dict['storage'] = {}
     d = strie.to_dict()
     for k in d.keys() + self.caches['all'].keys():
         v = d.get(k, None)
         subcache = self.caches.get('storage:'+address, {})
         v2 = subcache.get(utils.big_endian_to_int(k), None)
         hexkey = '0x'+k.encode('hex')
         if v2 is not None:
             if v2 != 0:
                 med_dict['storage'][hexkey] = '0x'+utils.int_to_big_endian(v2).encode('hex')
         elif v is not None:
             med_dict['storage'][hexkey] = '0x'+rlp.decode(v).encode('hex')
     return med_dict

 def commit_state(self):
     if not len(self.journal):
         return
     for address in self.caches['all']:
         acct = rlp.decode(self.state.get(address.decode('hex'))) \
             or self.mk_blank_acct()
         for i, (key, typ, default) in enumerate(acct_structure):
             if key == 'storage':
                 t = trie.Trie(utils.get_db_path(), acct[i])
                 t.proof_mode = self.proof_mode
                 t.proof_nodes = self.proof_nodes
                 for k, v in self.caches.get('storage:'+address, {}).iteritems():
                     enckey = utils.zpad(utils.coerce_to_bytes(k), 32)
                     val = rlp.encode(utils.int_to_big_endian(v))
                     if v:
                         t.update(enckey, val)
                     else:
                         t.delete(enckey)
                 acct[i] = t.root_hash
                 if self.proof_mode == RECORDING:
                     self.proof_nodes.extend(t.proof_nodes)
             else:
                 if address in self.caches[key]:
                     v = self.caches[key].get(address, default)
                     acct[i] = utils.encoders[acct_structure[i][1]](v)
         self.state.update(address.decode('hex'), rlp.encode(acct))
     if self.proof_mode == RECORDING:
         self.proof_nodes.extend(self.state.proof_nodes)
         self.state.proof_nodes = []
     self.reset_cache()

 def account_to_dict(self, address):
     med_dict = {}
     for i, val in enumerate(self.get_acct(address)):
         med_dict[acct_structure[i][0]] = val
     strie = trie.Trie(utils.get_db_path(), med_dict['storage']).to_dict()
     med_dict['storage'] = {utils.decode_int(k): utils.decode_int(v)
                            for k, v in strie.iteritems()}
     return med_dict

 def account_to_dict(self, address):
     med_dict = {}
     for i, val in enumerate(self.get_acct(address)):
         med_dict[acct_structure[i][0]] = val
     med_dict['code_hash'] = utils.sha3(med_dict['code']).encode('hex')
     med_dict['code'] = med_dict['code'].encode('hex')
     strie = trie.Trie(utils.get_db_path(), med_dict['storage'])
     med_dict['storage'] = {k.encode('hex'): v.encode('hex')
                            for k, v in strie.to_dict().iteritems()}
     med_dict['storage_root'] = strie.root_hash.encode('hex')
     return med_dict

 def account_to_dict(self, address):
     self.commit_state()
     med_dict = {}
     for i, val in enumerate(self.get_acct(address)):
         name, typ, default = acct_structure[i]
         med_dict[acct_structure[i][0]] = utils.printers[typ](val)
         if name == 'storage':
             strie = trie.Trie(utils.get_db_path(), val)
     med_dict['storage'] = {'0x'+k.encode('hex'):
                            '0x'+rlp.decode(v).encode('hex')
                            for k, v in strie.to_dict().iteritems()}
     return med_dict

 def _account_to_dict(self, acct):
     med_dict = {}
     for i, (name, typ, default) in enumerate(acct_structure):
         med_dict[name] = utils.decoders[typ](acct[i])
     chash = med_dict['code']
     strie = trie.Trie(utils.get_db_path(), med_dict['storage']).to_dict()
     med_dict['code'] = \
         self.state.db.get(chash).encode('hex') if chash else ''
     med_dict['storage'] = {
         utils.decode_int(k): utils.decode_int(strie[k]) for k in strie
     }
     return med_dict

    def deserialize(cls, rlpdata):
        header_args, transaction_list, uncles = rlp.decode(rlpdata)
        kargs = cls.deserialize_header(header_args)
        kargs['transaction_list'] = transaction_list
        kargs['uncles'] = uncles

        # if we don't have the state we need to replay transactions
        _db = db.DB(utils.get_db_path())
        if len(kargs['state_root']) == 32 and kargs['state_root'] in _db:
            return Block(**kargs)
        elif kargs['prevhash'] == GENESIS_PREVHASH:
            return Block(**kargs)
        else:  # no state, need to replay
            try:
                parent = get_block(kargs['prevhash'])
            except KeyError:
                raise UnknownParentException(kargs['prevhash'].encode('hex'))
            return parent.deserialize_child(rlpdata)

    def __init__(self, data=None):

        self.reward = 10 ** 18
        self.gas_consumed = 0
        self.gaslimit = 1000000  # for now

        if not data:
            self.number = 0
            self.prevhash = ''
            self.uncles_root = ''
            self.coinbase = '0' * 40
            self.state = Trie(get_db_path())
            self.transactions_root = ''
            self.transactions = []
            self.uncles = []
            self.difficulty = 2 ** 23
            self.timestamp = 0
            self.extradata = ''
            self.nonce = 0
            return

        if re.match('^[0-9a-fA-F]*$', data):
            data = data.decode('hex')

        header,  transaction_list, self.uncles = rlp.decode(data)
        self.number = decode_int(header[0])
        self.prevhash = header[1]
        self.uncles_root = header[2]
        self.coinbase = header[3].encode('hex')
        self.state = Trie(STATEDB_DIR, header[4])
        self.transactions_root = header[5]
        self.difficulty = decode_int(header[6])
        self.timestamp = decode_int(header[7])
        self.extradata = header[8]
        self.nonce = decode_int(header[9])
        self.transactions = [Transaction(x) for x in transaction_list]

        # Verifications
        if self.state.root != '' and self.state.db.get(self.state.root) == '':
            raise Exception("State Merkle root not found in database!")
        if sha3(rlp.encode(transaction_list)) != self.transactions_root:
            raise Exception("Transaction list root hash does not match!")
        if sha3(rlp.encode(self.uncles)) != self.uncles_root:
            raise Exception("Uncle root hash does not match!")

    def deserialize(cls, rlpdata):
        header_args, transaction_list, uncles = rlp.decode(rlpdata)
        assert len(header_args) == len(block_structure)
        kargs = dict(transaction_list=transaction_list, uncles=uncles)
        # Deserialize all properties
        for i, (name, typ, default) in enumerate(block_structure):
            kargs[name] = utils.decoders[typ](header_args[i])

        # if we don't have the state we need to replay transactions
        _db = db.DB(utils.get_db_path())
        if len(kargs['state_root']) == 32 and kargs['state_root'] in _db:
            return Block(**kargs)
        elif kargs['prevhash'] == GENESIS_PREVHASH:
            return Block(**kargs)
        else:  # no state, need to replay
            try:
                parent = get_block(kargs['prevhash'])
            except KeyError:
                raise UnknownParentException(kargs['prevhash'].encode('hex'))
            return parent.deserialize_child(rlpdata)

 def commit_state(self):
     for address in self.caches['all']:
         acct = rlp.decode(self.state.get(address.decode('hex'))) \
             or self.mk_blank_acct()
         for i, (key, typ, default) in enumerate(acct_structure):
             if key == 'storage':
                 t = trie.Trie(utils.get_db_path(), acct[i])
                 for k, v in self.caches[key].get(address, {}).iteritems():
                     enckey = utils.zpad(utils.coerce_to_bytes(k), 32)
                     val = rlp.encode(utils.int_to_big_endian(v))
                     if v:
                         t.update(enckey, val)
                     else:
                         t.delete(enckey)
                 acct[i] = t.root_hash
             else:
                 if address in self.caches[key]:
                     v = self.caches[key].get(address, default)
                     acct[i] = utils.encoders[acct_structure[i][1]](v)
         self.state.update(address.decode('hex'), rlp.encode(acct))
     self.reset_cache()

 def account_to_dict(self, address, with_storage_root=False):
     if with_storage_root:
         assert len(self.journal) == 0
     med_dict = {}
     for i, val in enumerate(self.get_acct(address)):
         name, typ, default = acct_structure[i]
         key = acct_structure[i][0]
         if name == "storage":
             strie = trie.Trie(utils.get_db_path(), val)
             if with_storage_root:
                 med_dict["storage_root"] = strie.get_root_hash().encode("hex")
         else:
             med_dict[key] = self.caches[key].get(address, utils.printers[typ](val))
     med_dict["storage"] = {}
     for k, v in strie.to_dict().iteritems():
         subcache = self.caches.get("storage:" + address, {})
         v2 = subcache.get(utils.big_endian_to_int(k), None)
         hexkey = "0x" + k.encode("hex")
         if v2 is not None:
             med_dict["storage"][hexkey] = "0x" + utils.int_to_big_endian(v2).encode("hex")
         else:
             med_dict["storage"][hexkey] = "0x" + v.encode("hex")
     return med_dict

 def __init__(self):
     self.db = db.DB(utils.get_db_path())
     self.pagenation = 1000

def has_block(blockhash):
    return blockhash in db.DB(utils.get_db_path())

def get_block(blockhash):
    return Block.deserialize(db.DB(utils.get_db_path()).get(blockhash))

    def __init__(
        self,
        prevhash="\00" * 32,
        uncles_hash=block_structure_rev["uncles_hash"][2],
        coinbase=block_structure_rev["coinbase"][2],
        state_root=trie.BLANK_ROOT,
        tx_list_root=trie.BLANK_ROOT,
        difficulty=block_structure_rev["difficulty"][2],
        number=0,
        min_gas_price=block_structure_rev["min_gas_price"][2],
        gas_limit=block_structure_rev["gas_limit"][2],
        gas_used=0,
        timestamp=0,
        extra_data="",
        nonce="",
        transaction_list=[],
        uncles=[],
        header=None,
    ):

        self.prevhash = prevhash
        self.uncles_hash = uncles_hash
        self.coinbase = coinbase
        self.difficulty = difficulty
        self.number = number
        self.min_gas_price = min_gas_price
        self.gas_limit = gas_limit
        self.gas_used = gas_used
        self.timestamp = timestamp
        self.extra_data = extra_data
        self.nonce = nonce
        self.uncles = uncles
        self.suicides = []
        self.postqueue = []
        self.caches = {"balance": {}, "nonce": {}, "code": {}, "all": {}}
        self.journal = []

        self.transactions = trie.Trie(utils.get_db_path(), tx_list_root)
        self.transaction_count = 0

        self.state = trie.Trie(utils.get_db_path(), state_root)

        if transaction_list:
            # support init with transactions only if state is known
            assert self.state.root_hash_valid()
            for tx_lst_serialized, state_root, gas_used_encoded in transaction_list:
                self._add_transaction_to_list(tx_lst_serialized, state_root, gas_used_encoded)

        # make sure we are all on the same db
        assert self.state.db.db == self.transactions.db.db

        # use de/encoders to check type and validity
        for name, typ, d in block_structure:
            v = getattr(self, name)
            assert utils.decoders[typ](utils.encoders[typ](v)) == v

        # Basic consistency verifications
        if not self.state.root_hash_valid():
            raise Exception("State Merkle root not found in database! %r" % self)
        if tx_list_root != self.transactions.root_hash:
            raise Exception("Transaction list root hash does not match!")
        if not self.transactions.root_hash_valid():
            raise Exception("Transactions root not found in database! %r" % self)
        if len(self.extra_data) > 1024:
            raise Exception("Extra data cannot exceed 1024 bytes")
        if self.coinbase == "":
            raise Exception("Coinbase cannot be empty address")
        if not self.is_genesis() and self.nonce and not check_header_pow(header or self.list_header()):
            raise Exception("PoW check failed")

 def get_storage(self, address):
     storage_root = self._get_acct_item(address, 'storage')
     return trie.Trie(utils.get_db_path(), storage_root)