def parse_attributes(serialized_attributes: str or bytes):
if len(serialized_attributes) == 0:
return list()
if isinstance(serialized_attributes, str):
stream = StreamManager.get_stream(
bytearray.fromhex(serialized_attributes))
elif isinstance(serialized_attributes, bytes):
stream = StreamManager.get_stream(serialized_attributes)
else:
raise SDKException(
ErrorCode.params_type_error(
'bytes or str parameter is required.'))
reader = BinaryReader(stream)
attributes_list = []
while True:
try:
attr_key = reader.read_var_bytes().decode('utf-8')
attr_type = reader.read_var_bytes().decode('utf-8')
attr_value = reader.read_var_bytes().decode('utf-8')
attr = dict(Key=attr_key, Type=attr_type, Value=attr_value)
attributes_list.append(attr)
except SDKException as e:
if 10000 < e.args[0] < 20000:
break
else:
raise e
return attributes_list
def __deserialize_stack_item(reader: BinaryReader) -> dict or bytearray:
param_type = reader.read_byte()
if param_type == BuildParams.Type.bytearray_type.value:
b = reader.read_var_bytes()
return b
elif param_type == BuildParams.Type.bool_type.value:
return reader.read_bool()
elif param_type == BuildParams.Type.int_type.value:
b = reader.read_var_bytes()
return ContractDataParser.__big_int_from_bytes(bytearray(b))
elif param_type == BuildParams.Type.struct_type.value or param_type == BuildParams.Type.array_type.value:
count = reader.read_var_int()
item_list = list()
for _ in range(count):
item = ContractDataParser.__deserialize_stack_item(reader)
item_list.append(item)
if param_type == BuildParams.Type.struct_type.value:
return Struct(item_list)
return item_list
elif param_type == BuildParams.Type.dict_type.value:
count = reader.read_var_int()
item_dict = dict()
for _ in range(count):
key = ContractDataParser.__deserialize_stack_item(reader)
value = ContractDataParser.__deserialize_stack_item(reader)
item_dict[key] = value
return item_dict
else:
raise SDKException(ErrorCode.other_error('type error'))
def deserialize_stack_item(reader: BinaryReader) -> dict:
t = reader.read_byte()
if t == BuildParams.Type.bytearray_type.value:
b = reader.read_var_bytes()
return b
elif t == BuildParams.Type.bool_type.value:
return reader.read_bool()
elif t == BuildParams.Type.int_type.value:
b = reader.read_var_bytes()
return bigint_from_bytes(b)
elif t == BuildParams.Type.struct_type.value or t == BuildParams.Type.array_type.value:
count = reader.read_var_int()
# TODO
item_list = list()
for _ in range(count):
item = deserialize_stack_item(reader)
item_list.append(item)
if t == t == BuildParams.Type.struct_type.value:
return Struct(item_list)
return item_list
elif t == BuildParams.Type.dict_type.value:
count = reader.read_var_int()
item_dict = dict()
for _ in range(count):
key = deserialize_stack_item(reader)
value = deserialize_stack_item(reader)
item_dict[key] = value
return item_dict
else:
raise SDKException(ErrorCode.other_error('type error'))
async def get_ddo(ont_id):
contract_address = b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' \
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03'
version = b'\x00'
remote = 'http://dappnode1.ont.io:20336/'
sdk = Ontology(rpc_address=remote)
args = dict(ontid=ont_id.encode('utf-8'))
invoke_code = build_vm.build_native_invoke_code(contract_address, version,
'getDDO', args)
tx = Transaction(0, 0xd1, 0, 0, b'', invoke_code)
response = await sdk.aio_rpc.send_raw_transaction_pre_exec(tx)
serialized_ddo = response['Result']
if len(serialized_ddo) == 0:
return dict()
if isinstance(serialized_ddo, str):
stream = StreamManager.get_stream(bytearray.fromhex(serialized_ddo))
elif isinstance(serialized_ddo, bytes):
stream = StreamManager.get_stream(serialized_ddo)
else:
raise SDKException(
ErrorCode.params_type_error('unexpected data type {}'.format(
type(serialized_ddo))))
reader = BinaryReader(stream)
try:
public_key_bytes = reader.read_var_bytes()
except SDKException:
public_key_bytes = b''
try:
attribute_bytes = reader.read_var_bytes()
except SDKException:
attribute_bytes = b''
try:
recovery_bytes = reader.read_var_bytes()
except SDKException:
recovery_bytes = b''
if len(recovery_bytes) != 0:
b58_recovery = Address(recovery_bytes).b58encode()
else:
b58_recovery = ''
try:
controller = reader.read_var_bytes().decode('utf-8')
except SDKException:
controller = ''
try:
recovery = reader.read_var_bytes().decode('utf-8')
except SDKException:
recovery = ''
pub_keys = ontid.OntId.parse_pub_keys(ont_id, public_key_bytes)
attribute_list = ontid.OntId.parse_attributes(attribute_bytes)
return dict(
id=ont_id,
keys=pub_keys,
ctrl=controller,
attributes=attribute_list,
recovery=recovery if recovery else b58_recovery,
)
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()
def deserialize(reader: BinaryReader):
invocation_script = reader.read_var_bytes()
verification_script = reader.read_var_bytes()
sig = Sig()
sig.__sig_data = ProgramBuilder.get_param_info(invocation_script)
info = ProgramBuilder.get_program_info(verification_script)
sig.public_keys = info.pubkeys
sig.m = info.m
return sig
def parse_pub_keys(ont_id: str, raw_pub_keys: str or bytes) -> list:
if isinstance(raw_pub_keys, str):
stream = StreamManager.get_stream(bytearray.fromhex(raw_pub_keys))
elif isinstance(raw_pub_keys, bytes):
stream = StreamManager.get_stream(raw_pub_keys)
else:
raise SDKException(ErrorCode.params_type_error('bytes or str parameter is required.'))
reader = BinaryReader(stream)
pub_keys = list()
while True:
try:
kid = f'{ont_id}#keys-{reader.read_int32()}'
bytes_key = reader.read_var_bytes()
hex_pub_key = bytes_key.hex()
if len(bytes_key) == 33:
key_info = dict(PubKeyId=kid, Type=KeyType.ECDSA.name, Curve=Curve.P256.name, Value=hex_pub_key)
else:
key_type = KeyType.from_label(bytes_key[0])
curve = Curve.from_label(bytes_key[1])
key_info = dict(PubKeyId=kid, Type=key_type, Curve=curve, Value=hex_pub_key)
pub_keys.append(key_info)
except SDKException as e:
if e.args[0] != 10001:
raise e
else:
break
return pub_keys
def parse_ddo(ont_id: str, serialized_ddo: str or bytes) -> dict:
"""
This interface is used to deserialize a hexadecimal string into a DDO object in the from of dict.
:param ont_id: the unique ID for identity.
:param serialized_ddo: an serialized description object of ONT ID in form of str or bytes.
:return: a description object of ONT ID in the from of dict.
"""
if len(serialized_ddo) == 0:
return dict()
if isinstance(serialized_ddo, str):
stream = StreamManager.get_stream(
bytearray.fromhex(serialized_ddo))
elif isinstance(serialized_ddo, bytes):
stream = StreamManager.get_stream(serialized_ddo)
else:
raise SDKException(
ErrorCode.params_type_error(
'bytes or str parameter is required.'))
reader = BinaryReader(stream)
try:
public_key_bytes = reader.read_var_bytes()
except SDKException:
public_key_bytes = b''
try:
attribute_bytes = reader.read_var_bytes()
except SDKException:
attribute_bytes = b''
try:
recovery_bytes = reader.read_var_bytes()
except SDKException:
recovery_bytes = b''
if len(recovery_bytes) != 0:
b58_recovery = Address(recovery_bytes).b58encode()
else:
b58_recovery = ''
pub_keys = OntId.parse_pub_keys(ont_id, public_key_bytes)
attribute_list = OntId.parse_attributes(attribute_bytes)
ddo = dict(Owners=pub_keys,
Attributes=attribute_list,
Recovery=b58_recovery,
OntId=ont_id)
return ddo
def op_code_to_int(op_code: str):
if op_code.lower() == '4f':
return -1
elif op_code == '00':
return 0
elif 80 < int(op_code, base=16) < 103:
return int(op_code, base=16) - 80
else:
op_code = bytearray.fromhex(op_code)
stream = StreamManager.get_stream(op_code)
reader = BinaryReader(stream)
op_code = bytearray(reader.read_var_bytes())
return ContractDataParser.neo_bytearray_to_big_int(op_code)
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 deserialize_from(txbytes: bytes):
ms = StreamManager.GetStream(txbytes)
reader = BinaryReader(ms)
tx = Transaction()
tx.version = reader.read_uint8()
tx.tx_type = reader.read_uint8()
tx.nonce = reader.read_uint32()
tx.gas_price = reader.read_uint64()
tx.gas_limit = reader.read_uint64()
tx.payer = reader.read_bytes(20)
tx.payload = reader.read_var_bytes()
attri_len = reader.read_var_int()
if attri_len is 0:
tx.attributes = bytearray()
sigs_len = reader.read_var_int()
tx.sigs = []
for i in range(sigs_len):
tx.sigs.append(Sig.deserialize(reader))
return tx
def deserialize_from(bytes_tx: bytes):
ms = StreamManager.get_stream(bytes_tx)
reader = BinaryReader(ms)
tx = Transaction()
tx.version = reader.read_uint8()
tx.tx_type = reader.read_uint8()
tx.nonce = reader.read_uint32()
tx.gas_price = reader.read_uint64()
tx.gas_limit = reader.read_uint64()
tx.payer = reader.read_bytes(20)
tx.payload = reader.read_var_bytes()
attribute_len = reader.read_var_int()
if attribute_len is 0:
tx.attributes = bytearray()
sig_len = reader.read_var_int()
tx.sig_list = list()
for _ in range(0, sig_len):
tx.sig_list.append(Sig.deserialize(reader))
return tx
def get_program_info(program: bytes) -> ProgramInfo:
length = len(program)
end = program[length - 1]
temp = program[:length - 1]
ms = StreamManager.get_stream(temp)
reader = BinaryReader(ms)
info = ProgramInfo()
if end == int.from_bytes(CHECKSIG, 'little'):
pub_keys = ProgramBuilder.read_bytes(reader)
info.set_pubkey([pub_keys])
info.set_m(1)
elif end == int.from_bytes(CHECKMULTISIG, 'little'):
length = program[len(program) - 2] - int.from_bytes(PUSH1, 'little') + 1
m = reader.read_byte() - int.from_bytes(PUSH1, 'little') + 1
pub = []
for _ in range(length):
pub.append(reader.read_var_bytes())
info.set_pubkey(pub)
info.set_m(m)
return info
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
