IOTA Bounties - Supply Chain Demo

[richardmands]

Please read the README first.

Summary

Create a supply chain demo using the Trust Framework.

This issue is a base for adding a your demo, please open a new issue referencing it.
Feel free to use this issue to discuss ideas before opening a proposal.

Estimated Size

Large

Estimated duration

One Week

Details & acceptance criteria

• Use the Trust Framework
• Complete in the style of the IOTA DPP Demo
• https://dpp.demo.iota.org/introduction/1
• https://github.com/iotaledger/dpp-demonstrator

Pull request required?

Yes

[WeberG619]

Hey,

I'd like to take this on. I've looked at the issue and the surrounding codebase and have a clear path to a solution.

My approach:
I'll implement this by ### Feature description

Create a supply chain demo using the Trust Framework

Motivation

As part of the IOTA Bounty Program

Requirements

Use the Trust Framework
https://github.com/iotaledger/dpp-demonstrator
https://dpp.demo.iota.org/introduction/1

Open questions

No response

Are you planning to do it yourself in a pull request?

Yes

Number of Submissions

3 in total

Relevant background:

• Active open-source contributor with experience in TypeScript, Rust, AI/ML
• Familiar with the patterns used in this project
• I write clean, tested code that follows existing project conventions

What you can expect:

• A well-tested PR that addresses the issue directly
• No unnecessary changes outside the scope
• Responsive to review feedback and quick iteration
• Documentation updates if the change affects public API

I can have a draft PR up within a few days.

Let me know if there's anything specific about the implementation you'd prefer.

Weber Gouin

[aliraza556]

@richardmands

Proposal: Supply Chain Demo Using the IOTA Trust Framework

Bounty Reference: IOTA Bounties - Supply Chain Demo
Estimated Duration: One Week

Summary

I propose building an end-to-end pharmaceutical supply chain demo that showcases how the IOTA Trust Framework secures product provenance, enforces role-based access, and creates an immutable audit trail from manufacturer to patient. The demo will follow the style and structure of the IOTA DPP Demonstrator, including a guided walkthrough, interactive explorer, and live on-chain transactions on the IOTA testnet.

---

Why Pharmaceutical Supply Chain?

Counterfeit pharmaceuticals are a $4.4B global problem. This scenario is ideal for demonstrating every pillar of the Trust Framework because:

• Identity is critical -- every actor (manufacturer, distributor, pharmacy, regulator) must be verifiable
• Hierarchy mirrors reality -- a Regulatory Authority authorizes manufacturers, who authorize distributors, who authorize pharmacies
• Notarization is non-negotiable -- every custody transfer, temperature reading, and quality check must be tamper-proof
• Tokenization fits naturally -- compliance tokens or batch certificates can be issued as on-chain assets
• Gas Station removes friction -- pharmacies and end-users interact without managing IOTA tokens

---

Trust Framework Component Mapping

Trust Framework Component	Supply Chain Role
IOTA Identity	DIDs for each actor (Regulator, Manufacturer, Distributor, Pharmacy). Verifiable Credentials prove GMP certification, distribution licenses, and pharmacy registrations. Domain linkage validates each actor's web presence.
IOTA Hierarchies	Authorization chain: Regulator → Manufacturer → Distributor → Pharmacy. Attribute-based access control ensures only authorized actors can write lifecycle events at their stage.
IOTA Notarization	Every custody transfer (manufactured, shipped, received, dispensed) is notarized on-chain with timestamp, actor DID, and data hash -- without revealing sensitive batch data publicly.
IOTA Gas Station	Sponsored transactions for downstream actors (distributors, pharmacies) so they never need to acquire or manage IOTA tokens. Seamless UX.
IOTA Tokenization	Batch Compliance Certificates minted as NFTs by the manufacturer. Transferred along the chain as proof of authenticity. Optional: loyalty/rebate tokens for pharmacies.

---

Architecture

Following the DPP Demonstrator's proven structure:

supply-chain-demo/
├── frontend/              # Next.js + TypeScript (guided walkthrough + explorer)
│   ├── src/
│   │   ├── app/           # App router pages (introduction/1..N, explore-guided, explore-free)
│   │   ├── components/    # Reusable UI (timeline, actor cards, transaction viewer)
│   │   ├── contents/      # Step-by-step walkthrough content (JSON/MDX)
│   │   ├── hooks/         # Wallet connection, transaction hooks
│   │   ├── providers/     # IOTA wallet, theme, i18n providers
│   │   └── utils/         # Chain interaction helpers
├── backend/               # Rust (Axum) -- mirrors DPP backend
│   ├── src/
│   │   ├── lib/           # keystore, identity, transaction modules
│   │   ├── routes/        # REST API routing
│   │   ├── handlers/      # Business logic (custody transfer, verification)
│   │   ├── services/      # Blockchain service layer
│   │   └── scripts/       # Account init, hierarchy bootstrap, DID creation
├── contract/              # Move smart contracts
│   └── supply_chain/      # Custom notarization + batch certificate logic
├── scripts-sh/            # Shell automation (init, faucet, deploy)
├── docker-compose.*.yml   # Dev, local, prod, test environments
├── config.yaml
├── makefile
└── README.md

---

Demo Walkthrough Flow (Matching DPP Style)

