def state_from_genesis_declaration(genesis_data, env, block=None, allow_empties=False, executing_on_head=False, pytricia={}): if block: assert isinstance(block, Block) else: block = block_from_genesis_declaration(genesis_data, env) state = State(env=env) #convert list to dictionary alloc_data = {} for elem in genesis_data["alloc"]: alloc_data[elem.keys()[0]] = elem[elem.keys()[0]] #print alloc_data for addr, data in alloc_data.iteritems(): addr = normalize_address(addr) assert len(addr) == 20 if 'balance' in data: balance = Balance(data['balance']['own_ips']) state.set_balance(addr, balance) for ip in data['balance']['own_ips']: pytricia[ip] = normalize_address(addr) if executing_on_head: state.executing_on_head = True state.commit(allow_empties=allow_empties) rdb = RefcountDB(state.db) block.header.state_root = state.trie.root_hash state.changed = {} state.prev_headers = [block.header] return state
def mk_basic_state(alloc, header=None, env=None, executing_on_head=False): state = State(root = "6c08c2bdb7c09eb5a2524e9ed8f3dac707c7b0f6ca2116a173989a5370f77340".decode('hex'),env=environment, executing_on_head=executing_on_head) print(state.get_balance("3282791d6fd713f1e94f4bfd565eaa78b3a0599d")) if not header: header = { "number": 0, "gas_limit": environment.config['BLOCK_GAS_LIMIT'], "gas_used": 0, "timestamp": 1467446877, "difficulty": 1 } h = BlockHeader() state.prev_headers = [h] for addr, data in alloc.items(): addr = normalize_address(addr) assert len(addr) == 20 if 'balance' in data: state.set_balance(addr, parse_as_int(data['balance'])) if 'nonce' in data: state.set_nonce(addr, parse_as_int(data['nonce'])) state.block_number = header["number"] state.timestamp = header["timestamp"] state.commit() environment.db.commit() return state
def metadata(self, data_string, data_buffer): data_buffer["metadata"] = [] data = data_string.split(',') it = iter(data) if data_buffer["category"] == 2: if len(data) % 3 != 0: raise Exception( "metadata of a transaction with category 2 is not multiple of 3" ) # de 3 en 3 for afi, ip, address in zip(*[iter(data)] * 3): data_buffer["metadata"].append(int(afi)) if int(afi) == 1 or int(afi) == 2: data_buffer["metadata"].append(str(ip)) else: raise Exception("Incorrect AFI in metadata") data_buffer["metadata"].append(normalize_address(str(address))) elif data_buffer["category"] == 3: if len(data) % 4 != 0: raise Exception( "metadata of a transaction with category 3 is not multiple of 4" ) # de 4 en 4 for afi, ip, priority, weight in zip(*[iter(data)] * 4): data_buffer["metadata"].append(int(afi)) if int(afi) == 1 or int(afi) == 2: data_buffer["metadata"].append(str(ip)) else: raise Exception("Incorrect AFI in metadata") data_buffer["metadata"].appned(int(priority)) data_buffer["metadata"].append(int(weight)) else: raise Exception("Category not yet defined")
def query_eid(self, ipaddr, nonce): try: address = normalize_address( self.chain.patricia.get_value(str(IPNetwork(ipaddr).ip))) balance = self.chain.state.get_balance(address) if balance is not None: if len(balance.map_server.keys()) > 0: map_servers = MapServers(info=balance.map_server.keys()) resp = Response(nonce=nonce, info=map_servers) return resp.to_bytes() elif len(balance.locator.keys()) > 0: locator_records = [] for key in balance.locator.keys(): locator_records.append( LocatorRecord(priority=balance.locator[key][0], weight=balance.locator[key][1], locator=key)) map_reply = MapReplyRecord(eid_prefix=IPNetwork(ipaddr), locator_records=locator_records) resp = Response(nonce=nonce, info=map_reply) return resp.to_bytes() else: databaseLog.info("Address %s has no balance", str(address)) print("Address %s has no balance", str(address)) except: print("IP address %s is not owned by anybody", str(ipaddr)) databaseLog.info("IP address %s is not owned by anybody", str(ipaddr)) return None
def init_keystore(keys_dir='./keystore/'): keys = [] addresses = [] for file in glob.glob(os.path.join(keys_dir, '*')): key = Keystore.load(keys_dir + file[-40:], "TFG1234") keys.append(key) addresses.append(normalize_address(key.keystore['address'])) return keys, addresses
def __init__(self, id: str, address: str, city: str, state: str, zipcode: str, deadline: str, mass: str, notes: str): self.dependent_packages = set[int]() self.dependencies = set[Package]() self.id = int(id) self.street_address = address self.city = city self.state = state self.zipcode = zipcode self.deadline = self.parse_time(deadline) self.mass = int(mass) self.__status = self.Status.AT_HUB self.__parse_note(notes) self.address = normalize_address( f'{self.street_address} ({self.zipcode})')
def create_block(self, coinbase, random_no, group_key, group_sig, count): self.chain.process_time_queue() prevhash = self.chain.head_hash prevnumber = self.chain.state.block_number coinbase = normalize_address(coinbase) assert isinstance(random_no, (str, unicode)) if (prevnumber + 1) % DKG_RENEWAL_INTERVAL == 0: if ((group_key is None) or (group_key == '')): raise DkgBlockRequiresGroupKey() else: group_key = "0x00" block = Block( BlockHeader(timestamp=int(time.time()), prevhash=prevhash, number=prevnumber + 1, coinbase=coinbase, random_number=parse_as_bin(random_no), group_pubkey=group_key, group_sig=group_sig, count=count)) snapshot = self.chain.state.to_snapshot() s = state.State().from_snapshot(snapshot, Env(_EphemDB())) databaseLog.info("Creating block with block number %s", str(prevnumber + 1)) for tx in self.transactions: if sys.getsizeof(block) < 1048576: try: dictionary = {} if (prevnumber + 1) % 2 == 0 and int( tx.afi ) == 1: # the next block has to be an IPv4 one apply_transaction(s, tx, dictionary) block.transactions.append(tx) elif (prevnumber + 1) % 2 != 0 and int( tx.afi ) == 2: # the next block has to be an IPv6 one apply_transaction(s, tx, dictionary) block.transactions.append(tx) except Exception as e: databaseLog.info(e.message) else: databaseLog.info("Block number %s filled to max. size", str(prevnumber + 1)) self._create_tries(block) return block
def mk_basic_state(alloc, header=None, env=None, executing_on_head=False): env = env or Env() state = State(env=env, executing_on_head=executing_on_head) if not header: header = {"number": 0, "timestamp": 1467446877} h = BlockHeader(timestamp=parse_as_int(header['timestamp']), number=parse_as_int(header['number'])) state.prev_headers = [h] for addr, data in alloc.items(): addr = normalize_address(addr) assert len(addr) == 20 if 'balance' in data: state.set_balance(addr, parse_as_int(data['balance'])) if 'nonce' in data: state.set_nonce(addr, parse_as_int(data['nonce'])) state.block_number = header["number"] state.timestamp = header["timestamp"] state.commit() return state
def load_master_private_keys(consensus, my_dkgIDs): try: priv_keys = open('master-private-dkg-keys.txt', 'r') except IOError as e: if e.errno == errno.ENOENT: #File does not exist, means it is not the master node return False else: raise e except Exception as e: print e sys.exit(1) mainLog.info( "Detected master private key file. Perfoming manual setup of DKG private keys and initial BLS." ) sec_keys = {} for line in priv_keys: content = line.split(' ') sec_keys[normalize_address(content[0])] = content[1].rstrip('\n') priv_keys.close() consensus.bootstrap_master_add_secret_keys_manual(sec_keys, my_dkgIDs) return True
def frm(self, data_string, data_buffer): address = normalize_address(data_string) data_buffer["from"] = address
def to(self, data_string, data_buffer): address = normalize_address(data_string) data_buffer["to"] = address
def remove_received_ips(self, address, ips): n_address = normalize_address(address) self.received_ips[n_address] = self.received_ips[n_address] - ips if len(self.received_ips[n_address]) == 0: self.received_ips.pop(n_address)
def get_balance(self, address): balance = self.get_and_cache_account( utils.normalize_address(address)).balance return utils.bin_to_object(balance)
def delta_balance(self, address, value): address = utils.normalize_address(address) acct = self.get_and_cache_account(address) newbal = acct.balance + value self.set_and_journal(acct, 'balance', newbal) self.set_and_journal(acct, 'touched', True)
def set_nonce(self, address, value): acct = self.get_and_cache_account(utils.normalize_address(address)) self.set_and_journal(acct, 'nonce', value) self.set_and_journal(acct, 'touched', True)
def get_map_server(self, address): normalize_address(address) return self.chain.state.get_balance(address).map_server
def get_received_ips(self, address): normalize_address(address) return self.chain.state.get_balance(address).received_ips
def get_delegated_ips(self, address): normalize_address(address) return self.chain.state.get_balance(address).delegated_ips
def get_own_ips(self, address): normalize_address(address) return self.chain.state.get_balance(address).own_ips
def __init__(self, name: str, address: str) -> None: self.name = name self.address = utils.normalize_address(address)
def __init__(self, nonce, category, to, afi, value, metadata=b'', time=0, v=0, r=0, s=0): if category == 0 or category == 1: if metadata != b'': raise InvalidTransaction("Invalid Metadata") metadata = b'' elif category == 2: if type(metadata) == list and len(metadata) % 3 == 0: _metadata = [] _afi = 0 if type(metadata[0]) == bytes: _bytes = True elif type(metadata[0]) == int: _bytes = False else: raise InvalidTransaction("Invalid Metadata") i = 0 while i < len(metadata): try: if _bytes: _afi = bytes_to_int(metadata[i]) _metadata.append(metadata[i]) else: _afi = metadata[i] _metadata.append(encode_int8(metadata[i])) if _afi != 1 and _afi != 2: raise InvalidTransaction("Invalid Metadata AFI") except: raise InvalidTransaction("Invalid Metadata AFI") try: if _bytes: if _afi == 1: ip = IPv4Address(Bytes(metadata[i + 1])) else: ip = IPv6Address(Bytes(metadata[i + 1])) _metadata.append(bytes(ip.packed)) addr = normalize_address(metadata[i + 2], allow_blank=True) _metadata.append(addr) else: if _afi == 1: ip = IPv4Address(metadata[i + 1]) else: ip = IPv6Address(metadata[i + 1]) _metadata.append(bytes(ip.packed)) addr = normalize_address(metadata[i + 2], allow_blank=True) _metadata.append(addr) i += 3 except: raise InvalidTransaction("Invalid Metadata") metadata = _metadata else: raise InvalidTransaction("Invalid Metadata") elif category == 3: if type(metadata) == list and len(metadata) % 4 == 0: _metadata = [] _afi = 0 if type(metadata[0]) == bytes: _bytes = True elif type(metadata[0]) == int: _bytes = False else: raise InvalidTransaction("Invalid Metadata") i = 0 while i < len(metadata): try: if _bytes: _afi = bytes_to_int(metadata[i]) _metadata.append(metadata[i]) else: _afi = metadata[i] _metadata.append(encode_int8(metadata[i])) if _afi != 1 and _afi != 2: raise InvalidTransaction("Invalid Metadata AFI") except: raise InvalidTransaction("Invalid Metadata AFI") try: if _bytes: if _afi == 1: ip = IPv4Address(Bytes(metadata[i + 1])) else: ip = IPv6Address(Bytes(metadata[i + 1])) _metadata.append(bytes(ip.packed)) priority = bytes_to_int(metadata[i + 2]) if priority < 0 or priority > 255: raise InvalidTransaction( "Invalid Metadata Priority") _metadata.append(int_to_bytes(priority)) weight = bytes_to_int(metadata[i + 3]) if weight < 0 or weight > 255: raise InvalidTransaction( "Invalid Metadata Weight") _metadata.append(int_to_bytes(weight)) else: if _afi == 1: ip = IPv4Address(metadata[i + 1]) else: ip = IPv6Address(metadata[i + 1]) _metadata.append(bytes(ip.packed)) priority = metadata[i + 2] if priority < 0 or priority > 255: raise InvalidTransaction( "Invalid Metadata Priority") _metadata.append(int_to_bytes(priority)) weight = metadata[i + 3] if weight < 0 or weight > 255: raise InvalidTransaction( "Invalid Metadata Weight") _metadata.append(int_to_bytes(weight)) i += 4 except: raise InvalidTransaction("Invalid Metadata") metadata = _metadata else: raise InvalidTransaction("Invalid Metadata") else: raise InvalidTransaction("Invalid Category") to = normalize_address(to, allow_blank=True) if afi != 1 and afi != 2: raise InvalidTransaction("Invalid AFI") try: if afi == 1: ipnet = IPv4Network(value) else: ipnet = IPv6Network(value) except: if len(value) == 5: try: ip = IPv4Address(Bytes(value[:4])) ipnet = IPv4Network( str(ip) + '/' + str(bytes_to_int(value[4]))) except: raise InvalidTransaction("Invalid Value") elif len(value) == 17: try: ip = IPv6Address(Bytes(value[:16])) ipnet = IPv6Network( str(ip) + '/' + str(bytes_to_int(value[16]))) except: raise InvalidTransaction("Invalid Value") else: raise InvalidTransaction("Invalid Value") value = bytes(ipnet.packed) + encode_int8(ipnet.prefixlen) super(Transaction, self).__init__(nonce, category, to, afi, value, metadata, time, v, r, s)
def get_locator(self, address): normalize_address(address) return self.chain.state.get_balance(address).locator
def increment_nonce(self, address): address = utils.normalize_address(address) acct = self.get_and_cache_account(address) newnonce = acct.nonce + 1 self.set_and_journal(acct, 'nonce', newnonce) self.set_and_journal(acct, 'touched', True)
def set_balance(self, address, balance): balance = utils.object_to_bin(balance) acct = self.get_and_cache_account(utils.normalize_address(address)) self.set_and_journal(acct, 'balance', balance) self.set_and_journal(acct, 'touched', True)
def account_to_dict(self, address): return self.get_and_cache_account(utils.normalize_address(address)).to_dict()
def add_received_ips(self, address, ips): n_address = normalize_address(address) if n_address in self.received_ips.keys(): self.received_ips[n_address].add(ips) else: self.received_ips[n_address] = IPSet(ips)
def get_nonce(self, address): return self.get_and_cache_account(utils.normalize_address(address)).nonce
def apply_transaction(state, tx, cached): validate_transaction(state, tx) category = tx.category if category == 0: # allocate sender = tx.sender to = tx.to value = tx.ip_network cached[str(value)] = normalize_address(to) sender_balance = state.get_balance(sender) affected = sender_balance.affected_delegated_ips(value) for add, ips in affected.iteritems(): sender_balance.remove_delegated_ips(add, ips) received_balance = state.get_balance(add) received_balance.remove_received_ips(sender, ips) state.set_balance(add, received_balance) to_balance = state.get_balance(to) sender_balance.remove_own_ips(value) to_balance.add_own_ips(value) state.set_balance(to, to_balance) state.set_balance(sender, sender_balance) state.increment_nonce(sender) elif category == 1: # delegate sender = tx.sender to = tx.to value = tx.ip_network cached[str(value)] = normalize_address(to) sender_balance = state.get_balance(sender) affected = sender_balance.affected_delegated_ips(value) for add, ips in affected.iteritems(): sender_balance.remove_delegated_ips(add, ips) received_balance = state.get_balance(add) received_balance.remove_received_ips(sender, ips) state.set_balance(add, received_balance) to_balance = state.get_balance(to) to_balance.add_received_ips(sender, value) sender_balance.add_delegated_ips(to, value) state.set_balance(to, to_balance) state.set_balance(sender, sender_balance) state.increment_nonce(sender) elif category == 2: # MapServer sender = tx.sender value = tx.metadata sender_balance = state.get_balance(sender) sender_balance.set_map_server(value) state.set_balance(sender, sender_balance) state.increment_nonce(sender) elif category == 3: # Locator sender = tx.sender value = tx.metadata sender_balance = state.get_balance(sender) sender_balance.set_locator(value) state.set_balance(sender, sender_balance) state.increment_nonce(sender) state.commit() return True
def set_code(self, address, value): # assert is_string(value) acct = self.get_and_cache_account(utils.normalize_address(address)) self.set_and_journal(acct, 'code', value) self.set_and_journal(acct, 'touched', True)
def get_addr_from_ip(self, ipaddr): return normalize_address(self.chain.patricia.get_value(str(ipaddr)))