Your rights in your pocket.
fuda turns memberships, tickets, and loyalty cards into on-chain Rights that people carry as Passes in Apple Wallet, Google Wallet, or the browser. Start without an app install or member sign-up, and sign in with a passkey when you want your passes kept across devices.
On-chain where trust matters. Invisible everywhere else.
Membership usually ties a right to the app or system that serves it. Paper and plastic cards are hard to update or revoke; custom apps cost money to build and ask every member to install another app.
The right should outlive the app. Its validity should remain independently verifiable when the software around it changes.
An Operator signs in with a passkey, sets up a Venue, designs a Card, and shares its link or QR. Members scan, save their Pass, and present it at the door or counter.
- Event passes — claim from a link and save to Apple Wallet, Google Wallet, or the browser, with no member account required.
- Membership and loyalty cards — publish a branded Card from the dashboard, then scan member Passes for entry and award Stamps under the Card's policy.
- Open verification — each Right is an EAS attestation on Base. Anyone can check its on-chain validity without a fuda account or API.
ENS gives issuers and Rights names; The Graph supports on-chain status views. Passkeys sign Members in. See Pass types and flows for onboarding and verification levels.
flowchart TB
DASH[Operator dashboard] -->|issue and revoke| API[fuda API]
APP[Member app] -->|claim, sign, submit a proof| API
GATE[Gate scanner] -->|verify| API
API <-->|rights and delegation checks| EAS[(EAS on Base)]
API <-->|challenges, slots, entry logs, badges| D1[(D1)]
API <-->|venue logos| R2[(R2)]
API -->|build and deliver| PASS[Apple, Google, and browser passes]
PASS -->|present QR| GATE
EAS --> INDEX[Rights index]
APP -->|read rights| INDEX
DASH -->|read on-chain status| INDEX
ENS[ENS resolver] <-->|name lookup via CCIP Read| API
APP -. "badge a right you hold" .-> WID[World ID app]
WID -. proof .-> APP
API -. "verify the proof, server-side" .-> WORLD[World ID · developer portal]
The rights index supports status views; ENS supplies names and address resolution. Gate admission uses EAS and D1. See the architecture overview for component responsibilities and trust boundaries.
The dashed path is optional. A deployment that sets the World ID secrets lets a member who already holds a Right attach a Verified Human badge to it; one that leaves them unset shows no badge control anywhere. Note where the dashes stop. The gate never reaches World — admission still reads EAS and D1 and nothing else — and a Right with no badge answers exactly as it did before the feature existed. See World ID.
A Bearer pass follows this sequence. Signed entry adds a holder signature; their flows are described in Pass types and flows.
sequenceDiagram
actor Operator
participant API as fuda API
participant EAS as EAS on Base
participant D1
actor Member
participant Gate as Gate scanner
Operator->>API: Issue a Bearer right
API->>EAS: Attest Entitlement
EAS-->>API: Confirmed UID
API->>D1: Record issued right
API-->>Operator: Pass links
Operator-->>Member: Share pass
Member->>Gate: Present QR
Gate->>API: Verify admission
API->>EAS: Read Entitlement and IssuerDelegation
EAS-->>API: Current chain records
API->>D1: Log verdict and consume slot if admitted and single-use
API-->>Gate: ADMIT or REJECT
opt ADMIT
API->>EAS: Record Attendance asynchronously, best-effort, if the card has it on
end
The gate app asks the API, which reads the Entitlement and its IssuerDelegation from EAS by eth_call. The hosted scanner trusts that API's verdict; an independent verifier can read the same records directly. D1 holds operational state — one-time challenges, single-use consumption, entry logs — and a failed chain read fails closed. Revoking on-chain turns the same QR red on the next scan. Anyone can check on-chain validity against Base without a fuda account; reproducing the hosted admission verdict also requires its operational state, including whether a single-use Right has already been consumed. Admissions of on-chain Rights are attested on-chain as best-effort Attendance.
The principle behind that split is decentralized at the core, hosted rails only for UX. A Right's validity lives on-chain, ownable and verifiable by anyone; Apple, Google, and fuda's own Workers are rails that make it pleasant to use. Strip the rails away and every function still has a self-runnable fallback, with worse UX. See UX and decentralization.
.
├── apps
│ ├── api issuance, gate verification, passes (Workers + D1)
│ ├── app Preact member app — /@handle, /signed, /rights
│ ├── dash operator dashboard — issue, revoke, members, card designer
│ └── gate Preact scanner — camera QR → verdict screen
├── packages
│ ├── sdk shared types, validators, qrSvg
│ ├── libs shared query, wallet, and authentication integrations
│ ├── pass Apple .pkpass and Google Wallet save-link builders
│ ├── ui shared Preact components, helpers, and page tooling
│ ├── styles shared base CSS
│ ├── i18n shared message catalogue
│ ├── chains chain ids, RPC defaults and EAS addresses
│ ├── e2e browser tests against the built Workers
│ ├── ens-contracts ENS resolver contracts and naming scripts
│ └── subgraphs/rights the Base query lane the apps read status from
├── .archive retired code kept for reference, such as the Substreams packages
├── skills agent skills to install, such as MCP setup
└── docs architecture, specs, ADRs, runbook
packages/subgraphs/* builds independently and does not join the pnpm workspace. .archive/ is not built or tested.
Stack: Cloudflare Workers built with Void (Hono handlers, Drizzle, D1, R2), Preact, viem, valibot, @noble crypto, EAS on Base. The protocol surface of the core loop is EAS. fuda runs one deployment per chain and they never share state — Base Sepolia today, Base mainnet at the cutover; see Environments.
See Local development for setup and startup instructions.
Claude Code, Codex and OpenCode can manage a store's cards and passes through fuda's MCP server. Install the setup skill for yours:
npx skills add oboroxyz/fuda-sh --skill fuda-mcp-setup -a claude-code
npx skills add oboroxyz/fuda-sh --skill fuda-mcp-setup -a codex
npx skills add oboroxyz/fuda-sh --skill fuda-mcp-setup -a opencodeThen ask the agent to connect to fuda. It walks you through registering the app in the dashboard and approving it with your passkey. Other agents are not tested yet.
- Architecture
- Architecture overview — components, authority and trust boundaries, environments, configuration
- Glossary — the one-name-per-concept vocabulary the specs, code, and UI share (level vs path, Right vs Pass, Device wallet vs Crypto wallet)
- Specifications (index)
- Attestation model — Entitlement, IssuerDelegation, Attendance, lifecycle, the EAS/D1 authority boundary
- Pass types and flows — templates, wallet roles, standard issuance, the gate protocol
- MCP server — connecting an agent, tokens bound to the server, the tools
- ENS naming — the name hierarchy, the member number, what a name resolves to, name lifecycle
- Integrations
- The Graph — rights indexing, the archived Substreams packages, and verification evidence
- ENS — venue and member names on the ENSv2 Sepolia deployment, the sponsored claim, and live resolution evidence
- World ID — the Verified Human badge: where it sits, what the proof must satisfy, and what the vendor's edge does undocumented
- Operations
- Runbook — local development, one-time Cloudflare and Base setup, secrets, deploy order
- Agent guidance — repository workflow and verification
- Records
- References — the standards, prior art, and platform docs the design drew on