Haulie

Demo

About

Haulie is a last-mile delivery marketplace built around one idea: an old verification badge should never be able to authorize a new delivery, and a courier who finished a delivery shouldn't wait days to be paid for it. WHY THIS MATTERS Identity checks today are heavy and repetitive. Delivery and gig platforms ask couriers to upload a driver's license or passport, pass background screening, and then keep proving it's really them with real-time selfie checks, because account sharing and account renting are common: one verified person signs up, and someone else does the deliveries. Deliveries that need an identity check at the door, and every re-verification, add more photo-ID scans. Each check collects sensitive personal data, adds friction, and still proves only that someone passed a check at some point in the past, not that the same person is doing this job right now. World ID gives a lighter, privacy-preserving alternative for that recurring question: "is this the same unique, verified human?" Instead of photographing a physical ID again, the courier approves a fresh World ID check on their phone in seconds, and the app learns only that the same verified human is present. No name, document number, or photo is shared. Haulie asks for it exactly where it matters: at acceptance and again at pickup. A reused or borrowed account can't pass those gates without the verified person. This doesn't replace legal ID where the law requires one, but it removes repeated document checks from the everyday workflow. Payouts are slow and costly. Couriers on today's platforms are usually paid on a weekly cycle, and bank transfers take a few more business days to arrive. Getting paid sooner usually means an instant-cashout fee. For people who depend on daily earnings, money they've already earned sits with the platform for days. Card and bank rails also make small, frequent payouts expensive, so platforms batch them. Sui removes that trade-off. Each delivery has its own escrow, and the moment the recipient confirms receipt, the fee goes straight to the courier's wallet in a single transaction that finalizes in about a second. Fees are fractions of a cent (our confirm-and-release transaction cost about 0.002 testnet SUI in gas), so paying per delivery is cheap enough to do every time, and Sui is built for high throughput, so this works at marketplace volume. There's no payout schedule, no three-day wait, and no fee for getting paid now. Merchants benefit too: funds are locked before the job is offered and are released only under the escrow's rules, and they can refund an unassigned job from their own wallet. HOW IT WORKS A merchant posts a local delivery and locks the courier's fee in a Sui escrow before any courier sees it. To accept the job, the courier completes a fresh World ID check. At pickup they verify again with the same World identity, and the merchant signs the handoff with the wallet that funded the escrow. When the recipient confirms receipt, the escrow releases the fee to the courier's wallet, and the app shows "Paid on Sui" with the transaction. Every parcel is a shared escrow object on Sui with its own state machine: funded → assigned → picked up → delivery confirmed → paid (with refund and dispute paths). Custody and payment therefore share one public, tamper-evident history. The /custody page reads that history live from Sui testnet and shows, for each parcel, who holds it, where the fee is (held, frozen, released, or refunded), and a link to every transaction. Only a SHA-256 job reference and public wallet addresses go on-chain, never street addresses, contacts, or World identifiers. The demo runs around Toranomon Hills Forum in Tokyo. The courier map opens at the venue, can switch to your device location, and lists pickups within 25 km. A PARCEL AS AN ON-CHAIN REAL-WORLD ASSET (SUPPLY CHAIN) A delivery is a real-world asset in motion: a physical parcel whose holder changes, plus money that should move only when custody rules are met. Haulie represents each shipment on Sui as its own shared escrow object. That object is the parcel's digital twin: it holds the value tied to the shipment (the courier's fee), records who holds the parcel, and enforces what can happen next. - Movement and custody: each handoff is an on-chain transition. Funded means the merchant holds the parcel, picked up means the courier does, and delivery confirmed means the recipient does. The /custody page derives "Parcel with: Merchant / Courier / Recipient" directly from chain state. - Provenance: every transition emits an event with the transaction digest, signer, and wallet involved, so each parcel has a complete, public, tamper-evident chain of custody that anyone can audit on SuiScan without trusting Haulie's database. - Settlement: payment is tied to custody. The fee can't be released until pickup and delivery are confirmed, and release pays exactly the courier wallet snapshotted at assignment, once. - Programmable asset controls: only the operator capability can advance custody; the payout address is locked at assignment and can't be redirected; the merchant can freeze funds with a dispute or refund an unassigned job without asking the operator; release and refund are exactly-once and terminal. Off-chain, each custody step needs its own approval: a fresh World ID check from the courier, the funding merchant's wallet signature, and a one-time recipient token. - Compliance-aware privacy: the chain stores only a SHA-256 job reference and public wallet addresses. Addresses, contacts, photos, and identity data stay off-chain, so the record can be public without exposing customers. This fits Curvegrid's "Supply Chain Assets" category (track movement, custody, provenance, and settlement by representing commercial goods on-chain) and its "Programmable Asset Controls" category (permissions and approval workflows around how an asset moves). The escrow is published on Sui testnet, and real parcels have moved through it end to end, including a clean paid delivery, a dispute resolved after delivery, an in-transit parcel, a merchant refund, and a live app delivery paid out on Sui. We didn't use MultiBaas, because Haulie is built on Sui and MultiBaas targets EVM chains; we used the Sui TypeScript SDK (gRPC) for transactions and Sui GraphQL to read custody events. TRUST BOUNDARY World ID proves a unique human is in control of the same identity at each step; it doesn't prove legal identity or that a parcel is intact. The chain enforces the order of custody and payment, but handoffs are attested by Haulie's backend, so this is operator-attested delivery with on-chain escrow, not cryptographic proof of physical delivery. The deployment uses World's sandbox with test identities and Sui testnet, with small SUI fees (a 5.50 fee escrows 0.0055 SUI) so one faucet drip covers many deliveries.

