L0product

Walked DePIN Product

Make a physical unit prove itself. Every hand that touches it signs. The label becomes the receipt.

1,200

Priority Score

Pain × Demand × Edge × Trend × Conversion

Customer Journey

Why should I care?

Five cards that sell the dream

1Why

The label became proof.

What if every jar on the shelf could prove its own story in under three seconds?

The friction: Ten thousand tonnes of manuka sold every year. Seventeen hundred tonnes produced. A six-fold fraud multiple. The buyer pays premium for a promise.

The desire: Scan the lid. See the hive, the harvest, the lab, the processor, the shelf. Every transfer signed. Every split atomic. None of it from the brand.

The proof: Walked Object explains why the premium migrates when the object proves itself.

The walked-object pattern

Picture

A Tokyo shelf of honey jars, one jar lifted by a hand with a phone scanning the lid. The phone screen shows a full chain — hive, harvest, lab, processor, export, shelf. Cinematic, 16:9

2Evidence

Every hand signs the move.

What if a beekeeper, a lab, and a processor could all sign the same object without trusting each other?

Sui enforces per-unit custody at compile time. Move prevents the bug class. A hive is an object. A harvest is an event. A lab attestation is a signed write. A split is one atomic PTB.

Batch world	Walked world
Averages across units	One object per jar
Paper lab report by PDF	Lab signs the batch object
Brand vouches	Chain shows every owner
Trust the label	Audit backward without asking

Custody chain stories

Picture

A hive in the Coromandel, a lab bench with a chromatograph, a processor splitting a batch into jars. Each location emits a signed event into a single custody chain. Cinematic, 16:9

3Platform

The split stays atomic.

What if the language itself made a counterfeit jar impossible?

Move's type system enforces atomic split at compile time. A batch consumes in one transaction. 2500 jar objects emerge. Each carries the full custody chain.

Object ownership is enforced at the virtual machine level. Only the current owner can transfer. Every move is a signed event.

This is not a feature. It is a constraint that eliminates the fraud class.

Object safety stories

Picture

A diagram of a batch object being split into 2500 jar objects in a single transaction. The batch is consumed. Every jar points back to the same lab attestation. Cinematic, 16:9

4Loop

Source, lab, split, shelf.

What is the shortest path from hive to scan?

Sprint	Ships	Proves
1 (2 wks)	Operator onboarding + hive + harvest	One beekeeper registers one hive via phone
2 (2 wks)	Batch + lab attestation + atomic split	One batch splits into jars in single PTB
3 (1 wk)	Transfer custody + scan endpoint	Full chain from hive to shelf visible by scan
4 (1 wk)	Backward walk + dogfood	One walked jar proves the pattern

Build order and dependencies

Picture

A four-track Gantt chart showing operator onboarding, lab attestation, atomic split, and shelf scan converging at 'First Walked Jar' milestone. Dark background, crimson milestones. Cinematic, 16:9

5People

Beekeepers who walk the object.

Who signs first when the brand stops vouching?

Who	Their job
Beekeeper (honest producer)	Register source, sign harvest, defend the claim
Lab (independent tester)	Sign attestation directly onto the batch
Buyer (Tokyo, Shanghai, New York)	Scan the lid, audit backward without asking

Kill signal: Zero walked jars after 30 days. Thesis wrong. Custody chains are read-only — the buyer proves it without asking anyone.

Who we test with

Picture

A beekeeper in a Waikato apiary holding a phone, a QR code on the hive. A lab technician signing a chromatography result. A buyer in Tokyo scanning a jar. Three hands, one chain. Cinematic, 16:9

1 / 5

Same five positions. Different seat.

The buyer sees the chain. The builder sees the object model. The outer game and inner game are the same loop — walk one jar, prove the pattern.

Feature Dev Journey

How does this get built?

Five cards that sell the process

1Job

The job: walk one jar end to end.

Can one beekeeper, one lab, and one processor walk a jar from hive to shelf?

Situation: Every premium unit is sold twice — once by the brand, once by the buyer who chooses to believe. The label stopped working.

Intention: One product exercising per-unit objects, atomic splits, signed attestations, and scan-to-chain resolution. If it works for manuka, the pattern transfers.

Obstacle: Operator onboarding. Contracts and frontend are solved problems. A beekeeper registering a hive via phone in five minutes is the novel dependency.

Intent contract

Picture

A map of New Zealand with a single walked path — hive in the Coromandel, lab in Hamilton, processor in Auckland, export to Tokyo. Cinematic, 16:9

2Stories

Every story has a number.

If the THEN doesn't name a threshold, what are you testing?

Story	THEN assertion	Forbidden
S1: Register	Hive on-chain in <5 min via phone	Wallet install required
S2: Attest	Lab signs batch in <60s	Producer writes own attestation
S3: Split	Single PTB splits batch to N jars	Partial or multi-tx split
S4: Scan	Full chain in <3s, no login	Gaps or stale data
S5: Walk	Backward walk in <2s, no permission	Access control blocks history

Full story contracts

Picture

A test dashboard — rows of story IDs, each with red or green indicators. Dark background, terminal aesthetic. Cinematic, 16:9

