EmergeBee: Events Prop Rentals + AR Rewards on Algorand

Trustless event prop rentals with blockchain-secured deposits and WebAR gamification rewards

EmergeBee combines a decentralized marketplace for event props with immersive AR experiences, rewarding attendees with on-chain tokens while ensuring secure, automated rental agreements through Algorand smart contracts.

🎯 One-Liner

Rent giant inflatables, run AR mini-games, reward attendees with blockchain tokens — all secured by Algorand smart contracts.

🌟 Key Features

🏪 Decentralized Prop Marketplace

Browse event props (inflatables, sculptures, branded setups)
Real-time availability calendar
Transparent pricing with blockchain-secured deposits
Vendor dashboards with flexible payout options

🎮 WebAR Gamification

QR code-activated AR experiences (no app download needed)
Tap-target mini-games built with A-Frame
Real-time scoring and leaderboards
Instant rewards via Pera Wallet

🔐 Blockchain Security

Smart Contract Escrow: Automated deposit management with delivery/return verification
Cryptographic Vouchers: Ed25519-signed reward claims prevent fraud
ASA Rewards: Three-tier token system (Bronze, Silver, Gold medals)
Trustless Payments: No intermediaries — rental agreements execute on-chain

🏗️ Architecture Overview

┌─────────────────────────────────────────────────────────────┐
│                        FRONTEND LAYER                        │
├──────────────┬──────────────────┬──────────────────────────┤
│  Marketplace │ Organizer Portal │    AR Experience         │
│  (Browse)    │  (Dashboard)     │    (WebAR + Rewards)     │
└──────────────┴──────────────────┴──────────────────────────┘
                          ▼
┌─────────────────────────────────────────────────────────────┐
│                   APPLICATION LAYER                          │
├──────────────────┬──────────────────┬──────────────────────┤
│   Express API    │  Voucher Signer  │   Payout Manager     │
│  (REST + Auth)   │  (Ed25519)       │   (Hybrid System)    │
└──────────────────┴──────────────────┴──────────────────────┘
                          ▼
┌─────────────────────────────────────────────────────────────┐
│                        DATA LAYER                            │
├──────────────────────────────┬──────────────────────────────┤
│      PostgreSQL (Neon)       │        Algorand TestNet      │
│  (Props, Bookings, Events)   │  (Smart Contracts + ASAs)    │
└──────────────────────────────┴──────────────────────────────┘

🛠️ Smart Contracts (PyTeal)

Contract: RentalEscrow.algo

Purpose: Manages rental deposits and automates payment flows with delivery/return verification.

Key Methods:

`deposit(vendorAddress, rentalFee, depositAmount)`

Organizer deposits rental fee + damage deposit in ALGO
Contract holds funds in escrow
Emits DepositReceived event

`confirmDelivery()`

Vendor confirms prop delivery
Marks rental as "active"
Enables return process

`confirmReturn(noDamage: bool)`

Organizer confirms prop return condition
If noDamage == true:
- Releases deposit back to organizer
- Transfers rental fee to vendor
If noDamage == false:
- Triggers dispute flow

`reportDamage(damageDescription, estimatedCost)`

Either party can report damage
Withholds deposit pending resolution
Logs damage details on-chain

`releaseFee()` / `refundDeposit()`

Admin-triggered settlement after verification
Automated fund distribution based on contract state

Security Features:

Timelock mechanisms prevent indefinite fund locking
Role-based access control (organizer vs vendor vs admin)
Immutable transaction history for dispute resolution

Contract: EventRewardManager.algo

Purpose: Verifies cryptographic vouchers and distributes ASA rewards to AR game players.

Key Methods:

`claimReward(voucherData, signature, tier)`

Validates Ed25519 signature against trusted public key
Verifies voucher hasn't been replayed (nonce tracking)
Transfers appropriate ASA token (Bronze/Silver/Gold)
Marks voucher as consumed

Voucher Structure:

{
  "eventId": 42,
  "wallet": "ALGORAND_ADDRESS",
  "score": 95,
  "tier": 3,
  "nonce": "unique-uuid",
  "expiry": 1729555200
}

Security:

Vouchers signed server-side after AR game validation
SHA-256 hashing before Ed25519 signature
Prevents front-running and replay attacks
Single-use nonce enforcement

🪙 Algorand Standard Assets (ASAs)

EmergeBee uses three reward tokens on Algorand TestNet:

