The Future of On-Chain Reputation: A Graph-Based Approach

Reputation is tied to wallet addresses, which are free to create. This makes systems like airdrop farming and governance attacks trivial. Soulbound Tokens (SBTs) attempt to solve this but are static and lack context.

• Cost of Attack: Near-zero for creating fake identities.
• Real-World Impact: Degraded governance and inefficient capital allocation.

Reputation is siloed within individual protocols like Compound (credit scores) or Aave (collateral history). A user's proven record on Uniswap means nothing when they interact with MakerDAO. This creates massive inefficiency and onboarding friction.

• Data Silos: Reputation does not compose across the stack.
• User Burden: Must rebuild trust from zero in each new protocol.

Current models capture a point-in-time state (e.g., NFT ownership, token balance) but ignore behavioral history and relationship dynamics. This is why Gitcoin Passport scores can be manipulated and lack predictive power for complex interactions like lending or delegation.

• Temporal Blindness: No understanding of reputation decay or growth over time.
• Behavioral Blindness: Cannot differentiate between a savvy user and a lucky airdrop farmer.

Many "reputation" systems, like those for undercollateralized lending, simply outsource trust to centralized oracles for off-chain data (credit scores, KYC). This reintroduces single points of failure and censorship, defeating the purpose of decentralized finance.

• Centralization Vector: Trust shifts from code to a data provider.
• Composability Break: Oracle-dependent reputation cannot be natively used by other smart contracts.

On-chain systems are bad at penalizing bad actors. A wallet that rug-pulls a project can simply create a new address. There is no persistent, composable record of malicious activity that other protocols can automatically query and act upon.

• Accountability Gap: Malice has no lasting consequence.
• Network Risk: Bad actors freely migrate across the ecosystem.

Reputation is overwhelmingly defined by financial metrics: TVL, trading volume, yield. This ignores crucial non-financial signals like governance participation, development contributions, or community moderation, which are the true backbone of protocol health.

• Metric Poverty: Reduces complex human behavior to token flow.
• Ecosystem Risk: Undervalues contributors who secure long-term value.

Current reputation systems like Etherscan labels or Sybil scores are siloed and static. They lack context and cannot be programmatically composed across dApps, limiting their utility to basic allowlists.

• No Cross-Protocol Context: A Uniswap LP's history is invisible to a lending protocol like Aave.
• Static vs. Dynamic: Reputation doesn't update in real-time with on-chain actions.
• Fragmented Data: Each project builds its own scoring model, leading to redundant work and inconsistent results.

Model reputation as a live property graph where wallets are nodes and interactions are edges. This creates a portable, context-rich identity layer for DeFi and governance.

• Composable Attributes: A wallet's MakerDAO governance weight and GMX trading volume become verifiable, linked properties.
• Real-Time Updates: The graph updates with each transaction via indexers like The Graph or Subsquid.
• Programmable Trust: dApps like Compound or Optimism Grants can query subgraphs for custom reputation logic.

Use the reputation graph to assess borrower risk beyond just collateral, enabling capital-efficient credit markets. This is the holy grail that protocols like Goldfinch and Maple pursue off-chain.

• Graph-Based Credit Scores: Score derived from consistent DCA history on CowSwap, governance participation, and NFT collateral age.
• Dynamic Loan Terms: Interest rates and LTV ratios adjust automatically based on real-time reputation flux.
• Default Clustering: Identify correlated risk by analyzing the borrower's connected entity graph.

Move beyond token-weighted voting by using graph analysis to filter out sybil attacks and measure genuine contribution. This solves a core flaw in DAOs like Uniswap and Arbitrum.

• Interaction Provenance: Weight votes based on the depth and diversity of a wallet's on-chain history (e.g., long-term Curve LP vs. airdrop farmer).
• Cluster Detection: Use graph algorithms to identify and downvote tightly-coupled wallet clusters attempting to game proposals.
• Reputation Decay: Implement time-based decay on non-active participants to prevent stale power accumulation.

Reputation graphs allow solvers (e.g., for UniswapX or CowSwap) to prioritize orders from high-reputation users, creating a trusted order flow ecosystem resistant to MEV.

• Trusted Order Flow: Solvers can offer better prices and guarantee of execution to wallets with a history of non-arbitrage, high-value swaps.
• Reputation-Staked Solvers: Solvers themselves are nodes in the graph; poor performance or MEV extraction damages their score and access to flow.
• Cross-Chain Context: A wallet's reputation on Ethereum informs its treatment on a Solana intent system via bridges like LayerZero.

Building this requires solving for selective disclosure (Zero-Knowledge proofs) and standardized schemas (like ERC-7231). Without this, the graph becomes a surveillance tool or fails to interoperate.

• ZK Reputation Proofs: Prove you have a score > X without revealing your entire transaction history, using systems like Sismo or Polygon ID.
• Universal Schema: A standard for labeling graph nodes and edges (e.g., "LP since 2022", "Safe multisig signer") enables cross-protocol comprehension.
• Incentivized Curation: Who writes reputation attributes to the graph? Needs a token-incentivized oracle network like UMA or Pyth for subjective traits.

Today's reputation is siloed by protocol (e.g., Aave's credit score) or primitive (e.g., Gitcoin Passport). This fails to capture the composite identity of a wallet across DeFi, governance, and social graphs. It's like judging a person's credit using only their Twitter followers.

• No Cross-Protocol Context: A top Uniswap LP is a new user on a lending market.
• Vulnerable to Sybil Attacks: Easy to game one-dimensional metrics.

Model wallets as nodes and their interactions (trades, governance votes, NFT holdings, social follows) as weighted edges. This creates a portable, composable reputation layer that any dApp can query. Think EigenLayer for identity, not security.

• Composability: A lending protocol can query a user's liquidity provision history from Uniswap and governance participation from Compound.
• Sybil Resistance: Clustering algorithms (like those used by Hop Protocol or Across) can identify coordinated wallets based on graph topology.

The trillion-dollar opportunity. A graph-based score assessing wallet longevity, diversified DeFi activity, and social capital can enable under-collateralized loans without KYC. This moves DeFi from over-collateralized pawn shops to true credit markets.

• Risk Pricing: Lenders like Aave or Maple Finance can price risk based on a user's entire financial graph, not just posted collateral.
• Default Prediction: Graph patterns can predict wallet churn and default probability more accurately than simple health factors.

Graph reputation enables trust-minimized intents. A wallet with high reputation can broadcast transaction intents (e.g., "swap X for Y") without revealing full strategy, relying on solvers (like UniswapX or CowSwap) to compete for execution. High-reputation users get better rates and MEV protection.

• Reduced Slippage: Solvers prioritize filling orders from reputable, long-term users.
• Privacy: Users don't expose full tx details; reputation acts as collateral for good behavior.

Current token-weighted governance is plutocratic and low-signal. A reputation graph weights votes by participation quality (forum activity, successful proposal history, delegated stake size). This creates a meritocratic layer atop token voting.

• Anti-Whale Dilution: A whale's vote is discounted if their graph shows no meaningful ecosystem contribution.
• Delegation Markets: Platforms like Sybil.org evolve into reputation-based delegate marketplaces, where users delegate voting power based on a delegate's expertise graph.

The infrastructure is being built now. EigenLayer restakers can opt-in to validate reputation subgraphs. Hyperlane and LayerZero enable cross-chain reputation state synchronization. The Graph indexes the complex relationship data. Builders should integrate these primitives.

• Data Availability: Store graph attestations on Celestia or EigenDA for cheap, verifiable updates.
• Cross-Chain Sync: A user's reputation on Arbitrum must be recognizable on Base via interoperability layers.