Yano

Yano is a Cardano Data node implementation in Java, built on top of Yaci (node-to-node / node-to-client mini protocols) and Cardano Client Lib. Persistence is RocksDB. The node ships as a runnable Quarkus application and as a library you can embed.

⚠️ Pre-release. Yano is under active development. APIs and storage formats may still change between pre-releases. Use it for development networks, regression testing, ledger experimentation, and downstream prototyping — not yet for production validation.

---

Where Yano fits

Yano's initial goal is to fill three roles:

• A devnet node that runs inside Yaci DevKit alongside the Haskell cardano-node, so teams can spin up a complete local Cardano network without managing a Haskell toolchain.
• An embeddable library that custom Java applications can depend on to drive a Cardano node in-process — for indexers, wallets, validation tooling, or research code.
• A test-network library for Java applications that need a real, block-producing Cardano network during integration tests, with deterministic block timing and a programmable past-time-travel mode for replaying history quickly.

Highlights

• Real ledger state — UTxO, account state (stakes / delegations / rewards), epoch snapshots, Conway-era governance (DReps, proposals, votes, committee), with full rollback support, including bounded epoch-boundary pool retirement and refund recovery. See account state and rollback.
• Devnet block producer — produce blocks from a configured genesis and serve them to downstream nodes (Haskell cardano-node, Dingo, your own indexer) via the n2n protocol on port 13337.
• Past-time-travel mode — start a fresh devnet "in the past", produce blocks deterministically from slot 0, then catch up to wall-clock; useful for replaying long histories quickly.
• Native image — supports a GraalVM native build for fast startup and small footprint.
• Modular — publishable libraries (yano-core-api, yano-runtime, yano-ledger-state, …) let downstream projects depend on just the slice they need.

---

Quick start

Requirements

• JDK 25 (Temurin or Oracle GraalVM); native image builds require Oracle GraalVM 25.3
• Gradle 9.4.1 (use the bundled ./gradlew)

Build

./gradlew clean build              # all modules + L1/app-chain core tests
./gradlew fullBuild                # optional extended + crypto + distribution verification
./gradlew :app:quarkusBuild        # produce app/build/yano.jar (Quarkus uber-jar)

See Building and testing Yano for the test tiers, single-suite commands, and packaged-distribution checks. Preview-to-preview migration notes are in Upgrading preview releases.

Run a preprod relay (default profile)

java -jar app/build/yano.jar
# REST API:        http://localhost:7070
# n2n peer port:   13337
# Health:          http://localhost:7070/q/health/ready

The default profile points at the public Cardano preprod network (protocol magic 1, upstream peer localhost:30000 — adjust in app/src/main/resources/application.yml or via system properties).

Run a local devnet block producer

java -Dquarkus.profile=devnet -Dquarkus.http.port=7070 -jar app/build/yano.jar

Genesis files live under app/config/network/devnet/. Yano updates the systemStart field automatically on each startup so a fresh chain begins at "now". Connect a downstream Haskell node, Dingo, or your own client to 127.0.0.1:13337 to consume the blocks.

Past-time-travel mode

java -Dquarkus.profile=devnet -Dquarkus.http.port=7070 \
  -Dyano.block-producer.past-time-travel-mode=true \
  -jar app/build/yano.jar

Block production is deferred until you call:

# Start the chain N epochs in the past (Yano produces sequential blocks from slot 0)
curl -X POST http://localhost:7070/api/v1/devnet/epochs/shift \
  -H 'Content-Type: application/json' -d '{"epochs": 4}'

# Once you have enough blocks, fast-forward to wall-clock and switch to live production
curl -X POST http://localhost:7070/api/v1/devnet/epochs/catch-up

---

Use as a library