Token	ASA ID	Purpose
SPBRNZ	747986229	Bronze Medal (score 50-74)
SPSLVR	747986230	Silver Medal (score 75-94)
SPGOLD	747986231	Gold Medal (score 95-100)

Automatic Distribution:

Player completes AR game
Backend issues signed voucher
Player connects Pera Wallet
Opts-in to ASA (one-time)
Claims reward via smart contract
Token appears in wallet instantly

🎮 AR Game Flow

sequenceDiagram
    participant User
    participant QR Code
    participant AR Game
    participant Backend
    participant Blockchain

    User->>QR Code: Scan at event
    QR Code->>AR Game: Launch WebAR (A-Frame)
    User->>AR Game: Play tap-target game (30s)
    AR Game->>Backend: Submit score
    Backend->>Backend: Validate + Sign voucher (Ed25519)
    Backend->>User: Return signed voucher
    User->>Blockchain: Connect Pera Wallet
    User->>Blockchain: Claim reward (submit voucher)
    Blockchain->>Blockchain: Verify signature + nonce
    Blockchain->>User: Transfer ASA token

🔒 Security Architecture

1. Cryptographic Vouchers

Signing Algorithm: Ed25519 (fast, secure, 64-byte signatures)
Hashing: SHA-256 before signature
Nonce Protection: UUID v4 ensures single-use
Expiry Enforcement: 24-hour TTL on vouchers

2. Smart Contract Security

Role-Based Access: Only authorized addresses can execute critical functions
Timelock Protection: Prevents indefinite fund locking (7-day auto-refund)
Event Logging: All state changes emit verifiable events
Replay Protection: On-chain nonce tracking

3. Wallet Authentication

Pera Wallet Integration: Industry-standard Algorand wallet
No Private Key Exposure: All signing happens client-side in wallet
Session Management: Secure session storage with auto-expiry

4. API Security

Input Validation: Zod schemas on all endpoints
Rate Limiting: Prevents abuse of voucher issuance
CORS Protection: Whitelisted origins only
Environment Secrets: All sensitive keys in .env (never committed)

💻 Tech Stack

Frontend

Framework: React 18 + Vite + TypeScript
Routing: Wouter (lightweight)
State: TanStack Query v5
UI: Shadcn UI + Radix UI + Tailwind CSS
Forms: React Hook Form + Zod
AR: A-Frame (WebXR)
Wallet: Pera Wallet Connect SDK

Backend

Server: Express.js + TypeScript
Database: PostgreSQL (Neon) + Drizzle ORM
Auth: Pera Wallet (blockchain-based)
Crypto: @noble/ed25519 for voucher signing
Blockchain: py-algorand-sdk for contract deployment

Smart Contracts

Language: PyTeal (Algorand)
Version: TEAL v10
Network: Algorand TestNet
Deployment: AlgoKit + py-algorand-sdk

🚀 Getting Started

Prerequisites

Node.js 18+
PostgreSQL database
Algorand TestNet account
Pera Wallet (mobile or browser extension)

Installation

# Clone repository
git clone https://github.com/yourusername/emergebee.git
cd emergebee

# Install dependencies
npm install

# Setup environment variables
cp .env.example .env
# Add your Algorand TestNet credentials, database URL, etc.

# Run database migrations
npm run db:push

# Start development server
npm run dev

Deploy Smart Contracts

# Install Python dependencies
pip install pyteal py-algorand-sdk

# Deploy escrow contract
python scripts/deploy_rental_escrow.py

# Deploy reward manager
python scripts/deploy_reward_manager.py

# Create ASA tokens (Bronze, Silver, Gold)
python scripts/create_reward_assets.py

Environment Variables

# Database
DATABASE_URL=postgresql://user:pass@host:5432/emergebee

# Algorand
ALGORAND_NETWORK=testnet
ALGORAND_ALGOD_URL=https://testnet-api.algonode.cloud
ALGORAND_INDEXER_URL=https://testnet-idx.algonode.cloud
ALGORAND_DEPLOYER_MNEMONIC=your_25_word_mnemonic

# Voucher Signing
ED25519_PRIVATE_KEY=your_private_key_base64
ED25519_PUBLIC_KEY=your_public_key_base64

# ASA IDs (after deployment)
ASA_BRONZE_ID=747986229
ASA_SILVER_ID=747986230
ASA_GOLD_ID=747986231

📊 Database Schema

Core Tables

props

