test: add Tempo transaction memo conformance (#21)

* test: add Tempo transaction memo conformance

* test: clarify Tempo receipt verification vector

* fix: address tempo receipt conformance review

Author: mablr

conformance/HARNESS_SPEC.md

@@ -175,8 +175,13 @@ Required for vector conformance:
 | `base64url.encode` | `{ "text": string }` | `{ "text": string }` |
 | `base64url.decode` | `{ "text": string }` | `{ "text": string }` |
 | `challenge.id` | challenge id params | `{ "id": string }` |
+| `tempo.receipt.verify` | Tempo credential plus receipt fixture | `{ "status": "success", "reference": string }` |
 | `stripe.external_id_binding` | Stripe request, credential payload, and PaymentIntent fixture | verification outcome |
 
+`tempo.receipt.verify` is an optional staged vector capability. Adapters that do
+not advertise it are skipped; passing it demonstrates conformance for supplied
+receipt fixture verification, not full signed Tempo transaction verification.
+
 Required for flow conformance:
 
 | Operation | Input | Output |

conformance/adapters/python/adapter.json

@@ -22,6 +22,7 @@
     "receipt.format",
     "base64url.encode",
     "base64url.decode",
-    "challenge.id"
+    "challenge.id",
+    "tempo.receipt.verify"
   ]
 }

conformance/adapters/python/adapter.py

@@ -7,6 +7,7 @@
 import hashlib
 import hmac
 import subprocess
+import asyncio
 
 from mpp import (
     Challenge,
@@ -148,9 +149,29 @@ def error(message: str, error_type: str = "unknown_error"):
     "base64url.encode": "base64url-encode",
     "base64url.decode": "base64url-decode",
     "challenge.id": "generate-challenge-id",
+    "tempo.receipt.verify": "verify-tempo-receipt",
 }
 
 
+class FakeRpcResponse:
+    def __init__(self, payload):
+        self._payload = payload
+
+    def raise_for_status(self):
+        return None
+
+    def json(self):
+        return self._payload
+
+
+class FakeRpcClient:
+    def __init__(self, receipt):
+        self._receipt = receipt
+
+    async def post(self, *args, **kwargs):
+        return FakeRpcResponse({"jsonrpc": "2.0", "result": self._receipt, "id": 1})
+
+
 def adapter_success(value):
     return {"ok": True, "value": value}
 
@@ -177,6 +198,40 @@ def response_value_for_operation(op: str, result):
     return result
 
 
+async def verify_tempo_receipt(input_value: dict):
+    from mpp.methods.tempo.intents import ChargeIntent
+    from mpp.server.intent import VerificationError
+
+    credential_data = input_value["credential"]
+    challenge_data = credential_data["challenge"]
+    request_json = json.dumps(challenge_data["request"], separators=(",", ":"))
+    request_b64 = base64url_encode(request_json)
+
+    credential = Credential(
+        challenge=ChallengeEcho(
+            id=challenge_data["id"],
+            realm=challenge_data.get("realm", ""),
+            method=challenge_data["method"],
+            intent=challenge_data["intent"],
+            request=request_b64,
+            expires=challenge_data.get("expires"),
+            digest=challenge_data.get("digest"),
+        ),
+        payload=credential_data["payload"],
+        source=credential_data.get("source"),
+    )
+
+    intent = ChargeIntent(rpc_url="https://rpc.test")
+    intent._http_client = FakeRpcClient(input_value["receipt"])
+
+    try:
+        receipt = await intent.verify(credential, challenge_data["request"])
+    except VerificationError as exc:
+        return error(str(exc), "verification_error")
+
+    return success({"status": receipt.status, "reference": receipt.reference})
+
+
 def run_legacy_subprocess(command: str, input_data: str = ""):
     result = subprocess.run(
         [sys.executable, __file__, command],
@@ -296,6 +351,9 @@ def main():
                 opaque=params.get("opaque"),
             )
             print(json.dumps(success(result)))
+        elif command == "verify-tempo-receipt":
+            params = json.loads(input_data)
+            print(json.dumps(asyncio.run(verify_tempo_receipt(params))))
         else:
             print(json.dumps(error(f"Unknown command: {command}")))
     except Exception as e:
@@ -307,6 +365,8 @@ def main():
             error_type = "encoding_error"
         elif command.startswith("generate-"):
             error_type = "generation_error"
+        elif command.startswith("verify-tempo-receipt"):
+            error_type = "verification_error"
         else:
             error_type = "unknown_error"
         print(json.dumps(error(str(e), error_type)))

