ETHGlobal Mumbai 2026 · architecture plan v4.6 · Fri 6 Nov 23:25 IST · status board below · comment with 💬 (blocks, diagram nodes, selected text)
Where we are (Fri 6 Nov 23:25 IST)
Everything is real on the deployed app: Kris, as a real passkey owner, bought chai on a real 0G decision; cigarettes went 0G ask_human → approval in World App with his Orb-verified account → enforcer PaymentApproved → paid (0xae55688e…ffa9); his episodes are on 0G Storage and anchored in EpisodeLog. Evidence: docs/evidence/README.md.
Robot evidence is live: the chip can start an errand by scanning (POST /api/chips/:robotId/scans, chip-signed, ≤ 64 KB QR crop kept in R2 and uploaded plain to 0G Storage as proof of the robot's work, its root and hash in the episode anchored on 0G; never sent to the brain) and the episode page shows "What the robot saw" with an on-chain verify badge. Rule 4 changed at 20:00: frames are evidence, not decision input; the chip may attach signed frames or clips to an episode, and the 0G decision never receives an image. The Radxa wiring guide is docs/hardware-handoff.md §5.
0G Compute in a TEE: the decision model is glm-5.3 (TeeML, registry provider 0xD179…E503) since 17:15 IST; the first two decisions' TEE signatures were verified independently with 0G's SDK, and the Worker now fetches each decision's proof at decision time, stores it with the decision and in the EpisodeLog-anchored evidence; the episode page shows "Sealed in a TEE ✓ (0G chat …)" after Verify (docs/evidence/2026-11-06-tee-verification.md).
Audit view:/wallet/episodes and /wallet/episodes/:id — timeline, the exact 0G input and decision, chip, Arc payment, World acr/amr, 0G evidence, Verify and Replay.
Merchant till:cafe.vitaquack.com, a point of sale on the same frozen routes; items over 1 USDC are badged "needs owner approval". Demo rules (6 Nov 17:45, spending limits only): grant 3.00/day, 1.00 per payment; thali 2.00 = the approval beat; a third thali in a day = the daily-cap walk-away; cigarettes are out of the catalogue.
Contracts and infra: Arc Studio (studio.arc.io/app/63241623…) is the single source; mainnet enforcer 0x7c2167B0a49108b28DFDA3aca5ddddd9Af68e4D3, Galileo EpisodeLog0x4C947E6D794C78d0F684e46EFC97f712E51a206A; the state-store incident is resolved and guarded.
The robot speaks on Telegram (live since 19:10):@vitaquack_bot messages the owner when the robot needs an approval (a button to the approval page and a fail-safe Deny), when it paid (with the Arc link), when a purchase was denied or expired, and when the allowance was stopped. Telegram may deny, never approve; approving stays World ID. Linked from the wallet's avatar sheet with a single-use code; a failed message never delays a payment. Spec §14.
Simulator duck (live since 19:30, first live run pending): Add robot → Simulator opens /sim/, a browser duck with a software chip beside a Duck Café of three stalls; glm-5.3 walks it to the stall, the head camera scans the QR, decide pays, the chip signs, Arc settles and the stall's gate opens. Nothing in that flow has run against live 0G and Arc yet. Spec §15.
Found by the new tests (fixed, deployed): after a denied thali the next thali errand reused the same invoice, so its approval could not be saved and the approval page answered 404; an invoice an owner was ever asked about is never offered again.
vitaquack.com (live since 20:45 IST): the app's Edge Worker holds the apex: / is the landing page, /app/ the wallet (passkeys are bound to the new host, so owners sign up again), /api/ unchanged, /plan/ this site, cafe.vitaquack.com the till. Release fcd4ee2; the cutover runbook is docs/DEPLOYMENT.md.
Simulator duck, first live run passed (20:30 IST, release 771e0a4): the browser duck paid a chai on Arc with glm-5.3 navigation turns (0x95338dc3…cfc4), the stall gate opened, a thali went ask_human and was denied, and asking for chai while scanning the samosa QR walked away. docs/evidence/2026-11-06-sim-e2e.md.
Counter display for the ESP32 (release fcd4ee2): the café owner's till puts one invoice on the counter screen (POST/GET /api/merchants/duck-cafe/counter); the real duck's scan claims the owner's intent, so the mismatch beat (asked chai, shown samosa) walks away on hardware too. Till page and handoff section in the next release.
Frames on 0G Storage (release 952fcd2, 21:05 IST): every chip-signed frame is uploaded plain to 0G Storage as proof of work, its root hash recorded next to its sha256 in the anchored episode JSON; Verify re-downloads it. First run: 8 episodes, 6 with a frame, one frame checked independently with curl (same sha256, a JPEG). The uploader now runs on netcup as the systemd service vitaquack-evidence-uploader (since 7 Nov). Wallet phase 2 is complete and deployed (release a91e0ca): left-today per robot, 0G and TEE marks in the conversation, the QR crop in the conversation, robot details, sheet animations, proof pages in the phone column, the real robot's "Get me a…" intents. Telegram's webhook and the till are on the new origin; World accepts the new callback.
Live camera view (release 0efdb5d, 23:05 IST): the robot's chat shows its latest head-camera frame; the chip signs each frame (POST /api/chips/:robotId/frames, its own EIP-191 message so a frame can never pass as a scan), the server keeps one frame per robot in R2 at most every 400 ms, the simulator pushes about once a second, the Radxa's camera process can push through the chip's local listener (POST /frame). Frames stay out of the 0G decision; keyframes to 0G wait for Kris's word. Behind APP_LIVE_ENABLED, on. Also live: a minute cron on the API Worker expires errands nobody is reading and sends queued Telegram messages; the wallet's motion vocabulary (skeletons, spinners, message entrances) lands in the next release.
Onboarding and Telegram UX (release caa3168, 23:25 IST): sign-up lands on /app/welcome (Telegram, then money in, then a robot); the Receive QR is an EIP-681 payment request on Arc; the Telegram row notices Start by itself; a stuck pairing can be cancelled; the allowance defaults to what the balance covers and warns before the passkey signs; a minute cron expires unread errands and sends queued Telegram messages. The approval message gains Approve with World ID: a single-use 300 s link that stands in for the passkey session only once the owner's World account is bound, the fresh World sign-in with the payment nonce still required, every bad link falling back to the approval page; Telegram itself still only denies. The real-IdP path of that link is untested until Kris runs it. The wallet's motion vocabulary (skeletons, spinners, message entrances, paid pops) is live since e66bd3b.
0G brain per message (release 79a7d3c, 7 Nov 00:10 IST): at 23:30 the glm-5.3 TeeML provider answered 429 for twenty minutes and every errand ended in safe_stop with nothing paid; Kris chose a hand switch over a silent fallback. Each request from the conversation carries an optional model (glm-5.3 in its TEE, or qwen3-vl-plus without one), chosen with a Brain chip in the dock, stored on the intent and the episode, used by that intent's navigation turns, the errand's decision and the scan that claims the intent; decide retries one 429 inside its 10 s budget; only a stored, verified TEE proof earns the badge. The live camera view now refreshes every 500 ms while an errand is open, at up to 384 px (release b97d0a4).
Open: Kris's run on vitaquack.com (sign-up, pairing the Radxa, thali approve and deny, the daily-cap walk-away, revoke) with Telegram linked; the hardware run with the ESP32 counter screen; the video Sat 06:00; submission by 08:00 IST.
Don't give a robot your wallet. Give it a budget.
Vitaquack. A passkey wallet on Arc grants a budget to a robot's chip. One Robot Agent per robot asks 0G what to buy, pays our merchant over x402, and asks a human through World Agent Pass when a purchase is over the limit or restricted. The chip always signs. The wallet never needs to know the grantee is a robot. Build order: docs/spec.md.
1 · WALLET
The foundation
Passkey account on Arc, fund / send / receive with no gas shown, grants to any address, an MCP server whose consent screen creates the grant, Agent Pass approvals.
2 · ROBOT AGENT
The brain
One errand state machine per robot (an Effect service over D1): asks 0G, hands the invoice to the chip over HTTPS long-polling, logs every decision. Runs with no chip too.
3 · MERCHANT
The till
Items, prices, rules (needs approval, restricted). x402 checkout settled by our own facilitator. Later an ESP32 shows the QR and opens a gate.
4 · CHIP
The body and the signer
The Radxa on the duck, or a mock chip in iteration 1. Holds the key the grant is given to and signs every robot payment. Camera and motors on the real one.
The one rule: Arc is the authority. Every limit and every human approval is checked on-chain when a payment lands. Our servers coordinate and relay; they can never authorise, steal or redirect a payment, only delay it.
Battle plan to Saturday 09:00 IST
Deadline: submissions close Sat 7 Nov 09:00 IST, no late entries. On Fri 04:30 no product code exists yet, only the foundation, these docs and spike prototypes. Everything is cut to fit about 28 hours. Details: docs/plan.md §0.
Scope
What
MUST
Passkey wallet on Arc mainnet → grant to the chip (real Radxa or mock) → the Robot Agent asks 0G and buys from our x402 merchant through our facilitator → a purchase over the per-payment cap needs Agent Pass (approve and deny), the daily cap is never lifted → revoke stops the next payment → 0G Storage episode log + contract → our enforcer(s) built in Arc Studio → the ESP32 gate opens on a signed "paid"
STRETCH
On-chain Agent Pass check · camera/vision · duck walking · a read-only MCP server
CUT
The float path · outside MCP hosts · funding from other chains · MPP · ENS · IDKit · 4337 break-glass (doc only)
0G decides with a stored request id; Agent Pass approve and deny both work
C · chip + merchant
Chip protocol, mock chip, Radxa runtime (Bun + viem, Python fallback); merchant (store, x402, invoices, signed status for the ESP32)
Mock chip and Radxa sign; merchant settles; ESP32 shows PAID
Teammates
Physical robot (duck build, Radxa OS, ESP32 wiring + servo, camera QR read) and booth questions
The Radxa and ESP32 run on the duckbench hotspot
By (IST)
Checkpoint
Fri 08:00
Prerequisites done: ~$20 USDC on Arc + relayer key, a keyed Arc RPC, the 0G key, 0G Chain gas for Storage, World IdP client, Arc Studio project, a product name. Spikes S1 (real-phone passkey), S3 (0G), S5 (Agent Pass returns our nonce)
Fri 14:00
First end-to-end headless purchase on Arc mainnet ($0.10, mock chip, our merchant, our facilitator)
Fri 20:00
Full MUST loop: Agent Pass approve/deny, revoke, 0G Storage log, the Radxa signing, the ESP32 gate opening
Sat 02:00
Stretch stops; README, architecture diagram, Arc Studio walkthrough
Sat 06:00
Feature freeze: video (2:30–2:59, fits both ETHGlobal's 2–4 min and 0G's under 3 min), World debrief, contract addresses
Sat 09:00
Submitted (aim for 08:00)
Demo (4 min)
Beat
0:00
Don't give a robot your wallet, give it a budget
0:20
Owner's passkey grants Vitaquack's chip $10/day on the consent screen
0:50
"Buy me a chai": 0G decides (request id) → the chip signs → paid on Arc → the gate opens
1:50
Thali 2.00, over the 1.00 per-payment cap → Agent Pass in World App → approve: paid → again → deny: nothing paid → a third thali would pass the 3.00 daily cap: walks away
2:50
Revoke → the next attempt fails on-chain
3:20
Architecture, our enforcer in Arc Studio, the episode log on 0G Storage
Must not forget
Why
README section on code that predates the event (the foundation boilerplate from the public styld.app repo, one commit on 5 Nov); product code in small commits
ETHGlobal: "from scratch", and "large single commits … may be disqualified"
Video: 2–4 min, ≥ 720p, real narration, no AI voice, not sped up, not filmed on a phone, ≤ 4 bullets per slide
Otherwise rejected on upload
Each of the 3 partner prizes needs "how we integrated it" + feedback; World needs a debrief (time to first success, friction, one improvement)
The only way partners assess the project
0G: contract deployment addresses + episode log on 0G Storage with a request id per decision
Required for Physical AI
Arc: shareable Studio URL, Studio shown in the demo, architecture diagram
Required for every Arc track
Gaps found in this review
Fix
The float path would bypass the merchant allowlist (pull to the chip, pay anyone)
Dropped entirely; later fix = a policy-bound escrow
How does Arc know an item is restricted?
Approval needed when over the per-payment cap or the payee isn't allowlisted; restricted items use a merchant payTo that's never allowlisted
Two ways to submit a payment (wallet MCP vs x402)
One route: the Robot Agent posts the chip-signed voucher to the merchant; no MCP in the money flow; the chip builds the leaf itself
x402 header is ≈ 12 KB
Test against the Worker; trim caveats; fallback: relay directly
No map of the apps
One web app: wallet (owner) + robot console (camera, control, decisions) + merchant (store, checkout); the ESP32 is the gate
System map
flowchart TB
subgraph U["👤 Owner"]
PH["Phone / laptop<br/>passkey · World App"]
end
subgraph W["1 · Wallet (Cloudflare)"]
WAPP["Wallet app<br/>signup · fund · grants · approvals"]
WMCP["Grant consent page<br/>the passkey signs the grant"]
FAC[("Our x402 facilitator / relayer<br/>grant payments · owner actions")]
end
subgraph RA["2 · Robot Agent (Effect service + D1, one per robot)"]
AG["Errand state machine<br/>0G decide · chip sign requests · evidence"]
end
subgraph C["4 · Chip"]
CHIP["Radxa or mock chip<br/>key · signs · camera · motors"]
end
subgraph M["3 · Merchant"]
STORE["Store<br/>items · prices · rules"]
X402["x402 checkout<br/>grant path, our facilitator"]
GATE["ESP32 gate (iter 2)<br/>QR · servo"]
end
subgraph ARC["Arc mainnet"]
ACC["Owner account<br/>HybridDeleGator (passkey)"]
DM["DelegationManager<br/>+ our enforcers (Arc Studio)"]
USDC["USDC"]
end
OG[["0G inference<br/>standard providers"]]
WORLD[["World IdP<br/>Agent Pass (OIDC)"]]
PH --> WAPP
WAPP --> WMCP
WAPP <--> WORLD
AG -- "in-process services" --> WAPP
AG -- "decide" --> OG
AG <-- "HTTPS long-poll (chip dials out)" --> CHIP
AG -- "x402" --> X402
CHIP -- "scan (iter 2)" --> GATE
STORE --> X402
X402 -- "grant path" --> FAC
WAPP --> FAC
FAC -- "redeemDelegations" --> DM
DM -- "checks every cap" --> ACC
ACC --> USDC
Grants: one mechanism, the chip is the grantee
A grant is a signed delegation from the owner's account to an address. Here that address is the robot's chip, so the chip signs every payment. The Robot Agent decides; it never holds a spending key.
flowchart TB
O["👤 Owner account (passkey)<br/>$42.10 USDC on Arc"]
G1["Grant → Vitaquack's chip (0xChip…)<br/>$10/day · max $2 each · allowlisted merchants · USDC only<br/>over $2 or payee not allowlisted (restricted): needs Agent Pass approval"]
G2["Grant → claude.ai (after the event)<br/>$2/day · key held by the wallet"]
V1["Voucher signed by the chip<br/>pay Chai Stand $1.50 · invoice 7f3a"]
V2["Voucher signed by the chip<br/>pay Samosa Stand $0.25 · invoice 91c2"]
RL["Our facilitator<br/>redeemDelegations(voucher → grant)"]
CHK{"Arc checks:<br/>caps · expiry · USDC only · invoice unused<br/>· approval co-signature"}
O --> G1
O --> G2
G1 --> V1 --> RL
G1 --> V2 --> RL
RL --> CHK
CHK -- "all pass" --> PAY["USDC moves"]
CHK -- "any fails" --> REV["revert: nothing paid"]
One way to pay, and why there is no float path
Every robot payment is a chip-signed voucher settled by our facilitator through the DelegationManager, so Arc checks the payee, amount, invoice, caps and revocation at the moment the money moves.
flowchart LR
a1["Chip signs a voucher<br/>pay merchant · exact amount · invoice"] --> a2["Our facilitator<br/>verify · simulate · redeemDelegations"] --> a3["Arc checks every cap<br/>at payment time"] --> a4["Owner → merchant"]
Grant path (the only path)
Settled by
Our facilitator (ported from the S2 spike; no open-source one exists for this scheme)
Limits
Daily cap, per-payment cap, payee allowlist, invoice replay guard, expiry, revocation, approval requirement: all on Arc
Measured cost
≈ 505–663k gas ≈ $0.010–0.013 per settle (simulated)
Why no float path
Reviewers showed that after a pull to the chip's own address, Arc no longer binds the payee, the invoice or revocation on the second transfer, which breaks the one rule above. Dropped for the event; the later fix is a policy-bound escrow contract, not a chip float
Iterations
flowchart LR
I0["0 · Wallet<br/>passkey · fund · send/receive<br/>grants · MCP · Agent Pass"]
I1["1 · Headless<br/>Robot Agent + mock chip per teammate<br/>merchant · our facilitator"]
I15["1.5 · Virtual resource<br/>no simulator: the chip buys<br/>an x402 API through the full flow"]
I2["2 · Hardware<br/>Radxa chip · ESP32 gate<br/>scan · sign · gate opens"]
I0 --> I1 --> I15 --> I2
Iteration
Done when
0 · Wallet
Sign up with only a passkey, receive $1, send $0.10, connect a client with a $2/day grant, revoke it, on Arc mainnet with no gas shown
1 · Headless
Fully virtual. Every teammate runs a mock chip (a Bun script with its own key, same long-polling protocol as the Radxa); the real Radxa pairs over the internet with the same code. The agent (0G) buys a normal item (grant path), a restricted or over-limit item (Agent Pass approve → paid, deny → nothing); revoke stops all; every 0G decision logged
1.5 · Virtual resource
No simulator: the chip buys a virtual resource, an x402 API (data, an image, a song), through the whole flow, with no physical QR
2 · Hardware
The duck scans the ESP32 QR, the Radxa signs, the gate opens on a signed "paid"
Flows
A · Sign up and fund
sequenceDiagram
autonumber
participant P as Owner (passkey)
participant W as Wallet backend
participant A as Arc
participant C as Circle CCTP / Gateway
P->>P: create passkey (Face ID)
P->>W: public key
W->>A: relayer deploys HybridDeleGator via SimpleFactory (~$0.005, we pay)
A-->>P: account address (same forever)
alt USDC already on Arc
P->>A: send to the address from any wallet
else USDC on another chain
P->>C: deposit / burn from MetaMask on Base, Ethereum, …
C->>A: mint to the account on Arc (Circle submits, no gas for the owner)
end
B · Pair the chip, grant the budget (consent = grant to the chip)
sequenceDiagram
autonumber
participant P as Owner (passkey)
participant WA as Wallet
participant RA as Robot Agent DO
participant CH as Chip (real or virtual)
P->>WA: add robot "Vitaquack" → pairing code
CH->>CH: generate key (never leaves the chip)
CH->>RA: POST /api/chips/pair (code + signed challenge)
RA-->>CH: challenge
CH->>RA: signature → RA now knows the chip address
RA->>WA: in-process: request a grant for the chip
WA-->>P: consent: "Vitaquack (0xChip…) wants $10/day until Sunday"
P->>P: passkey signs the grant (delegate = chip address, no transaction)
WA-->>RA: grant active (stored delegation · the chip polls for sign requests)
C · Headless purchase, grant path (iteration 1, mock chip)
sequenceDiagram
autonumber
participant RA as Robot Agent
participant OG as 0G
participant M as Merchant (x402)
participant CH as Chip
participant F as Our facilitator
participant A as Arc
RA->>OG: "buy chai" → plan (request_id logged)
RA->>M: GET /items/chai
M-->>RA: 402: $1.50 · exact / ERC-7710 · invoice 7f3a
RA->>CH: sign voucher: pay Chai Stand $1.50, invoice 7f3a
CH->>CH: check invoice and amount, sign
CH-->>RA: signed voucher
RA->>M: POST /api/invoices/7f3a/pay (the voucher)
M->>F: verify + settle
F->>A: redeemDelegations(voucher → grant)
A-->>F: caps OK → paid (final in under a second)
M-->>RA: 200 + receipt
D · Over the limit or restricted: Agent Pass (approve and deny); our backend verifies the token and co-signs
sequenceDiagram
autonumber
participant RA as Robot Agent
participant WA as Wallet
participant P as Owner phone (World App)
participant WO as World IdP
participant CH as Chip
participant A as Arc (RobotPaymentPolicyEnforcer)
RA->>WA: approval_request($8 chai, invoice 7f3a)
WA->>WA: nonce = EIP-712 hash {invoice 7f3a, $8, Chai Stand, expiry}
WA-->>P: our page shows "Vitaquack wants $8 for chai" + Approve with World
P->>WO: browser sign-in (nonce, max_age=0) → confirm in World App
alt approved
WO-->>WA: RS256-signed ID token (nonce echoed, fresh auth_time)
WA->>WA: verify the token (iss, aud, nonce, auth_time, amr has pop and not mfa, jti once) · co-sign the EIP-712 approval
WA-->>RA: approval signature
RA->>CH: sign voucher for invoice 7f3a
RA->>A: voucher + approval in the enforcer args
A->>A: approval signer, payee, amount, expiry, nonce unused
A-->>RA: paid
else denied / cancelled / expired
WO-->>WA: no token
WA-->>RA: denied: nothing co-signed, nothing paid
end
E · The robot buys at the ESP32 gate (iteration 2)
sequenceDiagram
autonumber
participant B as Browser (owner)
participant RA as Robot Agent
participant CH as Chip (Radxa)
participant G as ESP32 gate
participant M as Merchant
participant A as Arc
B->>RA: watch camera, take over any time
RA->>CH: approach the QR (deadman 300 ms)
G->>M: POST /invoices → QR on screen
CH->>CH: scan QR, fetch invoice
RA->>RA: 0G: "is this the chai? price sane?" → pay (request_id logged)
CH->>CH: sign voucher for the invoice it scanned itself
RA->>M: pay (x402)
M->>A: settle → paid
G->>M: poll status
M-->>G: Ed25519-signed "paid" + gate nonce
G->>G: open 🔓 → status "used"
F · Revoke and safe-stop
sequenceDiagram
participant P as Owner
participant W as Wallet
participant A as Arc
participant RA as Robot Agent
P->>W: revoke Vitaquack's grant
W->>W: step 1: stop serving it (instant)
P->>A: step 2: passkey-signed disableDelegation, relayed → grant dead on-chain
P->>RA: e-stop → robot stops moving and the chip stops signing
Note over RA: also automatic: 0G down → no new decisions → the robot stops
Robot Agent
One errand state machine per robot (an Effect service over D1) is the AI client. 0G never moves the duck: walking runs on the chip, offline, 50 times a second. The agent runs fine with no chip attached; no camera frames leave the chip.
flowchart LR
subgraph CF["☁️ Cloudflare"]
RA["Robot Agent<br/>errand state machine · 0G decide<br/>evidence · lease watchdog"]
end
subgraph Chip["🦆 Chip: Radxa (or virtual)"]
direction TB
KEY["Key + signer<br/>checks invoice, signs"]
NAV["Navigation 5–10×/s<br/>QR in frame → turn / walk / stop"]
POL["Walking policy 50×/s<br/>ONNX → 15 servos"]
NAV --> POL
end
BR["Browser<br/>robot console: errands, decisions, lease"]
OG[["0G"]]
WM[["Wallet services (in-process)"]]
RA <-- "HTTPS long-poll: sign requests + lease; signed frames as evidence" --> Chip
BR -- "start errand · watch" --> RA
RA --> OG
RA --> WM
Built in the foundation's own stack (Effect services, D1, Foldkit), not as a Durable Object or a copy of Goblin's Agents SDK agent: those don't compose with Effect/Alchemy and added hours without adding security. Camera, teleoperation and walking are the teammates' hardware track and stretch work.
Agent Pass vs the grant
The grant
Agent Pass
What
The standing budget: "$10/day until Sunday"
A one-off exception for one purchase
Who approves, where
Owner's passkey, in our wallet
Owner in World App (World IdP)
When
In the wallet, when adding a robot; again to raise the budget
Over the per-payment cap, or a restricted item
On-chain effect
A new signed delegation
For the event: our backend checks World's token and co-signs that one payment; HumanApprovalEnforcer checks the co-signature. Stretch: the enforcer verifies World's token itself
Blockchain involved
Arc
None in World's part: plain OIDC (RS256 ID token), so it fits Arc cleanly
World: Agent Pass
Piece
How
Flow
World IdP's browser flow (not the device flow, which can't carry a nonce): our wallet page asks World to sign in with nonce = the EIP-712 hash of {invoice, amount, payee, expiry} and max_age=0; the owner confirms in World App; World returns an RS256-signed ID token. Deny, cancel or expiry = no token = no payment
Binding
World App can't show what is being approved, so our wallet page shows item, amount, payee and invoice, and the approval is single-use for that invoice
Token checks
Accept acr orb or orb-face; reject passkey-only sign-ins (amr with mfa); auth_time after the request; jti used once. World's reference code gets two of these wrong
On Arc
Decided (D15): backend co-signer first. Our backend runs the same checks on World's token (iss, aud, exp, sub = owner, nonce = this payment, fresh auth_time, amr has pop and not mfa, jti once) and co-signs EIP-712; HumanApprovalEnforcer checks the co-signature. Stretch: the enforcer verifies the token itself (S5b prototype, ≈ $0.008), which removes the trusted backend but makes approvals linkable on-chain
Not used
IDKit 18+ registry (dropped) · AgentKit (archived) · World's wallet as our wallet: "World Money" is a Safe on World Chain only; World's SDK refuses other chains, a Safe can't be a Delegation Framework delegator, and allowances reset after each transaction. At most a World mini app could fund our Arc account
Owner actions and trust
Question
Answer
How does the owner send / revoke?
The passkey signs a one-time delegation; our relayer (the same code as the facilitator) submits it, ≈ $0.006. This is the pattern MetaMask's own facilitator uses
Break-glass
If the DelegationManager is ever paused: an ERC-4337 user operation via Pimlico's public bundler, gas paid by the account in USDC
Other chains (gas not in USDC)
ERC-4337 with a USDC paymaster (as Goblin's wallet did on Base)
Can the relayer steal?
No. Signatures fix the exact action and Arc checks every cap; a relayer or bundler can only delay. Hence the fallback
Passkey-native: still a "DeleGator"?
Yes. DeleGator is MetaMask's name for their delegation-capable smart accounts. Ours is a HybridDeleGator (own contract, passkey signer); the 7702 fallback points an EOA at EIP7702StatelessDeleGator. Same grants either way
0G and Arc: data, not money
The user's money stays USDC on Arc. 0G is a platform cost (credits from the team, standard providers). The two link through provenance.
flowchart LR
F["Camera frame<br/>+ invoice"] --> D["0G decision<br/>request_id · model"]
D -- "pay" --> P["USDC payment on Arc<br/>tx hash · invoice id"]
D --> S["0G Storage<br/>decision record incl. Arc tx hash"]
S --> E["EpisodeLog on 0G Chain<br/>episode hash"]
P -. "ledger: invoice → request_id" .-> D
Venue network
Setup
How
Primary: dedicated phone hotspot
Pixel hotspot duckbench, 2.4 GHz, WPA2, on the phone's own mobile data. Radxa, ESP32 and laptops all join it. Bench H4 found the venue Wi-Fi unusable (≈ 3 KB/s, pings up to 2.5 s)
Alternative
macOS Internet Sharing from a wired Ethernet uplink: channel 1/6/11, WPA2/WPA3 (never WPA3-only), Radxa key-mgmt wpa-psk, ESP32 setMinSecurity(WPA2_PSK), caffeinate -dis
Doesn't work
Mac → Android reverse tether over USB, then the phone's hotspot: on stock Android, hotspot clients bypass the tether's VPN
ESP32 gate wiring
Servo wire
Connect to
Signal (orange / yellow)
A GPIO, e.g. GPIO 13 (3.3 V logic is fine). Code: ESP32Servo attach(13, 500, 2400)
Power (red)
A separate 5 V supply, at least 1 A (power bank or adapter). Not the ESP32's 3.3 V pin; the ESP32's VIN over the Mac's USB can brown-out reset it
Ground (brown)
The supply's ground and the ESP32's GND (shared ground)
Extra
A 470 µF capacitor across the servo's 5 V / GND. No driver chip needed for one micro servo (SG90 / MG90S); a PCA9685 board only for many servos
Bench results so far
Spike
Result
C1: the chip signs the plan-v3 voucher
Pass, 20 / 20 checks. Hashes and caveats match MetaMask's kit; on live Arc the voucher pays the merchant, a different amount or payee fails, a replay fails
H1: Radxa health
Partial. OS and camera known, ≤ 57 °C in a short capture. The overheating was the camera ribbon: fixed by reseating it striped face up
H3: signing speed
Python signing works but takes 187 ms (pure-Python recovery); Bun + viem or libsecp256k1 needed. Bun not yet tested
H4: network
Venue Wi-Fi unusable, so a dedicated phone hotspot
H2, H6
Not yet run: reading the ESP32 QR with the camera, the signed bench loop (H5, frames to the cloud, is out of scope)
Spike results and the World Chain question (6 Nov)
What
Result
S2: our facilitator (grant path)
Pass, 14 / 14 on live Arc mainnet state (simulated with eth_call, nothing broadcast). Wrong amount, wrong payee, replayed invoice, expired, over the cap, revoked grant, wrong relayer, tampered signature: all rejected with the right reason. Cost ≈ $0.013 per payment, about double our earlier guess. Note: a plain anvil fork can't move Arc USDC (Arc's native-coin precompile is missing), so fork tests simulate against live state
S5b: World's token checked on Arc
Works: RSA check + claim parsing + one-use nonce and jti, ≈ $0.008. Two findings: (1) a passkey-only World sign-in also says pop, so the check must reject mfa; (2) the token becomes public on Arc, including the owner's World pseudonym and an email-like claim, so your approvals are linkable (decision D15)
World Chain + 0G + ENS instead of Arc
Not worth it. No World Chain prize exists; MetaMask's delegation contracts aren't on World Chain (≈ 45 contracts to deploy, all tests to redo); Circle's facilitator doesn't support it; gas is cheaper but in ETH; World's wallet still can't grant a robot allowance
ENS
Works on top of Arc: robots and merchants as subnames holding their Arc address and agent records (≈ 0.5–1 day, ≈ 8 USDC/year). But ETHGlobal caps a project at 3 partner prizes, so ENS ($7k, 4 places, ENSv2) would replace Arc ($3k, one winner) as the third pick (decision D16)
0G requirement
The Physical AI prize needs an episode log on 0G Storage plus a contract address: a build item, not optional
What we know, what we believe, what we don't
Known (with the evidence level)
Verified on-chain: HybridDeleGator, SimpleFactory, DelegationManager and the enforcers are live on Arc, byte-identical to Base; the P-256 precompile works.
Broadcast on Arc mainnet (6 Nov 06:10 IST): a $0.01 chip-signed voucher under a grant settled, replay refused (IdEnforcer:id-already-used), revoke broadcast, the next payment refused (CannotUseADisabledDelegation); docs/evidence/2026-11-06-smoke.md. The RobotPaymentPolicyEnforcer is deployed at 0x7c2167B0a49108b28DFDA3aca5ddddd9Af68e4D3, on-chain code = build, 8 approval cases pass against it (docs/evidence/contracts.md).
Broadcast from the deployed app (06:32 IST): a passkey-signed grant accepted on-chain (the Worker's relayer deploys the Hybrid account, Arc's ERC-1271 check accepts the passkey signature), through the API driver and through the real UI with a virtual authenticator; the mock chip pairs and long-polls (25 s) through the deployed edge; docs/evidence/2026-11-06-deployed-e2e.md, 2026-11-06-deployed-browser.md.
Deployed merchant: invoice → x402 402 → garbage payment 400 with named checks (nothing broadcast) → Ed25519 gate status; docs/evidence/2026-11-06-deployed-merchant.md.
Native, with stubs: 0G decide → signing, timeout → safe_stop (never faked), World token checks (10 cases incl. amr pop/mfa), console reload; 17 / 17.
Bench: the real Radxa builds and signs the voucher the kit expects (C1: 20 / 20).
Prototype: a World RS256 token can be verified in an Arc contract bound to one payment (S5b, 43 tests); no real World token yet; stretch.
Verified: Agent Pass is plain OIDC with no chain involved; deny / expire give no token.
Not run yet: a real 0G decision and a paid errand on the deployed app (needs the 0G key: every errand answers 503 until then), 0G Storage uploads and EpisodeLog on Galileo (needs gas), World approve / deny live (needs the IdP client), real passkeys on phones, the Arc Studio project. The MUST loop is not "end to end" until docs/evidence/demo-run.md exists.
Uncertain: one spike settles it
#
Spike
S1
Done (virtual authenticator): passkey → HybridDeleGator deployed by the relayer → passkey-signed grant accepted on Arc mainnet. Left: a real phone, and the $0.01 payment under that grant (needs 0G)
S2
Done (broadcast): $0.01 settled on Arc mainnet through our facilitator, replay and post-revoke refused; the x402 envelope verified on the deployed merchant
S2b
Dropped: the float path (authority gap after the pull)
S3
Open, blocked on the 0G key: packages/server/scripts/zg-probe.ts runs the exact decide call and reports model, latency and request id
S4
Dropped: MCP is off the critical path; the agent calls wallet services in-process
S5
Agent Pass browser flow with nonce (approve and deny) using Kris's Orb-verified ID: does the token echo the nonce, and which acr / amr values come back
S5b
Done (prototype): a contract verifies World's RS256 token on Arc, 43 tests, also run on live Arc; ≈ 409k gas ≈ $0.008. Left: a real World token with our nonce (S5, Kris's phone), key rotation
S6
Done (deployed): mock chip pairs and long-polls through the deployed edge (24.8 s holds, 35 s lease). Left: the Radxa running the same client (apps/chip/README.md, docs/hardware-handoff.md)
S7
The duckbench hotspot with the Radxa, ESP32 and laptops; then H2, H5, H6 on it
S8
Walking policy on the new servos (teammate)
Unknown: booth questions
0G: may Storage + EpisodeLog run on Galileo testnet?
World: how fast we get a production World IdP client (sandbox is separate), and spike S5: does the browser flow echo our nonce. ("Mocked proofs" in World's prize text only means teams without an Orb may use fake identities; we have Kris's real Orb ID, so it no longer matters.)
Arc: Studio URL viewable without login; deploying our Studio-built module to mainnet ourselves; Circle facilitator minimum amount; a keyed RPC.
Decisions
Decided
Choice
Owner account
Passkey-native HybridDeleGator; 7702 fallback
Robot brain
One errand state machine per robot, an Effect service over D1; no Durable Objects, WebSockets or MCP
Who signs
The chip, always; a mock chip in iteration 1
Payments
x402, grant path only via our facilitator; float path dropped (authority gap)
Login
Passkey only: the passkey is the login and the wallet signer
Name
Vitaquack
Owner actions
Our relayer; ERC-4337 break-glass
0G
Standard providers
World
Agent Pass only, the approval verified on Arc (browser flow, nonce = invoice hash); World's wallet can't replace ours
Iterations
Mock chip per teammate; no simulator (1.5 = a virtual x402 resource)
Arc track
Advanced Stablecoin Logic: RobotPaymentPolicyEnforcer + HumanApprovalEnforcer built in Arc Studio
Network
Dedicated phone hotspot (venue Wi-Fi unusable); Mac Internet Sharing from wired Ethernet as the alternative
Radxa OS, walking policy
Teammate
Still open
Recommendation
Who pays relayer gas
We absorb it (≈ $0.013 per payment measured in S2; ≈ $0.006 per owner action)
Recovery
Several passkeys now; guardians later
Accounts on other chains
Arc-only; other chains are funding routes
Who may watch / drive the robot
Owner drives; judges view
D15 (decided): the World token check
Backend co-signer for the event; on-chain verification as a stretch, with the privacy note in the pitch
D16: third prize pick
Decided: Arc + 0G + World (max $3k + $2.5k + $2.5k = $8k). ENS names only as an optional add-on; picks finalised at submission