def deserialize(self, reader: BinaryReader):
self.index = reader.read_int32()
self.peer_pubkey = a2b_hex(reader.read_var_str()).hex()
self.address = Address(reader.read_bytes(20))
self.status = reader.read_byte()
self.init_pos = reader.read_int64()
self.total_pos = reader.read_int64()
def __get_peer_pool_map(self, peer_pubkey=None):
contract_address = bytearray.fromhex(self.CONTRACT_ADDRESS)
contract_address.reverse()
view = self.__sdk.rpc.get_storage(contract_address.hex(),
self.GOVERNANCE_VIEW.encode().hex())
stream = StreamManager.GetStream(bytearray.fromhex(view))
reader = BinaryReader(stream)
governance_view = GovernanceView()
governance_view.deserialize(reader)
stream.close()
stream2 = StreamManager.GetStream()
writer = BinaryWriter(stream2)
writer.write_int32(governance_view.view)
view_bytes = stream2.ToArray()
peer_pool_bytes = self.PEER_POOL.encode('utf-8')
key_bytes = peer_pool_bytes + a2b_hex(view_bytes)
value = self.__sdk.rpc.get_storage(contract_address.hex(),
key_bytes.hex())
stream3 = StreamManager.GetStream(bytearray.fromhex(value))
reader2 = BinaryReader(stream3)
length = reader2.read_int32()
peer_pool_map = {}
for i in range(length):
item = PeerPoolItem()
item.deserialize(reader2)
peer_pool_map[item.peer_pubkey] = item.to_json()
if peer_pubkey is not None:
if peer_pubkey not in peer_pool_map:
return None
return peer_pool_map[peer_pubkey]
return peer_pool_map
def deserialize(self, reader: BinaryReader):
self.peer_pubkey = a2b_hex(reader.read_var_str()).hex()
self.max_authorize = reader.read_int64()
self.old_peerCost = reader.read_int64()
self.new_peer_cost = reader.read_int64()
self.set_cost_view = reader.read_int32()
self.field1 = reader.read_var_bytes()
self.field2 = reader.read_var_bytes()
self.field3 = reader.read_var_bytes()
self.field4 = reader.read_var_bytes()
class VmReader(object):
def __init__(self, bys: bytearray):
self.ms = StreamManager.GetStream(bys)
self.reader = BinaryReader(self.ms)
self.code = bys
def read_byte(self):
return self.reader.read_byte()
def read_bool(self):
b = self.reader.read_byte()
return b == 1
def read_bytes(self, count: int):
return self.reader.read_bytes(count)
def read_var_bytes(self):
return self.reader.read_var_bytes()
def read_uint16(self):
return self.read_uint16()
def read_uint32(self):
return self.reader.read_int32()
def read_uint64(self):
return self.reader.read_int64()
def position(self):
return self.reader.stream.tell()
def read_int16(self):
try:
res = bytearray(self.reader.read_bytes(2))
res.reverse()
return int(res.hex(), 16)
except Exception as e:
return 0
def read_var_int(self):
return self.reader.read_var_int()
def seek(self, offset: int):
return self.reader.stream.seek(offset)
def parse_ddo(ont_id: str, ddo: str) -> dict:
if ddo == "":
return dict()
ms = StreamManager.GetStream(a2b_hex(ddo))
reader = BinaryReader(ms)
try:
publickey_bytes = reader.read_var_bytes()
except Exception as e:
raise e
try:
attribute_bytes = reader.read_var_bytes()
except Exception as e:
attribute_bytes = bytearray()
try:
recovery_bytes = reader.read_var_bytes()
except Exception as e:
recovery_bytes = bytearray()
pubKey_list = []
if len(publickey_bytes) != 0:
ms = StreamManager.GetStream(publickey_bytes)
reader2 = BinaryReader(ms)
while True:
try:
index = reader2.read_int32()
d = {}
d['PubKeyId'] = ont_id + "#keys-" + str(index)
pubkey = reader2.read_var_bytes()
if len(pubkey) == 33:
d["Type"] = KeyType.ECDSA.name
d["Curve"] = Curve.P256.name
d["Value"] = pubkey.hex()
else:
d["Type"] = KeyType.from_label(pubkey[0])
d["Curve"] = Curve.from_label(pubkey[1])
d["Value"] = pubkey.hex()
pubKey_list.append(d)
except Exception as e:
break
attribute_list = []
if len(attribute_bytes) != 0:
ms = StreamManager.GetStream(attribute_bytes)
reader2 = BinaryReader(ms)
while True:
try:
d = {}
key = reader2.read_var_bytes()
if len(key) == 0:
break
d["Key"] = str(key, 'utf-8')
d["Type"] = str(reader2.read_var_bytes(), 'utf-8')
d["Value"] = str(reader2.read_var_bytes(), 'utf-8')
attribute_list.append(d)
except Exception as e:
break
d2 = {}
d2["Owners"] = pubKey_list
d2["Attributes"] = attribute_list
if len(recovery_bytes) != 0:
addr = Address(recovery_bytes)
d2["Recovery"] = addr.b58encode()
d2["OntId"] = ont_id
return d2
def deserialize(self, reader: BinaryReader):
self.view = reader.read_int32()
self.height = reader.read_int32()
self.tx_hash = reader.read_bytes(32).hex()
def deserialize(self, reader: BinaryReader):
self.address = Address(reader.read_bytes(20))
self.stake = reader.read_int64()
self.time_offset = reader.read_int32()
