Clutch Protocol

Open-source ride-sharing on a blockchain — the whole ride lifecycle settles on-chain, keys stay on the client, and drivers get paid in seconds instead of next week.

Aura consensus · Rust node · GraphQL Hub API · JavaScript SDK

Try stage demo · Documentation · Website · npm SDK

1. Open the demo → app-stage.clutchprotocol.io (public testnet)
2. Create a wallet → choose Passenger or Driver, then click Request CLT (faucet)
3. Run a ride → passenger: request on the map · driver: view requests and submit an offer

No signup, no app download, no real money — CLT is free test currency.

Read the full guide: Ride lifecycle · Environments

Clutch Protocol is an open, modular blockchain stack for decentralized ride-sharing. Apps connect through a GraphQL Hub API and JavaScript SDK; transactions are signed client-side and settled on-chain with Aura consensus. There is no central operator sitting between rider and driver holding funds or data.

Why on-chain actually buys you something here — not just "no middleman":

• Payout speed. Payment settles on-chain in seconds when a ride completes. No weekly payout cycle, no "pending balance." The driver has the money before the next pickup.
• No chargebacks. The passenger signs the payment directly, so there's no card issuer that can claw it back three weeks later. (The honest flip side: passengers give up that protection — see What's not built yet.)
• You own the account. No email/password. You hold a keypair; keys never leave your device. Auth is a signed challenge, not a stored credential.
• Auditable end to end. Every step — request, offer, acceptance, payment, cancellation — is a typed transaction on a public ledger.
• Fully open source. Run the entire stack locally with one docker compose command (below).

CLT economics: Drivers keep most of each fare. Referrers earn up to 4% (default 2%+2%) on RidePay. Validators earn a fixed block reward (50 CLT/block), separate from rides. See CLT Economics.

Clutch is alpha and built in the open. Being upfront about the edges:

Working today

• On-chain ride lifecycle: request → offer → acceptance → pay → cancel, all as signed transactions
• Rust node with Aura consensus (~1s blocks), libp2p P2P, WebSocket JSON-RPC
• GraphQL Hub API with wallet-based (signed-challenge) JWT auth and a testnet faucet
• Client SDK (npm), reference React demo, block explorer, one-command local stack
• Public stage testnet you can use right now

Not built yet (and this is the interesting part)

• Reputation / ratings — no driver or rider scoring
• Dispute resolution — cancellations are on-chain, but there's no arbitration when two parties disagree, and no no-show / fraud handling beyond cancel
• DAO governance — on the roadmap, not in the code
• Matching is simple; there's no surge/pricing engine or geospatial optimization

The operational layer (disputes, reputation, matching) is genuinely the hard part, and it's where I'd most value ideas and contributors. If you've built payment or marketplace infra, the discussions are open.

1. Start the stack

   git clone https://github.com/clutchprotocol/clutch-deploy.git && cd clutch-deploy
   cp .env.example .env && docker compose up -d

2. Open the demo → http://localhost:5173 · API health → http://localhost:3000/health
3. Build with the SDK → npm install clutch-hub-sdk-js — see Quick Start

Canonical docs: https://docs.clutchprotocol.io

Demo App / Your dApp
        │
        ▼
  clutch-hub-sdk-js  (client-side signing)
        │
        ▼
  clutch-hub-api     (GraphQL + /faucet)
        │
        ▼
  clutch-node        (WebSocket JSON-RPC, Aura validators)
        │
        ▼
  clutch-explorer    (indexes blocks → Postgres → REST UI)

npm install clutch-hub-sdk-js

import { ClutchHubSdk } from 'clutch-hub-sdk-js';

// Pass the private key so the SDK can sign the auth challenge + transactions locally.
const sdk = new ClutchHubSdk('http://localhost:3000', publicKey, privateKey);

await sdk.requestFaucet(publicKey);

const unsigned = await sdk.createUnsignedRideRequest({
  pickup: { latitude: 35.7, longitude: 51.4 },
  dropoff: { latitude: 35.8, longitude: 51.5 },
  fare: 1000,
});
const signed = await sdk.signTransaction(unsigned, privateKey);
await sdk.submitTransaction(signed.rawTransaction);

See Ride Lifecycle for the full passenger/driver flow.

Example: 10 CLT fare, one RidePay, both referrers → driver 8 CLT, referrers 1 CLT each.

Full details: docs.clutchprotocol.io/clutch-node/clt-economics

Alpha software — APIs may change without notice. Use at your own risk.

1. Fork a repository
2. Create a feature branch
3. Follow Conventional Commits
4. Open a pull request

• GitHub Discussions
• Documentation
• Report bugs via GitHub Issues in the relevant repo

• Private keys never leave the client — all signing is done via the SDK
• Wallet-based JWT auth via signed challenge (no username/password)
• Every transaction is auditable on-chain

Details: Security