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)))
