def get_smart_contract(self, contract_address: str) -> dict: """ This interface is used to get the information of smart contract based on the specified hexadecimal hash value. :param contract_address: str, a hexadecimal hash value. :return: the information of smart contract in dictionary form. """ if type(contract_address) != str: raise SDKException( ErrorCode.param_err( 'a hexadecimal contract address is required.')) if len(contract_address) != 40: raise SDKException( ErrorCode.param_err( 'the length of the contract address should be 40 bytes.')) payload = RpcClient.set_json_rpc_version(RPC_GET_SMART_CONTRACT, [contract_address, 1]) try: response = HttpRequest.request("post", self.addr, payload) except requests.exceptions.ConnectTimeout: raise SDKException( ErrorCode.other_error(''.join(['ConnectTimeout: ', self.addr]))) except requests.exceptions.ConnectionError: raise SDKException( ErrorCode.other_error(''.join(['ConnectionError: ', self.addr]))) contract = json.loads(response.content.decode())["result"] return contract
def get_smart_contract_event_by_height(self, height: int) -> dict: """ This interface is used to get the corresponding smart contract event based on the height of block. Args: height (int): a decimal height value. Return: the information of smart contract event in dictionary form. """ payload = RpcClient.set_json_rpc_version(RPC_GET_SMART_CONTRACT_EVENT, [height, 1]) try: response = HttpRequest.request("post", self.addr, payload) except requests.exceptions.ConnectTimeout: raise SDKException( ErrorCode.other_error(''.join(['ConnectTimeout: ', self.addr]))) except requests.exceptions.ConnectionError: raise SDKException( ErrorCode.other_error(''.join(['ConnectionError: ', self.addr]))) event = json.loads(response.content.decode())["result"] return event
def get_allowance(self, asset_name: str, from_address: str, to_address: str) -> str: """ This interface is used to get the the allowance from transfer-from account to transfer-to account in current network. Args: from_address (str): a base58 encoded account address Return: the information of allowance in dictionary form. """ payload = RpcClient.set_json_rpc_version( RPC_GET_ALLOWANCE, [asset_name, from_address, to_address]) try: response = HttpRequest.request("post", self.addr, payload) except requests.exceptions.ConnectTimeout: raise SDKException( ErrorCode.other_error(''.join(['ConnectTimeout: ', self.addr]))) except requests.exceptions.ConnectionError: raise SDKException( ErrorCode.other_error(''.join(['ConnectionError: ', self.addr]))) allowance = json.loads(response.content.decode())["result"] return allowance
def get_balance(self, base58_address: str) -> dict: """ This interface is used to get the account balance of specified base58 encoded address in current network. Args: base58_address (str): a base58 encoded account address Return: the value of account balance in dictionary form. """ payload = RpcClient.set_json_rpc_version(RPC_GET_BALANCE, [base58_address, 1]) try: response = HttpRequest.request("post", self.addr, payload) except requests.exceptions.ConnectTimeout: raise SDKException( ErrorCode.other_error(''.join(['ConnectTimeout: ', self.addr]))) except requests.exceptions.ConnectionError: raise SDKException( ErrorCode.other_error(''.join(['ConnectionError: ', self.addr]))) balance = json.loads(response.content.decode())["result"] return balance
def get_merkle_proof(self, tx_hash: str) -> dict: """ This interface is used to get the corresponding merkle proof based on the specified hexadecimal hash value. Args: tx_hash (str): an hexadecimal transaction hash value. Return: the merkle proof in dictionary form. """ payload = RpcClient.set_json_rpc_version(RPC_GET_MERKLE_PROOF, [tx_hash, 1]) try: response = HttpRequest.request("post", self.addr, payload) except requests.exceptions.ConnectTimeout: raise SDKException( ErrorCode.other_error(''.join(['ConnectTimeout: ', self.addr]))) except requests.exceptions.ConnectionError: raise SDKException( ErrorCode.other_error(''.join(['ConnectionError: ', self.addr]))) proof = json.loads(response.content.decode())["result"] return proof
def get_storage(self, contract_address: str, key: str) -> int: """ This interface is used to get the corresponding stored value based on hexadecimal contract address and stored key. Args: contract_address (str): hexadecimal contract address key (str): a hexadecimal stored key Return: the information of smart contract event in dictionary form. """ payload = RpcClient.set_json_rpc_version(RPC_GET_STORAGE, [contract_address, key, 1]) try: response = HttpRequest.request("post", self.addr, payload) except requests.exceptions.ConnectTimeout: raise SDKException(ErrorCode.other_error(''.join(['ConnectTimeout: ', self.addr]))) except requests.exceptions.ConnectionError: raise SDKException(ErrorCode.other_error(''.join(['ConnectionError: ', self.addr]))) s = json.loads(response.content.decode())["result"] # s = bytearray.fromhex(s) # value = (s[0]) | (s[1]) << 8 | (s[2]) << 16 | (s[3]) << 24 | (s[4]) << 32 | (s[5]) << 40 | (s[6]) << 48 | ( # s[7]) << 56 return s
def get_block_by_hash(self, block_hash: str) -> dict: """ This interface is used to get the hexadecimal hash value of specified block height in current network. Args: block_hash (str): a hexadecimal value of block hash Return: the block information of the specified block hash. """ payload = RpcClient.set_json_rpc_version(RPC_GET_BLOCK, [block_hash, 1]) try: response = HttpRequest.request("post", self.addr, payload) except requests.exceptions.ConnectTimeout: raise SDKException( ErrorCode.other_error(''.join(['ConnectTimeout: ', self.addr]))) except requests.exceptions.ConnectionError: raise SDKException( ErrorCode.other_error(''.join(['ConnectionError: ', self.addr]))) dict_block = json.loads(response.content.decode())["result"] return dict_block
def send_raw_transaction_pre_exec(self, tx: Transaction): """ This interface is used to send the transaction that is prepare to execute. Args: tx (Transaction): Transaction object in ontology Python SDK. Return: the execution result of transaction that is prepare to execute. """ buf = tx.serialize() tx_data = buf.hex() payload = RpcClient.set_json_rpc_version(RPC_SEND_TRANSACTION, [tx_data, 1]) try: response = HttpRequest.request("post", self.addr, payload) except requests.exceptions.ConnectTimeout: raise SDKException(ErrorCode.other_error(''.join(['ConnectTimeout: ', self.addr]))) except requests.exceptions.ConnectionError: raise SDKException(ErrorCode.other_error(''.join(['ConnectionError: ', self.addr]))) res = json.loads(response.content.decode()) err = res["error"] if err > 0: try: result = res['result'] raise RuntimeError(result) except KeyError: raise RuntimeError('send raw transaction pre-execute error') if res["result"]["State"] == 0: raise RuntimeError("State = 0") return res["result"]["Result"]
def get_block_hash_by_height(self, height: int) -> str: """ This interface is used to get the hexadecimal hash value of specified block height in current network. Args: height (int): a decimal block height value Return: the hexadecimal hash value of the specified block height. """ payload = RpcClient.set_json_rpc_version(RPC_GET_BLOCK_HASH, [height, 1]) try: response = HttpRequest.request("post", self.addr, payload) except requests.exceptions.ConnectTimeout: raise SDKException( ErrorCode.other_error(''.join(['ConnectTimeout: ', self.addr]))) except requests.exceptions.ConnectionError: raise SDKException( ErrorCode.other_error(''.join(['ConnectionError: ', self.addr]))) block_hash = json.loads(response.content.decode())["result"] return block_hash
def send_raw_transaction(self, tx: Transaction) -> str: """ This interface is used to send the transaction into the network. Args: tx (Transaction): Transaction object in ontology Python SDK. Return: a hexadecimal transaction hash value. """ buf = tx.serialize() tx_data = buf.hex() payload = RpcClient.set_json_rpc_version(RPC_SEND_TRANSACTION, [tx_data]) try: response = HttpRequest.request("post", self.addr, payload) except requests.exceptions.ConnectTimeout: raise SDKException(ErrorCode.other_error(''.join(['ConnectTimeout: ', self.addr]))) except requests.exceptions.ConnectionError: raise SDKException(ErrorCode.other_error(''.join(['ConnectionError: ', self.addr]))) data = json.loads(response.content.decode()) res = data["result"] if data["error"] != 0: raise SDKException(ErrorCode.other_error(res)) return res
def new_withdraw_ong_transaction(b58_claimer_address: str, b58_recv_address: str, amount: int, b58_payer_address: str, gas_limit: int, gas_price: int) -> Transaction: """ This interface is used to generate a Transaction object that allow one account to withdraw an amount of ong and transfer them to receive address. :param b58_claimer_address: a base58 encode address which is used to indicate who is the claimer. :param b58_recv_address: a base58 encode address which is used to indicate who receive the claimed ong. :param amount: the amount of asset that will be claimed. :param b58_payer_address: a base58 encode address which indicate who will pay for the transaction. :param gas_limit: an int value that indicate the gas limit. :param gas_price: an int value that indicate the gas price. :return: a Transaction object which can be used for withdraw ong. """ if not isinstance(b58_claimer_address, str) or not isinstance( b58_recv_address, str) or not isinstance( b58_payer_address, str): raise SDKException( ErrorCode.param_err( 'the data type of base58 encode address should be the string.' )) if len(b58_claimer_address) != 34 or len( b58_recv_address) != 34 or len(b58_payer_address) != 34: raise SDKException( ErrorCode.param_err( 'the length of base58 encode address should be 34 bytes.')) if amount <= 0: raise SDKException( ErrorCode.other_error( 'the amount should be greater than than zero.')) if gas_price < 0: raise SDKException( ErrorCode.other_error( 'the gas price should be equal or greater than zero.')) if gas_limit < 0: raise SDKException( ErrorCode.other_error( 'the gas limit should be equal or greater than zero.')) ont_contract_address = util.get_asset_address('onyx') ong_contract_address = util.get_asset_address("oxg") args = { "sender": Address.b58decode(b58_claimer_address).to_array(), "from": ont_contract_address, "to": Address.b58decode(b58_recv_address).to_array(), "value": amount } invoke_code = build_native_invoke_code(ong_contract_address, bytes([0]), "transferFrom", args) unix_time_now = int(time()) payer_array = Address.b58decode(b58_payer_address).to_array() return Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit, payer_array, invoke_code, bytearray(), [], bytearray())
def new_transfer_transaction(asset: str, b58_from_address: str, b58_to_address: str, amount: int, b58_payer_address: str, gas_limit: int, gas_price: int) -> Transaction: """ This interface is used to generate a Transaction object for transfer. :param asset: a string which is used to indicate which asset we want to transfer. :param b58_from_address: a base58 encode address which indicate where the asset from. :param b58_to_address: a base58 encode address which indicate where the asset to. :param amount: the amount of asset that will be transferred. :param b58_payer_address: a base58 encode address which indicate who will pay for the transaction. :param gas_limit: an int value that indicate the gas limit. :param gas_price: an int value that indicate the gas price. :return: a Transaction object which can be used for transfer. """ if not isinstance(b58_from_address, str) or not isinstance( b58_to_address, str) or not isinstance(b58_payer_address, str): raise SDKException( ErrorCode.param_err( 'the data type of base58 encode address should be the string.' )) if len(b58_from_address) != 34 or len(b58_to_address) != 34 or len( b58_payer_address) != 34: raise SDKException( ErrorCode.param_err( 'the length of base58 encode address should be 34 bytes.')) if amount <= 0: raise SDKException( ErrorCode.other_error( 'the amount should be greater than than zero.')) if gas_price < 0: raise SDKException( ErrorCode.other_error( 'the gas price should be equal or greater than zero.')) if gas_limit < 0: raise SDKException( ErrorCode.other_error( 'the gas limit should be equal or greater than zero.')) contract_address = util.get_asset_address(asset) raw_from = Address.b58decode(b58_from_address).to_array() raw_to = Address.b58decode(b58_to_address).to_array() raw_payer = Address.b58decode(b58_payer_address).to_array() state = [{"from": raw_from, "to": raw_to, "amount": amount}] invoke_code = build_native_invoke_code(contract_address, bytes([0]), "transfer", state) unix_time_now = int(time()) version = 0 tx_type = 0xd1 attributes = bytearray() signers = list() hash_value = bytearray() return Transaction(version, tx_type, unix_time_now, gas_price, gas_limit, raw_payer, invoke_code, attributes, signers, hash_value)
def new_approve_transaction(asset: str, b58_send_address: str, b58_recv_address: str, amount: int, b58_payer_address: str, gas_limit: int, gas_price: int) -> Transaction: """ This interface is used to generate a Transaction object for approve. :param asset: a string which is used to indicate which asset we want to approve. :param b58_send_address: a base58 encode address which indicate where the approve from. :param b58_recv_address: a base58 encode address which indicate where the approve to. :param amount: the amount of asset that will be approved. :param b58_payer_address: a base58 encode address which indicate who will pay for the transaction. :param gas_limit: an int value that indicate the gas limit. :param gas_price: an int value that indicate the gas price. :return: a Transaction object which can be used for approve. """ if not isinstance(b58_send_address, str) or not isinstance( b58_recv_address, str): raise SDKException( ErrorCode.param_err( 'the data type of base58 encode address should be the string.' )) if len(b58_send_address) != 34 or len(b58_recv_address) != 34: raise SDKException( ErrorCode.param_err( 'the length of base58 encode address should be 34 bytes.')) if amount <= 0: raise SDKException( ErrorCode.other_error( 'the amount should be greater than than zero.')) if gas_price < 0: raise SDKException( ErrorCode.other_error( 'the gas price should be equal or greater than zero.')) if gas_limit < 0: raise SDKException( ErrorCode.other_error( 'the gas limit should be equal or greater than zero.')) contract_address = util.get_asset_address(asset) raw_send = Address.b58decode(b58_send_address).to_array() raw_recv = Address.b58decode(b58_recv_address).to_array() raw_payer = Address.b58decode(b58_payer_address).to_array() args = {"from": raw_send, "to": raw_recv, "amount": amount} invoke_code = build_native_invoke_code(contract_address, bytes([0]), "approve", args) unix_time_now = int(time()) return Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit, raw_payer, invoke_code, bytearray(), [], bytearray())
def send_transfer_from(self, asset: str, sender: Account, b58_from_address: str, b58_recv_address: str, amount: int, payer: Account, gas_limit: int, gas_price: int) -> str: """ This interface is used to generate a Transaction object for transfer that allow one account to transfer a amount of ONT or ONG Asset to another account, in the condition of the first account had been approved. :param asset: a string which is used to indicate which asset we want to transfer. :param sender: an Account class that send the transfer transaction. :param b58_from_address: a base58 encode address which indicate where the asset from. :param b58_recv_address: a base58 encode address which indicate where the asset to. :param amount: the amount of asset want to transfer from from-address. :param payer: an Account class that used to pay for the transaction. :param gas_limit: an int value that indicate the gas limit. :param gas_price: an int value that indicate the gas price. :return: hexadecimal transaction hash value. """ if sender is None: raise SDKException( ErrorCode.param_err('the sender should not be None.')) if payer is None: raise SDKException( ErrorCode.param_err('the payer should not be None.')) if amount <= 0: raise SDKException( ErrorCode.other_error( 'the amount should be greater than than zero.')) if gas_price < 0: raise SDKException( ErrorCode.other_error( 'the gas price should be equal or greater than zero.')) if gas_limit < 0: raise SDKException( ErrorCode.other_error( 'the gas limit should be equal or greater than zero.')) b58_payer_address = payer.get_address_base58() b58_sender_address = sender.get_address_base58() tx = Asset.new_transfer_from_transaction(asset, b58_sender_address, b58_from_address, b58_recv_address, amount, b58_payer_address, gas_limit, gas_price) tx = self.__sdk.sign_transaction(tx, sender) if b58_sender_address != b58_payer_address: tx = self.__sdk.add_sign_transaction(tx, payer) self.__sdk.rpc.send_raw_transaction(tx) return tx.hash256_explorer()
def test_other_error(self): code = 59000 msg = 'TEST' desc = "Other Error, " + msg value = ErrorCode.other_error(msg) self.assertEqual(value["error"], code) self.assertEqual(value["desc"], desc)
def add_identity(self, id: Identity): for identity in self.identities: if identity.ont_id == id.ont_id: raise SDKException( ErrorCode.other_error( 'add identity failed, OntId conflict.')) self.identities.append(id)
def get_raw_transaction(self, tx_hash: str) -> dict: """ This interface is used to get the corresponding transaction information based on the specified hash value. :param tx_hash: str, a hexadecimal hash value. :return: dict """ payload = RpcClient.set_json_rpc_version(RPC_GET_TRANSACTION, [tx_hash, 1]) try: response = HttpRequest.request("post", self.addr, payload) except requests.exceptions.ConnectTimeout: raise SDKException(ErrorCode.other_error(''.join(['ConnectTimeout: ', self.addr]))) except requests.exceptions.ConnectionError: raise SDKException(ErrorCode.other_error(''.join(['ConnectionError: ', self.addr]))) tx = json.loads(response.content.decode())["result"] return tx
def get_gas_price(self) -> int: """ This interface is used to get the gas price in current network. Return: the value of gas price. """ payload = RpcClient.set_json_rpc_version(RPC_GET_GAS_PRICE, []) try: response = HttpRequest.request("post", self.addr, payload) except requests.exceptions.ConnectTimeout: raise SDKException(ErrorCode.other_error(''.join(['ConnectTimeout: ', self.addr]))) except requests.exceptions.ConnectionError: raise SDKException(ErrorCode.other_error(''.join(['ConnectionError: ', self.addr]))) price = json.loads(response.content.decode())["result"]['gasprice'] return price
def get_node_count(self) -> int: """ This interface is used to get the current number of connections for the node in current network. Return: the number of connections. """ payload = RpcClient.set_json_rpc_version(RPC_GET_NODE_COUNT, []) try: response = HttpRequest.request("post", self.addr, payload) except requests.exceptions.ConnectTimeout: raise SDKException(ErrorCode.other_error(''.join(['ConnectTimeout: ', self.addr]))) except requests.exceptions.ConnectionError: raise SDKException(ErrorCode.other_error(''.join(['ConnectionError: ', self.addr]))) count = json.loads(response.content.decode())["result"] return count
def get_current_block_hash(self) -> str: """ This interface is used to get the hexadecimal hash value of the highest block in current network. Return: the hexadecimal hash value of the highest block in current network. """ payload = RpcClient.set_json_rpc_version(RPC_GET_CURRENT_BLOCK_HASH) try: response = HttpRequest.request("post", self.addr, payload) except requests.exceptions.ConnectTimeout: raise SDKException(ErrorCode.other_error(''.join(['ConnectTimeout: ', self.addr]))) except requests.exceptions.ConnectionError: raise SDKException(ErrorCode.other_error(''.join(['ConnectionError: ', self.addr]))) res = json.loads(response.content.decode())["result"] return res
def get_block_by_height(self, height: int) -> dict: """ This interface is used to get the block information by block height in current network. Return: the decimal total number of blocks in current network. """ payload = RpcClient.set_json_rpc_version(RPC_GET_BLOCK, [height, 1]) try: response = HttpRequest.request("post", self.addr, payload) except requests.exceptions.ConnectTimeout: raise SDKException(ErrorCode.other_error(''.join(['ConnectTimeout: ', self.addr]))) except requests.exceptions.ConnectionError: raise SDKException(ErrorCode.other_error(''.join(['ConnectionError: ', self.addr]))) block = json.loads(response.content.decode())["result"] return block
def get_network_id(self) -> int: """ This interface is used to get the network id of current network. Return: the network id of current network. """ payload = RpcClient.set_json_rpc_version(RPC_GET_NETWORK_ID, []) try: response = HttpRequest.request("post", self.addr, payload) except requests.exceptions.ConnectTimeout: raise SDKException(ErrorCode.other_error(''.join(['ConnectTimeout: ', self.addr]))) except requests.exceptions.ConnectionError: raise SDKException(ErrorCode.other_error(''.join(['ConnectionError: ', self.addr]))) id = json.loads(response.content.decode())["result"] return id
def get_version(self) -> str: """ This interface is used to get the version information of the connected node in current network. Return: the version information of the connected node. """ payload = RpcClient.set_json_rpc_version(RPC_GET_VERSION, []) try: response = HttpRequest.request("post", self.addr, payload) except requests.exceptions.ConnectTimeout: raise SDKException(ErrorCode.other_error(''.join(['ConnectTimeout: ', self.addr]))) except requests.exceptions.ConnectionError: raise SDKException(ErrorCode.other_error(''.join(['ConnectionError: ', self.addr]))) version = json.loads(response.content.decode())["result"] return version
def send_approve(self, asset, sender: Account, b58_recv_address: str, amount: int, payer: Account, gas_limit: int, gas_price: int) -> str: """ This is an interface used to send an approve transaction which allow receiver to spend a amount of ONT or ONG asset in sender's account. :param asset: a string which is used to indicate what asset we want to approve. :param sender: an Account class that send the approve transaction. :param b58_recv_address: a base58 encode address which indicate where the approve to. :param amount: the amount of asset want to approve. :param payer: an Account class that used to pay for the transaction. :param gas_limit: an int value that indicate the gas limit. :param gas_price: an int value that indicate the gas price. :return: hexadecimal transaction hash value. """ if sender is None: raise SDKException( ErrorCode.param_err('the sender should not be None.')) if payer is None: raise SDKException( ErrorCode.param_err('the payer should not be None.')) if amount <= 0: raise SDKException( ErrorCode.other_error( 'the amount should be greater than than zero.')) if gas_price < 0: raise SDKException( ErrorCode.other_error( 'the gas price should be equal or greater than zero.')) if gas_limit < 0: raise SDKException( ErrorCode.other_error( 'the gas limit should be equal or greater than zero.')) b58_sender_address = sender.get_address_base58() b58_payer_address = payer.get_address_base58() tx = Asset.new_approve_transaction(asset, b58_sender_address, b58_recv_address, amount, b58_payer_address, gas_limit, gas_price) tx = self.__sdk.sign_transaction(tx, sender) if sender.get_address_base58() != payer.get_address_base58(): tx = self.__sdk.add_sign_transaction(tx, payer) self.__sdk.rpc.send_raw_transaction(tx) return tx.hash256_explorer()
def send_withdraw_ong_transaction(self, claimer: Account, b58_recv_address: str, amount: int, payer: Account, gas_limit: int, gas_price: int) -> str: """ This interface is used to withdraw a amount of ong and transfer them to receive address. :param claimer: the owner of ong that remained to claim. :param b58_recv_address: the address that received the ong. :param amount: the amount of ong want to claim. :param payer: an Account class that used to pay for the transaction. :param gas_limit: an int value that indicate the gas limit. :param gas_price: an int value that indicate the gas price. :return: hexadecimal transaction hash value. """ if claimer is None: raise SDKException( ErrorCode.param_err('the claimer should not be None.')) if payer is None: raise SDKException( ErrorCode.param_err('the payer should not be None.')) if amount <= 0: raise SDKException( ErrorCode.other_error( 'the amount should be greater than than zero.')) if gas_price < 0: raise SDKException( ErrorCode.other_error( 'the gas price should be equal or greater than zero.')) if gas_limit < 0: raise SDKException( ErrorCode.other_error( 'the gas limit should be equal or greater than zero.')) b58_claimer = claimer.get_address_base58() b58_payer = payer.get_address_base58() tx = Asset.new_withdraw_ong_transaction(b58_claimer, b58_recv_address, amount, b58_payer, gas_limit, gas_price) tx = self.__sdk.sign_transaction(tx, claimer) if claimer.get_address_base58() != payer.get_address_base58(): tx = self.__sdk.add_sign_transaction(tx, payer) self.__sdk.rpc.send_raw_transaction(tx) return tx.hash256_explorer()
def send_raw_transaction(self, tx: Transaction) -> str: """ This interface is used to send the transaction into the network. Args: tx (Transaction): Transaction object in ontology Python SDK. Return: a hexadecimal transaction hash value. """ buf = tx.serialize() tx_data = buf.hex() rpc_struct = RpcClient.set_json_rpc_version(RPC_SEND_TRANSACTION, [tx_data]) r = HttpRequest.request("post", self.addr, rpc_struct) data = json.loads(r.content.decode()) res = data["result"] if data["error"] != 0: raise SDKException(ErrorCode.other_error(res)) return res
def __init__(self, name: str = "MyWallet", version: str = "1.1", create_time: str = "", default_id: str = "", default_address="", scrypt: Scrypt = None, identities: list = None, accounts: list = None): if scrypt is None: scrypt = Scrypt() if not isinstance(scrypt, Scrypt): raise SDKException( ErrorCode.other_error('Wallet Data init failed')) if identities is None: identities = list() if accounts is None: accounts = list() self.name = name self.version = version self.create_time = create_time self.default_ont_id = default_id self.default_account_address = default_address self.scrypt = scrypt self.identities = list() self.accounts = list() for index in range(len(identities)): dict_identity = identities[index] if isinstance(dict_identity, dict): list_controls = list() try: try: is_default = dict_identity['isDefault'] except Exception as e: is_default = False for control_data in dict_identity['controls']: list_controls.append(Control.dict2obj(control_data)) identity = Identity(ont_id=dict_identity['ontid'], label=dict_identity['label'], lock=dict_identity['lock'], controls=list_controls, is_default=is_default) except KeyError: raise SDKException(ErrorCode.param_error) self.identities.append(identity) else: self.identities = identities break for index in range(len(accounts)): dict_account = accounts[index] if isinstance(dict_account, dict): try: public_key = dict_account['publicKey'] except KeyError: public_key = '' try: acct = AccountData( address=dict_account['address'], enc_alg=dict_account['enc-alg'], key=dict_account['key'], algorithm=dict_account['algorithm'], salt=dict_account['salt'], param=dict_account['parameters'], label=dict_account['label'], public_key=public_key, sign_scheme=dict_account['signatureScheme'], is_default=dict_account['isDefault'], lock=dict_account['lock']) except KeyError: raise SDKException(ErrorCode.param_error) self.accounts.append(acct) else: self.accounts = accounts break