conformance/adapters/python/pyproject.toml

@@ -5,5 +5,5 @@ description = "Python conformance adapter for MPP tooling"
 license = { text = "MIT" }
 requires-python = ">=3.12"
 dependencies = [
-    "pympp==0.8.2",
+    "pympp[tempo]==0.8.2",
 ]

conformance/adapters/python/uv.lock

@@ -0,0 +1,40 @@
+{
+  "schema": 1,
+  "op": "tempo.receipt.verify",
+  "input": {
+    "credential": {
+      "challenge": {
+        "id": "challenge-123",
+        "realm": "api.example.com",
+        "method": "tempo",
+        "intent": "charge",
+        "expires": "2030-01-01T00:00:00Z",
+        "request": {
+          "amount": "1000",
+          "currency": "0x1234567890123456789012345678901234567890",
+          "recipient": "0x4567890123456789012345678901234567890123"
+        }
+      },
+      "payload": {
+        "type": "hash",
+        "hash": "0x1111111111111111111111111111111111111111111111111111111111111111"
+      }
+    },
+    "receipt": {
+      "transactionHash": "0x1111111111111111111111111111111111111111111111111111111111111111",
+      "status": "0x1",
+      "logs": [
+        {
+          "address": "0x1234567890123456789012345678901234567890",
+          "topics": [
+            "0x57bc7354aa85aed339e000bccffabbc529466af35f0772c8f8ee1145927de7f0",
+            "0x000000000000000000000000abcdabcdabcdabcdabcdabcdabcdabcdabcdabcd",
+            "0x0000000000000000000000004567890123456789012345678901234567890123",
+            "0xef1ed712011ece072f76bd8b82350e00000000000000000000eb18f2d4402269"
+          ],
+          "data": "0x00000000000000000000000000000000000000000000000000000000000003e8"
+        }
+      ]
+    }
+  }
+}

conformance/examples/tempo-receipt-verify.request.json

@@ -0,0 +1,7 @@
+{
+  "ok": true,
+  "value": {
+    "status": "success",
+    "reference": "0x1111111111111111111111111111111111111111111111111111111111111111"
+  }
+}

conformance/examples/tempo-receipt-verify.response.json

@@ -89,6 +89,14 @@
       "errorTypes": ["http_error"],
       "comparison": "http",
       "description": "Send one normalized HTTP request through the SDK payment-aware transport."
+    },
+    "tempo.receipt.verify": {
+      "category": "vector",
+      "inputRef": "protocol.schema.json#/$defs/TempoReceiptVerificationInput",
+      "successRef": "protocol.schema.json#/$defs/TempoReceiptVerificationOutput",
+      "errorTypes": ["verification_error"],
+      "comparison": "exact",
+      "description": "Verify a Tempo credential against a supplied receipt fixture. This is an optional staged capability until full signed transaction verification vectors are available."
     }
   }
 }

conformance/operations.json

@@ -63,6 +63,10 @@
     {
       "if": { "properties": { "op": { "const": "http.payment_request" } }, "required": ["op"] },
       "then": { "properties": { "input": { "$ref": "protocol.schema.json#/$defs/HttpPaymentRequest" } } }
+    },
+    {
+      "if": { "properties": { "op": { "const": "tempo.receipt.verify" } }, "required": ["op"] },
+      "then": { "properties": { "input": { "$ref": "protocol.schema.json#/$defs/TempoReceiptVerificationInput" } } }
     }
   ]
 }

conformance/schemas/adapter-request.schema.json

@@ -15,8 +15,9 @@
         "base64url.encode",
         "base64url.decode",
         "challenge.id",
-        "stripe.external_id_binding",
-        "http.payment_request"
+        "tempo.receipt.verify",
+        "http.payment_request",
+        "stripe.external_id_binding"
       ]
     },
     "ErrorType": {
@@ -227,6 +228,24 @@
         },
         "body": { "type": "string" }
       }
+    },
+    "TempoReceiptVerificationInput": {
+      "type": "object",
+      "required": ["credential", "receipt"],
+      "additionalProperties": false,
+      "properties": {
+        "credential": { "$ref": "#/$defs/Credential" },
+        "receipt": { "$ref": "#/$defs/JsonObject" }
+      }
+    },
+    "TempoReceiptVerificationOutput": {
+      "type": "object",
+      "required": ["status", "reference"],
+      "additionalProperties": false,
+      "properties": {
+        "status": { "type": "string", "const": "success" },
+        "reference": { "type": "string", "minLength": 1 }
+      }
     }
   }
 }