How it's made

Frontend: Next.js 16 (App Router), React 19 and TypeScript, deployed on Vercel. The courier workspace uses Leaflet with OpenStreetMap tiles, opt-in browser geolocation (coordinates never leave the device), and a 25 km nearby filter around Toranomon Hills Forum. World ID: the courier flow uses World's sandbox OIDC (the World ID for Agents dev environment). Each accept or pickup starts a fresh authorization with PKCE, state, nonce, max_age=0 and prompt=login. The callback exchanges the code on the server and verifies the ID token with jose against World's JWKS (issuer, audience, nonce, auth_time freshness, orb ACR, same subject as the first check). The result is stored in an encrypted HttpOnly session (JWE, A256GCM). Query strings and local state never count as verification, and replaying a callback is rejected. Sui: the escrow is a Move package (15 Move tests). It holds the fee per parcel, snapshots the courier's payout wallet at assignment, enforces legal state transitions, lets the merchant freeze or refund without the operator, and allows exactly one release or refund. The merchant's wallet (Mysten dApp Kit, Wallet Standard) signs funding directly. The server holds an operator key and signs assign, confirm_pickup, and confirm_delivery plus release in a single transaction, but only after checking evidence it verified itself: the World session (acceptance, pickup, payout wallet), the funding merchant's signed handoff message (verifyPersonalMessageSignature), and an HMAC receipt token for the recipient. Before signing anything, it re-reads the escrow on-chain and checks its package, config, operator capability, and job-reference hash. Every step is idempotent, so a retry reconciles instead of paying twice. Custody explorer: /custody queries Sui GraphQL for every EscrowEvent from our package, validates the results with zod, groups them per parcel, and links each hashed job reference back to its order. Nothing on the page is hard-coded; new escrows appear automatically. Hacky bits worth mentioning: - The Sui CLI's publish still uses JSON-RPC, which public fullnodes have turned off, so we compile with `sui move build` and publish with the TypeScript SDK over gRPC. - There's no database on the live fee path. The chain is the source of truth, and the World session plus wallet signatures act as the authorization layer. - Fees are scaled to 1/1000 SUI because the faucet only drips 1 SUI. - We test the whole live flow on production with Playwright: a script injects a Wallet Standard wallet backed by a test key and completes real World sandbox logins, from funding to payout. Testing: Node's test runner covers state transitions, World token validation, custody parsing, and the escrow API refusing unauthenticated, cross-origin, forged-token and wrong-stage requests before any chain call. Playwright covers the map, geolocation fallbacks, wallet flows, and mobile layouts. The repository also includes a PostgreSQL backend with IDKit 4 session proofs, replay constraints, and an audit log for a multi-device marketplace; it isn't connected to the demo board yet.