From zero to
integrated.

Introduction

PROOF turns a wallet's onchain history into a single, portable reputation score. Instead of every protocol re-asking "who are you?" with a KYC form, they can ask PROOF — and get back a score grounded entirely in public chain data.

This is a demonstration project. The API responses are mocked, the scoring model is illustrative, and no protocol is integrating with PROOF in production. If you want to see what a real reputation primitive looks like in production, check out Gitcoin Passport, Karma3Labs, or Galxe.

Quickstart — 90 seconds

The fastest way to feel out PROOF is to score a wallet you already know.

curl https://api.proof.demo/v1/passport/0x7a3f...e2c1

Core concepts

Passport

A passport is the full document for a single wallet — score, tier, dimension breakdown, metrics, flags, and credentials. It's computed lazily on first request and cached for 24 hours unless refresh=true is passed.

Score

A single integer between 0 and 1000. Computed as a weighted sum of six normalized dimensions. The score is deterministic — the same chain state always produces the same score for the same model version.

Tier

A categorical bucket the score falls into: trusted (700+), verified (500–699), neutral (250–499), risky (under 250). Tiers are designed to be stable across minor model versions; gate on tier rather than raw score if you want fewer breaking changes.

Flags

Discrete risk signals attached to a wallet — sanctioned counterparty, mixer interaction, drainer victim, etc. Flags lower the Risk-free dimension and can also be queried directly via /flags/:address.

Credentials

Positive attestations — "DAO voter", "LP provider", "OG wallet (2017)". Earned automatically based on chain history. Not weighted into the score directly — they're a human-readable summary of what the wallet has done.

Frontend gating

The most common integration is gating a UI feature based on a connected wallet's tier. Here's a minimal example using fetch:

async function checkAccess(address) {
  const res = await fetch(
    `https://api.proof.demo/v1/tier/${address}`
  );
  const tier = await res.text();

  if (tier === 'risky') {
    return { allowed: false, reason: 'Wallet flagged' };
  }
  if (tier === 'neutral') {
    return { allowed: true, requireExtraStep: true };
  }
  return { allowed: true };
}

Cache the response on your end — passports update on a 24h cadence by default, so there's no benefit to re-fetching on every page load.

Smart contracts

Reading PROOF on-chain requires an oracle, since the score itself lives off-chain. We're working on a Chainlink Functions integration; in the meantime, you can use a signed attestation pattern:

contract GatedVault {
  address public proofSigner;

  function deposit(
    uint256 amount,
    uint256 score,
    uint256 expiry,
    bytes calldata sig
  ) external {
    require(score >= 500, "insufficient score");
    require(block.timestamp < expiry, "attestation expired");
    _verifySignature(msg.sender, score, expiry, sig);
    // ... deposit logic
  }
}

The user fetches a signed attestation from PROOF, then passes it into the contract along with their action. The contract verifies the signer and the freshness, then enforces whatever threshold makes sense.

Webhooks

Subscribe to changes on a list of wallets and get notified when their score crosses a tier boundary. Useful for monitoring an allowlist over time.

Available events: tier.changed, flag.added, flag.removed, credential.earned. Configure via the dashboard or POST /v1/webhooks.

FAQ

Changelog