ReBNB

ReBNBis a decentralized rental marketplace that lets owners list stays, brokers prebook and re-rent slots, and guests finalize bookings — all with verifiable Booking NFTs and trustless on-chain payouts.

Problem we solve

Centralized short-term rental platforms lock earnings in opaque fee systems, create single points of failure, and prevent creative secondary models (resellers, brokers, micro-hosts) from operating permissionlessly. Hosts want fair, transparent payouts; brokers want low-friction ways to monetize prebooked inventory; guests want easy, verifiable access. ReBNB unlocks a composable, permissionless secondary rental economy while preserving owner control and clarifying payouts.

Core idea :-

Enable prebooking: brokers can reserve inventory ahead of time by depositing a small stake.

Enable re-renting: brokers resell that reservation to final guests at flexible prices.

Represent each finalized reservation as a Booking NFT (time-bounded) for on-chain provenance and easy transfer.

Handle trustless payouts on-chain: owner, broker, and platform shares are computed transparently and distributed automatically.

Offer a relayer/service layer to mint access tokens, generate QR codes, and integrate with door locks or property management systems.

Key features

Listing creation with pricing, availability windows, and split rules (owner share BP, platform fee BP).

Broker prebook with deposit (escrowed on-chain).

Off-chain offer marketplace for brokers to list prebooked slots (optional).

Final guest checkout that triggers rerentFinalize: accepts token payment, executes split, and mints Booking NFT.

Booking NFT that encodes booking window and access metadata; can be time-restricted or ERC-4907 style rentable.

Dispute and refund flows with admin/owner hooks.

Relayer that listens to events, mints NFTs, issues QRs for door access, and optionally pays gas for UX (meta-txs).

Audit logs and on-chain transparency for all financial flows.

Architecture (high level)

On-chain (EVM):

ListingRegistry (optional): stores metadata pointers and listing defaults.

VaultEscrow (core): holds deposits and payments, enforces state machine for reservations, computes splits, emits events.

BookingNFT (ERC-721 or ERC-4907): minted to final renter after successful payment.

Marketplace (optional): on-chain offers to buy/sell prebooked reservations.

Frontend:

Owner dashboard (create listing, set splits, manage availability).

Broker dashboard (browse listings, prebook, list resale offers).

Guest UX (search, buy re-rent offers, wallet approvals, manage bookings).

Wallet integrations (Wagmi / Reown AppKit / Metamask) and support for ERC-20 permit to one-tx checkout.

Storage & media: IPFS / Arweave for listing metadata + images (or Cloudinary for images with IPFS pointers for metadata).

Data model (logical)

Listing: id, owner, basePrice, availability windows, ownerShareBP, platformFeeBP, metadataURI

Reservation: bookingId, listingId, originalPayer (broker), deposit, state (PREBOOKED, RERENTED, FINALIZED,…), expiresAt, renter, totalPaid

Booking NFT metadata: bookingId, listingId, startDate, endDate, accessURI (encrypted), issuer, timestamp

(we store minimal sensitive data on-chain — private access codes are stored encrypted off-chain and delivered only to NFT holder)

Smart-contract design & essential functions

prebook(listingId, deposit, prebookDuration, ownerShareBP, platformFeeBP) — broker deposits, creates PREBOOKED reservation.

rerentFinalize(bookingId, totalPaid) — final guest pays stablecoin; contract computes owner = totalPaid * ownerBP, platform = totalPaid * platformBP, broker = remainder; transfers funds and emits RerentFinalized.

mintBookingNFT(bookingId, renter) — can be called by relayer or Vault contract (preferably Vault triggers mint or allows authorized minter).

refundPrebook(bookingId) — returns deposit if unused or when conditions met.

openDispute(bookingId) and resolveDispute(bookingId, resolution) — administrative hooks for edge cases.

Events: Prebook, RerentFinalized, Payout, Refund, DisputeOpened, DisputeResolved.

Notes: use basis points (BP) for shares (10000 = 100%). Implement ReentrancyGuard, Pausable, and role-based access (Relayer/Operator).

Example payout math (concrete)

OwnerShareBP = 9000 (90%), PlatformFeeBP = 200 (2%) → Broker gets 10000 - 9000 - 200 = 800 BP (8%).

If guest pays 1000 USDC: Owner = 900 USDC, Platform = 20 USDC, Broker = 80 USDC.

Rounding policy: send rounding remainder to platform treasury (or configurable).

UX flows (detailed)

Owner

Connect wallet, create listing (metadata → IPFS), set price & splits.

Optionally approve platform to mint booking NFTs on owner’s behalf.

Monitor prebooked inventory, accept or restrict brokers (allowlist).

Broker

Browse listings, click prebook → approve USDC → prebook → deposit locked.

Create resale offers (off-chain orderbook) or list on in-app marketplace.

Once sold, broker coordinates with final guest (or guest buys directly).

Final guest

Finds re-rent offer, clicks buy → approve USDC (or use ERC-20 Permit) → rerentFinalize.