Prop listings with photos, pricing, vendor wallet address
Availability calendar (JSONB)
Categories, dimensions, location data

bookings

Rental agreements linking organizers to props
Escrow contract IDs, transaction hashes
Delivery/return status tracking
Damage reports and dispute resolution

events

AR experience configurations
QR code zones, reward tier thresholds
Live analytics (player count, avg score)

game_sessions

Individual AR gameplay records
Scores, voucher data, claim status
Device info, geolocation (optional)

vendors

Payout preferences (Stripe, bank, blockchain)
Pending balance tracking
Earnings history

🎨 User Flows

1. Vendor: List a Prop

Connect Pera Wallet
Navigate to Dashboard → List Props
Upload photos, set pricing + deposit
Submit → Wallet address auto-saved
Prop appears in marketplace

2. Organizer: Rent a Prop

Browse marketplace, select prop
Choose rental dates
Connect Pera Wallet
Smart contract deploys escrow
Sign transaction (rental fee + deposit)
Vendor confirms delivery → Rental active
After event, confirm return → Deposit refunded (if no damage)

3. Attendee: Play AR Game & Earn Rewards

Scan QR code at event venue
WebAR game loads (no app needed)
Play tap-target game (30 seconds)
Submit score → Backend issues voucher
Connect Pera Wallet
Opt-in to reward ASA (first time only)
Claim reward → Token transferred instantly

🌐 Live Demo

🔗 Website: https://emergebee.com
🔗 Marketplace: https://emergebee.com/marketplace
🔗 AR Demo: [Scan QR at event]

Demo Credentials (TestNet)

Test Wallet: Create one at Pera Wallet TestNet
Faucet: Get test ALGO at Algorand Dispenser

📦 Smart Contract Addresses (TestNet)

Contract	Address	Explorer Link
RentalEscrow	`0xABC123...` (EVM-compatible via AVM)	View on AlgoExplorer
RewardManager	`0xDEF456...`	View on AlgoExplorer
Bronze ASA	747986229	View Asset
Silver ASA	747986230	View Asset
Gold ASA	747986231	View Asset

🛣️ Roadmap

✅ MVP (Completed)

🚧 In Progress

Mobile app (React Native)
Multi-signature escrow for high-value props
AI damage detection (photo comparison)
Social sharing with auto-overlays
Analytics dashboard for organizers

🔮 Future (v2+)

Cross-chain support (Ethereum, Polygon)
NFT-based prop ownership certificates
DAO governance for dispute resolution
AR multiplayer games
Integration with Shopify (coupon redemption)

🤝 Contributing

We welcome contributions! Please follow these steps:

Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Commit changes (git commit -m 'Add amazing feature')
Push to branch (git push origin feature/amazing-feature)
Open a Pull Request

Development Guidelines

Follow existing code style (Prettier + ESLint configs)
Write tests for new features
Update documentation
Ensure smart contract changes are audited

📄 License

This project is licensed under the MIT License - see LICENSE file for details.

🙏 Acknowledgments

Algorand Foundation for blockchain infrastructure
A-Frame Community for WebAR framework
Shadcn UI for beautiful component library
Neon for serverless PostgreSQL
Pera Wallet for seamless wallet integration

Name		Name	Last commit message	Last commit date
attached_assets		attached_assets
client		client
contracts		contracts
server		server
shared		shared
.gitignore		.gitignore
.replit		.replit
README.md		README.md
components.json		components.json
design_guidelines.md		design_guidelines.md
drizzle.config.ts		drizzle.config.ts
package-lock.json		package-lock.json
package.json		package.json
postcss.config.js		postcss.config.js
pyproject.toml		pyproject.toml
replit.md		replit.md
tailwind.config.ts		tailwind.config.ts
tsconfig.json		tsconfig.json
uv.lock		uv.lock
vite.config.ts		vite.config.ts

Latest commit

History

Folders and files

Repository files navigation

EmergeBee: Events Prop Rentals + AR Rewards on Algorand

🎯 One-Liner

🌟 Key Features

🏪 Decentralized Prop Marketplace

🎮 WebAR Gamification

🔐 Blockchain Security

🏗️ Architecture Overview

🛠️ Smart Contracts (PyTeal)

Contract: RentalEscrow.algo

deposit(vendorAddress, rentalFee, depositAmount)

confirmDelivery()

confirmReturn(noDamage: bool)

reportDamage(damageDescription, estimatedCost)

releaseFee() / refundDeposit()