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(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 deserialize(self, reader: BinaryReader): self.peer_pubkey = a2b_hex(reader.read_var_str()).hex() self.address = Address(reader.read_bytes(20)) self.consensus_pos = reader.read_int64() self.freeze_pos = reader.read_int64() self.new_pos = reader.read_int64() self.withdraw_pos = reader.read_int64() self.withdraw_freeze_pos = reader.read_int64() self.withdraw_unfreeze_pos = reader.read_int64()
def read_bytes(reader: BinaryReader): code = reader.read_byte() if code == int.from_bytes(PUSHDATA4, 'little'): temp = reader.read_uint32() key_len = temp elif code == int.from_bytes(PUSHDATA2, 'little'): temp = reader.read_uint16() key_len = int(temp) elif code == int.from_bytes(PUSHDATA1, 'little'): temp = reader.read_uint8() key_len = int(temp) elif int.from_bytes(PUSHBYTES75, 'little') >= code >= int.from_bytes(PUSHBYTES1, 'little'): key_len = code - int.from_bytes(PUSHBYTES1, 'little') + 1 else: key_len = 0 res = reader.read_bytes(key_len) return res
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 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 get_param_info(program: bytes): ms = StreamManager.GetStream(program) reader = BinaryReader(ms) list = [] while True: try: res = ProgramBuilder.read_bytes(reader) except: break list.append(res) return list
def get_param_info(program: bytes): ms = StreamManager.get_stream(program) reader = BinaryReader(ms) param_info = [] while True: try: res = ProgramBuilder.read_bytes(reader) except SDKException: break param_info.append(res) return param_info
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_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'))
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_total_stake(self, address: str): contract_address = bytearray.fromhex(self.CONTRACT_ADDRESS) contract_address.reverse() total_bytes = self.TOTAL_STAKE.encode('utf-8') address_bytes = Address.b58decode(address).to_array() key = total_bytes + address_bytes res = self.__sdk.rpc.get_storage(contract_address.hex(), key.hex()) stream = StreamManager.GetStream(bytearray.fromhex(res)) reader = BinaryReader(stream) total_stake = TotalStake() total_stake.deserialize(reader) stream.close() return total_stake
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_peer_attributes(self, peer_pubkey: str): contract_address = bytearray.fromhex(self.CONTRACT_ADDRESS) contract_address.reverse() peer_attributes = self.PEER_ATTRIBUTES.encode('utf-8') peer_pubkey_bytes = a2b_hex(peer_pubkey.encode()) key = peer_attributes + peer_pubkey_bytes res = self.__sdk.rpc.get_storage(contract_address.hex(), key.hex()) if res is None or res == '': return None peer_attributes = PeerAttributes() stream = StreamManager.GetStream(bytearray.fromhex(res)) reader = BinaryReader(stream) peer_attributes.deserialize(reader) stream.close() return peer_attributes.to_json()
def get_split_fee_address(self, address: str): contract_address = bytearray.fromhex(self.CONTRACT_ADDRESS) contract_address.reverse() split_fee_address_bytes = self.SPLIT_FEE_ADDRESS.encode() address_bytes = Address.b58decode(address).to_array() key = split_fee_address_bytes + address_bytes res = self.__sdk.rpc.get_storage(contract_address.hex(), key.hex()) if res is None or res == '': return None split_fee_address = SplitFeeAddress() stream = StreamManager.GetStream(bytearray.fromhex(res)) reader = BinaryReader(stream) split_fee_address.deserialize(reader) stream.close() return split_fee_address.to_json()
def get_authorize_info(self, peer_pubkey: str, addr: Address): contract_address = bytearray.fromhex(self.CONTRACT_ADDRESS) contract_address.reverse() peer_pubkey_prefix = bytearray.fromhex(peer_pubkey) address_bytes = addr.to_array() authorize_info_pool = self.AUTHORIZE_INFO_POOL.encode() key = authorize_info_pool + peer_pubkey_prefix + address_bytes res = self.__sdk.rpc.get_storage(contract_address.hex(), key.hex()) if res is None or res == '': return None stream = StreamManager.GetStream(bytearray.fromhex(res)) reader = BinaryReader(stream) authorize_info = AuthorizeInfo() authorize_info.deserialize(reader) return authorize_info.to_json()
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 __init__(self, bys: bytearray): self.ms = StreamManager.GetStream(bys) self.reader = BinaryReader(self.ms) self.code = bys
def deserialize_from(sigbytes: bytes): ms = StreamManager.GetStream(sigbytes) reader = BinaryReader(ms) return Sig.deserialize(reader)
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.amount = reader.read_int64()