Diem ID Payment in Miniwallet with E2E Test

diem-types-ext/Metadata.py

@@ -1,5 +1,5 @@
 
-def decode_structure(self) -> typing.Union[None, 'GeneralMetadataV0', 'TravelRuleMetadataV0', 'RefundMetadataV0']:
+def decode_structure(self) -> typing.Union[None, 'GeneralMetadataV0', 'TravelRuleMetadataV0', 'RefundMetadataV0', 'PaymentMetadataV0']:
  """decode metadata structure
 
  Returns None for a non-structure type or undefined
@@ -14,4 +14,6 @@ def decode_structure(self) -> typing.Union[None, 'GeneralMetadataV0', 'TravelRul
  return typing.cast(RefundMetadataV0, self.value.value)
  elif type_index == 5:
  return typing.cast(CoinTradeMetadataV0, self.value.value)
+ elif type_index == 6:
+ return typing.cast(PaymentMetadataV0, self.value.value)
  return None

diem-types-ext/PaymentMetadataV0.py

@@ -0,0 +1,3 @@
+def to_bytes(self) -> bytes:
+ """Convert reference_id to bytes."""
+ return bytes(typing.cast(typing.Iterable[int], self.reference_id))

src/diem/diem_types/__init__.py

@@ -379,7 +379,9 @@ def bcs_deserialize(input: bytes) -> "Metadata":
  raise st.DeserializationError("Some input bytes were not read")
  return v
 
- def decode_structure(self) -> typing.Union[None, "GeneralMetadataV0", "TravelRuleMetadataV0", "RefundMetadataV0"]:
+ def decode_structure(
+ self,
+ ) -> typing.Union[None, "GeneralMetadataV0", "TravelRuleMetadataV0", "RefundMetadataV0", "PaymentMetadataV0"]:
  """decode metadata structure
 
  Returns None for a non-structure type or undefined
@@ -394,6 +396,8 @@ def decode_structure(self) -> typing.Union[None, "GeneralMetadataV0", "TravelRul
  return typing.cast(RefundMetadataV0, self.value.value)
  elif type_index == 5:
  return typing.cast(CoinTradeMetadataV0, self.value.value)
+ elif type_index == 6:
+ return typing.cast(PaymentMetadataV0, self.value.value)
  return None
 
 
@@ -567,6 +571,10 @@ def bcs_deserialize(input: bytes) -> "PaymentMetadataV0":
  raise st.DeserializationError("Some input bytes were not read")
  return v
 
+ def to_bytes(self) -> bytes:
+ """Convert reference_id to bytes."""
+ return bytes(typing.cast(typing.Iterable[int], self.reference_id))
+
 
 @dataclass(frozen=True)
 class RawTransaction:

src/diem/identifier/__init__.py

@@ -12,7 +12,7 @@
 from urllib import parse
 from typing import List
 
-from . import bech32
+from . import bech32, diem_id
 from .. import diem_types, utils, chain_ids
 
 from .bech32 import bech32_address_encode, bech32_address_decode, Bech32Error, _DIEM_BECH32_SIZE

src/diem/identifier/diem_id.py

@@ -0,0 +1,38 @@
+# Copyright (c) The Diem Core Contributors
+# SPDX-License-Identifier: Apache-2.0
+
+
+def create_diem_id(user_identifier: str, vasp_domain_identifier: str) -> str:
+ diem_id = user_identifier + "@" + vasp_domain_identifier
+ if not is_diem_id(diem_id):
+ raise ValueError(f"{diem_id} is not a valid DiemID.")
+ return diem_id
+
+
+def is_diem_id(account_identifier: str) -> bool:
+ if "@" not in account_identifier:
+ return False
+
+ user_identifier = account_identifier.split("@", 1)[0]
+ vasp_identifier = account_identifier.split("@", 1)[1]
+ if len(user_identifier) > 64 or len(vasp_identifier) > 63:
+ return False
+ for ch in user_identifier:
+ if not ch.isalnum() and ch != ".":
+ return False
+ for ch in vasp_identifier:
+ if not ch.isalnum() and ch != ".":
+ return False
+ return True
+
+
+def get_user_identifier_from_diem_id(diem_id: str) -> str:
+ if not is_diem_id(diem_id):
+ raise ValueError(f"{diem_id} is not a valid DiemID.")
+ return diem_id.split("@", 1)[0]
+
+
+def get_vasp_identifier_from_diem_id(diem_id: str) -> str:
+ if not is_diem_id(diem_id):
+ raise ValueError(f"{diem_id} is not a valid DiemID.")
+ return diem_id.split("@", 1)[1]

src/diem/offchain/client.py

@@ -23,6 +23,8 @@
  ErrorCode,
  FieldError,
  from_dict,
+ to_dict,
+ ReferenceIDCommandObject,
 )
 from .error import command_error, protocol_error
 
