GitLedger
Protocol Overview

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract GitLedger {
    IEAS    public immutable eas;
    IERC20  public immutable usdc;
    bytes32 public immutable schema;
    address public immutable chainlinkOracle;

    uint256 public constant ORACLE_WINDOW   = 30 days;
    uint256 public constant REPORTER_SHARE  = 7000; // 70% bps
    uint256 public constant TREASURY_SHARE  = 3000; // 30% bps

    struct StakeRecord {
        address reviewer;
        bytes32 basename;       // keccak256("name.base.eth")
        string  repoSlug;
        uint256 prId;
        uint256 amount;
        uint256 stakedAt;
        bytes32 attestationUID;
        StakeState state;
    }

    enum StakeState { Active, Slashed, Released }

    mapping(bytes32 => StakeRecord) public stakes;     // keccak256(reviewer + prId)
    mapping(bytes32 => uint256)     public reputation; // basename => score
    address public treasury;

    event StakeLocked(bytes32 stakeId, address reviewer, uint256 amount);
    event ReviewSlashed(bytes32 stakeId, address reporter, uint256 reporterAmt);
    event YieldReleased(bytes32 stakeId, address reviewer, uint256 total);

    function stakeReview(
        bytes32 basename, string calldata repoSlug, uint256 prId, uint256 amount
    ) external returns (bytes32 stakeId) {
        usdc.transferFrom(msg.sender, address(this), amount);
        stakeId = keccak256(abi.encodePacked(msg.sender, prId));
        stakes[stakeId] = StakeRecord(msg.sender, basename, repoSlug, prId,
            amount, block.timestamp, bytes32(0), StakeState.Active);
        bytes32 uid = eas.attest(buildAttestation(basename, repoSlug, prId, amount, "ACTIVE"));
        stakes[stakeId].attestationUID = uid;
        emit StakeLocked(stakeId, msg.sender, amount);
    }

    function slashReview(bytes32 stakeId, address reporter) external onlyOracle {
        StakeRecord storage s = stakes[stakeId];
        require(s.state == StakeState.Active);
        s.state = StakeState.Slashed;
        uint256 rAmt = (s.amount * REPORTER_SHARE) / 10000;
        usdc.transfer(reporter, rAmt);
        usdc.transfer(treasury, s.amount - rAmt);
        reputation[s.basename] = reputation[s.basename] >= 50
            ? reputation[s.basename] - 50 : 0;
        eas.revoke(s.attestationUID);
        eas.attest(buildAttestation(s.basename, s.repoSlug, s.prId, s.amount, "SLASHED"));
        emit ReviewSlashed(stakeId, reporter, rAmt);
    }

    function releaseYield(bytes32 stakeId) external onlyOracle {
        StakeRecord storage s = stakes[stakeId];
        require(s.state == StakeState.Active);
        require(block.timestamp > s.stakedAt + ORACLE_WINDOW);
        s.state = StakeState.Released;
        uint256 yld = computeYield(s);
        usdc.transfer(s.reviewer, s.amount + yld);
        reputation[s.basename] = min(reputation[s.basename] + 5, 1000);
        eas.revoke(s.attestationUID);
        eas.attest(buildAttestation(s.basename, s.repoSlug, s.prId, s.amount, "CLEAN"));
        emit YieldReleased(stakeId, s.reviewer, s.amount + yld);
    }

    function computeYield(StakeRecord storage s) internal view returns (uint256) {
        uint256 elapsed = block.timestamp - s.stakedAt;
        uint256 base    = (s.amount * 1800 * elapsed) / (365 days * 10000); // 18% APY
        uint256 mult    = reputation[s.basename] > 700 ? 15000 : 10000;
        return min((base * mult) / 10000, s.amount * 3);
    }

    modifier onlyOracle() { require(msg.sender == chainlinkOracle); _; }
    function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; }
}

