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)