Developers_Dojo

Developers Dojo — what it is (clearly, in detail)

Developers Dojo is a peer-to-peer micro-freelance marketplace built for builders. It lets anyone post small, well-scoped dev tasks (bug fixes, API hookups, UI tweaks, data chores), stake the reward up front, and pay out automatically when the work is verified. No middlemen, no chasing invoices—just ship → verify → release.

Who it’s for

Posters (founders, teams, indie hackers) who need quick help on narrowly defined tasks.

Builders (devs/designers) who want fast, paid gigs they can pick up and complete in hours—not weeks.

What you can do

Post a task with title, description, reward (in crypto), optional deadline, contact info, and optional geo-location (to show on the map).

Browse & filter tasks in a card view or on a live Mapbox map; pick nearby or remote tasks.

Accept a task (claim it), submit your work with a link/notes, and get paid once approved.

Stake rewards on-chain using an escrow smart contract, then release funds trustlessly when the job is done.

The end-to-end flow (clear status stages)

Open – Poster creates the task (stored off-chain in Supabase). It’s visible on the Browse + Map tabs.

Accepted – A builder claims it (poster cannot accept their own task). The task records the worker’s wallet.

Funded (escrow) – Poster funds the on-chain escrow with the exact reward amount. UI shows “Funded ✅”.

Submitted – Worker uploads a submission URL/notes. Poster reviews.

Approved → Release – Poster approves; the app triggers the on-chain release from the escrow to the worker.

Paid – App marks the task “paid” and stores the payout tx hash for traceability.

If changes are needed, the poster can Request Changes, which moves the task back to Accepted so the worker can resubmit.

Trust, safety, and constraints

Poster ≠ worker: posters are prevented from accepting their own tasks.

Escrow first, then payout: approval is blocked until escrow is funded, avoiding “approve without money” traps.

One source of truth for payment: payout happens from contract to worker; the tx hash is recorded alongside the task.

Minimal surface for abuse: no DMs or bidding wars in MVP—just clearly scoped tasks and a single assignee.

Architecture (plain and honest)

Frontend: React + Vite + Tailwind (clean, minimal, no gimmicky 3D). Tabs: Browse / Map / Post.

Auth & Wallets: Privy for login and wallet linking (wallet-only flow in MVP).

On-chain: Escrow contract with fund(taskId, worker) and release(taskId). Chain is configurable via env (Sepolia/Flow EVM/Zircuit testnet).

Data: Supabase for tasks (title, description, reward, location, category, deadline, contact, latitude/longitude, image_url, poster_wallet/email, worker_wallet, status, submission fields, review notes, tx hashes, timestamps).

Storage: Supabase Storage bucket task-images/ for optional screenshots.

Map: Mapbox (dark theme) with marker popups showing the task summary and reward.

Why this is different

Micro-scope by design: it’s built around small, finishable tasks—fast posting, fast claiming, fast paying.

Trustless settlement: funds are put in escrow up front and released on verification—no invoices or platforms holding your money hostage.

Geo-aware: optional coordinates let you attract local help (hardware tasks, IRL debugging) or stay fully remote.

What’s shipped vs. next

Shipped (MVP):

Wallet login (Privy), task CRUD (Supabase), image uploads, map view, accept/submit/approve/pay flow, on-chain escrow fund & release, and status guards (poster cannot self-assign, approval blocked until funded).

Next up:

Reputation & reviews, richer disputes (soft arbitration + time-boxed mediations), stablecoin support, in-app chat (e.g., XMTP), notifications, multi-chain presets (Zircuit + Flow EVM toggle), and a polished UI theme pass.

Example use cases

“Connect my frontend to this REST endpoint and display the results.”

“Fix a CSS layout bug on mobile.”

“Write a SQL query and export a CSV.”

“Add a loading state and error handling to this modal.”

🔧 Tech Stack

Frontend

React + Vite + TailwindCSS – for fast builds and a clean UI.

Framer Motion – smooth animations for hero sections, feature grids, and transitions.

Mapbox GL JS – interactive map view with live task markers and styled popups.

Authentication & Wallets

Privy (@privy-io/react-auth) – login + wallet linking in one flow.

Wagmi + Ethers.js – wallet provider management and contract interactions.

Backend / Storage

Supabase – database + storage.

tasks table holds all off-chain metadata (title, desc, reward, status, tx hashes, etc.).

Supabase Storage bucket (task-images/) handles optional screenshots.

Smart Contracts

Escrow.sol (deployed address provided via .env) – manages funding + payout.

Poster funds reward into escrow after a worker is assigned.

fund(taskId, worker) → locks ETH/Flow/ETH-testnet.

release(taskId) → contract pays worker directly.

⚙️ How the pieces connect

Landing Page Clean hero with LightRays background and onboarding CTA (“Launch App”). Visitors can see feature highlights like Trustless Escrow and Instant Settlements.

App Flow

Users connect with Privy → wallet linked or created.

Navbar shows Connect Wallet and Post Task button (if logged in).

Three main tabs: Browse (task cards), Map (geo-located pins), Post Task (form).

Posting Tasks

TaskForm collects metadata (title, desc, reward, category, deadline, location, geo).

If image attached → uploaded to Supabase Storage, returns a public URL.

Task inserted into Supabase DB with status = "open". Poster’s wallet/email are stored.

Accepting Work

Any user (except poster) can click Accept Task.

Supabase updates the task with worker’s wallet and sets status = "accepted". Poster cannot self-assign (checked in query).

Funding Escrow

Poster calls fundEscrow(task) from frontend.

Contract locks reward ETH into escrow.

UI updates “Escrow: Funded ✅” after checking chain state.

Submitting Work

Worker submits a URL + notes (stored in Supabase, task moves to "submitted").

Approving & Paying

Poster approves → triggers releaseEscrow(taskId) on-chain.

Contract transfers reward directly to worker’s wallet.

Supabase updates status "completed" → "paid", storing payout tx hash.

🚀 Partner Technologies (and why they mattered)

Privy – gave us wallet login + email fallback with minimal code. Saved hours of rolling custom MetaMask handling.

Supabase – handled all the messy CRUD (tasks, submissions, images) so we could focus on the escrow flow.

Mapbox – provided a polished task-discovery layer (seeing nearby work is a killer differentiator).

🤯 Hacky bits worth noting

Dual state sync – We keep task status both in Supabase and on-chain. To avoid double-funding bugs, we block approval until escrow is confirmed funded.

Poster ≠ worker guard – Added .neq("poster_wallet", workerWallet) directly into the Supabase update query so posters can’t accept their own tasks.

Fallback TX tracking – Even though payouts are on-chain, we also store tx hashes in Supabase so users can see history in their TaskCards.

Auto-geolocation – TaskForm pulls navigator.geolocation on load and pre-fills lat/long silently.

Popup sanitization – Mapbox popups escape HTML to prevent injection when showing user-provided text.

👉 In short: Developers Dojo is stitched together with a pragmatic mix of Supabase for state, Privy for identity, and an escrow smart contract for truth of funds. The frontend layers React/Tailwind/Mapbox for usability, while Privy + Ethers.js bridge to Web3.