Catch me if you can

Catch me if you can is an encrypted EVM Web3/AI protocol designed to quantify and surface regulatory arbitrage. We transform the opaque process of navigating legal grey zones into a transparent, measurable market.

The Problem: Regulatory systems are inefficient. Corporations with large legal teams exploit loopholes or intentionally violate rules when the profit outweighs the expected penalty. Regulators operate blind, unable to see where these inefficiencies are until significant damage is done. The system lacks a feedback loop to self-correct.

Our Solution: Catch me if you can provides a deterministic engine that calculates the Expected Value (EV) of regulatory arbitrage. The core logic is: EV = Profit – (Penalty × Enforcement Probability) – (Other Costs, e.g., Reputational Damage, Audit Latency)

We use an agent that evaluates:

•⁠ ⁠AI (LLM) queries for contextual legal/regulatory interpretation. •⁠ ⁠Structured data (via Enforcement Oracles) for real-world enforcement statistics. •⁠ ⁠Transaction proposals to deliver an expected-value verdict (EXECUTE, RISKY_EXECUTE, or DENY).

The Innovation: Transparent Arbitrage Unlike traditional compliance tools that offer a simple "yes/no," Catch me if you can explicitly surfaces profitable violations. Crucially, every evaluation is attested using Trusted Execution Environments (TEEs) and logged on-chain.

This creates a "self-healing" market for regulation:

Actors gain democratized access to sophisticated risk analysis and extract profit transparently.

Regulators gain a real-time heatmap of which laws are being exploited and why (e.g., low fines or weak enforcement), giving them the data required to close loopholes efficiently.

How it's made

The Catch Me If You Can architecture is built around a central MCP (Model-Computation-Predicate) Evaluator designed to run inside a Trusted Execution Environment (TEE) to ensure the integrity and confidentiality of the risk calculations.

The Technology Stack:

AI/ML Integration: We utilize Large Language Models (LLMs) to interpret unstructured legal text and regulatory templates, transforming them into machine-readable predicates for the risk engine.

Core Logic (The Arbitrage Engine): A deterministic Expected Value (EV) calculator implemented in Python (for the MVP). This engine incorporates advanced factors detailed in our research, including ReputationCost, AuditLatencyCost, and MultiJurisdictionPenalty.

Data Layer (Oracles): The engine relies on "Enforcement Data Oracles" to feed real-world statistics (penalty amounts, audit frequency). For the hackathon MVP, this is implemented via an enforcement adapter seeded with a mock JSON dataset simulating data from multiple jurisdictions (US, EU, SG).

Blockchain Layer (EVM): We use an EVM-compatible chain for transparency. The results of the EV calculation are compiled into an "Arbitrage Attestation," signed within the TEE (using EIP-712 standards), and committed on-chain.

Smart Contracts (Solidity): We developed the AttestationHub contract. To minimise gas costs, it only stores the hash and CID pointer of the full report (stored on IPFS), along with key metrics like expectedValueUSD and the decision.

Frontend (Next.js): An "Arbitrage Console" allows users to submit proposals and view the detailed EV breakdown.

A Notable Hack: To rapidly simulate the complex interplay between different jurisdictions for the MVP, we implemented the "Multi-Jurisdiction Cost Model" using a mock correlation matrix. This simulates whether penalties from different regulators (e.g., US and EU) "stack" or "substitute" when an actor violates laws in both, providing a more realistic risk assessment.