def test_startGame(self):
################### TEST_TOKEN ADD ###################
transaction = CallTransactionBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("init_add") \
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction, self._test1)
# print("signed_transaction: ", signed_transaction)
self.process_transaction(signed_transaction, self.icon_service)
transaction = CallTransactionBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.value(2000000000000000000) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("startGame") \
.build()
# print("self._test1.get_address(): ",self._test1.get_address())
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction, self._test1)
# print("signed_transaction: ", signed_transaction)
response = self.process_transaction(signed_transaction,
self.icon_service)
print("response: ", response)
def test_check_goal_reached(self):
donation = 10
transaction = CallTransactionBuilder() \
.from_(self._test1.get_address()) \
.to(self.token_score_address).method({}) \
.step_limit(2000000) \
.method("transfer") \
.params({"_to": self.crowdsale_score_address, "_value": 1000}) \
.build()
signed_transaction = SignedTransaction(transaction, self._test1)
tx_result = self.process_transaction(signed_transaction)
self.assertTrue('status' in tx_result)
self.assertEqual(1, tx_result['status'])
transaction = TransactionBuilder()\
.from_(self._test1.get_address())\
.to(self.crowdsale_score_address)\
.step_limit(2000000)\
.value(donation)\
.build()
signed_transaction = SignedTransaction(transaction, self._test1)
tx_result = self.process_transaction(signed_transaction)
self.assertTrue('status' in tx_result)
self.assertEqual(1, tx_result['status'])
transaction = CallTransactionBuilder() \
.from_(self._test1.get_address()) \
.to(self.crowdsale_score_address).method({}) \
.step_limit(2000000) \
.method("checkGoalReached") \
.build()
signed_transaction = SignedTransaction(transaction, self._test1)
tx_result = self.process_transaction(signed_transaction)
self.assertTrue('status' in tx_result)
self.assertEqual(1, tx_result['status'])
call = CallBuilder().from_(self._test1.get_address()) \
.to(self.crowdsale_score_address) \
.method("isCrowdsaleClosed") \
.build()
response = self.process_call(call, self.icon_service)
self.assertEqual(hex(True), response)
call = CallBuilder().from_(self._test1.get_address()) \
.to(self.crowdsale_score_address) \
.method("isFundingGoalReached") \
.build()
response = self.process_call(call, self.icon_service)
self.assertEqual(hex(True), response)
def test_safe_withdraw(self):
donation = 10
transaction = CallTransactionBuilder() \
.from_(self._test1.get_address()) \
.to(self.token_score_address).method({}) \
.step_limit(2000000) \
.method("transfer") \
.params({"_to": self.crowdsale_score_address, "_value": 1000}) \
.build()
signed_transaction = SignedTransaction(transaction, self._test1)
tx_result = self.process_transaction(signed_transaction)
self.assertTrue('status' in tx_result)
self.assertEqual(1, tx_result['status'])
transaction = TransactionBuilder()\
.from_(self._test1.get_address())\
.to(self.crowdsale_score_address)\
.step_limit(2000000)\
.value(donation)\
.build()
signed_transaction = SignedTransaction(transaction, self._test1)
tx_result = self.process_transaction(signed_transaction)
self.assertTrue('status' in tx_result)
self.assertEqual(1, tx_result['status'])
call = CallBuilder().from_(self._test1.get_address()) \
.to(self.crowdsale_score_address) \
.method("getBalance") \
.build()
response = self.process_call(call, self.icon_service)
self.assertEqual(hex(donation), response)
transaction = CallTransactionBuilder() \
.from_(self._test1.get_address()) \
.to(self.crowdsale_score_address).method({}) \
.step_limit(2000000) \
.method("safeWithdraw") \
.build()
signed_transaction = SignedTransaction(transaction, self._test1)
tx_result = self.process_transaction(signed_transaction)
self.assertTrue('status' in tx_result)
self.assertEqual(1, tx_result['status'])
call = CallBuilder().from_(self._test1.get_address()) \
.to(self.crowdsale_score_address) \
.method("getBalance") \
.build()
response = self.process_call(call, self.icon_service)
self.assertEqual(hex(0), response)
def _transfer_token(self, _from: KeyWallet, _to: KeyWallet, _statue: bool):
value = 500
params = {
'_to': _to.get_address(),
'_value': value,
}
transaction = CallTransactionBuilder() \
.from_(_from.get_address()) \
.to(self._score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("transfer") \
.params(params) \
.build()
signed_transaction = SignedTransaction(transaction, _from)
tx_result = self.process_transaction(signed_transaction,
self.icon_service)
#self.logger.debug('TX RESULT : %s' % tx_result)
self.assertTrue('status' in tx_result)
self.assertEqual(1, tx_result['status'])
if _statue:
response = self._call_balance(_to.get_address())
self.assertEqual(hex(value), response)
def test_001_prepare(self):
# currentDirPath = path.abspath(path.dirname(__file__))
# scorePath = path.join(currentDirPath, '../uc_contract_registry')
# installContentBytes = gen_deploy_data_content(scorePath)
installContentHex = TEST_CONTENT_HEX_CONTRACT_REGISTRY
installContentBytes = bytes.fromhex(installContentHex)
params = {}
self.__class__._scoreAddrOfContractRegistry = self._deploy(installContentBytes, params)
self._scoreAddrOfContractRegistry = self.__class__._scoreAddrOfContractRegistry
# currentDirPath = path.abspath(path.dirname(__file__))
# scorePath = path.join(currentDirPath, '../uc_store_agent_1')
# installContentBytes = gen_deploy_data_content(scorePath)
installContentHex = TEST_CONTENT_HEX_STORE_AGENT
installContentBytes = bytes.fromhex(installContentHex)
params = {}
self.__class__._scoreAddrOfStoreAgent = self._deploy(installContentBytes, params)
self._scoreAddrOfStoreAgent = self.__class__._scoreAddrOfStoreAgent
transaction = CallTransactionBuilder()\
.from_(self._walletOfUc.get_address())\
.to(self._scoreAddrOfContractRegistry)\
.step_limit(100000000)\
.nid(3)\
.nonce(100)\
.method('register')\
.params({'_contractAddress': self._scoreAddrOfStoreAgent})\
.build()
txResult = self._sendTransaction(transaction, self._walletOfUc)
def _transaction_call(self,
from_: KeyWallet,
to_: str,
method: str,
params: dict = None) -> dict:
# Generates an instance of transaction for calling method in SCORE.
transaction = CallTransactionBuilder() \
.from_(from_.get_address()) \
.to(to_) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method(method) \
.params(params) \
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction, from_)
# Sends the transaction to the network
tx_result = self.process_transaction(signed_transaction,
self.icon_service)
self.assertTrue('status' in tx_result)
self.assertEqual(1, tx_result['status'])
return tx_result
def add_token_test(request):
# Withouth all the mapping fusiness. This just min ts the token and show it up
#Connect to Federico wallet Method
node_uri = "https://bicon.net.solidwallet.io/api/v3"
network_id = 3
hello_world_address = "cx2a96ae73368ee622f29ea6df5a9e621059326feb"
keystore_path = "./walletFEDEKEYSTORE.119Z--hx8bad34f951350f2805af083b50562529241c5baf"
keystore_pw = "Darkarior448!"
wallet = KeyWallet.load(keystore_path, keystore_pw)
tester_addr = wallet.get_address()
icon_service = IconService(HTTPProvider(node_uri))
#Checking the wallet data
print("address: ", wallet.get_address()) # Returns an address
print("private key: ", wallet.get_private_key()) # Returns a private key
tester_addr = wallet.get_address()
icon_service = IconService(HTTPProvider(node_uri))
service_adress = "cx312f84fa11a0d315ea4331c5e601d3c4897575f8"
# TODO Here put the receiver address from the current logged in data
receiver_address = tester_addr
# Way to large
# tokenId = uuid.uuid1().int
tokenId_start = int(str(uuid.uuid1().int)[:5])
tokenId = tokenId_start + int(round(time.time() * 1000))
firebase_id = request.session['local_id']
champType = 1
addChampionToDB(firebase_id, tokenId, champType)
params = {
'_to': receiver_address,
'_tokenId': tokenId,
}
transaction = CallTransactionBuilder().from_(tester_addr)\
.to(service_adress)\
.method("mint")\
.nid(3)\
.nonce(100)\
.params(params)\
.step_limit(1000000)\
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction, wallet)
# Sends the transaction
tx_hash = icon_service.send_transaction(signed_transaction)
print(tx_hash)
context = {'newChampionName': "example"}
return render(request, join('core', 'champion_added.html'), context)
def test_send_call_wrong_address(self, _make_id):
wrong_address = "hx5bfdb090f43a808005ffc27c25b213145e8"
call_transaction_without_step_limit = CallTransactionBuilder() \
.from_(self.setting["from"]) \
.to(wrong_address) \
.nid(self.setting["nid"]) \
.step_limit(self.setting["step_limit"]) \
.nonce(self.setting["nonce"]) \
.method(self.setting["method"]) \
.params(self.setting["params_call"]) \
.build()
signed_transaction = SignedTransaction(
call_transaction_without_step_limit, self.wallet)
with requests_mock.Mocker() as m:
response_json = {
'jsonrpc': '2.0',
'id': 1234,
'error': {
'code': -32601,
'message': 'Method not found'
}
}
m.post(self.matcher, json=response_json)
result_dict = self.icon_service.send_transaction(
signed_transaction, full_response=True)
self.assertEqual(result_error_v3.keys(), result_dict.keys())
def test_send_token_to_ca(self):
call = CallBuilder().from_(self.tester_addr)\
.to(token_address)\
.method("balanceOf")\
.params({"_owner": hello_world_address})\
.build()
balance_before = self.icon_service.call(call)
token_value = "0x1"
transaction = CallTransactionBuilder()\
.from_(self.tester_addr)\
.to(token_address)\
.step_limit(2000000)\
.nid(network_id)\
.method("transfer")\
.params({"_to":hello_world_address, "_value":token_value})\
.build()
signed_transaction = SignedTransaction(transaction, self.wallet)
tx_hash = self.icon_service.send_transaction(signed_transaction)
sleep(10)
result = self.icon_service.get_transaction_result(tx_hash)
self.assertEqual(result['status'], 1)
self.assertFalse(result['eventLogs'] is None)
balance_after = self.icon_service.call(call)
self.assertEqual(int(balance_before,0)+int(token_value,0), int(balance_after,0))
def test_006_accept(self):
transaction = CallTransactionBuilder()\
.from_(self._walletOfProvider.get_address())\
.to(self._scoreAddrOfOrderAgentProxy)\
.step_limit(100000000)\
.nid(3)\
.nonce(100)\
.method('accept')\
.params({'_index': '0x0', '_value': '0x1000000000000000000'})\
.build()
txResult = self._sendTransaction(transaction, self._walletOfProvider)
call = CallBuilder().from_(self._walletOfProvider.get_address())\
.to(self._scoreAddrOfOrderAgentProxy)\
.method('get')\
.params({'_index': '0x0'})\
.build()
callResult = self._sendCall(call)
self.assertEqual(json.loads(callResult)['state'], 'accepted')
call = CallBuilder().from_(self._walletOfProvider.get_address())\
.to(self._scoreAddrOfOrderAgentProxy)\
.method('balanceOf')\
.params({'_owner': self._walletOfProvider.get_address()})\
.build()
callResult = self._sendCall(call)
self.assertEqual(callResult, '0x0')
def _transfer(wallet, account_id: int, token_type: str, contract_addr: str=None, to: str=0, amount: int=0):
""" Send icx or token with Smart wallet
:param wallet:
:param account_id: from account id
:param token_type:
:param contract_addr: if token, it needed
:param to: from account id or wallet address
:param amount: amount to transfer
:return:
"""
params = {"account_id": convert_int_to_hex_str(account_id), "token_type": token_type,
"contract_addr": contract_addr,
"to": to,
"amount": convert_int_to_hex_str(amount)}
transaction = CallTransactionBuilder()\
.from_(wallet.get_address())\
.to(IconServiceContainer.contract_addr)\
.step_limit(100000000000000)\
.nid(3)\
.nonce(2) \
.method("transfer") \
.params(params) \
.build()
result = _send_transaction(transaction, wallet, 9)
for log in result['eventLogs']:
if log['indexed'] == ['Pending(str)']:
return json.loads(log['data'][0])
def test_integrate_after_unit_tests(self):
call = CallBuilder().from_(self._test1.get_address()).to(
self._score_address).method("getSCOREValue").build()
response = self.process_call(call, self.icon_service)
self.assertEqual(response, "")
new_value = "new_value"
call_tx = CallTransactionBuilder().from_(self._test1.get_address()).to(self._score_address).\
method("setSCOREValue").params({"value": new_value}).step_limit(10000000).build()
signed_tx = SignedTransaction(call_tx, self._test1)
tx_result = self.process_transaction(signed_tx, self.icon_service)
self.assertTrue(tx_result['status'])
call = CallBuilder().from_(self._test1.get_address()).to(
self._score_address).method("getSCOREValue").build()
response = self.process_call(call, self.icon_service)
self.assertEqual(new_value, response)
call = CallBuilder().from_(self._test1.get_address()).to(
self._score_address).method("get_owner").build()
response = self.process_call(call, self.icon_service)
self.assertEqual(self._test1.get_address(), response)
call = CallBuilder().from_(self._test1.get_address()).to(self._score_address).method("get_balance").\
params({"address": self._test1.get_address()}).build()
response = self.process_call(call, self.icon_service)
self.assertEqual(hex(10**24), response)
call = CallBuilder().from_(self._test1.get_address()).to(self._score_address).method("simple_json_dumps")\
.build()
response = self.process_call(call, self.icon_service)
expected = json.dumps({"simple": "value"})
self.assertEqual(expected, response)
def test_balanceOf(self):
################### TEST_TOKEN ADD ###################
transaction = CallTransactionBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("init_add") \
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction, self._test1)
# print("signed_transaction: ", signed_transaction)
self.process_transaction(signed_transaction, self.icon_service)
################### _test1 / balanceOf ###################
params = {
# "_owner" : "hx08711b77e894c3509c78efbf9b62a85a4354c8df",
"_owner": "hx08711b77e894c3509c78efbf9b62a85a4354c8df",
# hxe7af5fcfd8dfc67530a01a0e403882687528dfcb
}
call_balanceOf = CallBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.method("balanceOf") \
.params(params)\
.build()
response = self.process_call(call_balanceOf, self.icon_service)
print("balanceOf : ", response)
def test_test(self):
# ################### TEST_TOKEN ADD ###################
params = {"_grade": "1"}
transaction = CallTransactionBuilder() \
.from_("hxe7af5fcfd8dfc67530a01a0e403882687528dfcb") \
.to(self._score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("createCard") \
.params(params) \
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction, self._test1)
# print("signed_transaction: ", signed_transaction)
self.process_transaction(signed_transaction, self.icon_service)
self.process_transaction(signed_transaction, self.icon_service)
call_balanceOf = CallBuilder() \
.from_("hxe7af5fcfd8dfc67530a01a0e403882687528dfcb") \
.to(self._score_address) \
.method("showAllCard") \
.build()
response = self.process_call(call_balanceOf, self.icon_service)
print("ownerOf : ", response)
def test_ownerOf(self):
################### TEST_TOKEN ADD ###################
transaction = CallTransactionBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("init_add") \
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction, self._test1)
# print("signed_transaction: ", signed_transaction)
self.process_transaction(signed_transaction, self.icon_service)
params = {
"_tokenId": 2,
}
call_ownerOf = CallBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.method("ownerOf") \
.params(params) \
.build()
response = self.process_call(call_ownerOf, self.icon_service)
print("token_owner : ", response)
def mint_tweet_token(self):
token_uri = self.timestamp_tweet_body()
params = {
"_id": self.tweet_id,
"_supply": 1,
"_uri": token_uri,
"_username": self.tweet_user
}
transaction = CallTransactionBuilder()\
.from_(wallet.get_address())\
.to(irc31_contract_address) \
.nid(3) \
.nonce(100) \
.method("mint")\
.params(params)\
.build()
estimate_step = icon_service.estimate_step(transaction)
step_limit = estimate_step + 10000
signed_transaction = SignedTransaction(transaction, wallet, step_limit)
tx_hash = icon_service.send_transaction(signed_transaction)
self.check_tx_result(tx_hash)
response = {
"mint_tx_hash": tx_hash,
"mint_params": {
"_id": self.tweet_id,
"_uri": token_uri,
"_username": self.tweet_user,
"_supply": 1
}
}
return response
def test_token_fallback(self):
call = CallBuilder().from_(self._test1.get_address()) \
.to(self.crowdsale_score_address) \
.method("isCrowdsaleClosed") \
.build()
response = self.process_call(call, self.icon_service)
self.assertEqual(hex(True), response)
transaction = CallTransactionBuilder() \
.from_(self._test1.get_address()) \
.to(self.token_score_address).method({}) \
.step_limit(2000000) \
.method("transfer") \
.params({"_to": self.crowdsale_score_address, "_value": 100}) \
.build()
signed_transaction = SignedTransaction(transaction, self._test1)
_ = self.process_transaction(signed_transaction)
# Generates a call instance using the CallBuilder
call = CallBuilder().from_(self._test1.get_address()) \
.to(self.crowdsale_score_address) \
.method("isCrowdsaleClosed") \
.build()
# Sends the call request
response = self.process_call(call, self.icon_service)
self.assertEqual(hex(False), response)
def test_008_withdraw(self):
transaction = CallTransactionBuilder()\
.from_(self._walletOfProvider.get_address())\
.to(self._scoreAddrOfOrderAgentProxy)\
.step_limit(100000000)\
.nid(3)\
.nonce(100)\
.method('withdraw')\
.params({'_value': '0x2000000000000000000'})\
.build()
txResult = self._sendTransaction(transaction, self._walletOfProvider)
balance = self._getBalance(self._walletOfProvider.get_address())
self.assertEqual(balance, 0x2000000000000000000)
balance = self._getBalance(self._walletOfCustomer.get_address())
self.assertEqual(balance, 0x0)
call = CallBuilder().from_(self._walletOfProvider.get_address())\
.to(self._scoreAddrOfOrderAgentProxy)\
.method('balanceOf')\
.params({'_owner': self._walletOfProvider.get_address()})\
.build()
callResult = self._sendCall(call)
self.assertEqual(callResult, '0x0')
def create_set_prep_tx(key_wallet: 'KeyWallet',
irep: int = None,
set_data: Dict[str, Union[str, bytes]] = None,
value: int = 0,
step_limit: int = DEFAULT_STEP_LIMIT,
nid: int = DEFAULT_NID,
nonce: int = 0) -> 'SignedTransaction':
if set_data is None:
set_data = {}
if irep is not None:
set_data[ConstantKeys.IREP] = hex(irep)
transaction = CallTransactionBuilder(). \
from_(key_wallet.get_address()). \
to(SYSTEM_ADDRESS). \
value(value). \
step_limit(step_limit). \
nid(nid). \
nonce(nonce). \
method("setPRep"). \
params(set_data). \
build()
signed_transaction = SignedTransaction(transaction, key_wallet)
return signed_transaction
def test_008_upgrade(self):
transaction = CallTransactionBuilder()\
.from_(self._walletOfUc.get_address())\
.to(self._scoreAddrOfContractRegistry)\
.step_limit(100000000)\
.nid(3)\
.nonce(100)\
.method('upgrade')\
.params({'_contractAddress': self._scoreAddrOfStoreAgent2})\
.build()
txResult = self._sendTransaction(transaction, self._walletOfUc)
call = CallBuilder().from_(self._walletOfUc.get_address())\
.to(self._scoreAddrOfContractRegistry)\
.method('getCount')\
.build()
callResult = self._sendCall(call)
self.assertEqual(callResult, '0x1')
call = CallBuilder().from_(self._walletOfUc.get_address())\
.to(self._scoreAddrOfContractRegistry)\
.method('getAddressByName')\
.params({'_contractName': 'StoreAgent'})\
.build()
callResult = self._sendCall(call)
self.assertEqual(callResult, self._scoreAddrOfStoreAgent2)
call = CallBuilder().from_(self._walletOfUc.get_address())\
.to(self._scoreAddrOfContractRegistry)\
.method('getAddressByName')\
.params({'_contractName': 'StoreAgent', '_version': '0x1'})\
.build()
callResult = self._sendCall(call)
self.assertEqual(callResult, self._scoreAddrOfStoreAgent)
call = CallBuilder().from_(self._walletOfUc.get_address())\
.to(self._scoreAddrOfContractRegistry)\
.method('get')\
.params({'_index': '0x0'})\
.build()
callResult = self._sendCall(call)
self.assertEqual(
json.loads(callResult)['address'], self._scoreAddrOfStoreAgent2)
self.assertEqual(json.loads(callResult)['version'], 2)
call = CallBuilder().from_(self._walletOfUc.get_address())\
.to(self._scoreAddrOfContractRegistry)\
.method('get')\
.params({'_index': '0x0', '_version': '0x1'})\
.build()
callResult = self._sendCall(call)
self.assertEqual(
json.loads(callResult)['address'], self._scoreAddrOfStoreAgent)
self.assertEqual(json.loads(callResult)['version'], 1)
def test_send_call(self, _make_id):
call_transaction_without_step_limit = CallTransactionBuilder()\
.from_(self.setting["from"])\
.to(self.setting["to"]) \
.nid(self.setting["nid"])\
.step_limit(self.setting["step_limit"])\
.nonce(self.setting["nonce"]) \
.method(self.setting["method"])\
.params(self.setting["params_call"])\
.build()
signed_transaction = SignedTransaction(
call_transaction_without_step_limit, self.wallet)
with requests_mock.Mocker() as m:
response_json = {
'jsonrpc':
'2.0',
'id':
1234,
'result':
'0x4bf74e6aeeb43bde5dc8d5b62537a33ac8eb7605ebbdb51b015c1881b45b3aed'
}
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.assertTrue(is_T_HASH(result_content))
self.assertEqual(result_success_v3.keys(), result_dict.keys())
def vote(walletName):
result = {}
if request.method == 'POST':
params = {"_vote": request.form['element']}
transaction = CallTransactionBuilder() \
.from_(wallets.get(walletName).get_address()) \
.to(default_score) \
.step_limit(9999999) \
.nid(3) \
.nonce(100) \
.method("vote") \
.params(params) \
.build()
signed_transaction = SignedTransaction(transaction,
wallets.get(walletName))
tx_hash = icon_service.send_transaction(signed_transaction)
result['post'] = signed_transaction.signed_transaction_dict
result['transactionHash'] = tx_hash
transaction_status = get_tx_result(tx_hash)
result['status'] = transaction_status['status']
result['message'] = ''
if transaction_status['status'] == 0:
result['message'] = transaction_status["failure"]["message"]
return json.dumps(result, sort_keys=True, indent=4)
def test_token_fallback(self):
input_params = {"initialSupply": 1000, "decimals": 1}
token_deploy_result = self._deploy_score(scorepath=self.SAMPLE_TOKEN,
_params=input_params)
score_address = token_deploy_result['scoreAddress']
transaction = CallTransactionBuilder().from_(self._test1.get_address()) \
.to(score_address) \
.step_limit(10000000000) \
.nid(3) \
.method("transfer") \
.params({"_to": self._score_address, "_value": 10}) \
.build()
signed_transaction = SignedTransaction(transaction, self._test1)
tx_result = self.process_transaction(signed_transaction,
self.icon_service)
self.assertEqual(1, tx_result['status'])
call = CallBuilder().from_(self._test1.get_address()) \
.to(score_address) \
.method("balanceOf") \
.params({"_owner": self._score_address}) \
.build()
response = self.process_call(call, self.icon_service)
self.assertEqual('0xa', response)
def buy_tap_fill_swap(icx_amount, swap_id):
""" It will fill someone's sell order if you provide the icx_amount and the swap_id. Returns tx hash """
if isinstance(icx_amount, int):
icx_amount = int_to_bigint(icx_amount)
else:
icx_amount = float_value(icx_amount)
swap_id = hex(swap_id)
swap = {"swap_id": swap_id}
transaction = CallTransactionBuilder() \
.from_(address) \
.to(iconswap_score) \
.value(icx_amount) \
.method("fill_icx_order") \
.params(swap) \
.step_limit(40000000) \
.nid(nid) \
.nonce(50) \
.build()
signed_transaction = SignedTransaction(transaction, my_wallet)
tx_hash = icon_service.send_transaction(signed_transaction)
return tx_hash
def _call_tx(self,
key_wallet: 'KeyWallet',
to: str,
method: str,
params: dict = {},
value: int = 0,
step_limit: int = DEFAULT_STEP_LIMIT,
nid: int = DEFAULT_NID,
nonce: int = 0) -> str:
transaction = CallTransactionBuilder() \
.from_(key_wallet.get_address()) \
.to(to) \
.value(value) \
.step_limit(step_limit) \
.nid(nid) \
.nonce(nonce) \
.method(method) \
.params(params) \
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction, key_wallet)
# Send transaction
return self.icon_service.send_transaction(signed_transaction)
def sell_tap_create_swap(icx_amount, tap_amount):
""" Creating a sell swap order from the given amounts. Returning the tx hash"""
if isinstance(icx_amount, int):
icx_amount = int_to_bigint(icx_amount)
else:
icx_amount = float_value(icx_amount)
tap_amount = int_to_bighexa(tap_amount)
pre_data = {
"action": "create_irc2_swap",
"taker_contract": icx_score,
"taker_amount": hex(icx_amount)
}
aft_data = json.dumps(pre_data, separators=(',', ':')).encode('utf-8')
data = convert_bytes_to_hex_str(aft_data)
# c = convert_hex_str_to_bytes("put hash here")
params = {"_to": iconswap_score, "_value": tap_amount, "_data": data}
transaction = CallTransactionBuilder() \
.from_(address) \
.to(tap_score) \
.step_limit(40000000) \
.nid(nid) \
.nonce(50) \
.method("transfer") \
.params(params) \
.build()
signed_transaction = SignedTransaction(transaction, my_wallet)
tx_hash = icon_service.send_transaction(signed_transaction)
return tx_hash
def test_remove_blacklist_by_stranger(self):
# Make params of add_blacklist method
to = self._wallet_array[2].get_address()
value = 100
params = {
'addr': to,
}
# Generates an instance of transaction for calling method in SCORE.
transaction = CallTransactionBuilder() \
.from_(self.non_owner_wallet.get_address()) \
.to(self._score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("remove_blacklist") \
.params(params) \
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction,
self.non_owner_wallet)
print('Remove blacklist by stranger', 'From:',
self._test1.get_address(), 'Address:', to)
tx_result = self.process_transaction(signed_transaction,
self.icon_service)
self.assertEqual(tx_result['status'], 0)
self.assertFalse(tx_result['failure'] is None)
print('\t(Transaction Reverted)', tx_result['failure']['message'])
def test_modify_status(self):
params = {"_scoreName": "Modified SCORE Name",
"_introduction": "Modified Introduction"}
transaction = CallTransactionBuilder() \
.method("modifyScoreStatus") \
.params(params) \
.step_limit(10000000000) \
.to(self._score_address) \
.build()
signed_transaction = SignedTransaction(transaction, self._test1)
tx_result = self.process_transaction(signed_transaction)
self.assertEqual(1, tx_result['status'])
print(tx_result['eventLogs'])
call = CallBuilder().from_(self._test1.get_address()) \
.to(self._score_address) \
.method("getScoreStatus") \
.build()
# Sends the call request
response = self.process_call(call, self.icon_service)
response_list = response.split("\n")
self.assertEqual("SCORE_NAME : Modified SCORE Name", response_list[0])
self.assertEqual("INTRODUCTION : Modified Introduction", response_list[1])
self.test_time_recording()
def test_003_register(self):
transaction = CallTransactionBuilder()\
.from_(self._walletOfProvider.get_address())\
.to(self._scoreAddrOfStoreAgentProxy)\
.step_limit(100000000)\
.nid(3)\
.nonce(100)\
.method('register')\
.params({'_itemName': 'A Used Bycicle', '_itemDetails': 'It\'s been used for 3 years'})\
.build()
txResult = self._sendTransaction(transaction, self._walletOfProvider)
call = CallBuilder().from_(self._walletOfProvider.get_address())\
.to(self._scoreAddrOfStoreAgentProxy)\
.method('getCount')\
.build()
callResult = self._sendCall(call)
self.assertEqual(callResult, '0x1')
call = CallBuilder().from_(self._walletOfProvider.get_address())\
.to(self._scoreAddrOfStoreAgentProxy)\
.method('get')\
.params({'_index': '0x0'})\
.build()
callResult = self._sendCall(call)
self.assertEqual(json.loads(callResult)['state'], 'ready')
self.assertEqual(json.loads(callResult)['owner'], self._walletOfProvider.get_address())
def test_token_transfer(self):
# Make params of transfer method
to = self._wallet_array[0].get_address()
value = 100
params = {
'_to': to,
'_value': value,
}
# Generates an instance of transaction for calling method in SCORE.
transaction = CallTransactionBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("transfer") \
.params(params) \
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction, self._test1)
# Sends the transaction to the network
tx_result = self.process_transaction(signed_transaction,
self.icon_service)
self.assertTrue('status' in tx_result)
self.assertEqual(1, tx_result['status'])
# Sends the call balanceOf
response = self._call_balance(to)
# check balance of receiver
self.assertEqual(hex(value), response)