def register_candidate(self, account: Account, peer_pubkey: str, init_pos: int, identity: Identity, password: str, key_no: int, payer: Account, gas_limit: int, gas_price: int): contract_address = bytearray.fromhex(self.CONTRACT_ADDRESS) param = { "peer_pubkey": peer_pubkey, "address": account.get_address().to_array(), "init_pos": init_pos, "ontid": identity.ont_id.encode(), "key_no": key_no } invoke_code = build_native_invoke_code(contract_address, bytes([0]), "registerCandidate", param) unix_time_now = int(time()) tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit, payer.get_address().to_array(), invoke_code, bytearray(), [], bytearray()) self.__sdk.sign_transaction(tx, account) ontid_acc = self.__sdk.wallet_manager.get_account( identity.ont_id, password) self.__sdk.add_sign_transaction(tx, ontid_acc) if account.get_address_base58() is not payer: self.__sdk.add_sign_transaction(tx, payer) res = self.__sdk.rpc.send_raw_transaction(tx) return tx.hash256_explorer()
def unauthorize_for_peer(self, account: Account, peer_publickeys: [], pos_lists: [], payer: Account, gas_limit: int, gas_price: int): contract_address = bytearray.fromhex(self.CONTRACT_ADDRESS) if len(peer_publickeys) != len(pos_lists): raise Exception( "the length of peer_publickeys should equal the length of pos_lists" ) param = { "address": account.get_address().to_bytes(), "publickeys_length": len(peer_publickeys) } for i in range(len(peer_publickeys)): param["publickey" + str(i)] = peer_publickeys[i] param["pos_lists_length"] = len(pos_lists) for i in range(len(pos_lists)): param["pos_lists" + str(i)] = pos_lists[i] invoke_code = build_native_invoke_code(contract_address, b'\x00', "unAuthorizeForPeer", param) unix_time_now = int(time()) tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit, payer.get_address().to_bytes(), invoke_code, bytearray(), []) tx.sign_transaction(account) if payer is not None and account.get_address_base58( ) is not payer.get_address_base58(): tx.add_sign_transaction(payer) return self.__sdk.get_network().send_raw_transaction(tx)
def revoke(self, claim_id: str, issuer: Account, payer: Account, gas_price: int, gas_limit: int): tx = self.new_revoke_tx(claim_id, issuer.get_address(), payer.get_address(), gas_price, gas_limit) tx.sign_transaction(issuer) if issuer.get_address_bytes() != payer.get_address_bytes(): tx.add_sign_transaction(payer) tx_hash = self._sdk.default_network.send_raw_transaction(tx) return tx_hash
def get_item_list_from_contract(identity_acct: Account) -> list: sdk = app.config['ONTOLOGY'] if not isinstance(sdk, Ontology): return list() get_item_list_func = WasmInvokeFunction('get_item_list') get_item_list_func.set_params_value(identity_acct.get_address()) tx = sdk.wasm_vm.make_invoke_transaction( app.config['CONTRACT_ADDRESS_HEX'], get_item_list_func, identity_acct.get_address(), app.config['GAS_PRICE'], app.config['GAS_LIMIT']) tx.sign_transaction(identity_acct) response = sdk.rpc.send_raw_transaction_pre_exec(tx) if not isinstance(response, dict): return list() result = response.get('Result') if result is None: return list() builder = WasmParamsBuilder(bytes.fromhex(result)) struct_len = builder.read_var_uint() album_list = list() for _ in range(struct_len): try: encrypted_ipfs_address_bytes = bytes.fromhex(builder.pop_str()) ext = builder.pop_str() aes_iv = bytes.fromhex(builder.pop_str()) encode_g_tilde = bytes.fromhex(builder.pop_str()) ipfs_address = ECIES.decrypt_with_cbc_mode( encrypted_ipfs_address_bytes, identity_acct.get_private_key_bytes(), aes_iv, encode_g_tilde) album_list.append([ipfs_address.decode('ascii'), ext]) except Exception as e: print('Decrypt with cbc mode failed: ', e.args[0]) return album_list
def withdraw(self, account: Account, peer_publickeys: list, withdraw_list: list, payer: Account, gas_limit: int, gas_price: int): contract_address = bytearray.fromhex(self.CONTRACT_ADDRESS) if len(peer_publickeys) != len(withdraw_list): raise Exception( "the length of peer_publickeys should equal the length of pos_lists" ) param = { "address": account.get_address().to_array(), "publickeys_length": len(peer_publickeys) } for i in range(len(peer_publickeys)): param["publickey" + str(i)] = peer_publickeys[i] param["pos_lists_length"] = len(withdraw_list) for i in range(len(withdraw_list)): param["pos_lists" + str(i)] = withdraw_list[i] invoke_code = build_native_invoke_code(contract_address, bytes([0]), "withdraw", param) unix_time_now = int(time()) tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit, payer.get_address().to_array(), invoke_code, bytearray(), [], bytearray()) self.__sdk.sign_transaction(tx, account) if payer is not None and account.get_address_base58( ) is not payer.get_address_base58(): self.__sdk.add_sign_transaction(tx, payer) self.__sdk.rpc.send_raw_transaction(tx) return tx.hash256_explorer()
def withdraw_fee(self, account: Account, payer: Account, gas_limit: int, gas_price: int): contract_address = bytearray.fromhex(self.CONTRACT_ADDRESS) param = {"address": account.get_address().to_array()} invoke_code = build_native_invoke_code(contract_address, bytes([0]), "withdrawFee", param) unix_time_now = int(time()) tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit, payer.get_address().to_array(), invoke_code, bytearray(), [], bytearray()) self.__sdk.sign_transaction(tx, account) if payer is not None and account.get_address_base58() is not payer.get_address_base58(): self.__sdk.add_sign_transaction(tx, payer) self.__sdk.rpc.send_raw_transaction(tx) return tx.hash256_explorer()
def transfer(self, from_acct: Account, to_address: Union[str, Address], amount: int, payer: Account, gas_price: int, gas_limit: int): """ This interface is used to send a transfer transaction that only for ONT or ONG. """ tx = self.new_transfer_tx(from_acct.get_address(), to_address, amount, payer.get_address(), gas_price, gas_limit) tx.sign_transaction(from_acct) if from_acct.get_address_bytes() != payer.get_address_bytes(): tx.add_sign_transaction(payer) return self._sdk.default_network.send_raw_transaction(tx)
def transfer_from(self, spender_acct: Account, from_acct: Account, b58_to_address: str, value: int, payer_acct: Account, gas_limit: int, gas_price: int): """ This interface is used to call the Allowance method in ope4 that allow spender to withdraw amount of oep4 token from from-account to to-account. :param spender_acct: an Account class that spend the oep4 token. :param from_acct: an Account class that actually pay oep4 token for the spender's spending. :param b58_to_address: a base58 encode address that receive the oep4 token. :param value: the amount of ope4 token in this transaction. :param payer_acct: 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: the hexadecimal transaction hash value. """ func = self.__abi_info.get_function('TransferFrom') Oep4.__b58_address_check(b58_to_address) if not isinstance(from_acct, Account): raise SDKException( ErrorCode.param_err( 'the data type of from_acct should be Account.')) if not isinstance(spender_acct, Account): raise SDKException( ErrorCode.param_err( 'the data type of spender_acct should be Account.')) spender_address_array = spender_acct.get_address().to_array() from_address_array = from_acct.get_address().to_array() to_address_array = Address.b58decode(b58_to_address).to_array() if not isinstance(value, int): raise SDKException( ErrorCode.param_err('the data type of value should be int.')) params = (spender_address_array, from_address_array, to_address_array, value) func.set_params_value(params) params = BuildParams.serialize_abi_function(func) unix_time_now = int(time.time()) params.append(0x67) for i in self.__contract_address: params.append(i) if payer_acct is None: raise SDKException(ErrorCode.param_err('payer account is None.')) payer_address_array = payer_acct.get_address().to_array() tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit, payer_address_array, params, bytearray(), [], bytearray()) self.__sdk.sign_transaction(tx, payer_acct) if spender_acct.get_address_base58() != payer_acct.get_address_base58( ): self.__sdk.add_sign_transaction(tx, spender_acct) if from_acct.get_address_base58() != payer_acct.get_address_base58(): self.__sdk.add_sign_transaction(tx, payer_acct) tx_hash = self.__sdk.rpc.send_raw_transaction(tx) return tx_hash
def change_max_authorization(self, account: Account, peer_publickey: str, max_authorize: int, payer: Account, gas_limit: int, gas_price: int): contract_address = bytearray.fromhex(self.CONTRACT_ADDRESS) param = {"peer_publickey": peer_publickey, "address": account.get_address().to_array(), "maxAuthorize": max_authorize} invoke_code = build_native_invoke_code(contract_address, bytes([0]), "changeMaxAuthorization", param) unix_time_now = int(time()) tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit, payer.get_address().to_array(), invoke_code, bytearray(), [], bytearray()) self.__sdk.sign_transaction(tx, account) if payer is not None and account.get_address_base58() is not payer.get_address_base58(): self.__sdk.add_sign_transaction(tx, payer) self.__sdk.rpc.send_raw_transaction(tx) return tx.hash256_explorer()
def approve(self, owner: Account, spender: Union[str, bytes, Address], amount: int, payer: Account, gas_price: int, gas_limit: int) -> str: """ 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. """ tx = self.new_approve_tx(owner.get_address(), spender, amount, payer.get_address(), gas_price, gas_limit) tx.sign_transaction(owner) if owner.get_address_bytes() != payer.get_address_bytes(): tx.add_sign_transaction(payer) tx_hash = self._sdk.default_network.send_raw_transaction(tx) return tx_hash
def transfer(self, from_acct: Account, to_address: Union[str, Address], amount: int, payer: Account, gas_price: int, gas_limit: int) -> str: """ This interface is used to transfer amount of tokens to to_address synchronously. """ tx = self.new_transfer_tx(from_acct.get_address(), to_address, amount, payer.get_address(), gas_price, gas_limit) tx.sign_transaction(from_acct) if from_acct.get_address_bytes() != payer.get_address_bytes(): tx.add_sign_transaction(payer) tx_hash = self._sdk.default_network.send_raw_transaction(tx) return tx_hash
def test_send_raw_transaction_preexec(self): private_key = '75de8489fcb2dcaf2ef3cd607feffde18789de7da129b5e97c81e001793cb7cf' acct = Account(a2b_hex(private_key.encode())) private_key2 = get_random_bytes(32) acct2 = Account(private_key2) tx = Asset.new_transfer_transaction("ont", acct.get_address().to_base58(), acct2.get_address().to_base58(), 2, acct.get_address_base58(), 20000, 500) tx = sdk.sign_transaction(tx, acct) res = sdk.rpc.send_raw_transaction_preexec(tx) self.assertEqual(res, '01')
async def transfer_from(self, spender: Account, owner: Union[str, bytes, Address], to_address: Union[str, bytes, Address], value: int, payer: Account, gas_price: int, gas_limit: int) -> str: tx = self.new_transfer_from_tx(spender.get_address(), owner, to_address, value, payer.get_address(), gas_price, gas_limit) tx.sign_transaction(spender) if spender.get_address_bytes() != payer.get_address_bytes(): tx.add_sign_transaction(payer) tx_hash = await self._sdk.default_aio_network.send_raw_transaction(tx) return tx_hash
def withdraw_fee(self, account: Account, payer: Account, gas_limit: int, gas_price: int): contract_address = bytearray.fromhex(self.CONTRACT_ADDRESS) param = {"address": account.get_address().to_bytes()} invoke_code = build_native_invoke_code(contract_address, b'\x00', "withdrawFee", param) unix_time_now = int(time()) tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit, payer.get_address().to_bytes(), invoke_code, bytearray(), []) tx.sign_transaction(account) if payer is not None and account.get_address_base58( ) is not payer.get_address_base58(): tx.add_sign_transaction(payer) return self.__sdk.get_network().send_raw_transaction(tx)
def send_add_public_key_by_recovery(self, ont_id: str, recovery: Account, hex_new_public_key: str, payer: Account, gas_limit: int, gas_price: int): """ This interface is used to send a Transaction object which is used to add public key based on the recovery account. :param ont_id: ontid. :param recovery: an Account object which used a recovery account. :param hex_new_public_key: the new hexadecimal public key in the form of string. :param payer: an Account object 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 hexadecimal transaction hash value. """ b58_payer_address = payer.get_address_base58() hex_recovery_address = recovery.get_address().to_hex_str() tx = OntId.new_add_public_key_transaction(ont_id, hex_recovery_address, hex_new_public_key, b58_payer_address, gas_limit, gas_price) self.__sdk.sign_transaction(tx, recovery) self.__sdk.add_sign_transaction(tx, payer) tx_hash = self.__sdk.rpc.send_raw_transaction(tx) return tx_hash
def approve(self, owner_acct: Account, b58_spender_address: str, amount: int, payer_acct: Account, gas_limit: int, gas_price: int): """ This interface is used to call the Approve method in ope4 that allows spender to withdraw a certain amount of oep4 token from owner account multiple times. If this function is called again, it will overwrite the current allowance with new value. :param owner_acct: an Account class that indicate the owner. :param b58_spender_address: a base58 encode address that be allowed to spend the oep4 token in owner's account. :param amount: an int value that indicate the amount oep4 token that will be transferred in this transaction. :param payer_acct: 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: the hexadecimal transaction hash value. """ func = self.__abi_info.get_function('approve') 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.')) owner_address = owner_acct.get_address().to_array() Oep4.__b58_address_check(b58_spender_address) spender_address = Address.b58decode(b58_spender_address).to_array() params = (owner_address, spender_address, amount) func.set_params_value(params) tx_hash = self.__sdk.neo_vm().send_transaction(self.__contract_address, owner_acct, payer_acct, gas_limit, gas_price, func, False) return tx_hash
def withdraw(self, claimer: Account, receiver: Union[str, Address], amount: int, payer: Account, gas_price: int, gas_limit: int) -> str: """ This interface is used to withdraw a amount of ong and transfer them to receive address. """ if amount <= 0: raise SDKException( ErrorCode.other_error( 'the amount should be greater than than zero.')) tx = self.new_withdraw_tx(claimer.get_address(), receiver, amount, payer.get_address(), gas_price, gas_limit) tx.sign_transaction(claimer) if claimer.get_address_bytes() != payer.get_address_bytes(): tx.add_sign_transaction(payer) return self._sdk.default_network.send_raw_transaction(tx)
def transfer_from(self, spender: Account, owner: Union[str, bytes, Address], to_address: Union[str, bytes, Address], value: int, payer: Account, gas_price: int, gas_limit: int) -> str: """ Transfers value amount of tokens from address owner to address to_address, and MUST fire the Transfer event. """ tx = self.new_transfer_from_tx(spender.get_address(), owner, to_address, value, payer.get_address(), gas_price, gas_limit) tx.sign_transaction(spender) if spender.get_address_bytes() != payer.get_address_bytes(): tx.add_sign_transaction(payer) tx_hash = self._sdk.default_network.send_raw_transaction(tx) return tx_hash
def send_neo_vm_transaction(self, contract_address: str or bytes or bytearray, acct: Account, payer_acct: Account, gas_limit: int, gas_price: int, func: AbiFunction or InvokeFunction, pre_exec: bool, is_full: bool = False): if isinstance(func, AbiFunction): params = BuildParams.serialize_abi_function(func) elif isinstance(func, InvokeFunction): params = func.create_invoke_code() else: raise SDKException(ErrorCode.other_error('the type of func is error.')) if isinstance(contract_address, str) and len(contract_address) == 40: contract_address = bytearray(binascii.a2b_hex(contract_address)) contract_address.reverse() if pre_exec: if isinstance(contract_address, bytes): tx = NeoVm.make_invoke_transaction(bytearray(contract_address), bytearray(params), b'', 0, 0) elif isinstance(contract_address, bytearray): tx = NeoVm.make_invoke_transaction(contract_address, bytearray(params), b'', 0, 0) else: raise SDKException(ErrorCode.param_err('the data type of contract address is incorrect.')) if acct is not None: tx.sign_transaction(acct) return self.send_raw_transaction_pre_exec(tx, is_full) else: unix_time_now = int(time()) params.append(0x67) for i in contract_address: params.append(i) if payer_acct is None: raise SDKException(ErrorCode.param_err('payer account is None.')) tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit, payer_acct.get_address().to_bytes(), params, bytearray(), []) tx.sign_transaction(payer_acct) if isinstance(acct, Account) and acct.get_address_base58() != payer_acct.get_address_base58(): tx.add_sign_transaction(acct) return self.send_raw_transaction(tx, is_full)
def assign_funcs_to_role(self, admin_identity: Identity, password: str, key_no: int, contract_address: str, role: str, function_name: list, payer: Account, gas_limit: int, gas_price: int): contract_address = bytearray.fromhex(contract_address) param = { "contract_address": contract_address, "ontid": admin_identity.ont_id.encode('utf-8'), "role": role.encode('utf-8') } param['length'] = len(function_name) for i in range(len(function_name)): param['name' + str(i)] = function_name[i] param['key_no'] = key_no invoke_code = build_native_invoke_code( bytearray.fromhex(self.contract_address), bytes([0]), "assignFuncsToRole", param) unix_time_now = int(time()) tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit, payer.get_address().to_array(), invoke_code, bytearray(), [], bytearray()) account = self.__sdk.wallet_manager.get_account( admin_identity.ont_id, password) self.__sdk.sign_transaction(tx, account) self.__sdk.add_sign_transaction(tx, payer) res = self.__sdk.rpc.send_raw_transaction(tx) return res
def delegate(self, identity: Identity, password: str, key_no: int, contract_address: str, to_ont_id: str, role: str, period: int, level: int, payer: Account, gas_limit: int, gas_price: int): contract_address = bytearray.fromhex(contract_address) param = { "contract_address": contract_address, "ont_id": identity.ont_id.encode('utf-8'), "to_ont_id": to_ont_id.encode('utf-8'), "role": role.encode('utf-8'), "period": period, "level": level, "key_no": key_no } invoke_code = build_native_invoke_code( bytearray.fromhex(self.contract_address), bytes([0]), "delegate", param) unix_time_now = int(time()) tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit, payer.get_address().to_array(), invoke_code, bytearray(), [], bytearray()) account = self.__sdk.wallet_manager.get_account( identity.ont_id, password) self.__sdk.sign_transaction(tx, account) self.__sdk.add_sign_transaction(tx, payer) res = self.__sdk.rpc.send_raw_transaction(tx) return res
def send_transaction(self, contract_address: bytearray, acct: Account, payer_acct: Account, gas_limit: int, gas_price: int, func: AbiFunction, pre_exec: bool): params = bytearray() if func is not None: params = BuildParams.serialize_abi_function(func) if pre_exec: tx = NeoVm.make_invoke_transaction(bytearray(contract_address), bytearray(params), b'', 0, 0) if acct is not None: self.__sdk.sign_transaction(tx, acct) return self.__sdk.rpc.send_raw_transaction_pre_exec(tx) unix_time_now = int(time()) params.append(0x67) for i in contract_address: params.append(i) tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit, payer_acct.get_address().to_array(), params, bytearray(), [], bytearray()) if acct is not None: self.__sdk.sign_transaction(tx, acct) if payer_acct is not None and acct is not None and acct.get_address_base58( ) != payer_acct.get_address_base58(): self.__sdk.add_sign_transaction(tx, payer_acct) return self.__sdk.rpc.send_raw_transaction(tx)
def transfer(self, from_acct: Account, b58_to_address: str, value: int, payer_acct: Account, gas_limit: int, gas_price: int) -> str: """ This interface is used to call the Transfer method in ope4 that transfer an amount of tokens from one account to another account. :param from_acct: an Account class that send the oep4 token. :param b58_to_address: a base58 encode address that receive the oep4 token. :param value: an int value that indicate the amount oep4 token that will be transferred in this transaction. :param payer_acct: 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: the hexadecimal transaction hash value. """ func = InvokeFunction('transfer') if not isinstance(value, int): raise SDKException( ErrorCode.param_err('the data type of value should be int.')) if value < 0: raise SDKException( ErrorCode.param_err( 'the value should be equal or great than 0.')) if not isinstance(from_acct, Account): raise SDKException( ErrorCode.param_err( 'the data type of from_acct should be Account.')) Oep4.__b58_address_check(b58_to_address) from_address = from_acct.get_address().to_bytes() to_address = Address.b58decode(b58_to_address).to_bytes() func.set_params_value(from_address, to_address, value) tx_hash = self.__sdk.get_network().send_neo_vm_transaction( self.__hex_contract_address, from_acct, payer_acct, gas_limit, gas_price, func, False) return tx_hash
def send_transaction(self, contract_address: bytes or bytearray, acct: Account, payer_acct: Account, gas_limit: int, gas_price: int, func: AbiFunction, pre_exec: bool): if func is not None: params = BuildParams.serialize_abi_function(func) else: params = bytearray() if pre_exec: if isinstance(contract_address, bytes): tx = NeoVm.make_invoke_transaction(bytearray(contract_address), bytearray(params), b'', 0, 0) elif isinstance(contract_address, bytearray): tx = NeoVm.make_invoke_transaction(contract_address, bytearray(params), b'', 0, 0) else: raise SDKException(ErrorCode.param_err('the data type of contract address is incorrect.')) if acct is not None: self.__sdk.sign_transaction(tx, acct) return self.__sdk.rpc.send_raw_transaction_pre_exec(tx) else: unix_time_now = int(time()) params.append(0x67) for i in contract_address: params.append(i) if payer_acct is None: raise SDKException(ErrorCode.param_err('payer account is None.')) tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit, payer_acct.get_address().to_array(), params, bytearray(), [], bytearray()) self.__sdk.sign_transaction(tx, acct) if acct.get_address_base58() != payer_acct.get_address_base58(): self.__sdk.add_sign_transaction(tx, payer_acct) return self.__sdk.rpc.send_raw_transaction(tx)
async def init(self, founder: Account, payer: Account, gas_price: int, gas_limit: int): tx = self.new_init_tx(payer.get_address(), gas_price, gas_limit) tx.sign_transaction(founder) if founder.get_address_bytes() != payer.get_address_bytes(): tx.add_sign_transaction(payer) tx_hash = await self._sdk.default_aio_network.send_raw_transaction(tx) return tx_hash
def approve(self, approver: Account, spender: Union[str, Address], amount: int, payer: Account, gas_price: int, gas_limit: 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. """ if amount <= 0: raise SDKException( ErrorCode.other_error( 'the amount should be greater than than zero.')) tx = self.new_approve_tx(approver.get_address(), spender, amount, payer.get_address(), gas_price, gas_limit) tx.sign_transaction(approver) if approver.get_address_bytes() != payer.get_address_bytes(): tx.add_sign_transaction(payer) return self._sdk.default_network.send_raw_transaction(tx)
def init(self, founder: Account, payer: Account, gas_price: int, gas_limit: int): """ Contract owner can use this interface to activate oep-4 token. """ tx = self.new_init_tx(payer.get_address(), gas_price, gas_limit) tx.sign_transaction(founder) if founder.get_address_bytes() != payer.get_address_bytes(): tx.add_sign_transaction(payer) tx_hash = self._sdk.default_network.send_raw_transaction(tx) return tx_hash
def test_dict(self, dict_msg: dict, payer_acct: Account, gas_limit, gas_price): func = InvokeFunction('testMap') func.set_params_value(dict_msg) tx = self.__sdk.neo_vm.make_invoke_transaction( self.__hex_contract_address, func, payer_acct.get_address(), gas_price, gas_limit) tx.sign_transaction(payer_acct) tx_hash = self.__sdk.rpc.send_raw_transaction(tx) return tx_hash
def test_struct_list_and_str(self, struct_list, str_msg, payer_acct: Account, gas_limit, gas_price): func = InvokeFunction('testStructListAndStr') func.set_params_value(struct_list, str_msg) tx = self.__sdk.neo_vm.make_invoke_transaction( self.__hex_contract_address, func, payer_acct.get_address(), gas_price, gas_limit) tx.sign_transaction(payer_acct) tx_hash = self.__sdk.rpc.send_raw_transaction(tx) return tx_hash
def reduce_init_pos(self, account: Account, peer_publickey: str, pos: int, payer: Account, gas_limit: int, gas_price: int): contract_address = bytearray.fromhex(self.CONTRACT_ADDRESS) param = { "peer_publickey": peer_publickey, "address": account.get_address().to_bytes(), "pos": pos } invoke_code = build_native_invoke_code(contract_address, b'\x00', "reduceInitPos", param) unix_time_now = int(time()) tx = Transaction(0, 0xd1, unix_time_now, gas_price, gas_limit, payer.get_address().to_bytes(), invoke_code, bytearray(), []) tx.sign_transaction(account) if payer is not None and account.get_address_base58( ) is not payer.get_address_base58(): tx.add_sign_transaction(payer) return self.__sdk.get_network().send_raw_transaction(tx)