How did you integrate our partners, if any?

Reactive Network (Lasna)

UniBrain’s strategy loop runs on Reactive. The hook (UniBrainTelemetryHook) emits telemetry on swap activity; we use Reactive’s subscribe(...) and react(LogRecord) so UniBrainReactiveStrategy consumes pool events, runs deterministic feature extraction and scoring (via DeterministicAI.sol), and emits callbacks with RVM argument replacement.

The Reactive contract is deployed on Lasna; we validated subscription lifecycle, decision computation, and callback emission with health checks and proof tx URLs on Lasna Reactscan. The demo script (make demo-sepolia) runs Base Sepolia activity, then proves Reactive-side DecisionComputed and Callback logs and destination execution on Base.

What are the key links to share? (Ex. demo video, GitHub, deck)

Github:https://github.com/cryptanu/unibrain_hooks Slides: https://gamma.app/docs/Autonomous-AI-Strategy-Hook-for-Uniswap-v4-Pools-via-Reactive-Con-5wkbjk2167t1vlm?mode=doc Project Link: Demo Video:https://kommodo.ai/recordings/Ps7qLM9gRc4BPX3GOytS?uploadId=vaJsVd227hI8BBK6xhoM

Problem / Background: What inspired the idea? What problems are you solving?

LP strategy operations in AMMs are still mostly manual or bot-driven: strategy updates are delayed or inconsistent under volatile markets, off-chain keepers introduce liveness and trust assumptions, and execution auth is often weak across chains. Protocol teams also struggle to prove deterministic, replay-safe decisioning to auditors and partners. We wanted a design where pool telemetry drives strategy updates through a verified on-chain path—hook emits events, Reactive runs deterministic logic, executor authenticates callback source and RVM identity and nonce—so there are no keepers, no opaque bots, and full provenance for every decision.

Impact: What makes this project unique? What impact will this make?

UniBrain is event-driven and fully authenticated: the hook emits telemetry, Reactive runs deterministic AI (feature extraction + scoring) in a replay-safe way, and the executor only applies updates after verifying callback source, RVM allowlist, and nonce. That gives LPs and protocols auditable, keeper-free strategy automation and a clear story for judges and auditors. We shipped it end-to-end on Base Sepolia (origin + destination) and Reactive Lasna, with 46/46 tests passing (including hook, strategy book, executor, and reactive package), high coverage on critical contracts, and a demo script that prints full tx URLs for telemetry, Lasna decision/callback, and destination execution. It shows that Uniswap v4 hooks plus Reactive can power autonomous strategy loops without trust in off-chain operators.

Challenges: What was challenging about building this project?

  1. Designing the three-domain flow (origin hook → Reactive → destination executor) so telemetry, subscription lifecycle, and callback payloads stay in sync and gas-bounded, with no unbounded loops or trust in off-chain data.
  2. Callback authenticity and replay protection: the executor must verify that callbacks come from the correct Reactive contract/RVM and that each job nonce is consumed once; we had to align nonce handling, RVM allowlist checks, and reentrancy guards across Solidity and the reactive package.
  3. Deterministic AI in Solidity: implementing feature extraction and scoring in DeterministicAI.sol so the reactive strategy is reproducible and audit-friendly while still encoding useful regime/risk logic.