Patrick Mockridge

Shared booking contracts on Rholo

R-Share

Holiday letting, events, ticketing, bike share, car rental, and robotics-as-a-service all run the same flow: booking, escrow, settlement.

Every rental market runs the same flow: booking, escrow, settlement. The unit changes — room, seat, bike, car, machine — and so do the interval and the policy; the flow does not. Web3 has barely entered this market because most projects build vertical products that do not scale, not shared concurrent components. R-Share is the shared component set: one contract path across holiday letting, events, ticketing, bike share, car rental, and robotics-as-a-service.

What
A set of concurrent booking and rental contracts on Rholo, settled through R-Cash. A provider publishes a listing; the listing owns units; each unit owns slots. A slot is one bookable unit of time: a room-night, a seat at a show, an hour with a machine. A booking takes one or more slots over an interval and carries escrow, cancellation, deposit, dispute, and ticket state.
Why
A rental is a multi-party state machine with money at stake. Every one of these businesses runs the same flow: booking, escrow, settlement. What differs is the unit, the interval, and the policy. Most rental software rebuilds that flow inside a proprietary database and a payment integration, so one operator controls the record and the funds, and every new vertical needs a new booking engine. R-Share is one booking and escrow path that every vertical reuses.
The combination
Four primitives — capacity, interval, escrow, and policy — on Rholo’s object capabilities, with R-Cash settlement and a per-listing allocator. The same contract path carries holiday letting, events, ticketing, bike share, car rental, and robotics-as-a-service. The product and the off-chain facts stay in the fork.

The same flow, six markets

Each business books capacity over an interval: a room for three nights, a seat at a show, a bike for an hour, a car for a day, a machine for an operating window. Each is paid before use and settled after. The unit, the interval, and the policy change; the flow is booking, escrow, settlement.

Most rental software rebuilds that flow per vertical, inside one operator’s database with a payment integration beside it. That gives the operator the record and the funds, and makes every new vertical a new booking engine. Most on-chain projects have repeated the vertical product rather than the shared flow.

R-Share is one set of concurrent booking, escrow, and settlement contracts that every vertical reuses by changing kind, attrs, slot IDs, terms, and at most one pure Remedy branch. No vertical adds a booking arm.

The listing has two units and six nightly slots. A guest booking both rooms for the full stay asks for all six; the allocator writes all six in one commit or writes none. No partial hold is possible.

The booking carries terms, hold, escrow, confirm, check-in, check-out, settle. Each booking has its own state cell, ticket projection, operation map, and a bond holding the escrow purse. Cancellation, no-show, deposit claims, disputes, and arbitration are on the same path, and settlement runs through R-Cash. The core is four primitives: capacity, interval, escrow, and policy. Calendar, identity, support, insurance, telemetry, and regulation are the fork’s product.

The ladder

Each rung adds a real-world constraint: whether listing to unit to slot to booking still fits. A new rung changes kind, attrs, slot IDs, and at most one pure Remedy branch. It does not change the booking machine, escrow, settlement buckets, or authority model. A rung that needs a new booking arm means the primitive set is wrong.

Table 1. The use-case ladder.One contract path, six rungs, and the status of each mapping.
Table 1. The use-case ladder.
RungUnit and slotWhat is exercised
Holiday lettingRoom / nightBooking, lifecycle, claim and conservation suites pass; slot settlement exercised.
Events managementSeat or section / showClaim suite and ticket arms pass; section capacity is mapping only.
TicketingTicket tier / eventRedeem, transfer and close pass.
Municipal bike shareBike / station-hourunit_generality passes for the kind; fleet and station capacity are mapping only.
Car rentalVehicle / day or windowunit_generality passes for the kind; inspection and insurance are mapping only.
Robotics-as-a-serviceMachine / operating windowBooking, allocator, pricing and claims pass; SLAs and evidence enforcement are design.

Holiday letting is the reference path; the other rungs are mappings over the same contract path. “Mapping only” is a status, not a claim of a dedicated suite.

Holiday letting is the reference path: a two-room house, three nights, one deposit, one cancellation policy, followed from terms to settlement. Robotics-as-a-service is the furthest case: machine windows, operators, certification, session evidence, and SLAs. The shared path is implemented; the RaaS-specific evidence and safety pieces are design. In the table, “pass” means a recorded suite or arm; “mapping only” means the use case rides the shared path without its own suite.

Concurrency and the allocator