string public constant SCHEMA =
    "bytes32 basename,"          // keccak256(name.base.eth)
    "string  repoSlug,"          // 'org/repo'
    "uint256 prId,"              // GitHub PR number
    "uint256 stakeAmount,"       // USDC 6-decimal units
    "string  verdict,"           // ACTIVE | CLEAN | SLASHED
    "uint256 reviewedAt,"        // block.timestamp
    "uint256 resolvedAt,"        // 0 if still active
    "uint256 reputationDelta,"   // +5, -50 etc.
    "string  repoLanguages";     // 'Solidity,TypeScript'

import { EAS, SchemaEncoder } from '@ethereum-attestation-service/eas-sdk';

const eas = new EAS(EAS_CONTRACT_BASE); eas.connect(signer);
const encoder = new SchemaEncoder(SCHEMA_STRING);

const encoded = encoder.encodeData([
  { name: 'basename',        value: keccak256(toUtf8Bytes('vitalik.base.eth')), type: 'bytes32' },
  { name: 'repoSlug',        value: 'uniswap/v4-core',           type: 'string'  },
  { name: 'prId',            value: 4821n,                        type: 'uint256' },
  { name: 'stakeAmount',     value: 500_000_000n,                 type: 'uint256' },
  { name: 'verdict',         value: 'ACTIVE',                     type: 'string'  },
  { name: 'reviewedAt',      value: BigInt(Math.floor(Date.now()/1000)), type: 'uint256' },
  { name: 'resolvedAt',      value: 0n,                           type: 'uint256' },
  { name: 'reputationDelta', value: 0n,                           type: 'uint256' },
  { name: 'repoLanguages',   value: 'Solidity,TypeScript',        type: 'string'  },
]);

const tx  = await eas.attest({
  schema: SCHEMA_UID,
  data: { recipient: reviewerAddress, revocable: true, data: encoded },
});
const uid = await tx.wait();

// 1. Client hits endpoint — receives 402
GET /api/reviewer/vitalik.base.eth
HTTP/1.1 402 Payment Required
X-Payment-Requirements: {
  "scheme": "exact", "network": "base-mainnet",
  "maxAmountRequired": "1000",
  "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
  "payTo": "0xGitLedger...Treasury",
  "description": "GitLedger reviewer reputation query"
}

// 2. Client signs payment and retries with X-PAYMENT header
// 3. Server verifies + settles, returns full profile
HTTP/1.1 200 OK
{
  "basename": "vitalik.base.eth",
  "score": 847, "percentile": 94, "accuracyRate": 0.993,
  "cleanCount": 282, "slashCount": 2,
  "totalYield": "2184000000",
  "attestations": [{ "uid": "0x...", "repo": "uniswap/v4-core",
    "pr": 4821, "verdict": "CLEAN", "stake": 500000000 }]
}

// src/app/api/reviewer/[basename]/route.ts
import { withPaymentRequired } from '@coinbase/x402-next';

export const GET = withPaymentRequired(
  async (req, { params }) => {
    const { basename } = params;
    const profile = await db.query.reviewers.findFirst({
      where: eq(reviewers.basename, basename),
      with: { attestations: { limit: 50, orderBy: desc(attestations.createdAt) } }
    });
    return profile ? Response.json(formatProfile(profile)) : Response.json({}, { status: 404 });
  },
  { amount: '1000', asset: USDC_BASE, network: 'base-mainnet' }
);

export const appRouter = router({
  reviewer: router({
    profile:     publicProcedure.input(z.string()).query(getReviewerProfile),
    leaderboard: publicProcedure.query(getLeaderboard),
    myStakes:    protectedProcedure.query(getMyStakes),
  }),
  attestation: router({
    byReviewer: publicProcedure.input(z.string()).query(getAttestationsByReviewer),
    byRepo:     publicProcedure.input(z.string()).query(getAttestationsByRepo),
    live:       publicSubscription.subscription(liveAttestationFeed),
  }),
  stake: router({
    initiate: protectedProcedure.input(stakeSchema).mutation(initiateStake),
    status:   protectedProcedure.input(z.string()).query(getStakeStatus),
    history:  protectedProcedure.query(getStakeHistory),
  }),
  repo: router({
    install:  webhookProcedure.mutation(handleGitHubInstall),
    settings: protectedProcedure.input(z.string()).query(getRepoSettings),
  }),
});