3Build

70% pattern reuse, 30% new.

What already exists that you haven't wired yet?

Layer	Exists	Build
Move contracts	14 packages, 2,500+ lines	6 new modules, ~1,200 lines
Frontend	dApp Kit, Tailwind, shadcn	3 new apps — operator, lab, scan
Gas station	Nothing	Sponsored transaction backend
Lab key management	Nothing	Lab signing flow + key storage

Dependency map

Picture

Architecture diagram split into layers — contracts, operator app, lab app, scan endpoint — with reuse percentages. Crimson highlights on new code. Cinematic, 16:9

4Sprints

Four sprints to one walked jar.

Which sprint proves the thesis — and which just ships features?

Sprint	Features	Acceptance
1	#1, #2, #9	One beekeeper registers one hive via phone
2	#3, #4, #5	Batch splits into jars in single PTB
3	#6, #7	Scan resolves full chain in <3s
4	#8, dogfood	One walked jar proves the pattern

Build order

Picture

A timeline with four sprint blocks. Each block lights up as features ship. Progress bar filling toward 'First Walked Jar' milestone. Cinematic, 16:9

5Validation

One walked jar or we stop.

What is the smallest experiment that proves per-unit custody works?

Kill signal: Zero walked jars on testnet after 30 days. OR operator registration requires more than 10 CLI commands. OR scan latency exceeds 3 seconds. Any one kills the pattern.

Gate	Evidence
L1	Walked-unit package deployed on testnet
L2	Hive → harvest → batch → jar in single chain
L3	One walked jar, scan resolves full chain
L4	Lab partner signs production attestation

Commissioning gates

Picture

A kill switch on a dark panel. Crimson countdown timer. The number 1 prominent. Stark, minimal. Cinematic, 16:9

1 / 5

The pitch is the shape. The flow diagrams prove the thinking. The VV stories validate the value.

Flow Diagrams VV Stories

Problem

Situation

Every premium unit is sold twice. Once by the brand. Once by the buyer who chooses to believe. Ten thousand tonnes of manuka honey sell each year. Seventeen hundred tonnes get produced. The label stopped working.

Intention

One jar of honey. One object on chain. One history that cannot be rewritten. The buyer scans. The phone returns the hive, the harvest, the lab, the processor, the shelf. None of it came from the brand.

Obstacle

No per-unit custody product exists on Sui. Operator onboarding is the binding constraint — a beekeeper with a phone must register a hive object in under five minutes. The scan-to-proof path from shelf to chain is unproven at the application level.

Hardest Thing

Operator onboarding. Move contracts are a known pattern. Dynamic NFTs are a known pattern. A beekeeper registering a hive, signing a harvest, and handing off to a lab — with zero crypto knowledge — is the novel dependency. If operators cannot walk the object, nothing walks.

Scorecard

Priority (5P)

4/5

Pain

4/5

Demand

5/5

Edge

5/5

Trend

3/5

Convert

Readiness (5R)

Principles4 / 5

Performance2 / 5

Platform3 / 5

Process4 / 5

Players2 / 5

What Exists

Component	State	Gap
Move contracts (14 packages)	Partial	Existing DePIN/identity packages on testnet. New walked_unit package needed (6 modules).
Frontend (Next.js 15 + dApp Kit)	Working	Stack exists. New operator + lab + scan app needed in NX monorepo.
Operator onboarding flow	Missing	No phone-first registration path. zkLogin needed for operators.
Lab attestation	Missing	No lab signing flow. Lab key management unproven.
QR scan endpoint	Missing	No public read path from QR to custody chain.

Frozen Scope

5 feature IDs from Onchain JTBD:

ID	Capability
WCAP-007	Gas abstraction — sponsored operator transactions
WCAP-008	Seedless onboarding — zkLogin for operators
WCAP-011	Dynamic objects — custody chain visible via scan
WCAP-019	Atomic multi-operation — batch to jar split in one PTB
WCAP-020	Attestation writes — lab signs the batch object

Relationships

PRD	Contributes
Walked Object (Meta)	The public framing of the walked-unit pattern and why it matters.
Food Industry Hub	The industry that goes first — sharpest fraud pain, most mature sensor layer.
Sui Protocol	The object model that enforces per-unit custody at compile time.
Smart Contracts	Intelligent hyperlinks that carry logic, gates, and measurement.
Onchain JTBD	The capability register this PRD advances (WCAP-007, -008, -011, -019, -020).

Kill Signal

Zero walked jars on testnet after 30 days, OR operator registration requires more than 10 CLI commands, OR scan latency exceeds 3 seconds. Kill date: 2026-05-13.

Questions

What would a walked jar need to prove before a Tokyo buyer would trust it more than the brand?

If operator onboarding is the binding constraint, why are we building Move contracts first — courage or avoidance?
The split PTB enforces atomicity at compile time — but what class of errors does it NOT prevent?
If one beekeeper walks one hive end to end on testnet, does that prove the pattern — or just that one beekeeper is tolerant?
Why does food go first, and what happens to the pattern when it moves to whisky, wool, or carbon?