@@ -122,6 +124,27 @@ def ping(
  jws_msg = jws.serialize(request, sign)
  return self.send_request(self.my_compliance_key_account_id, counterparty_account_identifier, jws_msg)
 
+ def ref_id_exchange_request(
+ self,
+ sender: str,
+ sender_address: str,
+ receiver: str,
+ reference_id: str,
+ counterparty_account_identifier: str,
+ sign: typing.Callable[[bytes], bytes],
+ cid: typing.Optional[str] = None,
+ ) -> CommandResponseObject:
+ reference_id_command_object = ReferenceIDCommandObject(
+ sender=sender, sender_address=sender_address, receiver=receiver, reference_id=reference_id
+ )
+ request = CommandRequestObject(
+ cid=cid or str(uuid.uuid4()),
+ command_type=CommandType.ReferenceIDCommand,
+ command=to_dict(reference_id_command_object),
+ )
+ jws_msg = jws.serialize(request, sign)
+ return self.send_request(self.my_compliance_key_account_id, counterparty_account_identifier, jws_msg)
+
  def send_command(self, command: Command, sign: typing.Callable[[bytes], bytes]) -> CommandResponseObject:
  return self.send_request(
  request_sender_address=command.my_address(),

src/diem/offchain/payment_command.py

@@ -48,6 +48,7 @@ def init(
  original_payment_reference_id: typing.Optional[str] = None,
  description: typing.Optional[str] = None,
  inbound: bool = False,
+ reference_id: typing.Optional[str] = None,
  ) -> "PaymentCommand":
  """init functon initializes a new `PaymentCommand` for starting the process of exchanging KYC data
  and recipient signature."""
@@ -62,6 +63,7 @@ def init(
  currency,
  original_payment_reference_id=original_payment_reference_id,
  description=description,
+ reference_id=reference_id,
  ),
  inbound=inbound,
  )

src/diem/offchain/types/__init__.py

@@ -156,14 +156,15 @@ def new_payment_object(
  currency: str,
  original_payment_reference_id: typing.Optional[str] = None,
  description: typing.Optional[str] = None,
+ reference_id: typing.Optional[str] = None,
 ) -> PaymentObject:
  """Initialize a payment request command
 
  returns generated reference_id and created `CommandRequestObject`
  """
 
  return PaymentObject(
- reference_id=str(uuid.uuid4()),
+ reference_id=reference_id or str(uuid.uuid4()),
  sender=PaymentActorObject(
  address=sender_account_id,
  kyc_data=sender_kyc_data,
@@ -242,11 +243,13 @@ def new_payment_request(
 def reply_request(
  cid: typing.Optional[str],
  err: typing.Optional[OffChainErrorObject] = None,
+ result: typing.Optional[typing.Dict[str, typing.Any]] = None,
 ) -> CommandResponseObject:
  return CommandResponseObject(
  status=CommandResponseStatus.failure if err else CommandResponseStatus.success,
  error=err,
  cid=cid,
+ result=result,
  )
 
 

src/diem/testing/miniwallet/app/app.py

@@ -2,16 +2,17 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from typing import List, Tuple, Dict, Optional, Any, Callable
+import uuid
 from json.decoder import JSONDecodeError
-from .store import InMemoryStore
+from .store import InMemoryStore, NotFoundError
 from .pending_account import PENDING_INBOUND_ACCOUNT_ID
 from .diem_account import DiemAccount
-from .models import Subaddress, Account, Transaction, Event, KycSample, PaymentCommand
+from .models import Subaddress, Account, Transaction, Event, KycSample, PaymentCommand, ReferenceID
 from .event_puller import EventPuller
 from .json_input import JsonInput
 from ... import LocalAccount
-from .... import jsonrpc, offchain, utils
-from ....offchain import KycDataObject
+from .... import jsonrpc, offchain, utils, identifier
+from ....offchain import KycDataObject, ErrorCode
 import threading, logging, numpy, time
 
 
@@ -46,6 +47,9 @@ def create_account(self, data: JsonInput) -> Dict[str, str]:
  # it is used for testing offchain api.
  disable_background_tasks=data.get_nullable("disable_outbound_request", bool),
  )
+ if len(self.diem_account.diem_id_domains()) != 0:
+ diem_id = identifier.diem_id.create_diem_id(str(account.id), self.diem_account.diem_id_domains()[0])
+ self.store.update(account, diem_id=diem_id)
  balances = data.get_nullable("balances", dict)
  if balances:
  for c, a in balances.items():
@@ -59,8 +63,14 @@ def create_account(self, data: JsonInput) -> Dict[str, str]:
 
  def create_account_payment(self, account_id: str, data: JsonInput) -> Dict[str, Any]:
  self.store.find(Account, id=account_id)
- payee = data.get("payee", str, self._validate_account_identifier)
- subaddress_hex = None if self.offchain.is_my_account_id(payee) else self._gen_subaddress(account_id).hex()
+ subaddress_hex = None
+ payee = data.get("payee", str)
+ if identifier.diem_id.is_diem_id(payee):
+ self._validate_diem_id(payee)
+ else:
+ self._validate_account_identifier("payee", payee)
+ subaddress_hex = None if self.offchain.is_my_account_id(payee) else self._gen_subaddress(account_id).hex()
+
  txn = self._create_transaction(
  account_id,
  Transaction.Status.pending,
@@ -129,7 +139,13 @@ def _send_pending_payments(self) -> None:
  continue
  self.logger.info("processing %s", txn)
  try:
- if self.offchain.is_my_account_id(str(txn.payee)):
+ if identifier.diem_id.is_diem_id(str(txn.payee)):
+ vasp_identifier = identifier.diem_id.get_vasp_identifier_from_diem_id(str(txn.payee))
+ if vasp_identifier in self.diem_account.diem_id_domains():
+ self._send_internal_payment_txn(txn)
+ else:
+ self._send_external_payment_txn(txn)
+ elif self.offchain.is_my_account_id(str(txn.payee)):
  self._send_internal_payment_txn(txn)
  else:
  self._send_external_payment_txn(txn)
@@ -142,6 +158,7 @@ def _send_pending_payments(self) -> None:
  self.store.update(txn, status=Transaction.Status.canceled, cancel_reason=str(e))
 
  def _send_internal_payment_txn(self, txn: Transaction) -> None:
+ # TODO diem_id: handle DiemID case for internal
  _, payee_subaddress = self.diem_account.decode_account_identifier(str(txn.payee))
  subaddress = self.store.find(Subaddress, subaddress_hex=utils.hex(payee_subaddress))
  self.store.create(
@@ -171,7 +188,33 @@ def _send_external_payment_txn(self, txn: Transaction) -> None:
  else:
  self._start_external_payment_txn(txn)
 
- def _start_external_payment_txn(self, txn: Transaction) -> None:
+ def _start_external_payment_txn(self, txn: Transaction) -> None: # noqa: C901
+ if identifier.diem_id.is_diem_id(str(txn.payee)):
+ reference_id = self._create_reference_id(txn)
+ try:
+ vasp_identifier = identifier.diem_id.get_vasp_identifier_from_diem_id(str(txn.payee))
+ domain_map = self.diem_client.get_diem_id_domain_map()
+ diem_id_address = domain_map.get(vasp_identifier)
+ if diem_id_address is None:
+ raise ValueError(f"Diem ID domain {vasp_identifier} was not found")
+ self.store.update(txn, reference_id=reference_id)
+ response = self.offchain.ref_id_exchange_request(
+ sender=str(self.store.find(Account, id=txn.account_id).diem_id),
+ sender_address=self.diem_account.account_identifier(),
+ receiver=str(txn.payee),
+ reference_id=reference_id,
+ counterparty_account_identifier=identifier.encode_account(
+ diem_id_address, None, self.diem_account.hrp
+ ),
+ sign=self.diem_account.sign_by_compliance_key,
+ )
+ receiver_address, _ = self.diem_account.decode_account_identifier(
+ response.result.get("receiver_address") # pyre-ignore
+ )
+ self.store.update(txn, payee_onchain_address=receiver_address.to_hex())
+ except offchain.Error as e:
+ if e.obj.code == ErrorCode.duplicate_reference_id:
+ return
  if self.offchain.is_under_dual_attestation_limit(txn.currency, txn.amount):
  if not txn.signed_transaction:
  signed_txn = self.diem_account.submit_p2p(txn, self.txn_metadata(txn))
@@ -244,3 +287,35 @@ def _gen_subaddress(self, account_id: str) -> bytes:
  sub = self.store.next_id().to_bytes(8, byteorder="big")
  self.store.create(Subaddress, account_id=account_id, subaddress_hex=sub.hex())
  return sub
+
+ def validate_unique_reference_id(self, reference_id: str) -> None:
+ try:
+ duplicate_ref_id = self.store.find(ReferenceID, reference_id=reference_id)
+ raise ValueError(f"{reference_id} exists for account ID {duplicate_ref_id.account_id}")
+ except NotFoundError:
+ return
+
+ # Check the payee diem ID can be found in the domain map
+ # Check if payee is in the same wallet, the receiver account exists
+ def _validate_diem_id(self, diem_id: str) -> None:
+ payee_vasp_identifier = identifier.diem_id.get_vasp_identifier_from_diem_id(diem_id)
+ domain_map = self.diem_client.get_diem_id_domain_map()
+ payee_onchain_address = domain_map.get(payee_vasp_identifier)
+ if payee_onchain_address is None:
+ raise ValueError(f"Diem ID domain {payee_vasp_identifier} was not found")
+ if payee_vasp_identifier in self.diem_account.diem_id_domains():
+ self.store.find(Account, diem_id=diem_id)
+
+ def _create_reference_id(self, txn: Transaction) -> str:
+ while True:
+ reference_id = str(uuid.uuid4())
+ try:
+ self.store.create(
+ ReferenceID,
+ before_create=lambda data: self.validate_unique_reference_id(data["reference_id"]),
+ account_id=txn.account_id,
+ reference_id=reference_id,
+ )
+ return reference_id
+ except ValueError:
+ continue

src/diem/testing/miniwallet/app/diem_account.py

@@ -42,6 +42,10 @@ def travel_metadata(self, cmd: offchain.PaymentCommand) -> Tuple[bytes, bytes]:
  def payment_metadata(self, reference_id: str) -> Tuple[bytes, bytes]:
  return (txnmetadata.payment_metadata(reference_id), b"")
 
+ def diem_id_domains(self) -> List[str]:
+ account = self._client.get_account(self._account.account_address)
+ return [] if account is None else account.role.diem_id_domains
+
  def submit_p2p(
  self,
  txn: Transaction,
@@ -50,8 +54,10 @@ def submit_p2p(
  ) -> str:
  from_account = self._get_payment_account(by_address)
  self._ensure_account_balance(from_account, txn)
-
- to_account = identifier.decode_account_address(str(txn.payee), self.hrp)
+ if identifier.diem_id.is_diem_id(str(txn.payee)):
+ to_account = utils.account_address(str(txn.payee_onchain_address))
+ else:
+ to_account = identifier.decode_account_address(str(txn.payee), self.hrp)
  script = stdlib.encode_peer_to_peer_with_metadata_script(
  currency=utils.currency_code(txn.currency),
  amount=txn.amount,

src/diem/testing/miniwallet/app/event_puller.py

@@ -5,9 +5,10 @@
 from typing import Dict, Any, Iterator
 from .store import InMemoryStore, NotFoundError
 from .pending_account import PENDING_INBOUND_ACCOUNT_ID
-from .models import Transaction, Subaddress, PaymentCommand, RefundReason, Account
+from .models import Transaction, Subaddress, PaymentCommand, RefundReason, Account, ReferenceID
 from .... import jsonrpc, diem_types, txnmetadata, identifier, utils
 import copy, logging
+import uuid
 
 
 @dataclass
@@ -50,7 +51,7 @@ def save_payment_txn(self, event: jsonrpc.Event) -> None:
  self.logger.exception("process event failed")
  self._create_txn(PENDING_INBOUND_ACCOUNT_ID, event)
 
- def _save_payment_txn(self, event: jsonrpc.Event) -> None:
+ def _save_payment_txn(self, event: jsonrpc.Event) -> None: # noqa: C901
  metadata = txnmetadata.decode_structure(event.data.metadata)
  if isinstance(metadata, diem_types.GeneralMetadataV0):
  subaddress = utils.hex(metadata.to_subaddress)
@@ -72,6 +73,14 @@ def _save_payment_txn(self, event: jsonrpc.Event) -> None:
  reason = RefundReason.from_diem_type(metadata.reason)
  account_id = self._find_refund_account_id(version)
  return self._create_txn(account_id, event, refund_diem_txn_version=version, refund_reason=reason)
+ elif isinstance(metadata, diem_types.PaymentMetadataV0):
+ reference_id = str(uuid.UUID(bytes=metadata.to_bytes()))
+ try:
+ ref_id = self.store.find(ReferenceID, reference_id=reference_id)
+ except NotFoundError:
+ self.logger.exception("Transaction with reference ID %r not found" % reference_id)
+ return self._refund(RefundReason.other, event)
+ return self._create_txn(ref_id.account_id, event, reference_id=reference_id)
  raise ValueError("unrecognized metadata: %r" % event.data.metadata)
 
  def _find_refund_account_id(self, version: int) -> str: