def test_process_message_with_events(self):
# Prepare data for deployment message
keypair = async_core_client.crypto.generate_random_sign_keys()
signer = Signer.from_keypair(keypair=keypair)
call_set = CallSet(
function_name='constructor', header={'pubkey': keypair.public})
# Encode deployment message
encoded = async_core_client.abi.encode_message(
abi=self.events_abi, signer=signer,
deploy_set=self.deploy_set, call_set=call_set)
# Send grams
send_grams(address=encoded['address'])
# Deploy account
generator = async_core_client.processing.process_message(
abi=self.events_abi, signer=signer, deploy_set=self.deploy_set,
call_set=call_set, send_events=True)
events = []
for event in generator:
events.append(event)
result = events[-1]['response_data']
self.assertEqual([], result['out_messages'])
self.assertEqual(
{'out_messages': [], 'output': None}, result['decoded'])
def test_wait_for_transaction_with_events(self):
# Create deploy message
keypair = async_core_client.crypto.generate_random_sign_keys()
signer = Signer.from_keypair(keypair=keypair)
call_set = CallSet(
function_name='constructor', header={'pubkey': keypair.public})
encoded = async_core_client.abi.encode_message(
abi=self.events_abi, signer=signer,
deploy_set=self.deploy_set, call_set=call_set)
# Send grams
send_grams(address=encoded['address'])
# Send message
generator = async_core_client.processing.send_message(
message=encoded['message'], send_events=True, abi=self.events_abi)
events = []
for event in generator:
events.append(event)
shard_block_id = events[-1]['response_data']
# Wait for transaction
generator = async_core_client.processing.wait_for_transaction(
message=encoded['message'], shard_block_id=shard_block_id,
send_events=True, abi=self.events_abi)
events.clear()
for event in generator:
events.append(event)
result = events[-1]['response_data']
self.assertEqual([], result['out_messages'])
self.assertEqual(
{'out_messages': [], 'output': None}, result['decoded'])
def test_wait_for_transaction(self):
# Create deploy message
keypair = async_custom_client.crypto.generate_random_sign_keys()
signer = Signer.Keys(keys=keypair)
call_set = CallSet(
function_name='constructor',
header=FunctionHeader(pubkey=keypair.public))
encode_params = ParamsOfEncodeMessage(
abi=self.events_abi, signer=signer, deploy_set=self.deploy_set,
call_set=call_set)
encoded = async_custom_client.abi.encode_message(params=encode_params)
# Send grams
send_grams(address=encoded.address)
# Send message
send_params = ParamsOfSendMessage(
message=encoded.message, send_events=False, abi=self.events_abi)
send = async_custom_client.processing.send_message(
params=send_params)
# Wait for transaction
wait_params = ParamsOfWaitForTransaction(
message=encoded.message, shard_block_id=send.shard_block_id,
send_events=False, abi=self.events_abi)
wait = async_custom_client.processing.wait_for_transaction(
params=wait_params)
self.assertEqual([], wait.out_messages)
self.assertEqual([], wait.decoded.out_messages)
self.assertIsNone(wait.decoded.output)
def __check_address(address: str) -> Union[str, None]:
""" Check if address exists or `send_grams` """
q_params = ParamsOfQueryCollection(
collection='accounts', result='id',
filter={'id': {'eq': address}})
result = async_custom_client.net.query_collection(params=q_params)
if len(result.result):
return result.result[0]['id']
send_grams(address=address)
def test_wait_for_transaction_with_events(self):
# Create deploy message
keypair = async_custom_client.crypto.generate_random_sign_keys()
signer = Signer.Keys(keys=keypair)
call_set = CallSet(
function_name='constructor',
header=FunctionHeader(pubkey=keypair.public))
encode_params = ParamsOfEncodeMessage(
abi=self.events_abi, signer=signer, deploy_set=self.deploy_set,
call_set=call_set)
encoded = async_custom_client.abi.encode_message(params=encode_params)
# Send grams
send_grams(address=encoded.address)
# Send message
events = []
def __callback(response_data, response_type, *args):
self.assertEqual(
ProcessingResponseType.PROCESSING_EVENT, response_type)
event = ProcessingEvent.from_dict(data=response_data)
events.append(event)
send_params = ParamsOfSendMessage(
message=encoded.message, send_events=True, abi=self.events_abi)
send = async_custom_client.processing.send_message(
params=send_params, callback=__callback)
logging.info('Send message events:')
for e in events:
logging.info(e.type)
logging.info(f'Shard block id: {send.shard_block_id}')
# Wait for transaction
events.clear()
wait_params = ParamsOfWaitForTransaction(
message=encoded.message, shard_block_id=send.shard_block_id,
send_events=True, abi=self.events_abi)
wait = async_custom_client.processing.wait_for_transaction(
params=wait_params, callback=__callback)
self.assertEqual([], wait.out_messages)
self.assertEqual([], wait.decoded.out_messages)
self.assertIsNone(wait.decoded.output)
logging.info('Wait message events:')
for e in events:
logging.info(e.type)
def test_process_message_with_events(self):
# Prepare data for deployment message
keypair = async_custom_client.crypto.generate_random_sign_keys()
signer = Signer.Keys(keys=keypair)
call_set = CallSet(
function_name='constructor',
header=FunctionHeader(pubkey=keypair.public))
# Encode deployment message
encode_params = ParamsOfEncodeMessage(
abi=self.events_abi, signer=signer, deploy_set=self.deploy_set,
call_set=call_set)
encoded = async_custom_client.abi.encode_message(params=encode_params)
# Send grams
send_grams(address=encoded.address)
# Deploy account
events = []
def __callback(response_data, response_type, *args):
self.assertEqual(
ProcessingResponseType.PROCESSING_EVENT, response_type)
event = ProcessingEvent.from_dict(data=response_data)
events.append(event)
deploy_params = ParamsOfProcessMessage(
message_encode_params=encode_params, send_events=True)
deploy = async_custom_client.processing.process_message(
params=deploy_params, callback=__callback)
self.assertEqual(
encoded.address, deploy.transaction['account_addr'])
self.assertEqual('finalized', deploy.transaction['status_name'])
self.assertEqual(0, len(deploy.out_messages))
logging.info('Events fired')
for e in events:
logging.info(e.type)
def test_process_message(self):
# Prepare data for deployment message
keypair = async_custom_client.crypto.generate_random_sign_keys()
signer = Signer.Keys(keys=keypair)
call_set = CallSet(
function_name='constructor',
header=FunctionHeader(pubkey=keypair.public))
# Encode deployment message
encode_params = ParamsOfEncodeMessage(
abi=self.events_abi, signer=signer, deploy_set=self.deploy_set,
call_set=call_set)
encoded = async_custom_client.abi.encode_message(params=encode_params)
# Send grams
send_grams(address=encoded.address)
# Deploy account
process_params = ParamsOfProcessMessage(
message_encode_params=encode_params, send_events=False)
result = async_custom_client.processing.process_message(
params=process_params)
self.assertEqual(
encoded.address, result.transaction['account_addr'])
self.assertEqual('finalized', result.transaction['status_name'])
self.assertEqual(0, len(result.out_messages))
# Contract execution error
with self.assertRaises(TonException):
call_set = CallSet(function_name='returnValue', input={'id': -1})
encode_params = ParamsOfEncodeMessage(
abi=self.events_abi, signer=signer, address=encoded.address,
call_set=call_set)
process_params = ParamsOfProcessMessage(
message_encode_params=encode_params, send_events=False)
async_custom_client.processing.process_message(
params=process_params)
def test_suspend_resume(self):
# Data for contract deployment
keypair = async_custom_client.crypto.generate_random_sign_keys()
abi = Abi.from_path(path=os.path.join(SAMPLES_DIR, 'Hello.abi.json'))
with open(os.path.join(SAMPLES_DIR, 'Hello.tvc'), 'rb') as fp:
tvc = base64.b64encode(fp.read()).decode()
signer = Signer.Keys(keys=keypair)
deploy_set = DeploySet(tvc=tvc)
call_set = CallSet(function_name='constructor')
# Prepare deployment params
encode_params = ParamsOfEncodeMessage(
abi=abi, signer=signer, deploy_set=deploy_set, call_set=call_set)
encode = async_custom_client.abi.encode_message(params=encode_params)
# Subscribe for address deploy transaction status
transactions = []
def __callback(response_data, response_type, *args):
if response_type == SubscriptionResponseType.OK:
result = ResultOfSubscription(**response_data)
transactions.append(result.result)
self.assertEqual(encode.address, result.result['account_addr'])
if response_type == SubscriptionResponseType.ERROR:
logging.info(ClientError(**response_data).__str__())
subscribe_params = ParamsOfSubscribeCollection(
collection='transactions', result='id account_addr',
filter={'account_addr': {'eq': encode.address}, 'status_name': {'eq': 'Finalized'}})
subscribe = async_custom_client.net.subscribe_collection(
params=subscribe_params, callback=__callback)
# Send grams to new account to create first transaction
send_grams(address=encode.address)
# Give some time for subscription to receive all data
time.sleep(2)
# Suspend subscription
async_custom_client.net.suspend()
time.sleep(2) # Wait a bit for suspend
# Deploy to create second transaction.
# Use another client, because of error: Fetch first block failed:
# Can not use network module since it is suspended
second_config = ClientConfig()
second_config.network.server_address = CUSTOM_BASE_URL
second_client = TonClient(config=second_config)
process_params = ParamsOfProcessMessage(
message_encode_params=encode_params, send_events=False)
second_client.processing.process_message(params=process_params)
second_client.destroy_context()
# Check that second transaction is not received when
# subscription suspended
self.assertEqual(1, len(transactions))
# Resume subscription
async_custom_client.net.resume()
time.sleep(2) # Wait a bit for resume
# Run contract function to create third transaction
call_set = CallSet(function_name='touch')
encode_params = ParamsOfEncodeMessage(
abi=abi, signer=signer, address=encode.address, call_set=call_set)
process_params = ParamsOfProcessMessage(
message_encode_params=encode_params, send_events=False)
async_custom_client.processing.process_message(params=process_params)
# Give some time for subscription to receive all data
time.sleep(2)
# Check that third transaction is now received after resume
self.assertEqual(2, len(transactions))
self.assertNotEqual(transactions[0]['id'], transactions[1]['id'])
# Unsubscribe
async_custom_client.net.unsubscribe(params=subscribe)
