def test_receive_payment_with_travel_rule_metadata_and_invalid_reference_id( sender_account: AccountResource, receiver_account: AccountResource, currency: str, hrp: str, stub_config: AppConfig, diem_client: jsonrpc.Client, pending_income_account: AccountResource, invalid_ref_id: Optional[str], ) -> None: """ There is no way to create travel rule metadata with invalid reference id when the payment amount meets travel rule threshold, because the metadata signature is verified by transaction script. Also, if metadata signature is provided, transaction script will also verify it regardless whether the amount meets travel rule threshold, thus no need to test invalid metadata signature case. This test bypasses the transaction script validation by sending payment amount under the travel rule threshold without metadata signature, and receiver should handle it properly and refund. Test Plan: 1. Generate a valid account identifier from receiver account as payee. 2. Submit payment under travel rule threshold transaction from sender to receiver on-chain account. 3. Wait for the transaction executed successfully. 4. Assert the payment is refund eventually. Note: the refund payment will be received by pending income account of the MiniWallet Stub, because no account owns the original invalid payment transaction which is sent by test. """ receiver_account_identifier = receiver_account.generate_account_identifier( ) receiver_account_address = identifier.decode_account_address( receiver_account_identifier, hrp) sender_account_identifier = sender_account.generate_account_identifier() sender_address = identifier.decode_account_address( sender_account_identifier, hrp) metadata, _ = txnmetadata.travel_rule(invalid_ref_id, sender_address, amount) # pyre-ignore original_payment_txn: jsonrpc.Transaction = stub_config.account.submit_and_wait_for_txn( diem_client, stdlib.encode_peer_to_peer_with_metadata_script( currency=utils.currency_code(currency), amount=amount, payee=receiver_account_address, metadata=metadata, metadata_signature=b"", ), ) pending_income_account.wait_for_event( "created_transaction", status=Transaction.Status.completed, refund_diem_txn_version=original_payment_txn.version, ) assert receiver_account.balance(currency) == 0
def test_travel_rule_metadata_and_sig_message(factory): cmd = factory.new_sender_payment_command() metadata, sig_msg = txnmetadata.travel_rule( cmd.payment.reference_id, cmd.sender_account_address(factory.hrp()), cmd.payment.action.amount) assert metadata == cmd.travel_rule_metadata(factory.hrp()) assert sig_msg == cmd.travel_rule_metadata_signature_message(factory.hrp())
def test_travel_rule_metadata(): address = utils.account_address("f72589b71ff4f8d139674a3f7369c69b") metadata, sig_msg = txnmetadata.travel_rule("off chain reference id", address, 1000) assert metadata.hex() == "020001166f666620636861696e207265666572656e6365206964" assert ( sig_msg.hex() == "020001166f666620636861696e207265666572656e6365206964f72589b71ff4f8d139674a3f7369c69be803000000000000404024244449454d5f41545445535424244040" )
def p2p_by_travel_rule( self, currency: str, amount: int, receiver_vasp_address: str, off_chain_reference_id: str, metadata_signature: bytes, ) -> jsonrpc.Transaction: metadata, _ = txnmetadata.travel_rule( off_chain_reference_id, self.config.vasp_account_address(), amount, ) return self._p2p_transfer(currency, amount, receiver_vasp_address, metadata, metadata_signature)
def test_process_incoming_travel_rule_txn() -> None: account = create_account("fake_account") sender_addr = "46db232847705e05525db0336fd9f337" receiver_addr = "lrw_vasp" sender_subaddr = generate_new_subaddress(account.id) amount = 1000 * 1_000_000 sender = account_address(sender_addr) sequence = 1 currency = DiemCurrency.XUS blockchain_version = 1 off_chain_reference_id = "off_chain_reference_id" metadata, _ = travel_rule(off_chain_reference_id, sender, amount) storage.add_transaction( amount=amount, currency=currency, payment_type=TransactionType.OFFCHAIN, status=TransactionStatus.OFF_CHAIN_READY, source_id=account.id, source_address=sender_addr, source_subaddress=sender_subaddr, destination_address=receiver_addr, reference_id=off_chain_reference_id, ) process_incoming_transaction( sender_address=sender_addr, receiver_address=receiver_addr, sequence=sequence, amount=amount, currency=currency, metadata=diem_types.Metadata__TravelRuleMetadata.bcs_deserialize( metadata), blockchain_version=blockchain_version, ) # successfully parse meta and sequence tx = storage.get_transaction_by_details(source_address=sender_addr, source_subaddress=sender_subaddr, sequence=sequence) assert tx is not None assert tx.sequence == sequence assert tx.blockchain_version == blockchain_version
async def test_p2p_above_threshold_by_reference_id(): client = create_client() faucet = Faucet(client) sender = await faucet.gen_account() receiver = await faucet.gen_account() await receiver.rotate_dual_attestation_info(client, base_url="http://localhost") amount = 20_000_000_000 reference_id = str(uuid.uuid4()) metadata, metadata_signing_msg = txnmetadata.travel_rule( reference_id, sender.account_address, amount) metadata_signature = receiver.compliance_key.sign(metadata_signing_msg) payload = stdlib.encode_peer_to_peer_with_metadata_script_function( currency=utils.currency_code(XUS), payee=receiver.account_address, amount=amount, metadata=metadata, metadata_signature=metadata_signature, ) seq_num = await client.get_account_sequence(sender.account_address) txn = diem_types.RawTransaction( sender=sender.account_address, sequence_number=seq_num, payload=payload, max_gas_amount=1_000_000, gas_unit_price=0, gas_currency_code=XUS, expiration_timestamp_secs=int(time.time()) + 30, chain_id=chain_ids.TESTNET, ) signed_txn = sender.sign(txn) await client.submit(signed_txn) executed_txn = await client.wait_for_transaction(signed_txn) assert executed_txn is not None
def send_transaction_travel_rule( self, currency: DiemCurrency, amount: int, source_sub_address: str, dest_vasp_address: str, dest_sub_address: str, off_chain_reference_id: str, metadata_signature: bytes, ) -> Tuple[int, int]: account_info = self.fetch_account_info() if not account_info: raise RuntimeError(f"Could not find account {self.address_str}") sender = utils.account_address(self.address_str) metadata, metadata_sig = txnmetadata.travel_rule( off_chain_reference_id, sender, amount ) # sender constructs transaction after off chain communication script = stdlib.encode_peer_to_peer_with_metadata_script( currency=utils.currency_code(currency.value), payee=utils.account_address(dest_vasp_address), amount=amount, metadata=metadata, metadata_signature=metadata_signature, ) tx = self._custody.create_transaction( self._custody_account_name, account_info.sequence_number, script, currency.value, ) self._diem_client.submit(tx) onchain_tx = self._diem_client.wait_for_transaction(tx, 30) return onchain_tx.version, account_info.sequence_number
def test_p2p_by_travel_rule(): sender = context.generate(1) receiver = context.generate(2) faucet = testnet.Faucet(sender.jsonrpc_client) faucet.mint(sender.auth_key().hex(), 2_000_000_000, sender.config.gas_currency_code) faucet.mint(receiver.auth_key().hex(), 1_000, receiver.config.gas_currency_code) receiver.reset_dual_attestation_info() reference_id = "reference_id" amount = 1_800_000_000 metadata, sig_msg = txnmetadata.travel_rule( reference_id, sender.config.vasp_account_address(), amount, ) metadata_signature = receiver.config.compliance_private_key().sign(sig_msg) txn = sender.p2p_by_travel_rule( receiver.config.vasp_address, testnet.TEST_CURRENCY_CODE, amount, metadata, metadata_signature, ) assert txn assert txn.transaction.sender.lower() == sender.config.vasp_address script = txn.transaction.script assert script.receiver.lower() == receiver.config.vasp_address assert script.amount == amount assert script.metadata_signature == metadata_signature.hex() metadata = diem_types.Metadata.bcs_deserialize( bytes.fromhex(script.metadata)) assert isinstance(metadata, diem_types.Metadata__TravelRuleMetadata) assert metadata.value.value.off_chain_reference_id == reference_id
def test_custodial_to_custodial_above_threshold(): client = testnet.create_client() faucet = testnet.Faucet(client) sender_custodial = CustodialApp.create(faucet.gen_account()) receiver_custodial = CustodialApp.create(faucet.gen_account()) receiver_custodial.init_compliance_keys() intent_id = receiver_custodial.payment(user_id=0, amount=2_000_000_000) intent = identifier.decode_intent(intent_id, identifier.TDM) sender = sender_custodial.available_child_vasp() # sender & receiver communicate by off chain APIs off_chain_reference_id = "32323abc" metadata, metadata_signing_msg = txnmetadata.travel_rule( off_chain_reference_id, sender.account_address, intent.amount) metadata_signature = receiver_custodial.compliance_key.sign( metadata_signing_msg) # sender constructs transaction after off chain communication script = stdlib.encode_peer_to_peer_with_metadata_script( currency=utils.currency_code(intent.currency_code), payee=utils.account_address(intent.account_address), amount=intent.amount, metadata=metadata, metadata_signature=metadata_signature, ) seq_num = client.get_account_sequence(sender.account_address) txn = create_transaction(sender, seq_num, script, intent.currency_code) signed_txn = sender.sign(txn) client.submit(signed_txn) executed_txn = client.wait_for_transaction(signed_txn) assert executed_txn is not None