Root is a privacy-aware social graph application designed to make trusted introductions and relationships visible, usable, and composable across communities and builder ecosystems.

Root focuses on real connections, not content or engagement. It allows builders, founders, and community members to navigate who knows whom, request and mediate introductions, and coordinate access—while giving users and communities fine-grained control over what parts of the graph are visible.

Built as a Telegram MiniApp, Root fits naturally into where Web3 networking already happens, while adding structure, memory, and privacy to otherwise fragmented interactions. Root has a clear path toward becoming shared social infrastructure as relationships need to be reused beyond the UI.

Key Features

• Interactive social graph UI
  Visualize connections between builders, founders, and community members using a force-directed graph, optimized for clarity rather than popularity or ranking.

• Trusted introductions (intro flows)
  Request, accept, and mediate introductions explicitly—turning social coordination into an intentional, auditable process rather than cold outreach.

• Community- scoped graphs
  Each community can have its own graph with custom visibility rules, enabling private or semi-private networks without fragmenting identity.

• Privacy-first graph visibility
  Users control which connections are visible, to whom, and in which contexts. Relationships can exist without being publicly exposed.

• Builder, Intromaker, and Founder workflows
  Root is designed for people who actively create value through connections—making it easy to navigate networks, spot introduction paths, and coordinate collaboration.

• Event- and cohort-ready relationships
  Connections can be time-bound or context-specific, enabling use cases like events, programs, and temporary communities

Core Design Goals

1. Explicit social actions
   Every meaningful interaction (connection request, acceptance, introduction) is represented as a state transition.

2. Privacy-aware by default
   The system separates verifiable facts (on-chain) from semantic meaning (off-chain).

3. Community-scoped graphs
   Social graphs are contextualized by communities, not global by default.

4. Event-driven architecture
   On-chain contracts emit minimal events that are indexed and composed off-chain.

5. Infra-ready modularity
   Contracts are structured so higher-level primitives (attestations, snapshots, access hooks) can be added without breaking the core

Technical challenges

• Graph Visualization at Scale
  Rendering meaningful social graphs without overwhelming users required careful tuning of layouts, filters, and interaction patterns.

• Privacy vs. Usability
  Balancing visibility and privacy was a core challenge—ensuring users feel safe exposing connections while keeping the graph useful for coordination.

• Modeling Social Actions On-Chain
  Translating real-world social interactions (like introductions) into explicit, verifiable smart contract flows required careful state modeling.

• Avoiding Social Anti-Patterns
  Root deliberately avoids rankings, scores, and engagement mechanics, which required rethinking common “social product” assumptions.

Tech Stack and Architecture

Frontend & UI

• React 18 + TypeScript SPA, bundled with Vite for fast iteration.

• Tailwind CSS with token-based theming via CSS variables.

• Accessible UI components built on Radix UI (shadcn-style).

• Motion and feedback handled with Framer Motion and Sonner.

Routing & Navigation

• Client-side routing using React Router.

• Two main routes: landing (/) and Trust Map (/trustmap).

• In-app navigation only, no full page reloads.

Backend Stack

• Supabase as the backend platform.

• Postgres for application data and indexed state.

• Supabase Auth for identity and Edge Functions for privileged logic.

• Server-side wallet signature verification and asset handling.

Indexing & Data Flow

• All contracts emit structured events

• Off-chain indexers transform events into graph representations

• Sensitive metadata (handles, notes, context) remains off-chain and access-controlled.

Network Targeting

• Mantle contract address injected via environment configuration.

• UI blocks actions if the user is on the wrong network.

• Supports local, staging, and production environments via config only.

Execution Flow

• User connects a wallet and the network is validated.

• Smart contract write records a trust or connection action.

• Transaction receipt is awaited and stored off-chain.

• UI links on-chain proof while reading state from Supabase.

Why This Matters Technically

Root demonstrates that:

• Social interactions can be modeled as verifiable state machines

• Privacy and composability are compatible

• A social graph can be both usable today and reusable tomorrow

  The system shows a clear path from application-layer utility to protocol-layer infrastructure without redesigning the core.

Pre-seed. Building MVP for test and early traction.