def test_convert_tx_to_jsonrpc_request_for_deploy_transaction(self):
# Update SCORE
deploy_transaction = DeployTransactionBuilder() \
.from_(self.setting["from"]) \
.to(self.setting["to"]) \
.step_limit(self.setting["step_limit"]) \
.nid(self.setting["nid"]) \
.content_type(self.setting["content_type"]) \
.content(self.setting["content_update"]) \
.build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
deploy_transaction)
self.assertTrue(is_deploy_transaction(tx_dict))
# Install SCORE
deploy_transaction = DeployTransactionBuilder() \
.from_(self.setting["from"]) \
.to(self.setting["to_install"]) \
.step_limit(self.setting["step_limit"]) \
.nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]) \
.content_type(self.setting["content_type"]) \
.content(self.setting["content_install"]) \
.params(self.setting["params_install"]) \
.build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
deploy_transaction)
self.assertTrue(is_deploy_transaction(tx_dict))
def test_convert_tx_to_jsonrpc_request_for_message_transaction(self):
# Message send
msg_transaction = MessageTransactionBuilder().from_(self.setting["from"]).to(self.setting["to"]) \
.step_limit(self.setting["step_limit"]).nid(self.setting["nid"]).data(self.setting["data"]).build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
msg_transaction)
self.assertTrue(is_message_transaction(tx_dict))
def test_convert_tx_to_jsonrpc_request_for_call_transaction(self):
# SCORE method call
call_transaction = CallTransactionBuilder().from_(self.setting["from"]).to(self.setting["to"]) \
.step_limit(self.setting["step_limit"]).nid(self.setting["nid"]).nonce(self.setting["nonce"]) \
.method(self.setting["method"]).params(self.setting["params_call"]).build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
call_transaction)
self.assertTrue(is_call_transaction(tx_dict))
def test_send_message(self, _make_id):
message_transaction = MessageTransactionBuilder() \
.from_(self.setting["from"]) \
.to(self.setting["to"]) \
.step_limit(self.setting["step_limit"]) \
.nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]) \
.data(self.setting["data"]) \
.timestamp(self.setting["timestamp"]) \
.build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
message_transaction)
self.assertTrue(is_message_transaction(tx_dict))
signed_transaction = SignedTransaction(message_transaction,
self.wallet)
with requests_mock.Mocker() as m:
tx_hash = "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"
expected_request = {
'id': 1234,
'jsonrpc': '2.0',
'method': 'icx_sendTransaction',
'params': {
'data':
self.setting["data"],
'dataType':
'message',
'from':
self.setting["from"],
'nid':
hex(self.setting["nid"]),
'nonce':
hex(self.setting["nonce"]),
'timestamp':
hex(self.setting["timestamp"]),
'signature':
signed_transaction.signed_transaction_dict["signature"],
'stepLimit':
hex(self.setting["step_limit"]),
'to':
self.setting["to"],
'version':
hex(3)
}
}
response_json = {'jsonrpc': '2.0', 'result': tx_hash, 'id': 1234}
m.post(self.matcher, json=response_json)
result = self.icon_service.send_transaction(signed_transaction)
self.assertTrue(is_T_HASH(result))
actual_request = json.loads(m._adapter.last_request.text)
self.assertEqual(expected_request, actual_request)
def test_convert_tx_to_jsonrpc_request_for_icx_transaction(self):
# Transfer
# When having an optional property, nonce
icx_transaction = TransactionBuilder().from_(self.setting["from"]).to(self.setting["to"]) \
.value(self.setting["value"]).step_limit(self.setting["step_limit"]).nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]).build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
icx_transaction)
self.assertTrue(is_icx_transaction(tx_dict))
# When not having an optional property, nonce
icx_transaction = TransactionBuilder().from_(self.setting["from"]).to(self.setting["to"]) \
.value(self.setting["value"]).step_limit(self.setting["step_limit"]).nid(self.setting["nid"]).build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
icx_transaction)
self.assertTrue(is_icx_transaction(tx_dict))
# When not having an required property, value
icx_transaction = TransactionBuilder().from_(self.setting["from"]).to(self.setting["to"]) \
.step_limit(self.setting["step_limit"]).nid(self.setting["nid"]).build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
icx_transaction)
self.assertFalse(is_icx_transaction(tx_dict))
def test_transfer(self, _make_id):
icx_transaction = TransactionBuilder() \
.from_(self.setting["from"]) \
.to(self.setting["to"]) \
.value(self.setting["value"]) \
.step_limit(self.setting["step_limit"]) \
.nid(3) \
.nonce(self.setting["nonce"]) \
.version(3) \
.timestamp(self.setting["timestamp"]) \
.build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
icx_transaction)
self.assertTrue(is_icx_transaction(tx_dict))
signed_transaction = SignedTransaction(icx_transaction, self.wallet)
with requests_mock.Mocker() as m:
tx_hash: str = "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"
expected_request = {
'id': 1234,
'jsonrpc': '2.0',
'method': 'icx_sendTransactionAndWait',
'params': {
'from':
self.setting["from"],
'nid':
hex(self.setting["nid"]),
'nonce':
hex(self.setting["nonce"]),
'signature':
signed_transaction.signed_transaction_dict["signature"],
'stepLimit':
hex(self.setting["step_limit"]),
'timestamp':
hex(self.setting["timestamp"]),
'to':
self.setting["to"],
'value':
hex(self.setting["value"]),
'version':
'0x3'
}
}
response_json: dict = {
"jsonrpc": "2.0",
"result": tx_hash,
"id": 1234
}
m.post(self.matcher, json=response_json)
self.icon_service.send_transaction_and_wait(signed_transaction)
actual_request = json.loads(m._adapter.last_request.text)
self.assertEqual(expected_request, actual_request)
def test_to_dict(self):
# Transfer
# When having an optional property, nonce
icx_transaction = TransactionBuilder().from_(self.setting["from"]).to(self.setting["to"]) \
.value(self.setting["value"]).step_limit(self.setting["step_limit"]).nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]).build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
icx_transaction)
self.assertTrue(is_icx_transaction(tx_dict))
# When not having an optional property, nonce
icx_transaction = TransactionBuilder().from_(self.setting["from"]).to(self.setting["to"]) \
.value(self.setting["value"]).step_limit(self.setting["step_limit"]).nid(self.setting["nid"]).build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
icx_transaction)
self.assertTrue(is_icx_transaction(tx_dict))
# When not having an required property, value
icx_transaction = TransactionBuilder().from_(self.setting["from"]).to(self.setting["to"]) \
.step_limit(self.setting["step_limit"]).nid(self.setting["nid"]).build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
icx_transaction)
self.assertFalse(is_icx_transaction(tx_dict))
# Update SCORE
deploy_transaction = DeployTransactionBuilder().from_(self.setting["from"]).to(self.setting["to"]) \
.step_limit(self.setting["step_limit"]).nid(self.setting["nid"]).content_type(self.setting["content_type"]) \
.content(self.setting["content_update"]).build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
deploy_transaction)
self.assertTrue(is_deploy_transaction(tx_dict))
# Install SCORE
deploy_transaction = DeployTransactionBuilder().from_(self.setting["from"]).to(self.setting["to_install"]) \
.step_limit(self.setting["step_limit"]).nid(self.setting["nid"]).nonce(self.setting["nonce"]) \
.content_type(self.setting["content_type"]).content(self.setting["content_install"]) \
.params(self.setting["params_install"]).build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
deploy_transaction)
self.assertTrue(is_deploy_transaction(tx_dict))
# SCORE method call
call_transaction = CallTransactionBuilder().from_(self.setting["from"]).to(self.setting["to"]) \
.step_limit(self.setting["step_limit"]).nid(self.setting["nid"]).nonce(self.setting["nonce"]) \
.method(self.setting["method"]).params(self.setting["params_call"]).build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
call_transaction)
self.assertTrue(is_call_transaction(tx_dict))
# Message send
msg_transaction = MessageTransactionBuilder().from_(self.setting["from"]).to(self.setting["to"]) \
.step_limit(self.setting["step_limit"]).nid(self.setting["nid"]).data(self.setting["data"]).build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
msg_transaction)
self.assertTrue(is_message_transaction(tx_dict))
def test_convert_tx_to_jsonrpc_request_for_add_deposit_transaction(self):
# Add deposit
add_deposit_transaction: DepositTransaction = DepositTransactionBuilder() \
.from_(self.setting["from"]) \
.to(self.setting["to"]) \
.value(self.setting["value"]) \
.step_limit(self.setting["step_limit"]) \
.nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]) \
.action("add") \
.build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
add_deposit_transaction)
self.assertTrue(is_deposit_transaction(tx_dict, "add"))
def test_convert_tx_to_jsonrpc_request_for_withdraw_deposit_transaction(
self):
# Withdraw deposit
withdraw_deposit_transaction: DepositTransaction = DepositTransactionBuilder() \
.from_(self.setting["from"]) \
.to(self.setting["to"]) \
.step_limit(self.setting["step_limit"]) \
.nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]) \
.id(self.setting["id"]) \
.action("withdraw") \
.build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
withdraw_deposit_transaction)
self.assertTrue(is_deposit_transaction(tx_dict, "withdraw"))
def test_send_message(self):
sleep_time = 2
# Checks if making an instance of message transaction correctly
message_transaction = MessageTransactionBuilder()\
.from_(self.setting["from"])\
.to(self.setting["to"]) \
.step_limit(self.setting["step_limit"])\
.nid(self.setting["nid"]) \
.nonce(self.setting["nonce"])\
.data(self.setting["data"]).build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(message_transaction)
self.assertTrue(is_message_transaction(tx_dict))
# Checks if sending transaction correctly
signed_transaction = SignedTransaction(message_transaction, self.wallet)
result = self.icon_service.send_transaction(signed_transaction)
self.assertTrue(is_T_HASH(result))
# When having an optional property, nonce
sleep(sleep_time)
message_transaction = MessageTransactionBuilder().from_(self.setting["from"]).to(self.setting["to"]) \
.step_limit(self.setting["step_limit"]).nid(self.setting["nid"]).data(self.setting["data"]).build()
signed_transaction = SignedTransaction(message_transaction, self.wallet)
result = self.icon_service.send_transaction(signed_transaction)
self.assertTrue(is_T_HASH(result))
# When the data is hex string
sleep(sleep_time)
tx_result = self.icon_service.get_transaction_result(result)
tx = self.icon_service.get_transaction(result)
# Checks the transaction
self.assertEqual(tx["data"], self.setting["data"])
block = self.icon_service.get_block(int(tx_result["blockHeight"]))
# Checks the block's transaction
self.assertEqual(block["confirmed_transaction_list"][0]["data"], self.setting["data"])
# When data is not hex string
message_transaction = MessageTransactionBuilder() \
.from_(self.setting["from"]) \
.to(self.setting["to"]) \
.step_limit(self.setting["step_limit"]) \
.nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]) \
.data("test")
# Raise DataTypeException
self.assertRaises(DataTypeException, message_transaction.build)
# When address is wrong
message_transaction = MessageTransactionBuilder().from_(self.setting["from"]).to(self.setting["to"][2:]) \
.step_limit(self.setting["step_limit"]).nid(self.setting["nid"]).data(self.setting["data"]).build()
signed_transaction = SignedTransaction(message_transaction, self.wallet)
self.assertRaises(JSONRPCException, self.icon_service.send_transaction, signed_transaction)
# When not having a required property, nid
message_transaction = MessageTransactionBuilder().from_(self.setting["from"]).to(self.setting["to"][2:]) \
.step_limit(self.setting["step_limit"]).data(self.setting["data"]).build()
signed_transaction = SignedTransaction(message_transaction, self.wallet)
self.assertRaises(JSONRPCException, self.icon_service.send_transaction, signed_transaction)
# When a sending address is wrong - not the wallet's address
message_transaction = MessageTransactionBuilder().from_(self.setting["to"]).to(self.setting["to"]) \
.step_limit(self.setting["step_limit"]).nid(self.setting["nid"]).data(self.setting["data"]).build()
signed_transaction = SignedTransaction(message_transaction, self.wallet)
self.assertRaises(JSONRPCException, self.icon_service.send_transaction, signed_transaction)
def test_deploy_integrate(self):
"""
Integrate-test for deploying SCORE
1. Installs a SCORE named SampleToken.
2. Checks if making an instance of installing SCORE transaction correctly.
*** It needs about 1 sec to build consensus.
3. Sends a call Transaction which calls a method `acceptScore` to make the new SCORE active
4. Updates the SCORE having added methods
5. Checks if making an instance of updating SCORE transaction correctly.
*** It needs about 1 sec to build consensus.
6. Sends a call transaction which calls a method `acceptScore` to make the updated SCORE active
7. Calls a querying method `hello` of the updated SCORE
8. Calls a querying method `total_supply` of the updated SCORE
9. Calls a invoking method `transfer` of the updated SCORE
"""
# Test install SCORE : Checks if making an instance of deploy transaction correctly
param = {"init_supply": 10000}
deploy_transaction = DeployTransactionBuilder() \
.from_(self.setting["from"]) \
.to(self.setting["to_install"]) \
.step_limit(self.setting["step_limit"]) \
.nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]) \
.content_type(self.setting["content_type"]) \
.content(self.setting["content_install"]) \
.params(param) \
.version(3) \
.build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
deploy_transaction)
self.assertTrue(is_deploy_transaction(tx_dict))
# Test install SCORE : Sends transaction which makes the SCORE install correctly
signed_transaction_dict = SignedTransaction(deploy_transaction,
self.wallet)
result_install = self.icon_service.send_transaction(
signed_transaction_dict)
self.assertTrue(is_T_HASH(result_install))
# Test install SCORE : Sends a call transaction calling a method `acceptScore` to make the SCORE active
params = {"txHash": result_install}
call_transaction = CallTransactionBuilder() \
.from_(self.setting["from"]) \
.to(self.setting["to_governance"]) \
.step_limit(self.setting["step_limit"]) \
.nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]) \
.method("acceptScore") \
.params(params) \
.build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
call_transaction)
self.assertTrue(is_call_transaction(tx_dict))
signed_transaction_dict = SignedTransaction(call_transaction,
self.wallet)
result = self.icon_service.send_transaction(signed_transaction_dict)
self.assertTrue(is_T_HASH(result))
# Test update SCORE : Checks if making an instance of deploy transaction correctly
sleep(2)
installed_score_address = self.icon_service.get_transaction_result(
result_install)["scoreAddress"]
deploy_transaction = DeployTransactionBuilder() \
.from_(self.setting["from"]) \
.to(installed_score_address) \
.step_limit(self.setting["step_limit"]) \
.nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]) \
.content_type(self.setting["content_type"]) \
.content(self.setting["content_update"]) \
.build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
deploy_transaction)
self.assertTrue(is_deploy_transaction(tx_dict))
# Test update SCORE : Sends transaction which makes the SCORE update correctly
signed_transaction_dict = SignedTransaction(deploy_transaction,
self.wallet)
result_update = self.icon_service.send_transaction(
signed_transaction_dict)
self.assertTrue(is_T_HASH(result_update))
# Test update SCORE : Sends a call transaction calling a method `acceptScore` to make the SCORE active
params = {"txHash": result_update}
call_transaction = CallTransactionBuilder().from_(self.setting["from"]).to(self.setting["to_governance"]) \
.step_limit(self.setting["step_limit"]).nid(self.setting["nid"]).method("acceptScore").params(
params).build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
call_transaction)
self.assertTrue(is_call_transaction(tx_dict))
signed_transaction_dict = SignedTransaction(call_transaction,
self.wallet)
result = self.icon_service.send_transaction(signed_transaction_dict)
self.assertTrue(is_T_HASH(result))
# Test update SCORE : Calls a method `hello` of the updated SCORE
sleep(2)
call_transaction = CallBuilder().from_(self.setting["from"]).to(installed_score_address) \
.method("hello").build()
result = self.icon_service.call(call_transaction)
self.assertEqual(result, "Hello")
# Test update SCORE : Calls a method `total_supply` of the updated SCORE
call_transaction = CallBuilder().from_(self.setting["from"]).to(installed_score_address) \
.method("total_supply").build()
result = self.icon_service.call(call_transaction)
self.assertEqual(result, "0x0")
# Test call a invoking method of SCORE
value = "0x1"
params = {
"addr_to": "hxab2d8215eab14bc6bdd8bfb2c8151257032ecd8b",
"value": value
}
call_transaction = CallTransactionBuilder() \
.from_(self.setting["from"]) \
.to(installed_score_address) \
.method("transfer") \
.params(params) \
.nid(self.setting["nid"]) \
.step_limit(self.setting["step_limit"]) \
.build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
call_transaction)
self.assertTrue(is_call_transaction(tx_dict))
signed_transaction_dict = SignedTransaction(call_transaction,
self.wallet)
result = self.icon_service.send_transaction(signed_transaction_dict)
self.assertTrue(is_T_HASH(result))
def test_deposit_add_and_withdraw(self):
# Test install SCORE : Checks if making an instance of deploy transaction correctly
param = {"init_supply": 10000}
deploy_transaction = DeployTransactionBuilder() \
.from_(self.setting["from"]) \
.to(self.setting["to_install"]) \
.step_limit(self.setting["step_limit"]) \
.nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]) \
.content_type(self.setting["content_type"]) \
.content(self.setting["content_install"]) \
.params(param) \
.version(3) \
.build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
deploy_transaction)
self.assertTrue(is_deploy_transaction(tx_dict))
# Test install SCORE : Sends transaction which makes the SCORE install correctly
signed_transaction_dict = SignedTransaction(deploy_transaction,
self.wallet)
result_install = self.icon_service.send_transaction(
signed_transaction_dict)
self.assertTrue(is_T_HASH(result_install))
sleep(2)
installed_score_address = self.icon_service.get_transaction_result(
result_install)["scoreAddress"]
_DEPOSIT_AMOUNT = 5000 * (10**18)
deposit_transaction_of_add_0: DepositTransaction = DepositTransactionBuilder() \
.from_(self.setting["from"]) \
.to(installed_score_address) \
.value(_DEPOSIT_AMOUNT) \
.step_limit(self.setting["step_limit"]) \
.nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]) \
.action("add") \
.build()
# Checks if sending transaction correctly
signed_transaction_dict = SignedTransaction(
deposit_transaction_of_add_0, self.wallet)
result = self.icon_service.send_transaction(signed_transaction_dict)
self.assertTrue(is_T_HASH(result))
sleep(2)
self.assertEqual(
self.icon_service.get_transaction_result(result)["status"], 1)
# transaction instance for withdraw action
deposit_transaction_of_withdraw: DepositTransaction = DepositTransactionBuilder() \
.from_(self.setting["from"]) \
.to(installed_score_address) \
.step_limit(self.setting["step_limit"]) \
.nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]) \
.id(result) \
.action("withdraw") \
.build()
signed_transaction_dict = SignedTransaction(
deposit_transaction_of_withdraw, self.wallet)
result = self.icon_service.send_transaction(signed_transaction_dict)
self.assertTrue(is_T_HASH(result))
sleep(2)
self.assertEqual(
self.icon_service.get_transaction_result(result)["status"], 1)
def test_transfer(self):
# When having an optional property, nonce
icx_transaction = TransactionBuilder()\
.from_(self.setting["from"])\
.to(self.setting["to"]) \
.value(self.setting["value"])\
.step_limit(self.setting["step_limit"])\
.nid(3) \
.nonce(self.setting["nonce"])\
.version(3) \
.build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
icx_transaction)
self.assertTrue(is_icx_transaction(tx_dict))
signed_transaction_dict = SignedTransaction(icx_transaction,
self.wallet)
result = self.icon_service.send_transaction(signed_transaction_dict)
self.assertTrue(is_T_HASH(result))
# When not having an optional property, nonce
icx_transaction = TransactionBuilder().from_(self.setting["from"]).to(self.setting["to"]) \
.value(self.setting["value"]).step_limit(self.setting["step_limit"]).nid(self.setting["nid"]).build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
icx_transaction)
self.assertTrue(is_icx_transaction(tx_dict))
signed_transaction_dict = SignedTransaction(icx_transaction,
self.wallet)
result = self.icon_service.send_transaction(signed_transaction_dict)
self.assertTrue(is_T_HASH(result))
# When value is wrong prefixed with '0x'
wrong_value = "0x34330000000"
icx_transaction = TransactionBuilder().from_(self.setting["from"]).to(self.setting["to"]) \
.value(wrong_value).step_limit(self.setting["step_limit"]).nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]).build()
self.assertRaises(DataTypeException, SignedTransaction,
icx_transaction, self.wallet)
# When value is valid which type is int
wrong_value = 34330000000
icx_transaction = TransactionBuilder().from_(self.setting["from"]).to(self.setting["to"]) \
.value(wrong_value).step_limit(self.setting["step_limit"]).nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]).build()
signed_transaction_dict = SignedTransaction(icx_transaction,
self.wallet)
result = self.icon_service.send_transaction(signed_transaction_dict)
self.assertTrue(is_T_HASH(result))
# When address is wrong
wrong_address = "hx5bfdb090f43a808005ffc27c25b213145e8"
icx_transaction = TransactionBuilder().from_(self.setting["from"]).to(wrong_address) \
.value(self.setting["value"]).step_limit(self.setting["step_limit"]).nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]).build()
signed_transaction_dict = SignedTransaction(icx_transaction,
self.wallet)
self.assertRaises(JSONRPCException, self.icon_service.send_transaction,
signed_transaction_dict)
# When not having a required property, nid
icx_transaction = TransactionBuilder().from_(self.setting["from"]).to(self.setting["to"]) \
.value(self.setting["value"]).step_limit(self.setting["step_limit"]) \
.nonce(self.setting["nonce"]).build()
signed_transaction_dict = SignedTransaction(icx_transaction,
self.wallet)
self.assertRaises(JSONRPCException, self.icon_service.send_transaction,
signed_transaction_dict)
# When a sending address is wrong - not the wallet's address
wrong_address = "hx5bfdb090f43a808005ffc27c25b213145e80b7cd"
icx_transaction = TransactionBuilder().from_(wrong_address).to(self.setting["to"]) \
.value(self.setting["value"]).step_limit(self.setting["step_limit"]).nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]).build()
signed_transaction_dict = SignedTransaction(icx_transaction,
self.wallet)
self.assertRaises(JSONRPCException, self.icon_service.send_transaction,
signed_transaction_dict)
