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