Yano publishes its modules to Maven Central and, from the next release on, to the BloxBean Maven repository (https://repo.bloxbean.org/maven/releases).

Development snapshots are in https://repo.bloxbean.org/maven/snapshots, one version per commit, for example 0.1.0-pre18-de81cc5-SNAPSHOT. The newest version, a ready-to-paste snippet and the snapshot distribution zips are on the Development snapshot release page.

repositories {
    mavenCentral()
    // Development snapshots (pin the exact version from the Development snapshot release):
    maven {
        url = uri('https://repo.bloxbean.org/maven/snapshots')
        mavenContent { snapshotsOnly() }
    }
}

ext {
    yanoVersion = '<latest>'  // a release from Maven Central, or a snapshot version
}

dependencies {
    implementation "org.yanoproject:yano-runtime:$yanoVersion"
    // or pull a slim slice:
    implementation "org.yanoproject:yano-core-api:$yanoVersion"
    implementation "org.yanoproject:yano-ledger-state:$yanoVersion"
}

Published modules

Coordinate	What it is
org.yanoproject:yano-core-api	Public node interfaces and plugin SPI
org.yanoproject:yano-runtime	Node implementation with RocksDB persistence
org.yanoproject:yano-ledger-state	Account / delegation / governance state stores
org.yanoproject:yano-ledger-rules	Transaction validation API and Conway ledger rules
org.yanoproject:yano-script-evaluators	Aiken / julc Plutus script evaluators (ExUnits)
org.yanoproject:yano-scalus-bridge	Scalus-based Plutus script evaluation adapter
org.yanoproject:yano-bootstrap-providers	Initial-state providers (Blockfrost / Koios / …)

The Quarkus REST application (org.yanoproject.app, the app/ module) is not published; it's distributed as an uber-jar (app/build/yano.jar) and as a GraalVM native binary (app/build/yano).

---

Native image (GraalVM)

# JAVA_HOME must point at Oracle GraalVM 25.3
./gradlew :app:build -Dquarkus.profile=native
./app/build/yano -Dquarkus.profile=devnet -Dquarkus.http.port=7070

A distributable zip (yano-native-<version>-<platform>.zip) is produced under app/build/distributions/.

---

Project layout

yano/
├── core-api/            # Public node interfaces + plugin SPI
├── plugin-catalog/      # Manifest validation + JVM-only yano-plugins CLI
├── runtime/             # Main node implementation (RocksDB-backed)
├── ledger-state/        # Account / delegation / governance state stores
├── ledger-rules/        # Transaction validation API and Conway ledger rules
├── script-evaluators/   # Aiken / julc Plutus script evaluators
├── scalus-bridge/       # Scalus Plutus script-eval adapter (Scala + Java)
├── bootstrap-providers/ # Initial-state providers
├── app/                 # Quarkus REST application + devnet block producer
└── adr/                 # Architecture decision records

---

Documentation

For deeper coverage of how to operate and extend Yano, see:

Doc	What's inside
docs/appchain/README.md	Yano's generic app-chain host, ordered-log, proofs, plugin contracts, and L1 anchoring.
Yano X	JVM extensions: additional state machines, capabilities, connectors, products, examples, and tools.
app/README.md	Operator's guide — run modes (relay, devnet, native), start.sh / start-devnet.sh, configuration knobs, REST API reference, profiles, Swagger UI, integration with yaci-store, and the test tiers (unit / integration / e2e).
app/ARCHITECTURE.md	Internal architecture — high-level topology, header/body split sync pipeline, event system, plugin system, module overview, REST API surface, configuration modes, and extension points.
docs/PLUGIN_OPERATIONS.md	Plugin catalog validation, operations API authentication, health/metrics exposure, dashboard behavior, and JVM/native deployment notes.

Architecture decision records covering specific design choices live under adr/ — notably adr/ledger-state/ for the state-store implementation and adr/014-slot-leader-selection-block-production.md for block production.

---

Related projects

• Yaci — Cardano protocol library Yano is built on
• Yaci DevKit — local Cardano dev environment (Yano is the underlying node)
• Cardano Client Lib — transaction building, address handling, crypto
• Yano X — JVM extension ecosystem for Yano app chains

---

License

MIT