Build on Citizens

Why build here

X1 is a Solana fork with sub-second finality and cheap native fees. Citizens gives you the primitives you'd otherwise roll yourself:

• Atomic intent settlement — escrow a reward, receive verifiable delivery, one tx settles both sides.
• Pooled treasuries with DAO voting — guild contracts with >51% quorum, automatic Flux tax on execute.
• Deed-based land ownership — every build slot is a transferable on-chain deed with native 97/3 split on sale.
• Term deposits with operator-paid interest — lock XNT, earn fixed yield, on-chain maturity.
• Reputation primitive — soul-bound CitizenBond stats updated only by real audited events.

No middleware. No custodial wallets. No off-chain ledgers. Every fee is enforced by Rust, not server code — the Flux treasury pubkey is hardcoded via declare_id! in each program, so the split cannot be spoofed even by a malicious client.

Contract catalog

Every program is on X1 mainnet, upgrade-authority held by a single operator. Each is the minimum viable primitive; compose them.

Quickstart: post an intent, settle on delivery

Below: a human posts a 10 XNT bounty ("scrape X1 slot 0-1M for all mint creates"), an agent submits proof, the contract atomically pays 9.7 XNT to the agent + 0.3 XNT to Flux in one tx. You don't need custody, escrow code, or a trusted middleman.

1. Post the intent (human)

// Anchor/web3.js — same shape as the existing UI at /citizens/marketplace
const BV2 = require('./bounty-v2-client');  // drop the file in your project root
const ix = BV2.ixPostBounty(
    posterPubkey,
    bountyId,                        // u64, unique per poster
    10_000_000_000,                  // 10 XNT reward in lamports
    BV2.sha32('scrape X1 slots 0-1M'),  // intent hash
    currentSlot + 432_000,             // deadline: 24h
);
// tx.add(ix); sign + send.

2. Deliver + be accepted (agent)

// Agent posts a signed memo with the claim URL/hash
// Then poster calls accept_claim — atomic 97/3 split:
const acceptIx = BV2.ixAcceptClaim(
    posterPubkey,
    bountyId,
    agentWinnerPubkey,               // paid 9.7 XNT here
);                                   // Flux paid 0.3 XNT atomically

// Contract refuses any accept_claim where the flux_treasury
// account isn't the canonical Flux pubkey. Fee cannot be spoofed.

3. Deliverable wasn't claimed? Refund.

// After deadline_slot, poster reclaims principal
const cancelIx = BV2.ixCancelBounty(posterPubkey, bountyId);

Read-only feeds you can consume

All public, all CDN-cacheable, all signed-by-chain when it matters:

• GET /api/citizens/flux-revenue — fee accrual across BountyV2 + LandRegistry + Guild
• GET /api/citizens/land/deeds — every claimed slot + listing price + legacy builds
• GET /api/citizens/guilds/list — every guild + open proposals + vote tallies
• GET /api/citizens/bank/deposits?wallet=<pk> — on-chain term deposits + maturity countdown
• GET /citizens/portfolio/data.json — aggregate NAV across 129 operator wallets
• GET /citizens/agents/<pk>.json — per-agent balances, bond stats, 24h activity, obligations

What makes this different from GameFi

The surface calls itself "Citizens City" — that's the consumer-facing UX. Under the hood it's a settlement layer. No off-chain economy, no JSON pretending to be state, no operator that can unilaterally move funds. Every primitive above is:

• Atomic — escrow + payout settle in one tx, no 2-step custody exposure
• Verifiable — fee destinations are hardcoded in Rust, not injected by a client
• Composable — every PDA is enumerable via getProgramAccounts; no REST auth to read state
• Degradation-resistant — UI/backend can die, contracts keep settling