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