app.post('/webhooks/github', async (req, res) => {
  if (!verifyGH(req.headers['x-hub-signature-256'], req.rawBody)) return res.status(401).end();

  const dedup = 'gh:' + req.headers['x-github-delivery'];
  if (await redis.exists(dedup)) return res.status(200).send('dup');
  await redis.set(dedup, 1, 'EX', 30);

  const { review, pull_request, repository } = req.body;
  if (req.headers['x-github-event'] === 'pull_request_review'
      && req.body.action === 'submitted'
      && review.state === 'approved') {

    const repo = await db.query.repos.findFirst({
      where: eq(repos.slug, repository.full_name)
    });

    if (repo?.stakeEnabled) {
      await queue.add('prompt-stake', {
        reviewerId: review.user.login,
        repoSlug:   repository.full_name,
        prId:       pull_request.number,
        minStake:   repo.minStakeUsdc,
      });
    }
  }
  res.status(200).send('ok');
});

// ReviewerCard.tsx
import { Identity, Name, Avatar, Badge, Address } from '@coinbase/onchainkit/identity';
import { base } from 'viem/chains';

export function ReviewerCard({ address, stakeAmount, verdict }) {
  return (
    <Identity address={address} chain={base} schemaId={GL_EAS_SCHEMA}>
      <Avatar />
      <Name />     {/* Resolves name.base.eth */}
      <Address />  {/* Shortened 0x... fallback */}
      <Badge />    {/* Coinbase verification badge */}
    </Identity>
  );
}

// StakeTransaction.tsx
import { Transaction, TransactionButton } from '@coinbase/onchainkit/transaction';

export function StakeTransaction({ amount, prId, basename, repoSlug }) {
  const contracts = [{
    address: GITLEDGER_ADDRESS, abi: GitLedgerABI,
    functionName: 'stakeReview',
    args: [basename, repoSlug, BigInt(prId), parseUnits(amount, 6)],
  }];
  return (
    <Transaction contracts={contracts} chainId={8453}>
      <TransactionButton text={"Stake $" + amount + " USDC"} />
    </Transaction>
  );
}

const [prId, repoSlug, stakeId, stakedAt] = args;
const windowEnd = parseInt(stakedAt) + 30 * 24 * 3600;

if (Math.floor(Date.now()/1000) < windowEnd) {
  return Functions.encodeString('WATCHING');
}

const res = await Functions.makeHttpRequest({
  url: 'https://api.github.com/search/issues',
  params: {
    q: 'repo:' + repoSlug + ' is:pr is:merged "' + prId + '" in:body',
    sort: 'created', order: 'asc', per_page: 10,
  },
  headers: { Authorization: 'Bearer ' + secrets.GITHUB_TOKEN }
});

const hotfixRE = /^(fix|hotfix|revert|patch):/i;
const hits = (res.data.items || []).filter(pr => {
  const createdAt = new Date(pr.created_at).getTime() / 1000;
  return hotfixRE.test(pr.title) && createdAt <= windowEnd;
});

if (hits.length > 0) {
  return Functions.encodeString('SLASH:' + stakeId + ':' + hits[0].user.login);
}
return Functions.encodeString('CLEAN:' + stakeId);

function checkUpkeep(bytes calldata) external view returns (bool, bytes memory) {
    bytes32[] memory due = getStakesDueCheck();
    return (due.length > 0, abi.encode(due));
}

function performUpkeep(bytes calldata performData) external onlyForwarder {
    bytes32[] memory stakeIds = abi.decode(performData, (bytes32[]));
    for (uint i = 0; i < stakeIds.length; i++) {
        _sendFunctionsRequest(stakeIds[i]);
    }
}

function fulfillRequest(bytes32, bytes memory response, bytes memory) internal override {
    string memory result = string(response);
    if (startsWith(result, 'SLASH:')) {
        (bytes32 stakeId, address reporter) = parseSlash(result);
        gitLedger.slashReview(stakeId, reporter);
    } else if (startsWith(result, 'CLEAN:')) {
        gitLedger.releaseYield(parseClean(result));
    }
}

