[P3] Make licensing WIRE handlers case-tolerant for the client's snake_case

The iOS client encodes every body to snake_case, so register_ip / license_ip
must accept ip_id / evidence_hash exactly as they accept ipId / evidenceHash.
Add a _first(body, *keys) helper and read owner/type/name/ipId/evidenceHash via
both cases; honest 400 when a required field is truly absent. This lets the P3
client execution legs (LicensingView.registerIP / issueLicense) actually
traverse to ip_royalties through the _call seam. Regenerated ROUTES.md (handler
line numbers) + snake_case test. Full suite 656 green.

Author: Neo

docs/ROUTES.md

@@ -63,7 +63,7 @@
 | POST | `/api/v1/governance/snapshot/vote` | `_handle_snapshot_vote` | service_routes.py:350 |  |
 | POST | `/api/v1/governance/treasury/transfer` | `_handle_treasury_transfer` | service_routes.py:351 |  |
 | POST | `/api/v1/governance/vote` | `_handle_governance_vote` | service_routes.py:227 |  |
-| POST | `/api/v1/groups` | `_handle_groups_create` | service_routes.py:1881 |  |
+| POST | `/api/v1/groups` | `_handle_groups_create` | service_routes.py:1908 |  |
 | POST | `/api/v1/iap/asn` | `handle_iap_asn` | server.py:2056 | ✅ |
 | POST | `/api/v1/iap/verify` | `handle_iap_verify` | server.py:2055 | ✅ |
 | POST | `/api/v1/identity/create` | `_handle_did_create` | service_routes.py:201 |  |
@@ -83,14 +83,14 @@
 | POST | `/api/v1/legal/agreement/execute` | `_handle_agreement_execute` | service_routes.py:365 |  |
 | POST | `/api/v1/legal/dispute/file` | `_handle_legal_dispute_file` | service_routes.py:366 |  |
 | POST | `/api/v1/legal/license/grant` | `_handle_license_grant` | service_routes.py:364 |  |
-| POST | `/api/v1/licensing/ip` | `_handle_licensing_register_ip` | service_routes.py:1885 |  |
-| POST | `/api/v1/licensing/licenses` | `_handle_licensing_create_license` | service_routes.py:1887 |  |
+| POST | `/api/v1/licensing/ip` | `_handle_licensing_register_ip` | service_routes.py:1912 |  |
+| POST | `/api/v1/licensing/licenses` | `_handle_licensing_create_license` | service_routes.py:1914 |  |
 | POST | `/api/v1/loyalty/earn` | `_handle_loyalty_earn` | service_routes.py:246 |  |
 | POST | `/api/v1/loyalty/redeem` | `_handle_loyalty_redeem` | service_routes.py:247 |  |
 | POST | `/api/v1/marketplace/buy` | `_handle_marketplace_buy` | service_routes.py:223 |  |
 | POST | `/api/v1/marketplace/list` | `_handle_marketplace_list` | service_routes.py:222 |  |
-| GET | `/api/v1/messaging/conversations` | `_handle_messaging_conversations` | service_routes.py:1871 |  |
-| GET | `/api/v1/messaging/conversations/{conversationId}/messages` | `_handle_messaging_messages` | service_routes.py:1872 |  |
+| GET | `/api/v1/messaging/conversations` | `_handle_messaging_conversations` | service_routes.py:1898 |  |
+| GET | `/api/v1/messaging/conversations/{conversationId}/messages` | `_handle_messaging_messages` | service_routes.py:1899 |  |
 | POST | `/api/v1/nft/batch-mint` | `_handle_nft_batch_mint` | service_routes.py:303 |  |
 | POST | `/api/v1/nft/bridge` | `_handle_nft_bridge` | service_routes.py:305 |  |
 | POST | `/api/v1/nft/collection/create` | `_handle_nft_collection_create` | service_routes.py:195 |  |

gateway/service_routes.py

@@ -1823,29 +1823,56 @@ async def _handle_groups_create(self, request: web.Request) -> web.Response:
         )
         return self._ok(result)
 
+    @staticmethod
+    def _first(body: dict, *keys: str):
+        """First present, non-empty value among *keys*.
+
+        The iOS client encodes every body to snake_case, so a client-supplied
+        camelCase key (``ipId``) arrives as ``ip_id``. Accept both forms.
+        """
+        for k in keys:
+            v = body.get(k)
+            if v not in (None, ""):
+                return v
+        return None
+
     async def _handle_licensing_register_ip(self, request: web.Request) -> web.Response:
         body = await self._parse_body(request)
-        self._require(body, "owner", "type", "name")
+        owner = self._first(body, "owner")
+        ip_type = self._first(body, "type", "ip_type")
+        name = self._first(body, "name")
+        if not owner or not ip_type or not name:
+            raise web.HTTPBadRequest(
+                text=json.dumps({"error": "owner, type and name are required"}),
+                content_type="application/json",
+            )
         result = await self._call(
             "ip_royalties", "register_ip",
-            owner=body["owner"],
-            ip_type=body["type"],
+            owner=owner,
+            ip_type=ip_type,
             metadata={
-                "title": body["name"],
-                "description": body.get("description", ""),
-                "content_hash": body.get("evidenceHash", ""),
+                "title": name,
+                "description": self._first(body, "description") or "",
+                "content_hash": self._first(body, "evidenceHash", "evidence_hash") or "",
             },
         )
         return self._ok(result)
 
     async def _handle_licensing_create_license(self, request: web.Request) -> web.Response:
         body = await self._parse_body(request)
-        self._require(body, "ipId", "recipient", "terms")
+        ip_id = self._first(body, "ipId", "ip_id")
+        recipient = self._first(body, "recipient")
+        terms = self._first(body, "terms")
+        if not ip_id or not recipient or terms is None:
+            raise web.HTTPBadRequest(
+                text=json.dumps({"error": "ipId, recipient and terms are required"}),
+                content_type="application/json",
+            )
         result = await self._call(
             "ip_royalties", "license_ip",
-            ip_id=body["ipId"],
-            licensee=body["recipient"],
-            terms=body["terms"],
+            ip_id=ip_id,
+            licensee=recipient,
+            terms=terms,
         )
         return self._ok(result)
 

tests/test_p2_route_completion.py

@@ -72,6 +72,27 @@ async def test_licensing_create_license_never_500(client):
     assert resp.status != 500, await resp.text()
 
 
+async def test_licensing_accepts_snake_case_body(client):
+    # The iOS client encodes bodies to snake_case; the handlers must accept it
+    # (ip_id / evidence_hash) exactly as they accept camelCase. A snake_case
+    # register must NOT be rejected as "missing name/type" (would be a 400).
+    reg = await client.post(
+        "/api/v1/licensing/ip",
+        json={"owner": "0xabc", "type": "patent", "name": "Snakey", "evidence_hash": "0xfeed"},
+    )
+    assert reg.status in (200, 400), await reg.text()   # 200 record or honest ip_type 400
+    assert reg.status != 500
+
+    lic = await client.post(
+        "/api/v1/licensing/licenses",
+        json={"ip_id": "ip_x", "recipient": "0xabc", "terms": {"license_type": "non_exclusive"}},
+    )
+    # Reached the service with ip_id populated -> not the "ipId required" 400.
+    assert lic.status != 500, await lic.text()
+    if lic.status == 400:
+        assert "required" not in (await lic.json()).get("error", "").lower()
+
+
 # ── NOT_IMPLEMENTED routes: honest 501, never a fake 200 ───────────────
 
 NOT_IMPLEMENTED = [