def create_set_revision_tx(from_: 'KeyWallet',
revision: int) -> 'SignedTransaction':
# set revision
transaction = CallTransactionBuilder() \
.from_(from_.get_address()) \
.to(GOVERNANCE_ADDRESS) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("setRevision") \
.params({"code": revision, "name": f"1.4.{revision}"}) \
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction, from_)
return signed_transaction
def test_remove_user(self):
send = CallTransactionBuilder().from_(self.tester_addr) \
.version(3) \
.step_limit(3000000000000000000000) \
.timestamp(0x573117f1d6568) \
.nid(0x3) \
.to(vote_dao_address) \
.method("remove_user") \
.params({"contents": "hx8d29ac2645805452a6e921c888b23c58be862cf0"}) \
.build()
signed_transaction = SignedTransaction(send, self.wallet)
tx_hash = self.icon_service.send_transaction(signed_transaction)
sleep(10)
result = self.icon_service.get_transaction_result(tx_hash)
assert result['status'] == 0 or 1
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 writeTransaction(self, method: str, params: []) -> {}:
transaction = CallTransactionBuilder()\
.from_(self._test1.get_address())\
.to(self._score_address)\
.step_limit(100000000)\
.nid(3)\
.nonce(100)\
.method(method)\
.params(params)\
.build()
signed_transaction = SignedTransaction(transaction, self._test1)
tx_result = self.process_transaction(signed_transaction, self.icon_service)
assert 'status' in tx_result
assert 1 == tx_result['status']
return tx_result
def _use_scrooge_(self, _to: Address, _ratio: int):
transaction_use_scrooge = CallTransactionBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("scrooge") \
.params({
"_to":_to,
"_ratio":_ratio
}) \
.build()
signed_transaction = SignedTransaction(transaction_use_scrooge, self._test1)
tx_result = self.process_transaction(signed_transaction, self.icon_service)
return tx_result
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.to_dict(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.to_dict(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.to_dict(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.to_dict(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.to_dict(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.to_dict(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.to_dict(msg_transaction)
self.assertTrue(is_message_transaction(tx_dict))
def test_stake(self):
# use pre-defined account
# account = self._wallet_array[0]
# make new account
account = self._make_account()
stake_value: int = 0x64
# Generates a 'setStake' instance of transaction
transaction = CallTransactionBuilder() \
.from_(account.get_address()) \
.to(self.SYSTEM_ADDRESS) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("setStake") \
.params({"value": stake_value}) \
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction, account)
# process the transaction
tx_result = self.process_transaction(signed_transaction,
self.icon_service)
self.assertTrue('status' in tx_result)
self.assertEqual(1, tx_result['status'])
# Generates a 'getStake' call instance using the CallBuilder
call = CallBuilder().from_(account.get_address()) \
.to(self.SYSTEM_ADDRESS) \
.method("getStake") \
.params({"address": account.get_address()}) \
.build()
# Sends the call request
response = self.process_call(call, self.icon_service)
expect_result = {
"stake": hex(stake_value),
"unstake": "0x0",
"unstakedBlockHeight": "0x0"
}
self.assertEqual(expect_result, response)
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'])
# Make params of balanceOf method
params = {
'_owner': to
}
# Generates a call instance using the CallBuilder
call = CallBuilder().from_(self._test1.get_address()) \
.to(self._score_address) \
.method("balanceOf") \
.params(params) \
.build()
# Sends the call request
response = self.process_call(call, self.icon_service)
# check balance of receiver
self.assertEqual(hex(value), response)
def dice_fast_bets(bet_amount, params_bet, loop_times):
signed_tx = []
for _ in range(loop_times):
transaction = CallTransactionBuilder() \
.from_(wallet.get_address()) \
.to(daoDice_contract) \
.step_limit(40000000) \
.value(bet_amount) \
.nid(nid) \
.nonce(50) \
.method("call_bet") \
.params(params_bet) \
.build()
# Signs and sends the tx to the contract
signed_transaction = SignedTransaction(transaction, wallet)
signed_tx.append(signed_transaction)
return signed_tx
def cancel_my_swap(swap_id):
"""Cancels my swap by id, Returning the txhash """
swap_id = hex(swap_id)
params = {"swap_id": swap_id}
transaction = CallTransactionBuilder() \
.from_(address) \
.to(iconswap_score) \
.value(0) \
.method("cancel_swap") \
.params(params) \
.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 set_refs_by_using_relay(self, _symbols, _rates, _resolve_times,
_request_ids):
transaction = (CallTransactionBuilder().from_(
self._test1.get_address()).to(self._std_basic).step_limit(
100_000_000_000).nid(3).nonce(100).method("relay").params({
"_symbols":
json.dumps(_symbols),
"_rates":
json.dumps(_rates),
"_resolve_times":
json.dumps(_resolve_times),
"_request_ids":
json.dumps(_request_ids),
}).build())
signed_transaction = SignedTransaction(transaction, self._test1)
tx_result = self.process_transaction(signed_transaction,
self.icon_service)
self.assertEqual(True, tx_result["status"])
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('address', type=str)
parser.add_argument('amount', type=int)
args = parser.parse_args();
transaction = CallTransactionBuilder()\
.from_(admin_addr)\
.to(contract_address)\
.step_limit(100000000)\
.nid(3)\
.nonce(100)\
.method("set")\
.params({"_to":args['address'], "_amount":args['amount']})\
.build()
signed_transaction = SignedTransaction(transaction, wallet)
tx_hash = icon_service.send_transaction(signed_transaction)
def create_transaction(multiplier=1):
transaction = (
CallTransactionBuilder()
.from_(player_wallet.get_address())
.to(CASINO_SCORE_ADDRESS)
.method("play")
.value(BET_AMOUNT * multiplier)
.step_limit(2000000)
.nid(3)
.nonce(100)
.params({})
.build()
)
signed_transaction = SignedTransaction(transaction, player_wallet)
signed_transaction_hash = icon_service.send_transaction(signed_transaction)
print('Transaction hash: {} '.format(signed_transaction_hash))
return signed_transaction_hash
def create_claim_iscore_tx(key_wallet: 'KeyWallet',
value: int = 0,
step_limit: int = DEFAULT_STEP_LIMIT,
nid: int = DEFAULT_NID,
nonce: int = 0) -> 'SignedTransaction':
transaction = CallTransactionBuilder(). \
from_(key_wallet.get_address()). \
to(SYSTEM_ADDRESS). \
value(value). \
step_limit(step_limit). \
nid(nid). \
nonce(nonce). \
method("claimIScore"). \
build()
signed_transaction = SignedTransaction(transaction, key_wallet)
return signed_transaction
def _exchange(self, _from: KeyWallet, amount: int):
params = {
'amount': amount
}
transaction_exchange = CallTransactionBuilder() \
.from_(_from.get_address()) \
.to(self._sample_game_score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("exchange") \
.params(params) \
.build()
signed_transaction_exchange = SignedTransaction(transaction_exchange, _from)
tx_result_exchange = self.process_transaction(signed_transaction_exchange, self.icon_service)
return tx_result_exchange
def write_data(self, contract_address, action_name, wallet_key, params):
wallet = KeyWallet.load(bytes.fromhex(wallet_key))
call_transaction = CallTransactionBuilder() \
.from_(wallet.get_address()) \
.to(contract_address) \
.step_limit(self.get_max_step_limit(wallet.get_address())) \
.nid(self.network_id) \
.nonce(self.network_id) \
.method(action_name) \
.params(params) \
.build()
signed_transaction = SignedTransaction(call_transaction, wallet)
tx_hash = self.icon_service.send_transaction(signed_transaction)
# print('tx_hash:', tx_hash)
tx_result = self.get_transaction_result(tx_hash)
return tx_result
def setMethod(self, _method: dict, type: str) -> dict:
result = {}
if type == "DIR":
contract_address = self.id_contract_address
elif type == "PTM":
contract_address = self.ptm_contract_address
elif type == "PGM":
contract_address = self.pgm_contract_address
else:
print("Not supported contract type")
result["status"] = "failure"
result["message"] = ""
return result
if not _method.__contains__("params"):
_method["params"] = ""
transaction = CallTransactionBuilder() \
.from_(self.key_wallet.get_address()) \
.to(contract_address) \
.step_limit(10000000) \
.nid(self.nid) \
.method(_method["name"]) \
.params(_method["params"]) \
.build()
# sign the transaction with key wallet
signed_tx = SignedTransaction(transaction, self.key_wallet)
# commit(send) the signed transaction to the service endpoint
tx_hash = self.service_endpoint.send_transaction(signed_tx)
sleep(3) # wait a second for the transaction to be finalized
tx_result = self.service_endpoint.get_transaction_result(tx_hash)
print(tx_result)
if "failure" in tx_result:
result["status"] = "failure"
result["message"] = tx_result["failure"]
else:
result["status"] = "success"
result["message"] = tx_result["eventLogs"][0]["data"]
return result
def _build_transaction(self, type_="write", **kwargs):
if type_ not in ("transfer", "write", "read"):
raise ValueError("Wrong type value")
from_ = self._wallet.get_address(
) if "from_" not in kwargs else kwargs["from_"]
to_ = self._score_address if "to" not in kwargs else kwargs["to"]
margin_ = 2500000 if "margin" not in kwargs else kwargs["margin"]
value_ = 0 if "value" not in kwargs else kwargs["value"]
method_ = None if "method" not in kwargs else kwargs["method"]
params_ = {} if "params" not in kwargs else kwargs["params"]
tx = None
if type_ == "write":
steps_ = self._estimate_steps(margin_)
tx = CallTransactionBuilder() \
.from_(from_) \
.to(to_) \
.value(value_) \
.nid(3) \
.step_limit(steps_) \
.nonce(100) \
.method(method_) \
.params(params_) \
.build()
elif type_ == "read":
tx = CallBuilder() \
.from_(from_) \
.to(to_) \
.method(method_) \
.params(params_) \
.build()
elif type_ == "transfer":
steps_ = self._estimate_steps(margin_)
tx = TransactionBuilder() \
.from_(from_) \
.to(to_) \
.value(value_) \
.step_limit(steps_) \
.nid(3) \
.build()
return tx
def test_009_downgrade(self):
call = CallBuilder().from_(self._walletOfUc.get_address())\
.to(self._scoreAddrOfContractRegistry)\
.method('getLatestVersion')\
.params({'_index': '0x0'})\
.build()
callResult = self._sendCall(call)
self.assertEqual(callResult, '0x2')
transaction = CallTransactionBuilder()\
.from_(self._walletOfUc.get_address())\
.to(self._scoreAddrOfContractRegistry)\
.step_limit(100000000)\
.nid(3)\
.nonce(100)\
.method('downgrade')\
.params({'_index': '0x0', '_version': '0x1'})\
.build()
txResult = self._sendTransaction(transaction, self._walletOfUc)
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._scoreAddrOfStoreAgent)
self.assertEqual(json.loads(callResult)['version'], 1)
call = CallBuilder().from_(self._walletOfUc.get_address())\
.to(self._scoreAddrOfContractRegistry)\
.method('getLatestVersion')\
.params({'_index': '0x0'})\
.build()
callResult = self._sendCall(call)
self.assertEqual(callResult, '0x2')
def transaction_call(icon_integrate_test_base: IconIntegrateTestBase,
from_: KeyWallet,
to_: str,
method: str,
params: dict = None,
value: int = 0,
icon_service: IconService = None) -> dict:
"""Sends the call transaction by using SDK
:param icon_integrate_test_base: IconIntegrateTestBase
:param from_: wallet address making a transaction
:param to_: wallet address to receive coin or SCORE address to receive a transaction
:param method: name of an external function
:param params: parameters as dict passed on the SCORE methods (optional)
:param value: amount of ICX to be sent (Optional)
:param icon_service: IconService
:return: transaction result as 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) \
.value(value) \
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction, from_)
# Sends the transaction to the network
tx_result = icon_integrate_test_base.process_transaction(
signed_transaction, icon_service)
assert 'status' in tx_result
assert 1 == tx_result['status']
return tx_result
def test_004_open(self):
transaction = CallTransactionBuilder()\
.from_(self._walletOfProvider.get_address())\
.to(self._scoreAddrOfStoreAgentProxy)\
.step_limit(100000000)\
.nid(3)\
.nonce(100)\
.method('open')\
.params({'_index': '0x0'})\
.build()
txResult = self._sendTransaction(transaction, self._walletOfProvider)
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')
def test_game(self):
#CallBuildern을 사용하여호출 인스턴스 생성
params = {"_choice": 1, "_time": 1}
transaction = CallTransactionBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.value(2000000000000000000)\
.method("game_start") \
.params(params) \
.build()
# 서명이있는 서명 된 트랜잭션 객체를 반환합니다.
signed_transaction = SignedTransaction(transaction, self._test1)
# print("signed_transaction: ", signed_transaction)
txresult = self.process_transaction(signed_transaction,
self.icon_service)
print("txresult: ", txresult)
def sell_tap_fill_swap(tap_amount, swap_id):
""" It will fill someone's sell order if you provide the tap_amount and the swap_id. Returns tx hash """
swap_id = hex(swap_id)
tap_amount = int_to_bighexa(tap_amount)
pre_data = {'action': 'fill_irc2_order', 'swap_id': swap_id}
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 has 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_createCard(self):
params = {
"_grade": 1,
}
transaction = CallTransactionBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.value(1000000000000000000) \
.method("createCard") \
.params(params) \
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction, self._test1)
# print("signed_transaction: ", signed_transaction)
txresult = self.process_transaction(signed_transaction,
self.icon_service)
def call_transaction(_score_address, _fromWallet, _method, _params):
transaction = CallTransactionBuilder()\
.from_(_fromWallet.get_address())\
.to(_score_address)\
.step_limit(1000000000)\
.nid(3)\
.nonce(100)\
.method(_method)\
.params(_params)\
.build()
signed_transaction = SignedTransaction(transaction, _fromWallet)
txhash = TestACT.icon_service.send_transaction(signed_transaction)
#print('txhash = [{}] {}'.format(type(txhash), txhash))
time.sleep(10)
txresult = TestACT.icon_service.get_transaction_result(txhash)
#print('txresult = [{}] {}'.format(type(txresult), txresult))
return txresult
def build_transaction(self,
from_: KeyWallet,
to: str,
value: int = 0,
method: str = None,
params: dict = None) -> dict:
call_transaction = CallTransactionBuilder() \
.from_(from_.get_address()) \
.to(to) \
.value(value) \
.nid(3) \
.nonce(100) \
.method(method) \
.params(params) \
.build()
signed_transaction = SignedTransaction(call_transaction, from_,
10000000)
tx_result = self.process_transaction(signed_transaction,
self.icon_service)
self.assertEqual(tx_result['status'], 1)
return tx_result
def create_set_stake_tx(key_wallet: KeyWallet,
stake: int,
value: int = 0,
step_limit: int = DEFAULT_STEP_LIMIT,
nid: int = DEFAULT_NID,
nonce: int = 0) -> 'SignedTransaction':
transaction = CallTransactionBuilder(). \
from_(key_wallet.get_address()). \
to(SYSTEM_ADDRESS). \
value(value). \
step_limit(step_limit). \
nid(nid). \
nonce(nonce). \
method("setStake"). \
params({"value": hex(stake)}). \
build()
signed_transaction = SignedTransaction(transaction, key_wallet)
return signed_transaction
def test_005_propose(self):
transaction = CallTransactionBuilder()\
.from_(self._walletOfCustomer.get_address())\
.to(self._scoreAddrOfOrderAgentProxy)\
.step_limit(100000000)\
.nid(3)\
.nonce(100)\
.method('propose')\
.params({'_itemId': '0x0', '_value': '0x1000000000000000000'})\
.build()
txResult = self._sendTransaction(transaction, self._walletOfCustomer)
call = CallBuilder().from_(self._walletOfCustomer.get_address())\
.to(self._scoreAddrOfOrderAgentProxy)\
.method('getCount')\
.build()
callResult = self._sendCall(call)
self.assertEqual(callResult, '0x1')
call = CallBuilder().from_(self._walletOfCustomer.get_address())\
.to(self._scoreAddrOfOrderAgentProxy)\
.method('get')\
.params({'_index': '0x0'})\
.build()
callResult = self._sendCall(call)
self.assertEqual(json.loads(callResult)['state'], 'proposed')
self.assertEqual(
json.loads(callResult)['value'], 0x1000000000000000000)
call = CallBuilder().from_(self._walletOfCustomer.get_address())\
.to(self._scoreAddrOfOrderAgentProxy)\
.method('balanceOf')\
.params({'_owner': self._walletOfCustomer.get_address()})\
.build()
callResult = self._sendCall(call)
self.assertEqual(callResult, '0x0')
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 test_std_reference_proxy_set_std_basic(self):
call = (CallBuilder().from_(self._test1.get_address()).to(
self._std_reference_proxy).method("get_ref").build())
response = self.process_call(call, self.icon_service)
self.assertEqual(self._std_basic, response)
transaction = (CallTransactionBuilder().from_(
self._test1.get_address()).to(
self._std_reference_proxy).step_limit(100_000_000_000).nid(
3).nonce(100).method("set_ref").params({
"_ref":
self._test1.get_address()
}).build())
signed_transaction = SignedTransaction(transaction, self._test1)
tx_result = self.process_transaction(signed_transaction,
self.icon_service)
self.assertEqual(True, tx_result["status"])
call = (CallBuilder().from_(self._test1.get_address()).to(
self._std_reference_proxy).method("get_ref").build())
response = self.process_call(call, self.icon_service)
self.assertEqual(self._test1.get_address(), response)