Autonomous, verification-gated servicing for tokenized real-world cashflows on Casper.
An autonomous agent and on-chain vault that release a tokenized cashflow to its holders only after independently verifying the money actually arrived — verification, not attestation.

Built for the Casper Agentic Buildathon 2026 · Casper Innovation Track.

---

Contents

• The problem
• The insight
• How it works
• The demonstrable moment
• Proven on-chain
• See it live
• Architecture
• Repository layout
• Run it locally
• Honesty & disclosure
• License

---

The problem

Tokenized real-world assets — invoices, rent, royalties, private credit — are a fast-growing on-chain market. But servicing them is still manual and trust-based: someone has to confirm the off-chain cashflow genuinely arrived, then distribute it to token holders. On-chain today, projects push data in via oracles; nobody autonomously pushes verified cashflow out. Holders are left trusting an issuer's word that they got paid.

Recording that a payout happened is not proof it was owed.

The insight: verify, not attest

Quittance shifts servicing from attestation (one source's say-so) to verification (an independent 2-of-3 quorum) before any funds move. The agent doesn't take anyone's word — it pays independent verifiers to check, and gates the on-chain distribution on their quorum.

How it works

Each cycle, the autonomous servicer agent:

1. Detects a cycle is due for a tokenized asset.
2. Pays three independent verifiers over x402 to answer: "did the cashflow arrive?" — real, per-call economic commitment, settled on Casper.
3. Requires a 2-of-3 quorum of signed yes/no verdicts.
4. If met → calls the vault's quorum-gated distribute(), paying holders pro-rata on-chain, and writes a verifiable receipt (signers + verdict hashes in the event).
5. If not → halts, pays out nothing, flags a dispute.

detect cycle → pay 3 verifiers (x402) → 2-of-3 quorum?
                                          ├─ yes → distribute on-chain + receipt
                                          └─ no  → HALT · funds withheld

The demonstrable moment

Feed a fake "paid" claim through one compromised verifier and watch the agent refuse to release the funds. That refusal — paid-for, independent, and enforced on-chain — is the whole product.

Proven on-chain (casper-test)

Both paths are real, executed, and verifiable on testnet.cspr.live. The agent uses the same vault and the same three verifiers for both cycles — only the consensus differs.

Event	Path	Result	Transaction
ServicerVault deployed	—	entity 6a6747d2…b27e132	4313f749…1c4c9e
Qualifying x402 settle	—	first verifier payment	6b03ad75…bf3cd4
Distribute	✅ Happy — 3/3 → quorum met	Holder A +7 / Holder B +3 CSPR (pro-rata)	6821e0f3…c37829
Verifier settle · v1	🛑 Fraud — 1/3 → quorum NOT met	agent paid, then halted	a02b1c7d…d6a7d
Verifier settle · v2	🛑 Fraud	agent paid, then halted	40a85e53…75df93
Verifier settle · v3	🛑 Fraud	agent paid, then halted	8a962e50…4115ff

The result that matters: in the fraud cycle one verifier lies "yes" while the two honest ones say "no." The agent still pays all three for verification (real money, on-chain) — and still refuses to release the cashflow on a single dishonest "yes." Holder balances stay unchanged; the agent's own funds never move into a distribution. You cannot bribe one verifier to unlock the money.

See it live

🟢 Live dashboard	quittance.rectorspace.com — issuer view (asset + both cycle histories)
👛 Holder view	quittance.rectorspace.com/holder — balances read live from chain (7 / 3 CSPR, unchanged)
🎬 Demo video	quittance.rectorspace.com/demo (~2 min)

Architecture

Component	Responsibility	Stack
ServicerVault	Holds the native-CSPR distribution pool + holder registry; records per-cycle receipts; exposes quorum-gated distribute().	Odra (Rust), Casper
Servicer agent	Runs the cycle: pays verifiers over x402, enforces the quorum, calls the contract through stable adapter seams, verifies finality.	TypeScript, casper-js-sdk v5
Verifier services ×3	Independent, x402-gated HTTP endpoints returning signed yes/no verdicts over evidence.	TypeScript / Express
Dashboard	Issuer config + holder view: cycle history, quorum stamps, live on-chain balances, every tx deep-linked to cspr.live.	Next.js 15, Vercel

Casper-native by design: an Odra contract on casper-test, a native-CSPR pool with pro-rata transfers, x402 verifier payments settled via the CSPR.cloud facilitator, real Ed25519 Casper identities, and holder balances read live from chain.

Repository layout

quittance/
├── agent/          # autonomous servicer agent — runCycle state machine
├── packages/
│   ├── core/       # domain logic: verdict verification, quorum rules (framework-free)
│   └── adapters/   # chain + verifier client adapters (casper-js-sdk, x402)
├── contracts/      # ServicerVault — Odra (Rust) smart contract + wasm
├── verifiers/      # x402-gated verifier services (independent yes/no signers)
├── dashboard/      # Next.js dashboard (issuer + holder views), deployed on Vercel
├── e2e/            # end-to-end harness: deploy, fund, run-cycle, settle, check-balances
├── SPEC.md         # design
├── PLAN.md         # implementation plan
└── DAY1-DERISK.md  # critical-path de-risk runbook

Run it locally

Prerequisites: Node ≥ 18, pnpm, and (for the contract) the Rust toolchain + cargo-odra.

pnpm install                                   # install the workspace
pnpm --filter @quittance/core test             # domain logic (verdict + quorum)
pnpm --filter @quittance/dashboard dev          # dashboard at http://localhost:3000
pnpm --filter @quittance/dashboard test         # dashboard unit tests

Contract build & tests:

cd contracts && cargo odra test                # OdraVM unit tests

End-to-end on casper-test (needs a funded testnet key — see .env.example):

node e2e/deploy-servicer.mjs submit            # deploy the vault
node e2e/harness/run-cycle.mjs happy           # quorum met  → distribute
node e2e/harness/run-cycle.mjs fraud           # quorum fails → halt

Honesty & disclosure

For the buildathon demo, the off-chain "cashflow arrived" evidence is mocked/sandboxed — the three verifiers stand in for real payment-rail adapters (bank APIs, Stripe, etc.). The innovation is the verification-gated autonomous release, not the data source. Testnet only: verifier payments use WCSPR via x402, holder distribution is native test CSPR; the payout token is a test asset, not a real stablecoin.

License

MIT — © RECTOR-LABS.

_{Quittance · casper-test · verify, not attest}