The allocator uses the tuple space — the shared pool of messages Rholang processes take from and put back — to arbitrate, with no lock and no global cell. A booking takes all requested slots in one commit or none.

  • One allocation cell per listing. Units and slots live in listingState; a slot is data, not a contract. No slot URI or live capability is published.
  • One commit. acquire validates the whole request and writes every requested slot in one take/commit. No partial state is reachable.
  • A peek is a hint, not a lock. A stale peek causes a clean refusal, not a double booking.
  • select is forbidden. The node turns PChoice into parallel receives, so it is not an atomic single-winner choice.
  • No global counters. IDs are client- or provider-supplied and uniqueness-checked.
  • Per-listing serialization is accepted. Different listings never share a cell; different slots of one listing serialize. This is the cost of atomic multi-slot acquisition and the known hotspot.

Lean proves that after a successful acquire, every active reservation containing a requested slot belongs to the acquiring booking. It also proves that an acquire either refuses and leaves the state unchanged, or appends exactly one reservation. The proof is over the model, not a Rholang refinement.

The client, and the fork

The client shows how to use the contracts; it is not the product. The repository ships the contracts, a Rust SDK, a CLI, a WASM wallet, and a React reference client. There is no backend server, indexer, or off-chain database. The chain is the backend.

The campaign covers the same surface from three directions: a CLI journey (quote, book, held-slot refusal, replay, wrong-terms refusal, manual accept and cancel, one-signature refusal, two-signature pause and resume), browser journeys for guest, provider, and admin-multisig, and seven real settlement scenarios over a closed balance set with a negative control for untracked escrow.

Fork it: keep the AGPL notices, copy the contracts, harness, tools, crates, and web app, and change the kind, the attrs, the slot IDs, the terms, and at most one pure Remedy branch. The off-chain parts are yours. R-Share is the settlement core; R-Cash is the payment rail; neither is a marketplace.

Evidence

On 3 November 2026, a fresh devnet built from Rholo e2d073d with R-Cash 49b441d recorded 16 passing suites, covering root, payments, lifecycle, claims, pricing, booking, pause, allocator, admin, events, provider, listing, and conservation. Claim coverage is 20 of 30 cells; four claim classes run across five kinds.

The allocator suite checks atomic multi-slot acquisition, token-gated confirm and release, pause gates, expiry takeover, and no slot-capability leak. Conservation covers seven settlement scenarios with a closed balance set and a negative control. Lean records 37 axiom audits, 21 vectors, 33 rules, 29 arms, and 13 core arms proved-model; these are internal checks, not a security audit.

R-Share evidence
MeasureValueSource
Behavioural suites16/16; fresh devnet; 3 November 2026Verification record
Deploy terms13; build, measure, and parse with the target node parserContract map
Claim coverage20 of 30 cells; four claim classes across five kindsVerification record
Conservation7 settlement scenarios; closed balance set; negative controlVerification record
Lean 437 axiom audits; 21 vectors; no sorry, admit, axiom, or native_decideFormal model
Flow manifest33 rules; 29 arms; 13 core arms proved-modelFormal model
Allocator theoremacquire_no_double_owner; single-owner, atomic acquisition, bounded holdsFormal model
Client campaignCLI journey plus guest, provider, and admin-multisig browser journeys; 3–4 November 2026Status and scope

Sources: verification record, formal model, and status chapter, as of 3–4 November 2026. Counts drift; the linked artifact is authoritative. The 37 axiom audits are an internal Lean check, not a security audit.

Limits

  • Maturity. Devnet-only, unaudited, pinned to R-Cash v0.5 at 49b441d; no real value.
  • Allocation. Per-listing serialization is the accepted hotspot: different listings do not share a cell; different slots of one listing serialize.
  • Privacy. Bookings, addresses, dates, and prices are on-chain. There is no confidential booking and no KYC, legal identity, or reputation in the core.
  • Not yet run. providerDeliveryBreach and partialPerformance have no code. Fleet-scale allocation, station capacity, provider-bond legs, obligation objects, generalized claims, and evidence enforcement are not run.
  • Out of scope. Backend, indexer, off-chain database, cross-shard settlement, telemetry, remote stop, machine safety, and a full governor or timelock.
  • Verification. The 37 axiom audits are an internal Lean check, not a security audit. Lean is model-level, not a Rholang refinement.
  • Governance. No code of conduct, security-disclosure policy, or maintainer council is in place.