Migrating from UMA v0.x to UMA v1

response = create_pay_req_response(
    # ... other params ...
    signing_private_key=self.config.get_signing_privkey(),
)

# You can pull the uma_version from the lnurlp response.
if uma_major_version > 0:
    try:
        verify_pay_req_response_signature(
            sender_address=sending_user.get_uma_address(),
            receiver_address=initial_request_data.receiver_uma,
            response=payreq_response,
            other_vasp_pubkeys=receiver_vasp_pubkey_response,
            nonce_cache=self.nonce_cache,
        )
    except InvalidSignatureException as e:
        _abort_with_error(
            424, f"Error verifying payreq response signature: {e}"
        )

# Note that in V1, you need to create the post-tx callback object using this
# function rather than manually constructing and serializing only the utxos.
post_tx_callback = create_post_transaction_callback(
    utxos_with_amounts,
    self.config.get_uma_domain(),
    self.config.get_signing_privkey()
)
res = requests.post(
    utxo_callback,
    json=post_tx_callback.to_dict(),
    timeout=10,
)

try:
    tx_callback = PostTransactionCallback.from_json(json.dumps(request.json))
except Exception as e:
    raise UmaException(
        status_code=400, message=f"Error parsing UTXO callback: {e}"
    )

if uma_major_version > 0:
    other_vasp_pubkeys = fetch_public_key_for_vasp(
        vasp_domain=tx_callback.vasp_domain,
        cache=pubkey_cache,
    )
    try:
        verify_post_transaction_callback_signature(
            tx_callback, other_vasp_pubkeys, nonce_cache
        )
    except InvalidSignatureException as e:
        raise UmaException(
            f"Error verifying post-tx callback signature: {e}", 424
        )

@app.route("/.well-known/lnurlpubkey")
def handle_public_key_request():
    # Note: The `to_dict()` at the end here is important to correctly serialize
    # the response.
    return create_pubkey_response(
        config.signing_cert_chain, config.encryption_cert_chain
    ).to_dict()

other_vasp_pubkeys = fetch_public_key_for_vasp(
    vasp_domain=tx_callback.vasp_domain,
    cache=pubkey_cache,
)

try:
    verify_uma_lnurlp_query_signature(
        request=lnurlp_request,
        other_vasp_pubkeys=other_vasp_pubkeys,
        nonce_cache=self.nonce_cache,
    )
except Exception as e:
    raise UmaException(
        f"Invalid signature: {e}",
        status_code=400,
    )

# If you're sending a specific amount in the sending currency,
# set is_amount_in_receiving_currency to False and specify the amount
# in msats. If you're sending a specific amount in the receiving
# currency, set is_amount_in_receiving_currency to True, which will
# lock to the receiving amount like in UMA v0.x. In that case, you'll
# need to specify amount in the smallest unit of the receiving currency
# like in UMA v0.x.
payreq = create_pay_request(
    receiving_currency_code=receiving_currency_code,
    is_amount_in_receiving_currency=is_amount_in_receiving_currency,
    amount=amount,
    # ... other params ...
)

# Note that the PayRequest object's fields changed slightly in v1. The
# `currency_code` field is now `receiving_currency_code` and there's a new
# `sending_currency_code` field. When creating the payreq response:
response = create_pay_req_response(
    request=pay_request,
    receiving_currency_code=pay_request.receiving_currency_code,
    # ... other params ...
)

requested_payee_data = create_counterparty_data_options(
    {
        "compliance": True,
        "identifier": True,
        # This boolean is just whether the field is mandatory or not.
        "email": False,
        "name": False,
        # ... any fields can be requested here ...
    }
)
payreq = create_pay_request(
    # ... other params ...
    requested_payee_data=requested_payee_data,
)

payee_data = {
    "name": "Satoshi Nakamoto",
    "email": "satoshi@nakomoto.com",
    # ... other fields if desired ...
    # Note that the compliance and identifier fields are added automatically for
    # UMA by the SDK.
}
response = create_pay_req_response(
    # ... other params ...
    payee_data=payee_data,
)

# The migration effort for Python is minimal. The SDK will automatically detect the
# version of the messages being parsed and in some cases, will create an
# uma_major_version field on the parsed object for visibility. For example, the
# PayRequest and PayreqResponse objects now have `uma_major_version` fields if you
# want to check the version of the message.

# The only change required in Python for backwards-compatibility is passing the UMA
# major version to the create_pay_request function. You can get this version by
# remembering the lnurlp response you received from the counterparty, which will
# include the UMA major version:
uma_version = initial_request_data.lnurlp_response.uma_version
if uma_version is not None:
    uma_major_version = ParsedVersion.load(uma_version).major
payreq = create_pay_request(
    # ... other params ...
    uma_major_version=uma_major_version if uma_version is not None else 1,
)

# On the receiving side, when handling an lnurlp request:
lnurlp_request: LnurlpRequest
try:
    lnurlp_request = parse_lnurlp_request(flask_request.url)
except UnsupportedVersionException as e:
    raise e
except Exception as e:
    print(f"Invalid UMA lnurlp request: {e}")
    raise UmaException(
        f"Invalid UMA lnurlp request: {e}",
        status_code=400,
    )

if not lnurlp_request.is_uma_request():
    # If you only support UMA, but not LNURL, you can return an error here.
    return self._handle_non_uma_lnurlp_request(lnurlp_request)

# Now you can handle the UMA-specific fields in the request like before.

# ... On the sending side, when you get back the lnurlp response:

lnurlp_response: LnurlpResponse
try:
    lnurlp_response = parse_lnurlp_response(response.text)
except Exception as e:
    _abort_with_error(424, f"Error parsing LNURLP response: {e}")

if not lnurlp_response.is_uma_response():
    # If you only support UMA, but not LNURL, you can return an error here.
    return self._handle_as_non_uma_lnurl_response(lnurlp_response, receiver_uma)

# There are similar functions available on the other message objects like
# PayRequest, PayreqResponse, etc.