Payreq Response
The receiving VASP needs to construct an invoice for the sending VASP for the correct amount and
then return a valid
PayReqResponse
. The SDK can help with this process. First, we'll need an
implementation of the UmaInvoiceCreator
interface.class IUmaInvoiceCreator(ABC):
@abstractmethod
def create_uma_invoice(
self,
amount_msats: int,
metadata: str,
receiver_identifier: Optional[str],
) -> str:
pass
You can use any node implementation to create the invoice and wrap the invoice creation in an
implementation of this interface. Consult your node's documentation for how to create an invoice
with the correct amount and metadata hash.
From there, we can use this invoice creator and the SDK to construct the
PayReqResponse
.# The receiver's utxos might be used by the sending VASP to pre-screen the
# transaction with their compliance provider. This function is
# implementation-specific and need to be written by you.
receiver_utxos = get_node_utxos(receiver_identity)
# If known, the public key of the receiver's node. If supported by the sending
# VASP's compliance provider, this will be used to pre-screen the sender's UTXOs
# for compliance purposes. This function is implementation-specific and need to
# be written by you.
receiver_node_pubkey = get_node_pubKey(receiver_identity)
# This callback is the URL path that the sending VASP will call to send UTXOs of
# the channel that the sender used to receive the payment once it completes. See
# the "Sending the Payment & Post-transaction Hooks" section for more info.
utxo_callback = "https://vasp2.com/api/uma/utxocallback?txid=" + transaction_id
# You can populate payee data based on what was requested in the pay request.
payee_data = {
"name": "Alice",
"email": "alice@mailcompany.org",
"identifier": "$alice@vasp2.com"
}
response_json = uma.create_pay_req_response(
request=request,
invoice_creator=invoice_creator,
metadata=metadata,
# The currency code that the receiver will receive for this payment.
receiving_currency_code="USD",
# 2 decimal places in USD
receiving_currency_decimals=2,
msats_per_currency_unit=msats_per_currency_unit,
receiver_fees_msats=receiver_fees_msats,
receiver_node_pubkey=receiver_node_pubkey,
receiver_utxos=receiver_utxos,
utxo_callback=utxo_callback,
payee_identifier=receiver_uma,
signing_private_key=signing_private_key,
payee_data=payee_data,
).to_dict()
A note on exchange rates and expiration: The conversion rate returned in the initial
LnurlpResponse
is just considered an estimate. However, in the PayReqResponse
, you
are meant to be providing an exchange rate quote that is valid for the transaction until
the invoice you've created expires, so that the sender can ensure the end recipient receives
the intended amount by sending enough to cover any exchange costs and other fees charged by
the receiving VASP. Therefore, you should approach these rate quotations and invoice expiries
consistent with your current customer agreements and practices for these transactions.In this example, we're using a 10 minute expiration, but you should set this based on the
considerations above. Note that if the sending VASP's user takes a while to confirm and
send the payment, the invoice may expire. Some potential UX solutions are outlined in the
next section, “Sending the Payment & Post-transaction Hooks”.
There is also a
receiverFeesMillisats
field in which you can include any exchange fees
separately from the exchange rate. This gives both the sender and receiver more clarity around
transaction costs. Both the exchange rate and fees will be included in the created invoice amount.The response can now be serialized to JSON and sent back to the sending VASP in the response body.
When the sending VASP receives the response, it needs to first deserialize the response body to a
PayReqResponse
object:pay_req_response = uma.parse_pay_req_response(pay_req_response_json)
The full
PayReqResponse
structure is:@dataclass
class PayReqResponse:
encoded_invoice: str
"""
The encoded BOLT11 invoice that the sender will use to pay the receiver.
"""
routes: List[str]
"""
Always just an empty array for legacy reasons.
"""
payee_data: Optional[PayeeData]
"""
The data about the receiver that the sending VASP requested in the payreq
request. Required for UMA.
"""
payment_info: Optional[PayReqResponsePaymentInfo]
"""
Information about the payment that the receiver will receive. Includes
Final currency-related information for the payment. Required for UMA.
"""
disposable: Optional[bool] = None
"""
This field may be used by a WALLET to decide whether the initial LNURL link
will be stored locally for later reuse or erased. If disposable is null, it
should be interpreted as true, so if SERVICE intends its LNURL links to be
stored it must return `disposable: false`. UMA should never return
`disposable: false` due to signature nonce checks, etc. See LUD-11.
"""
success_action: Optional[Dict[str, str]] = None
"""
Defines a struct which can be stored and shown to the user on payment
success. See LUD-09.
"""
uma_major_version: Optional[int] = MAJOR_VERSION
"""
The major version of the UMA protocol that this currency adheres to.
This is not serialized to JSON.
"""
@dataclass
class PayReqResponseCompliance(JSONable):
utxos: List[str]
"""
List of UTXOs of channels over which the receiver will likely receive
the payment
"""
utxo_callback: str
"""
URL that the sender VASP will call to send UTXOs of the channel that the
sender used to send the payment once it completes
"""
node_pubkey: Optional[str]
"""Public key of the receiver's node if known"""
signature: Optional[str]
"""
Signature is the base64-encoded signature of
sha256(ReceiverAddress|Nonce|Timestamp)
Note: This field is optional for UMA v0.X backwards-compatibility.
It is required for UMA v1.X.
"""
signature_nonce: Optional[str]
"""
Random string that is used to prevent replay attacks
Note: This field is optional for UMA v0.X backwards-compatibility.
It is required for UMA v1.X.
"""
signature_timestamp: Optional[int]
"""
Time stamp of the signature in seconds since epoch
Note: This field is optional for UMA v0.X backwards-compatibility.
It is required for UMA v1.X.
"""
@dataclass
class PayReqResponsePaymentInfo(JSONable):
amount: Optional[int]
"""
The amount that the receiver will receive in the receiving currency not
including fees. The amount is specified in the smallest unit of the currency
(eg. cents for USD).
Note: This field is optional for UMA v0.X backwards-compatibility.
It is required for UMA v1.X.
"""
currency_code: str
"""
The currency code that the receiver will receive for this payment.
"""
decimals: int
"""
Number of digits after the decimal point for the receiving currency. For
example, in USD, by convention, there are 2 digits for cents - $5.95. In
this case, `decimals` would be 2. This should align with the currency's
`decimals` field in the LNURLP response. It is included here for convenience.
See [UMAD-04](https://github.com/uma-universal-money-address/protocol/blob/main/umad-04-lnurlp-response.md)
for details, edge cases, and examples.
"""
multiplier: float
"""
The conversion rate. It is the number of millisatoshis that the receiver will
receive for 1 unit of the specified currency (eg: cents in USD). In this
context, this is just for convenience. The conversion rate is also baked into
the invoice amount itself. Specifically:
`invoiceAmount = amount * multiplier + exchange_fees_msats`
"""
exchange_fees_msats: int
"""
The fees charged (in millisats) by the receiving VASP for this transaction.
This is separate from the `multiplier`.
"""
Like other UMA responses, the
PayReqResponse
includes signature which can be verified as follows:try:
uma.verify_pay_req_response_signature(
sender_address="$alice@vasp1.com",
receiver_address="$bob@vasp2.com",
response=response,
other_vasp_pubkeys=receiver_pubkey_response,
nonce_cache=nonce_cache,
)
except Exception as e:
# Handle the error
Now, if desired, the sending VASP can pre-screen the compliance info in the response with their
Compliance Provider by sending either
payreqResponse.Compliance.Utxos
or
payreqResponse.Compliance.NodePubKey
to the Compliance Provider.There's also a good chance that you'll want to save important
payReqResponse
data somewhere
persistent, so that when your user confirms that they want to send the payment, you still have
the encoded invoice, conversion rate, and any other identifiers you need to track the transaction
internally. If you also plan to show the sending user the conversion rate from their preferred
currency to bitcoin (or straight to the receiving currency), you should return it to your client
here. Note that the UMA standard describes only the interaction between VASPs, but the interaction
between you (a VASP) and your end-user devices is up to you. For an example implementation, see the
full example VASP implementation here.At this point, you can show the user a confirmation screen, including conversion rates, etc.