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): 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() self.init_dcp_list()
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 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, 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 _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 get_block(blockhash): """ Assumtion: blocks loaded from the db are not manipulated -> can be cached including hash """ return CachedBlock.create_cached( Block.deserialize(db.DB(utils.get_db_path()).get(blockhash)))
def POST(self): # todo add ping event response data = web.data() try: data_dict = json.loads(data) except: print 'Invalid json received' traceback.print_exc() raise web.webapi.BadRequest() if data_dict.get('forced') is not True: # only save force pushes, so ignore other push events raise web.webapi.ok() simple_response_validation(data_dict) conn = sqlite3.connect(get_db_path()) ref = str(data_dict.get('ref')) repo_name = str( data_dict.get('repository', {}).get('full_name'), '<name_missing>') conn.execute('INSERT INTO data(repo_name,ref,event) VALUES (?,?,?)', (repo_name, ref, data)) conn.commit() conn.close() return web.webapi.Accepted()
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 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 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_root'] = strie.get_root_hash().encode('hex') 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 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, 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=[]): 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.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 utils.sha3(rlp.encode(self.uncles)) != self.uncles_hash: raise Exception("Uncle root hash does not match!") if len(self.uncles) != len(set(self.uncles)): raise Exception("Uncle hash not uniqe in uncles list") 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 self.check_proof_of_work(self.nonce): raise Exception("PoW check failed")
def has_block(blockhash): return db.DB(utils.get_db_path()).has_key(blockhash)
def dbget(x): db = trie.DB(utils.get_db_path()) print db.get(x.decode('hex'))
def has_block(blockhash): return blockhash in db.DB(utils.get_db_path())
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 __init__(self): super(ChainManager, self).__init__() self.transactions = set() self.blockchain = DB(utils.get_db_path()) self.head = None
def set_state_root(self, state_root_hash): self.state = trie.Trie(utils.get_db_path(), state_root_hash) self.reset_cache()
def _initialize_blockchain(self): logger.info('Initializing new chain @ %s', utils.get_db_path()) genesis = blocks.genesis({self_addr: 10**18}) self._store_block(genesis) self._update_head(genesis) self.blockchain.commit()
def get_storage(self, address): storage_root = self._get_acct_item(address, 'storage') return trie.Trie(utils.get_db_path(), storage_root)
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=[]): 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.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 utils.sha3(rlp.encode(self.uncles)) != self.uncles_hash: raise Exception("Uncle root hash does not match!") if len(self.uncles) != len(set(self.uncles)): raise Exception("Uncle hash not uniqe in uncles list") 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 self.check_proof_of_work(self.nonce): raise Exception("PoW check failed")
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) self.proof_mode = None self.proof_nodes = [] # If transaction_list is None, then it's a block header imported for # SPV purposes if transaction_list is not None: # 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) if tx_list_root != self.transactions.root_hash: raise Exception("Transaction list root hash does not match!") if not self.is_genesis() and self.nonce and\ not check_header_pow(header or self.list_header()): raise Exception("PoW check failed") # 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 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")
def _initialize_blockchain(self): logger.info('Initializing new chain @ %s', utils.get_db_path()) genesis = blocks.genesis() self._store_block(genesis) self._update_head(genesis) self.blockchain.commit()
def dbget(x): db = trie.DB(utils.get_db_path()) return db.get(x.decode('hex'))
def __init__(self): self.db = db.DB(utils.get_db_path()) self.pagenation = 1000
def get_block(blockhash): """ Assumtion: blocks loaded from the db are not manipulated -> can be cached including hash """ return CachedBlock.create_cached(Block.deserialize(db.DB(utils.get_db_path()).get(blockhash)))