Quick Start

This guide gets a node running on your own machine, sets up your operator identity, and publishes a first signed passport that anyone can verify without going through Odal. Developers and operators use the same tool for all of it: the odal command.

What you need

Docker, a Rust toolchain (to build the CLI once), and the dpp-engine repository. After that, odal handles infrastructure, setup and passports.

1. Get the engine

Clone dpp-engine. It is the only repository you need:

git clone https://github.com/odal-node/dpp-engine
cd dpp-engine

No need to clone the core

The engine builds against the core’s published releases on crates.io, so it compiles and runs on its own. Clone dpp-core only if you want to work on the core itself.

2. Build the odal CLI

Build the CLI once and put it on your PATH. You use odal for everything after this: infrastructure, setup and passports.

cargo build -p dpp-cli --release
# the binary lands at target/release/odal; add it to your PATH

3. Set your secrets

Copy the example environment file and fill in your own values: database passwords, a key-store passphrase and your admin credentials. The node fails closed if a secret is missing.

cp .env.example .env
# then edit .env

4. Bring the node up

Run odal with no arguments for guided setup. It starts the stack, onboards you and mints your first API key:

odal

To script it instead, run odal up (build and start) and then odal bootstrap (onboard and mint the key).

Built from source

The first up compiles the node from the source in your clone, which takes a few minutes; later starts are immediate. Ready-made images of the node and resolver are not public yet, so for now a node runs from a clone of the repository.

5. Drive it from the Console

Once the node is up, running odal on its own opens the Console, an interactive menu with every task in it:

? What would you like to do?
> Infrastructure            start · stop · status · update images
  Operator                  view · edit configuration
  Registry identity         facilities · operator identifiers
  Passports                 import · validate · publish · export
  Dossiers                  verify an exported evidence dossier
  API keys                  create · list · revoke
  Environment               switch · create · view profiles (dev/prod)
  Schema                    check for updates
  Setup / Reconfigure       connect · start · onboard · first key
[↑↓ to move · ⏎ select · Esc to quit]

Move to a section with the arrow keys and press Enter. Every section is also a direct command, so the same actions can run in CI:

Console section	What it does	Scripted equivalent
Infrastructure	Start, stop, check status, update the node	odal up · odal down · odal status · odal update
Passports	The full lifecycle: import, validate, publish, export	odal passport · import · validate · publish · export
Operator	View and edit your operator identity and branding	odal operator show · set
Registry identity	The facilities and operator identifiers stamped on new passports	odal facility · odal operator-id
Dossiers	Check an evidence dossier against the node	odal verify
API keys	Create, list, and revoke keys for CI or integrations	odal key · create · list · revoke
Environment	Switch or create profiles for more than one node (dev/prod)	odal profile · use · create · list
Schema	Check for product-group schema updates as the regulation moves	odal schema check · list · show
Setup / Reconfigure	Reconnect, re-onboard, or mint a first key	odal --reconfigure · odal bootstrap

Start with Infrastructure → Status to check that the node is validating, signing and serving.

6. Your first passport

Under Passports, a passport goes through three steps:

1. Import: bring product data in from a spreadsheet; each row becomes a draft. odal template <product-group> gives you the header row the import expects.
2. Validate: check the drafts against the product group’s schema and rules before anything is signed, while problems are still easy to fix.
3. Publish: sign each passport with your key and make it resolvable.

The published passport carries a signature bound to your public identity. Any consumer, authority or recycler can verify it against your DID document, without access to your node and without Odal.

Where to go next

• Importing product data: templates, trial runs and row-by-row findings.
• A passport’s lifecycle: everything you can do after publishing.
• Self-Hosting: full prerequisites and the operational picture.
• What Odal Node can and cannot see: exactly what data Odal can and cannot reach.