def test_deposit_transaction_to_dict_for_withdraw_action(self):
# transaction instance for withdraw action
tx_list = [
DepositTransactionBuilder() \
.from_(self.transaction_as_setting["from_"]) \
.to(self.transaction_as_setting["to"]) \
.step_limit(self.transaction_as_setting["step_limit"]) \
.nid(self.transaction_as_setting["nid"]) \
.nonce(self.transaction_as_setting["nonce"]) \
.version(self.transaction_as_setting["version"]) \
.timestamp(self.transaction_as_setting["timestamp"]) \
.id(self.transaction_as_setting["id"]) \
.amount(None)
.action("withdraw") \
.build(),
DepositTransactionBuilder() \
.from_(self.transaction_as_setting["from_"]) \
.to(self.transaction_as_setting["to"]) \
.step_limit(self.transaction_as_setting["step_limit"]) \
.nid(self.transaction_as_setting["nid"]) \
.nonce(self.transaction_as_setting["nonce"]) \
.version(self.transaction_as_setting["version"]) \
.timestamp(self.transaction_as_setting["timestamp"]) \
.id(None) \
.amount(self.transaction_as_setting["amount"]) \
.action("withdraw") \
.build(),
]
for tx in tx_list:
self._check_deposit_withdraw_transaction(tx)
def test_add_deposit(self, _make_id):
# transaction instance for add action
action = "add"
deposit_transaction = DepositTransactionBuilder() \
.from_(self.setting["from"]) \
.to(self.setting["to"]) \
.value(self.setting["value"]) \
.timestamp(self.setting["timestamp"]) \
.step_limit(self.setting["step_limit"]) \
.nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]) \
.action(action) \
.build()
signed_transaction = SignedTransaction(deposit_transaction,
self.wallet)
with requests_mock.Mocker() as m:
tx_hash = "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"
expected_request = {
'id': 1234,
'jsonrpc': '2.0',
'method': 'icx_sendTransaction',
'params': {
'data': {
'action': action
},
'dataType':
'deposit',
'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':
hex(3)
}
}
response_json = {"jsonrpc": "2.0", "result": tx_hash, "id": 1234}
m.post(self.matcher, json=response_json)
result_dict = self.icon_service.send_transaction(
signed_transaction, full_response=True)
actual_request = json.loads(m._adapter.last_request.text)
result_content = result_dict['result']
self.assertEqual(expected_request, actual_request)
self.assertEqual(result_success_v3.keys(), result_dict.keys())
self.assertTrue(is_T_HASH(result_content))
def test_deposit_transaction_to_dict_for_withdraw_action(self):
# transaction instance for withdraw action
deposit_transaction_of_withdraw_0: DepositTransaction = DepositTransactionBuilder() \
.from_(self.transaction_as_setting["from_"]) \
.to(self.transaction_as_setting["to"]) \
.step_limit(self.transaction_as_setting["step_limit"]) \
.nid(self.transaction_as_setting["nid"]) \
.nonce(self.transaction_as_setting["nonce"]) \
.version(self.transaction_as_setting["version"]) \
.timestamp(self.transaction_as_setting["timestamp"]) \
.id(self.transaction_as_setting["id"]) \
.action("withdraw") \
.build()
# convert transaction into dict correctly
# check 0 : check if it is deposit transaction
deposit_transaction_of_withdraw_as_dict = deposit_transaction_of_withdraw_0.to_dict(
)
self.assertTrue(
self._is_deposit_transaction(
deposit_transaction_of_withdraw_as_dict))
# check 1 : check if converted deposit transaction from dict is same as an origin deposit transaction
deposit_transaction_of_withdraw_as_dict = deposit_transaction_of_withdraw_0.to_dict(
)
deposit_transaction_of_withdraw_1: DepositTransaction = DepositTransactionBuilder \
.from_dict(deposit_transaction_of_withdraw_as_dict) \
.build()
self.assertEqual(deposit_transaction_of_withdraw_0.to_dict(),
deposit_transaction_of_withdraw_1.to_dict())
# case 0 when action is 'withdraw' : without id
try:
deposit_transaction_of_add_with_id: DepositTransaction = DepositTransactionBuilder() \
.from_(self.transaction_as_setting["from_"]) \
.to(self.transaction_as_setting["to"]) \
.step_limit(self.transaction_as_setting["step_limit"]) \
.nid(self.transaction_as_setting["nid"]) \
.nonce(self.transaction_as_setting["nonce"]) \
.version(self.transaction_as_setting["version"]) \
.timestamp(self.transaction_as_setting["timestamp"]) \
.action("withdraw") \
.build()
except DataTypeException:
self.assertTrue(True)
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_signed_transaction_with_deposit_transaction_of_deposit_action_without_step_limit(
self):
deposit_transaction_without_step_limit: DepositTransaction = DepositTransactionBuilder() \
.from_(self.setting["from"]) \
.to(self.setting["to"]) \
.nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]) \
.action("withdraw") \
.id(self.setting["id"]) \
.build()
# fail without step limit
self.assertRaises(DataTypeException, SignedTransaction,
deposit_transaction_without_step_limit, self.wallet)
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_add_deposit(self):
# transaction instance for add action
deposit_transaction_of_add_0: 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()
# 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))
def get_transaction(conf: dict, params: dict):
data_type = params.get('dataType')
params_data = params.get('data', {})
try:
transaction_params = {
"from_": params['from'],
"to": params['to'],
"nid": convert_hex_str_to_int(conf['nid']),
"value": convert_hex_str_to_int(params.get('value', "0x0"))
}
if data_type is None:
transaction_builder = TransactionBuilder(**transaction_params)
elif data_type == "call":
transaction_params['method'] = params_data.get('method')
transaction_params['params'] = params_data.get('params')
transaction_builder = CallTransactionBuilder(
**transaction_params)
elif data_type == "deploy":
transaction_params['content'] = params_data.get('content')
transaction_params['content_type'] = params_data.get(
'contentType')
transaction_params['params'] = params_data.get('params')
transaction_builder = DeployTransactionBuilder(**params)
elif data_type == "message":
transaction_params['data'] = params_data
transaction_builder = MessageTransactionBuilder(
**transaction_params)
elif data_type == "deposit":
transaction_params['action'] = params_data.get('action')
transaction_params['id'] = params_data.get('id')
transaction_builder = DepositTransactionBuilder(
**transaction_params)
else:
raise JsonContentsException("Invalid dataType")
transaction = transaction_builder.build()
except KeyError:
raise JsonContentsException(
"Invalid json content. check json contents")
except TypeError:
raise JsonContentsException("Invalid json content. check keys")
except DataTypeException:
raise JsonContentsException("Invalid json content. check values")
else:
return transaction
def test_deposit_transaction_id_and_amount_at_same_time_for_withdraw_action(
self):
try:
deposit_transaction_of_add_with_id: DepositTransaction = DepositTransactionBuilder() \
.from_(self.transaction_as_setting["from_"]) \
.to(self.transaction_as_setting["to"]) \
.step_limit(self.transaction_as_setting["step_limit"]) \
.nid(self.transaction_as_setting["nid"]) \
.nonce(self.transaction_as_setting["nonce"]) \
.version(self.transaction_as_setting["version"]) \
.timestamp(self.transaction_as_setting["timestamp"]) \
.action("withdraw") \
.id(self.transaction_as_setting["id"]) \
.amount(self.transaction_as_setting["amount"]) \
.build()
except DataTypeException:
self.assertTrue(True)
def test_signed_transaction_with_deposit_transaction_of_deposit_action_without_step_limit(
self):
deposit_transaction_without_step_limit: DepositTransaction = DepositTransactionBuilder() \
.from_(self.setting["from"]) \
.to(self.setting["to"]) \
.nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]) \
.action("withdraw") \
.id(self.setting["id"]) \
.build()
# fail without step limit
self.assertRaises(DataTypeException, SignedTransaction,
deposit_transaction_without_step_limit, self.wallet)
# success with param of step limit
signed_transaction_dict = SignedTransaction(
deposit_transaction_without_step_limit, self.wallet,
self.setting["step_limit"])
result = self.icon_service.send_transaction(signed_transaction_dict)
self.assertTrue(is_T_HASH(result))
def test_deposit_transaction_to_dict_for_add_action(self):
"""Test for converting deposit transaction object to dict by using 'to_dict' method"""
# transaction instance for add action
deposit_transaction_of_add_0: DepositTransaction = DepositTransactionBuilder() \
.from_(self.transaction_as_setting["from_"]) \
.to(self.transaction_as_setting["to"]) \
.value(self.transaction_as_setting["value"]) \
.step_limit(self.transaction_as_setting["step_limit"]) \
.nid(self.transaction_as_setting["nid"]) \
.nonce(self.transaction_as_setting["nonce"]) \
.version(self.transaction_as_setting["version"]) \
.timestamp(self.transaction_as_setting["timestamp"]) \
.action("add") \
.build()
# convert transaction into dict correctly
# check 0 : check if it is deposit transaction
deposit_transaction_of_add_as_dict = deposit_transaction_of_add_0.to_dict(
)
self.assertTrue(
self._is_deposit_transaction(deposit_transaction_of_add_as_dict))
# check 1 : check if converted deposit transaction from dict is same as an origin deposit transaction
deposit_transaction_of_add_as_dict = deposit_transaction_of_add_0.to_dict(
)
deposit_transaction_of_add_1: DepositTransaction = DepositTransactionBuilder \
.from_dict(deposit_transaction_of_add_as_dict) \
.build()
self.assertEqual(deposit_transaction_of_add_0.to_dict(),
deposit_transaction_of_add_1.to_dict())
# case 0 when action is 'add' : without action
tmp_deposit_transaction_of_add_as_dict = deepcopy(
deposit_transaction_of_add_as_dict)
del tmp_deposit_transaction_of_add_as_dict["action"]
self.assertFalse(
self._is_deposit_transaction(
tmp_deposit_transaction_of_add_as_dict))
# case 1 when action is 'add' : without value
tmp_deposit_transaction_of_add_as_dict = deepcopy(
deposit_transaction_of_add_as_dict)
del tmp_deposit_transaction_of_add_as_dict["value"]
self.assertFalse(
self._is_deposit_transaction(
tmp_deposit_transaction_of_add_as_dict))
# case 2 when action is 'add' : without value
try:
deposit_transaction_of_add_with_id: DepositTransaction = DepositTransactionBuilder() \
.from_(self.transaction_as_setting["from_"]) \
.to(self.transaction_as_setting["to"]) \
.step_limit(self.transaction_as_setting["step_limit"]) \
.nid(self.transaction_as_setting["nid"]) \
.nonce(self.transaction_as_setting["nonce"]) \
.version(self.transaction_as_setting["version"]) \
.timestamp(self.transaction_as_setting["timestamp"]) \
.action("add") \
.id(self.transaction_as_setting["id"]) \
.build()
except DataTypeException:
self.assertTrue(True)
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)