// src/db/schema.ts
export const repos = pgTable('repos', {
  id:           uuid('id').primaryKey().defaultRandom(),
  slug:         text('slug').unique().notNull(),
  ghInstallId:  bigint('gh_install_id', { mode: 'number' }),
  minStakeUsdc: integer('min_stake_usdc').default(10_000_000),
  stakeEnabled: boolean('stake_enabled').default(true),
  installedAt:  timestamp('installed_at').defaultNow(),
});

export const reviewers = pgTable('reviewers', {
  address:          text('address').primaryKey(),
  basename:         text('basename').unique(),
  githubLogin:      text('github_login').unique(),
  reputationScore:  integer('reputation_score').default(500),
  totalStakedUsdc:  numeric('total_staked_usdc').default('0'),
  totalYieldUsdc:   numeric('total_yield_usdc').default('0'),
  totalSlashedUsdc: numeric('total_slashed_usdc').default('0'),
  cleanCount:       integer('clean_count').default(0),
  slashCount:       integer('slash_count').default(0),
  languages:        text('languages').array(),
  lastActiveAt:     timestamp('last_active_at'),
  createdAt:        timestamp('created_at').defaultNow(),
});

export const stakes = pgTable('stakes', {
  id:              uuid('id').primaryKey().defaultRandom(),
  stakeId:         text('stake_id').unique().notNull(),
  reviewerAddr:    text('reviewer_addr').notNull(),
  repoId:          uuid('repo_id').references(() => repos.id),
  prId:            integer('pr_id').notNull(),
  prTitle:         text('pr_title'),
  amountUsdc:      integer('amount_usdc').notNull(),
  state:           text('state').default('active'),
  attestationUid:  text('attestation_uid'),
  txHashStake:     text('tx_hash_stake'),
  txHashResolve:   text('tx_hash_resolve'),
  yieldEarned:     integer('yield_earned').default(0),
  windowEndsAt:    timestamp('window_ends_at'),
  stakedAt:        timestamp('staked_at').defaultNow(),
  resolvedAt:      timestamp('resolved_at'),
});

// TimescaleDB hypertable
// SELECT create_hypertable('attestation_events', 'time');
export const attestationEvents = pgTable('attestation_events', {
  time:           timestamp('time').defaultNow(),
  reviewerAddr:   text('reviewer_addr'),
  repoSlug:       text('repo_slug'),
  prId:           integer('pr_id'),
  eventType:      text('event_type'),
  amountUsdc:     integer('amount_usdc'),
  attestationUid: text('attestation_uid'),
  txHash:         text('tx_hash'),
});

# CHAIN
BASE_RPC_URL=https://mainnet.base.org
BASE_SEPOLIA_RPC=https://sepolia.base.org
GITLEDGER_DEPLOYER_PK=0x...
GITLEDGER_CONTRACT=0x...
EAS_CONTRACT_BASE=0x4200000000000000000000000000000000000021
EAS_SCHEMA_UID=0x...

# COINBASE CDP
CDP_API_KEY_NAME=...
CDP_API_KEY_PRIVATE_KEY=...

# CHAINLINK
CL_FUNCTIONS_ROUTER=0xf9B8fc078197181C841c296C876945aaa425B278
CL_FUNCTIONS_SUBSCRIPTION_ID=...
CL_DON_ID=fun-base-mainnet-1
CL_AUTOMATION_REGISTRY=0x...
CL_GITHUB_TOKEN_SECRET=...

# GITHUB APP
GITHUB_APP_ID=...
GITHUB_APP_PRIVATE_KEY=-----BEGIN RSA...
GITHUB_WEBHOOK_SECRET=...

# DATABASE
DATABASE_URL=postgresql://gitledger:...@db:5432/gitledger
REDIS_URL=redis://cache:6379

# SERVICES
NEXT_PUBLIC_DYNAMIC_ENV_ID=...
NEXT_PUBLIC_GITLEDGER_CONTRACT=0x...
X402_TREASURY_ADDRESS=0x...