Backend relayer sees RerentFinalized → mints NFT to guest and issues QR/JWT for access.

Guest shows QR to gate/lock or uses unique code to check in.

Relayer & Access

Relayer mints NFT and calls access API of smart-lock or property manager.

It stores encrypted door code tied to Booking NFT; when NFT transfers, new holder can request decrypted code if authorized.

Security & safety

Use OpenZeppelin libraries for ERC-20/ERC-721, SafeERC20, ReentrancyGuard, Ownable/AccessControl.

Checks-effects-interactions pattern before external transfers.

Withdraw pattern for failed transfers.

Pausable + admin timelock for emergency changes.

Role-based minter (only Vault or relayer multisig can mint Booking NFT).

On-chain invariants & property owner verification (off-chain KYC optional).

Audit recommended for payout & dispute logic.

Unit & integration tests: payout math, state transitions, reentrancy attempts, rounding.

Keep private access codes off-chain and encrypted; never store secret plain text in smart-contract metadata.

Edge cases & policy decisions

Does deposit count toward final payout? We recommend simple model where final payment alone funds splits and deposit is either refunded or used for penalties. Alternatively, deposit+payment can form the pool — implement whichever matches your business rules.

Double booking prevention: maintain date-based availability checks (either on-chain for critical windows or off-chain with relayer checks plus on-chain finalization guard).

Cancellations: specify owner/broker/guest cancellation windows and penalty logic (deduct from broker payout or deposit).

Refunds & disputes: allow openDispute with arbitration window; escrow funds until resolution.

Implementation stack & tools (recommended)

Smart contracts: Solidity 0.8.x, OpenZeppelin, Foundry (fast tests) or Hardhat (greater plugin ecosystem).

Frontend: Next.js (App Router), React, TailwindCSS, Wagmi + Reown AppKit for wallet UX.

Backend: Node.js/TypeScript, ethers.js, Prisma/Postgres for indexing, IPFS for metadata, Cloudinary for images.

Relayer: Node service listening to events (ethers or Alchemy webhooks), responsible for minting and access token issuance.

CI/tests: Foundry/Hardhat test suites, TypeScript contract interaction tests, integration test with relayer dev server.

Deployment: target Polygon or Polygon zkEVM (low gas) or other EVM chain.

Monetization & tokenomics

Platform fee BP set per listing or global (e.g., 2%).

Optional subscription tiers for brokers (lower fees, featured listings).

Future: governance token for fee rebates, staking to list as verified broker, or insurance pools for cancellations.

Roadmap / future features

On-chain orderbook marketplace for prebooked slots.

Secondary NFT marketplace for Booking NFTs (transferable within allowed time window).

ERC-4907 time-based rental standard to separate owner vs user rights.

Dynamic pricing / yield optimization for hosts.

Identity & reputation system for brokers and guests.

Fiat on-ramp & payout rail to bank via custodial rails.

Insurance & cancellation protection pools (on-chain).

Dev / audit checklist

Unit tests for every state transition and rounding edge case.

Integration tests for relayer + NFT minting flow.

Security audit for payout logic, deposit handling, and dispute resolution.

Privacy review for access code storage/encryption.

Gas & UX optimization (permit pattern for one-tx flows; meta-tx relayer to pay gas).

Closing TL

ReBNB is a pragmatic Web3 product: simple on-chain primitives (prebook, finalize, split), Booking NFTs for verifiable access, and an off-chain relayer that glues NFTs to real-world door access and UX. It enables brokers to monetize prebooked inventory, gives owners transparent receipts and predictable revenue splits, and gives guests an auditable, transferable booking experience.

We built ReBNB by combining smart contracts, Booking NFTs, and a relayer-backed frontend to create a seamless Web3 rental experience. The core logic lives on-chain in Solidity smart contracts that handle escrow deposits, re-rent finalization, and transparent revenue splits between owners, brokers, and the platform. We used OpenZeppelin libraries for security (SafeERC20, ReentrancyGuard, Ownable) and implemented payouts in basis points for precision.

On the frontend, we built with Next.js (App Router), React, and TailwindCSS to deliver a clean booking and resale dashboard. We integrated Wagmi + Reown AppKit for wallet connections, and used ERC-20 Permit where possible to allow one-transaction checkouts. Booking confirmations are represented as NFTs (ERC-721), minted automatically when a guest finalizes a booking.

We connected off-chain services via a Node.js relayer that listens to on-chain events (e.g., RerentFinalized) and issues booking NFTs, generates signed QR codes, and can even integrate with smart locks. Listing metadata and images are stored on IPFS/Cloudinary, while availability and resale offers are indexed in a lightweight Postgres/Prisma backend for fast queries.

A hacky but fun part was experimenting with deposit logic: brokers stake a small amount to prebook, and we designed two payout models (deposit-only vs deposit+final pool). For the hackathon demo, we used the simpler “final payment only” split, but kept hooks for switching models later.

By piecing these technologies together, we created a decentralized Airbnb-like experience that’s fair, composable, and ready to integrate with real-world property management.