Preserve ABI revert evidence for pinned NFT lifecycle reads

Author: wock9000

docs/RPC_OPERATIONS.md

@@ -24,6 +24,12 @@ contract outcome, not a provider outage. The caller receives the RPC error and
 the provider remains available for other calls. Transport failures, malformed
 responses, and missing archive state still trigger capability-specific failover.
 
+Routed RPC exceptions retain the redacted JSON-RPC error payload, including
+ABI revert data. The pinned-state decoder uses that evidence to recognize
+`Invalid token ID` only at a verified same-receipt NFT mint/burn boundary.
+Keeping only the provider message loses this proof and retries valid receipts
+indefinitely. Unproven absence and unrelated errors still fail enrichment.
+
 ## Goldsky measurements and limits
 
 A small anonymous-output probe from the production host verified the donated provider privately: chain 4663; exact matching block/header and log digests against the local node; old block headers; USDG `decimals()` at blocks 30,000,000 and 56,400,000; receipts; `debug_traceTransaction` with `callTracer`; and a four-item JSON-RPC batch. The local pruned node could not answer those archive-state calls. Individual successful Goldsky requests in this probe took roughly 76–352 ms; these are samples, not percentile/SLA claims.

src/rhpools/lp_rpc.py

@@ -659,8 +659,10 @@ def _validate_item(self, source: _Source, item: Any, request_id: int, method: st
         if error is not None:
             code = error.get("code") if isinstance(error, Mapping) else None
             message = error.get("message") if isinstance(error, Mapping) else error
+            # Pinned NFT lifecycle reads need the ABI revert payload, not just
+            # its message. Keep the full error while redacting provider secrets.
             failure = self._error(
-                f"{source.name} {method}: {self._registry._safe_error(source, RuntimeError(str(message)))}",
+                f"{source.name} {method}: {self._registry._safe_error(source, RuntimeError(str(error)))}",
                 code=code if isinstance(code, int) else None,
             )
             if method in {"eth_call", "eth_estimateGas"} and (

tests/test_lp_rpc.py

@@ -217,3 +217,74 @@ def response(item):
         assert client.batch([good]) == ["0x01"]
     finally:
         factory.close()
+
+
+@pytest.mark.parametrize("lifecycle", ["mint", "burn"])
+def test_nfpm_lifecycle_absence_survives_routed_batch_fallback(
+        provider, monkeypatch, tmp_path, lifecycle):
+    from eth_abi import encode
+    from rhpools.lp_market_index import MarketIndexer, RpcError
+    from rhpools.lp_market_protocols import (
+        ProtocolDecodeError, UNISWAP_V3_POSITION_MANAGER,
+        decode_position_state_results, position_state_requests,
+    )
+    from rhpools.lp_market_store import MarketStore
+
+    monkeypatch.setattr(provider._registry, "error_type", RpcError)
+    zero, owner = "0x" + "0" * 40, "0x" + "1" * 40
+    missing_pin = "0x9" if lifecycle == "mint" else "0xa"
+    liquidity = 100 if lifecycle == "mint" else 0
+    revert_data = "0x08c379a0" + encode(["string"], ["Invalid token ID"]).hex()
+    position_data = "0x" + encode(
+        ["uint96", "address", "address", "address", "uint24", "int24",
+         "int24", "uint128", "uint256", "uint256", "uint128", "uint128"],
+        [0, zero, owner, "0x" + "2" * 40, 500, -60, 60, liquidity, 0, 0, 0, 0],
+    ).hex()
+
+    def post(_client, _source, payload):
+        def response(item):
+            result = {"jsonrpc": "2.0", "id": item["id"]}
+            if item["method"] == "eth_chainId":
+                result["result"] = hex(CHAIN_ID)
+            elif item["params"][1] == missing_pin:
+                result["error"] = {
+                    "code": 3,
+                    "message": "RuntimeError: execution reverted: Invalid token ID",
+                    "data": revert_data,
+                }
+            else:
+                result["result"] = position_data
+            return result
+        return [response(item) for item in payload] if isinstance(payload, list) else response(payload)
+
+    monkeypatch.setattr(lp_rpc.RoutedRpc, "_post", post)
+    event = {
+        "protocol": "nft", "kind": "transfer", "block_number": 10,
+        "block_hash": "0x" + "a" * 64, "tx_hash": "0x" + "b" * 64,
+        "tx_index": 0, "log_index": 1, "token_id": "42",
+        "custody": UNISWAP_V3_POSITION_MANAGER,
+        "data": {
+            "manager_protocol": "v3", "mint": lifecycle == "mint",
+            "burn": lifecycle == "burn",
+            "prior_owner": zero if lifecycle == "mint" else owner,
+            "new_owner": owner if lifecycle == "mint" else zero,
+        },
+    }
+    with MarketStore(tmp_path / "market.sqlite") as store:
+        scanner = MarketIndexer(store, SimpleNamespace(), "", rpc=provider)
+        try:
+            requests = position_state_requests([event])
+            results = scanner._rpc_state_batch(scanner._state_rpc_calls(requests))
+            update = decode_position_state_results(requests, results)[0]["data"]
+            missing = "position_before" if lifecycle == "mint" else "position_after"
+            present = "position_after" if lifecycle == "mint" else "position_before"
+            assert update[missing]["exists"] is False
+            assert update[missing]["claims_empty"] is True
+            assert update[present]["exists"] is True
+            assert update[present]["liquidity"] == str(liquidity)
+
+            event["data"].update(mint=False, burn=False)
+            with pytest.raises(ProtocolDecodeError, match="pinned eth_call failed"):
+                decode_position_state_results(position_state_requests([event]), results)
+        finally:
+            scanner.close()