def to_bytes_address(hex_address: str) -> bytes: try: bytes_address = bytes.fromhex(hex_address) except ValueError as e: raise SDKException(ErrorCode.other_error(e.args[0])) address = Address(bytes_address) return address.to_bytes()
def new_transfer_multi_tx(self, transfer_list: list, payer: Union[str, bytes, Address], gas_price: int, gas_limit: int) -> InvokeTransaction: """ This interface is used to generate a transaction which can transfer amount of token from from-account to to-account multiple times. """ func = NeoInvokeFunction('transferMulti') for index, item in enumerate(transfer_list): if not isinstance(item[2], int): raise SDKException( ErrorCode.param_err( 'the data type of value should be int.')) if item[2] < 0: raise SDKException( ErrorCode.param_err( 'the value should be equal or great than 0.')) transfer_list[index] = [ Address.b58decode(item[0]), Address.b58decode(item[1]), item[2] ] for item in transfer_list: func.add_params_value(item) params = InvokeTransaction.generate_neo_vm_invoke_code( self._contract_address, func) tx = InvokeTransaction(payer, gas_price, gas_limit, params) return tx
def new_revoke_tx(self, claim_id: str, issuer: Union[str, bytes, Address], payer: Union[str, bytes, Address], gas_price: int, gas_limit: int): func = NeoInvokeFunction('Revoke') func.set_params_value(claim_id, Address.b58decode(issuer)) tx = InvokeTransaction(Address.b58decode(payer), gas_price, gas_limit) tx.add_invoke_code(self.__hex_contract_address, func) return tx
def new_allowance_tx(self, from_address: Union[str, Address], to_address: Union[str, Address]) -> InvokeTransaction: args = dict(from_address=Address.b58decode(from_address), to_address=Address.b58decode(to_address)) invoke_code = build_native_invoke_code(self._invoke_address, self._version, 'allowance', args) return InvokeTransaction(payload=invoke_code)
def test_b58decode(self): length = 20 rand_code = utils.get_random_bytes(length) address = Address(rand_code) b58_address = address.b58encode() zero = Address.b58decode(b58_address).to_bytes() self.assertEqual(rand_code, zero) decode_address = Address.b58decode(b58_address).to_bytes() self.assertEqual(rand_code, decode_address)
def new_allowance_tx( self, owner: Union[str, bytes, Address], spender: Union[str, bytes, Address]) -> InvokeTransaction: func = NeoInvokeFunction('allowance') func.set_params_value(Address.b58decode(owner), Address.b58decode(spender)) tx = InvokeTransaction() tx.add_invoke_code(self._contract_address, func) return tx
def new_commit_tx(self, claim_id: str, issuer_address: Union[str, bytes, Address], owner_ont_id: str, payer_address: Union[str, bytes, Address], gas_price: int, gas_limit: int) -> InvokeTransaction: func = NeoInvokeFunction('Commit') func.set_params_value(claim_id, Address.b58decode(issuer_address), owner_ont_id) tx = InvokeTransaction(Address.b58decode(payer_address), gas_price, gas_limit) tx.add_invoke_code(self.__hex_contract_address, func) return tx
def new_transfer_tx(self, from_address: Union[str, Address], to_address: Union[str, Address], amount: int, payer: Union[str, Address], gas_price: int, gas_limit: int) -> InvokeTransaction: """ This interface is used to generate a transaction which can transfer amount of tokens to to_address. """ func = NeoInvokeFunction('transfer') func.set_params_value(Address.b58decode(from_address), Address.b58decode(to_address), amount) params = InvokeTransaction.generate_neo_vm_invoke_code( self._contract_address, func) tx = InvokeTransaction(payer, gas_price, gas_limit, params) return tx
def new_change_recovery_tx(self, did: str, b58_new_recovery_address: str, b58_recovery_address: str, payer: Union[str, bytes, Address], gas_price: int, gas_limit: int) -> InvokeTransaction: bytes_new_recovery = Address.b58decode( b58_new_recovery_address).to_bytes() bytes_recovery = Address.b58decode(b58_recovery_address).to_bytes() args = dict(did=did.encode('utf-8'), new_recovery=bytes_new_recovery, recovery=bytes_recovery) tx = self._generate_transaction('changeRecovery', args, payer, gas_price, gas_limit) return tx
def new_transfer_from_tx(self, spender: Union[str, bytes, Address], owner: Union[str, bytes, Address], to_address: Union[str, bytes, Address], value: int, payer: Union[str, bytes, Address], gas_price: int, gas_limit: int) -> InvokeTransaction: func = NeoInvokeFunction('transferFrom') if not isinstance(value, int): raise SDKException( ErrorCode.param_err('the data type of value should be int.')) func.set_params_value(Address.b58decode(spender), Address.b58decode(owner), Address.b58decode(to_address), value) tx = InvokeTransaction(payer, gas_price, gas_limit) tx.add_invoke_code(self._contract_address, func) return tx
def new_balance_of_tx(self, owner: Union[str, Address]) -> InvokeTransaction: owner = Address.b58decode(owner) invoke_code = build_native_invoke_code(self._invoke_address, self._version, 'balanceOf', owner) return InvokeTransaction(payload=invoke_code)
def create_account_info(self, label: str, pwd: str, salt: str, private_key: str) -> AccountInfo: acct = self.__create_account(label, pwd, salt, private_key, True) info = AccountInfo() info.address_base58 = Address.from_public_key(acct.get_public_key_bytes()).b58encode() info.public_key = acct.get_public_key_bytes().hex() info.encrypted_pri_key = acct.export_gcm_encrypted_private_key(pwd, salt) info.address_u160 = acct.get_address().to_bytes().hex() info.salt = salt return info
def new_transfer_from_tx(self, spender: Union[str, Address], from_address: Union[str, Address], receiver: Union[str, Address], amount: int, payer: Union[str, Address], gas_price: int, gas_limit: int) -> InvokeTransaction: """ This interface is used to generate a Transaction object 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. """ args = dict(spender=Address.b58decode(spender), from_address=Address.b58decode(from_address), to_address=Address.b58decode(receiver), amount=amount) invoke_code = build_native_invoke_code(self._invoke_address, self._version, 'transferFrom', args) return InvokeTransaction(Address.b58decode(payer), gas_price, gas_limit, invoke_code)
async def test_get_balance(self): pub_keys = [acct1.get_public_key_bytes(), acct2.get_public_key_bytes(), acct3.get_public_key_bytes()] multi_address = Address.from_multi_pub_keys(2, pub_keys) address_list = [acct1.get_address_base58(), acct2.get_address_base58(), acct3.get_address_base58(), acct4.get_address_base58(), multi_address.b58encode()] for address in address_list: balance = await sdk.websocket.get_balance(address) self.assertTrue(isinstance(balance, dict)) self.assertGreaterEqual(balance['ONT'], 0) self.assertGreaterEqual(balance['ONG'], 0)
async def unbound(self, address: Union[str, Address]) -> int: """ This interface is used to query the amount of account's unbound ong. """ ont_contract = b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01' if isinstance(address, Address): address = address.b58encode() return int(await self._sdk.default_aio_network.get_allowance( 'ong', Address(ont_contract).b58encode(), address))
def new_approve_tx(self, approver: Union[str, Address], spender: Union[str, Address], amount: int, payer: Union[str, Address], gas_price: int, gas_limit: int) -> Transaction: """ This interface is used to generate a Transaction object for approve. """ if amount <= 0: raise SDKException( ErrorCode.other_error( 'the amount should be greater than than zero.')) args = dict(sender=Address.b58decode(approver), receiver=Address.b58decode(spender), amount=amount) invoke_code = build_native_invoke_code(self._invoke_address, self._version, 'approve', args) return InvokeTransaction(Address.b58decode(payer), gas_price, gas_limit, invoke_code)
def new_balance_of_tx( self, owner: Union[str, bytes, Address]) -> InvokeTransaction: """ This interface is used to generate transaction which can get the account balance of another account with owner address. """ func = NeoInvokeFunction('balanceOf') func.set_params_value(Address.b58decode(owner)) tx = InvokeTransaction() tx.add_invoke_code(self._contract_address, func) return tx
def test_balance_of_transaction(self): func = WasmInvokeFunction('balanceOf') func.set_params_value(Address.b58decode('ANDfjwrUroaVtvBguDtrWKRMyxFwvVwnZD')) tx = sdk.wasm_vm.make_invoke_transaction(self.oep4_contract_address, func, acct4.get_address(), self.gas_price, self.gas_limit) target_payload = '0faeff23255536928b308e5caa38bc2dc14f30c31e0962616c6' \ '16e63654f6646b1a18af6b7c9f8a4602f9f73eeb3030f0c29b7' self.assertEqual(target_payload, tx.payload.hex()) tx.sign_transaction(acct4) result = sdk.rpc.send_raw_transaction_pre_exec(tx) self.assertGreaterEqual(WasmData.to_int(result.get('Result')), 0)
def test_from_hd_pubkey(self): hd_pub_key = HDPublicKey.b58decode(self.bip32_pubkey) address = Address.from_hd_public_key(hd_pub_key) self.assertEqual('AW8Tf5R4kyURy6LQ8Th181Z5GpTovWGLg6', address.b58encode()) child_address_lst = [ 'ARXRQog4iZazp5YfXRyDZvU6ahrt3c2bb7', 'APXh8MqcARUgafqvUNnpECzwKDtipkf3Zr', 'ASpmd1MpFSpQ5rhicjRDqBpE1inP3Z7tus', 'APA3M4BRqjBsHXRkeTFiFVb4X1u8FiEgAr', 'AKq5SBTCzHBaqWWDUTGvekbsNJKKtf4ff5', 'APzMnHqrGF1cGZyAdFCwEL29TnAgCuBrY6', 'AJ8LEkLGeNsWvVrP7SgK9szoZ1MGgUTq1s', 'AJo49LSK6rQEwc6qTYMsAZmvLPRrb6qcWa', 'AYzCcNY3PwV432iXVREpDHvpX166KN45xP', 'AbL1wvGCnbzywHBuX1VwQev8xuhJxbPE4P' ] for index, child_address in enumerate(child_address_lst): child_pks = HDPublicKey.from_path(hd_pub_key, f'0/{index}') address = Address.from_hd_public_key(child_pks[-1]) self.assertEqual(child_address, address.b58encode())
def new_transfer_tx(self, from_address: Union[str, Address], to_address: Union[str, Address], amount: int, payer: Union[str, Address], gas_price: int, gas_limit: int) -> Transaction: """ This interface is used to generate a Transaction object for transfer. """ if amount <= 0: raise SDKException( ErrorCode.other_error( 'the amount should be greater than than zero.')) state = [{ 'from': Address.b58decode(from_address), 'to': Address.b58decode(to_address), 'amount': amount }] invoke_code = build_native_invoke_code(self._invoke_address, self._version, 'transfer', state) return InvokeTransaction(Address.b58decode(payer), gas_price, gas_limit, invoke_code)
def ensure_bytes_address(*objs: str or bytes or Account): result = list() for obj in objs: if isinstance(obj, bytes): result.append(obj) elif isinstance(obj, str): result.append(Address.b58decode(obj).to_bytes()) elif isinstance(obj, Account): result.append(obj.get_address_bytes()) else: raise SDKException(ErrorCode.param_error) return tuple(result)
def setUp(self): pub_keys = [ acct1.get_public_key_bytes(), acct2.get_public_key_bytes(), acct3.get_public_key_bytes() ] multi_address = Address.from_multi_pub_keys(2, pub_keys) self.address_list = [ acct1.get_address_base58(), acct2.get_address_base58(), acct3.get_address_base58(), acct4.get_address_base58(), multi_address.b58encode() ]
def __iter__(self): data = dict() data['version'] = self.version data['txType'] = self.tx_type data['nonce'] = self.nonce data['gasPrice'] = self.gas_price data['gasLimit'] = self.gas_limit data['payer'] = Address(self.payer).b58encode() data['payload'] = binascii.b2a_hex(self.payload) data['attributes'] = binascii.b2a_hex(self.attributes) data['sigs'] = list() for sig in self.sig_list: data['sigs'].append(dict(sig)) for key, value in data.items(): yield (key, value)
def new_approve_tx(self, owner: Union[str, bytes, Address], spender: Union[str, bytes, Address], amount: int, payer: Union[str, bytes, Address], gas_price: int, gas_limit: int) -> InvokeTransaction: """ This interface is used to generate a transaction which allows spender to withdraw from owner account multiple times, up to the _value amount. If this function is called again it overwrites the current allowance with amount value. """ if not isinstance(amount, int): raise SDKException( ErrorCode.param_err('the data type of amount should be int.')) if amount < 0: raise SDKException( ErrorCode.param_err( 'the amount should be equal or great than 0.')) func = NeoInvokeFunction('approve') func.set_params_value(Address.b58decode(owner), Address.b58decode(spender), amount) params = InvokeTransaction.generate_neo_vm_invoke_code( self._contract_address, func) tx = InvokeTransaction(payer, gas_price, gas_limit, params) return tx
def parse_ddo(did: 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 did: 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 = DID.parse_pub_keys(did, public_key_bytes) attribute_list = DID.parse_attributes(attribute_bytes) ddo = dict(Owners=pub_keys, Attributes=attribute_list, Recovery=b58_recovery, DID=did) return ddo
def test_transfer_tx(self): amount = 100 func = WasmInvokeFunction('transfer') func.set_params_value(acct1.get_address(), Address.b58decode('AazEvfQPcQ2GEFFPLF1ZLwQ7K5jDn81hve'), amount) tx = sdk.wasm_vm.make_invoke_transaction(self.oep4_contract_address, func, acct2.get_address(), self.gas_price, self.gas_limit) target_payload = '0faeff23255536928b308e5caa38bc2dc14f30c341087472616e7366657246b1a18af6b7c9f8a4602f9f73' \ 'eeb3030f0c29b7d2c124dd088190f709b684e0bc676d70c41b377664000000000000000000000000000000' self.assertEqual(target_payload, tx.payload.hex()) tx.sign_transaction(acct1, acct2) result = sdk.rpc.send_raw_transaction_pre_exec(tx) self.assertEqual('01', result.get('Result')) self.assertEqual(1, result.get('State')) notify_list = Event.get_event_from_event_list_by_contract_address(result.get('Notify'), self.oep4_contract_address) self.assertEqual(self.oep4_contract_address, notify_list[0].get('ContractAddress')) states = notify_list[1].get('States') self.assertEqual('transfer', WasmData.to_utf8(states[0])) self.assertEqual(acct1.get_address().b58encode(), WasmData.to_b58_address(states[1])) self.assertEqual('AazEvfQPcQ2GEFFPLF1ZLwQ7K5jDn81hve', WasmData.to_b58_address(states[2])) self.assertEqual(amount, WasmData.to_int(states[3]))
def __init__(self, version=0, tx_type: TxType or int = None, gas_price: int = 0, gas_limit: int = 0, payer: Union[str, bytes, Address, None] = b'', payload: bytearray = bytearray(), nonce: int = None, attributes: bytearray = bytearray(), sig_list: List[Sig] = None): 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.')) self.version = version if isinstance(tx_type, int): tx_type = TxType(tx_type) if tx_type is not None: self.tx_type = tx_type.value if not nonce: nonce = randint(0, 0xFFFFFFFF) self.nonce = nonce self.gas_price = gas_price self.gas_limit = gas_limit if not payer: payer = b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' if isinstance(payer, str): payer = Address.b58decode(payer).to_bytes() if isinstance(payer, Address): payer = payer.to_bytes() self.payer = payer self.payload = payload self.attributes = attributes if not sig_list: sig_list = list() self.sig_list = sig_list
def test_add_multi_sign_transaction(self): pub_keys = [ acct1.get_public_key_bytes(), acct2.get_public_key_bytes(), acct3.get_public_key_bytes() ] m = 2 b58_multi_address = Address.from_multi_pub_keys(m, pub_keys).b58encode() amount = 1 gas_price = 500 gas_limit = 20000 tx_hash = sdk.native_vm.ont().transfer(acct2, b58_multi_address, amount, acct2, gas_price, gas_limit) self.assertEqual(64, len(tx_hash)) tx_hash = sdk.native_vm.ong().transfer(acct2, b58_multi_address, amount, acct2, gas_price, gas_limit) self.assertEqual(64, len(tx_hash)) b58_acct1_address = acct1.get_address_base58() b58_acct2_address = acct2.get_address_base58() self.assertEqual('ATyGGJBnANKFbf2tQMp4muUEZK7KuZ52k4', b58_multi_address) tx = sdk.native_vm.ong().new_transfer_tx(b58_acct1_address, b58_multi_address, amount, b58_acct1_address, gas_price, gas_limit) tx.add_sign_transaction(acct1) tx = sdk.native_vm.ont().new_transfer_tx(b58_multi_address, b58_acct2_address, amount, b58_acct1_address, gas_price, gas_limit) tx.sign_transaction(acct1) tx.add_multi_sign_transaction(m, pub_keys, acct1) tx.add_multi_sign_transaction(m, pub_keys, acct2) tx_hash = sdk.rpc.send_raw_transaction(tx) self.assertEqual(64, len(tx_hash))
def test_push_address(self): b58_address_list = [ 'AS7MjVEicEsJ4zjEfm2LoKoYoFsmapD7rT', 'AFmseVrdL9f9oyCzZefL9tG6UbviEH9ugK', 'AS3SCXw8GKTEeXpdwVw7EcC4rqSebFYpfb', 'AJkkLbouowk6teTaxz1F2DYKfJh24PVk3r', 'Ad4pjz2bqep4RhQrUAzMuZJkBC3qJ1tZuT', 'AK98G45DhmPXg4TFPG1KjftvkEaHbU8SHM' ] wasm_address_list = [ '71609b2c2f7b9447b089ad1da31586f42ca9eb10', '0000000000000000000000000000000000000007', '70a2ababdae0a9d1f9fc7296df3c6d343b772cf7', '20b1dc499cdf56ba70a574a1e17ac986d1f06ec2', 'e98f4998d837fcdd44a50561f7f32140c7c6c260', '24ed4f965d3a5a76f5d0e87633c0b76941fc8827' ] for index, b58_address in enumerate(b58_address_list): self.builder.push_address(Address.b58decode(b58_address)) self.assertEqual(wasm_address_list[index], self.builder.to_bytes().hex()) self.builder.clear_up()
def __init__(self, private_key: str or bytes, scheme=SignatureScheme.SHA256withECDSA): self.__signature_scheme = scheme if scheme == SignatureScheme.SHA256withECDSA: self.__key_type = KeyType.ECDSA elif scheme == SignatureScheme.SHA3_384withECDSA: self.__key_type = KeyType.ECDSA elif scheme == SignatureScheme.SHA3_384withECDSA: self.__key_type = KeyType.ECDSA elif scheme == SignatureScheme.SHA512withECDSA: self.__key_type = KeyType.ECDSA elif scheme == SignatureScheme.SHA3_224withECDSA: self.__key_type = KeyType.ECDSA else: raise TypeError if isinstance(private_key, bytes) and len(private_key) == 32: self.__private_key = private_key elif isinstance(private_key, str) and len(private_key) == 64: self.__private_key = bytes.fromhex(private_key) else: raise SDKException(ErrorCode.invalid_private_key) self.__curve_name = Curve.P256 self.__public_key = Signature.ec_get_public_key_by_private_key(self.__private_key, self.__curve_name) self.__address = Address.from_public_key(self.__public_key)