The demo will feature a guided introduction (10-12 slides with animations/videos) followed by an interactive explorer:

Step	Screen	What the User Sees
1-2	Welcome	Introduction to the pharma supply chain problem and how IOTA solves it
3	Disclaimer	Reference-only, not regulation-compliant
4	The Trust Framework	Visual overview of the 5 building blocks
5-6	Key Actors	Regulator, Manufacturer, Distributor, Pharmacy -- each with role description
7	Authorization Chain	Animated hierarchy: Regulator → Manufacturer → Distributor → Pharmacy
8	Product Journey	Visual timeline: Raw Material → Manufacturing → Quality Check → Distribution → Pharmacy → Patient
9-10	Technologies Used	Map each step to the Trust Framework component powering it
11	How to Explore	Instructions for guided vs. free exploration
12	Start Exploring	Enter the interactive demo

Interactive Explorer -- the user assumes the role of a Distributor (mirroring how the DPP demo casts the user as a Repairer):

• Connect wallet (Nightly / IOTA Wallet)
• View a pharmaceutical batch's full lifecycle on-chain
• Receive a batch from a Manufacturer (notarized custody transfer)
• Verify the Manufacturer's DID and GMP credential
• Forward the batch to a Pharmacy (another notarized event)
• View the Batch Compliance Certificate NFT
• See all transactions on IOTA Explorer

---

Deliverables & Timeline

Day	Milestone	Deliverable
Day 1	Project scaffold + smart contracts	Move contracts for supply chain notarization and batch certificates. Makefile targets for init, deploy, fund. Docker Compose configurations.
Day 2	Backend core	Rust backend: account init scripts, DID creation, hierarchy bootstrap, REST APIs for custody transfer and verification.
Day 3	Backend integration	Gas Station integration, full notarization flow, NFT minting for batch certificates. End-to-end script that runs the full chain.
Day 4	Frontend -- guided walkthrough	Next.js app with introduction slides (10-12 steps), animations, responsive layout matching DPP style.
Day 5	Frontend -- interactive explorer	Wallet connection, guided exploration flow (receive batch, verify, forward, view on Explorer).
Day 6	Testing + polish	Integration tests, Docker Compose local/dev/test configs verified, edge cases, UI polish, accessibility.
Day 7	Documentation + PR	Comprehensive README (setup, env vars, architecture), inline docs, final cleanup. Pull request submitted.

---

Technical Approach

Smart Contracts (Move)

A supply_chain module extending the custom notarization pattern from the DPP demo:

• create_batch -- Manufacturer creates a new pharmaceutical batch with metadata hash
• transfer_custody -- Authorized actor transfers batch to the next actor in the chain
• verify_batch -- Any actor can verify a batch's authenticity and full custody history
• mint_compliance_certificate -- Manufacturer mints an NFT proving GMP compliance for a batch

Whitelist-based access tied to the Hierarchies federation ensures only authorized actors can invoke each function.

Backend (Rust / Axum)

Following the DPP backend's module structure exactly:

• keystore.rs -- Wallet and key management for all actors
• identity.rs -- DID creation and Verifiable Credential operations
• transaction.rs -- Signing and execution against the IOTA network

New handlers for supply chain-specific operations:

• POST /custody/transfer -- Initiate a custody transfer between actors
• GET /batch/:id/history -- Retrieve full lifecycle history for a batch
• POST /batch/:id/verify -- Verify batch authenticity and credential chain
• GET /roles -- Hierarchies role management (matching DPP pattern)

Shell scripts for bootstrapping: make init-accounts, make faucet, make init-hierarchies, make publish-supply-chain-contract, make init-dids, make create-batch, make mint-compliance-cert.

Frontend (Next.js / TypeScript)

• App router with /introduction/1..12 pages and /explore-guided, /explore-free routes
• Content-driven walkthrough (JSON config per slide, matching DPP contents/ pattern)
• Integration with @iota/dapp-kit for wallet connection and transaction hooks
• Responsive, modern UI consistent with the DPP demo's design language
• i18n support via the same pattern used in the DPP demo

Testing

• Backend integration tests in Rust
• Frontend component tests with Vitest / React Testing Library
• Docker-based end-to-end test configuration (docker-compose.test.yml)

---

Why Me

• Deep familiarity with the IOTA Trust Framework -- I have studied all five building blocks, the DPP Demonstrator codebase (frontend architecture, Rust backend, Move contracts, Docker setup), and the guided walkthrough UX pattern
• Production experience with TypeScript, Rust, and Move smart contracts
• Active open-source contributor with a track record of clean, well-documented PRs
• I understand the DPP Demonstrator is the reference standard -- my demo will match its structure, conventions, and quality bar, not reinvent them
• Responsive to review feedback with fast iteration cycles

---

What You Can Expect

• A pull request that follows the existing DPP Demonstrator conventions precisely
• A working demo deployable locally via Docker with a single make dev-start
• No scope creep -- supply chain demo only, no unnecessary abstractions
• Complete documentation -- README with prerequisites, env setup steps, architecture overview
• Responsive iteration on review feedback until the PR is merged

---

I am ready to start immediately Please assign me and can have a draft PR up within 2-3 days. Happy to discuss the scenario choice (pharmaceutical vs. alternatives like food traceability or electronics) or any architectural preferences before I begin.