Hyperledger Iroha 2

Iroha is a modern, advanced distributed ledger (DLT). With simplicity, modularity, reliability and code quality as its main design principles, Iroha powers anything from Private blockchains in central banks, as well public blockchains for your NFT and cryptocurrency trading needs.

Iroha is efficient, Byzantine-fault-tolerant and flexible, with a WASM — powered smart contract engine and event-driven architecture. It was designed with cross-blockchain communication in mind, allowing fast and convenient transaction processing.


Fungible and non-fungible tokens: mint, burn, transfer and set them to any value imaginable
Sophisticated permission system: have permissioned and non-permissioned blockchains on the same network
WASM-based smart contracts: use any language to develop your on-chain logic and hook it into Iroha event trigger system
Support for Hyperledger Cactus and Polkaswap protocol: deploy a network on Iroha, interact with a consortium of networks deployed on other ledgers, transact with no limits

Rewritten in Rust

Iroha 2 is a revolutionary next step in Distributed ledger technology.
We have improved on the previous iteration of Iroha in every way, making it a definitive upgrade. We offer a smooth upgrade path for users of Iroha 1, but strongly encourage all new projects to use Iroha 2 because of its...

Memory safety

Almost all CVEs are due the memory management errors. Rust eliminates memory safety problems but without sacrificing performance. The Borrow checker prevents a class of bugs related to use-after free and dangling pointers.

Energy efficiency

According to «Energy Efficiency across Programming Languages», Rust is among the top 3 power-effecient languages, 3 times more efficient than Go and twice as efficient as Java, and within margin of error of C and C++.

Event-driven architecture

We use an improved event driven architecture coupled with lazy evaluation to reduce the power consumption of an Iroha node even further. As a consequence, Iroha 2 also uses less bandwidth and is more flexible in the types of behaviours that can be implemented on a typical network.

Undefined behaviour

Rust improves security in more ways than one. You cannot implicitly overflow on arithmetic, and all financial operations retain full precision. Rust is statically linked, preventing a class of injection attacks, as well as guaranteeing behaviour on different machines.


Rust is widely accepted as the most beloved modern language, because of its emphasis on developer productivity and code simplicity. Developing smart contracts in Rust is much more straightforward than an interpreted language.


Sumeragi supports parallel and out-of-order instruction execution.

Supports Byzantine fault tolerance (BFT)

A Byzantine fault is a condition of a computer system, particularly distributed computing systems, where components may fail and there is imperfect information on whether a component has failed.

The term takes its name from an allegory, the «Byzantine generals problem», developed to describe a situation in which, in order to avoid catastrophic failure of the system, the system’s actors must agree on a concerted strategy, but some of these actors are unreliable.

Moore’s law is dead

A famous «law» named after Gordon Earle Moore was previously true: every two years, the number of transistrors in dense integrated circuits like CPUs and GPUs doubled.

Nowadays, the situation is complicated: too many factors that are hard to control arise when someone is trying to make the integrated circuits smaller.

With that in mind, one can’t expect that programs will simply become faster, requiring more effecient approaches to the coding.

Faster code with out-of-order execution

With out-of-order execution paradigm used in most high-performance CPUs, a processor executes instructions in an order governed by the availability of input data and execution units, rather than by their original order in a program.

In doing so, the processor can avoid being idle while waiting for the preceding instruction to complete.

SDK support


Our best supported SDK, with practical applications for Android development and integration into enterprise banking systems. Write once and run everywhere.


Need to create a front-end for your application? Use JavaScript SDK to interact natively with Iroha nodes using Iroha state-of-the-art async API.


Want to prototype a system? Use Python SDK. Quick and flexible development can then be directly translated to efficient Rust code, thanks to embedded dynamic-link libraries.

Smart contracts

Iroha 2 is an event-driven ledger. Each change in the state of the blockchain is accompanied by its own event that can trigger a smart contract: complex logic designed for use in on-chain scripting.

Iroha Special Instructions (ISI)

If you want something simple done efficiently, you can write the on-chain changes directly thanks to our Iroha Special Instructions. Combined with the Expression system, they allow you to write surprisingly complex reactions to simple events.

In addition to that, our revolutionary out-of-order execution model allows to optimise these instructions.

ISIs work as basic smart-contract operations.
Iroha 2 tutorial

Web ASseMbly (WASM)

If you need something more complex, you can write the logic in a cross-platform binary standard called Web Assembly (WASM).

This allows you to write the logic in any language you like that has the WASM target; execute the logic with near-native performance (much faster than interpreted languages), and have great flexibility in terms of introspection and debugging.

A statically typed, statically linked executable is much easier to understand and fix than an interpreted script with undocumented behaviour and no safety guarantees.

Additional features

High code quality standards

Iroha 2 is a minimalist code base. We take great care to vet our dependencies and avoid large inter-dependent chunks of code.

introspection and debugging is also an important feature that is oftend overlooked in Distributed ledgers. We provide tooling for many tools such as prometheus, structured logging via bunyan.

Our data is strongly-typed, our methods are statically dispatched. We make use of the best that Rust has to offer: serde and parity_scale_codec for serialisation, tokio for co-operative multithreading, as well as testing, benchmarking, static analysis and code auditing tools that come packaged with the exemplary cargo.

We provide helpful error messages, and try to automatically recover wherever possible. We have no implicit panics, only explicit error propagation with meaningful information tacked on at every level in the call-stack. We guarantee no undefined behaviour being triggered in any instance of Iroha, through judicious evasion of unsafe.


Iroha uses many state-of-the-art testing techniques and our QA process is robust.

We use property-based testing to verify the behaviour of all Iroha special instructions and failure-point testing to ensure that errors are properly handled and no catastrophic data corruption is possible.

To prove that Iroha is indeed as memory safe and reliable as any other Rust project, we performed an extensive fuzzing of all Iroha endpoints.


We provide nix-based transactional packages which combine the safety of containers, at the cost of none of the hassle.

Want docker instead? Use the hyperledger/iroha2-lts image. Want a .deb for your Ubuntu server? `apt install iroha`. Want a Mac package? `brew install iroha`. Useing Arch? `paru -S iroha`.

We provide architecture-optimised binaries with link-time code elimination, to ensure that the operation is smooth and optimal in all of the binary packages. Your M1 Mac runs the native version of the binaries, so if you plan to deploy an energy-efficient network, just use a couple of mac minis.

Free and Open Source

We have a large community of open source contributors under the aegis of Hyperledger foundation, a subsidiary of the Linux foundation.

We use open source software for development, and our internal processes all run with privacy-respecting FLOSS.

Solid rolling release cycle

Iroha comes in three versions: `dev` with all the most up-to-date features, `stable` with reasonably well-tested monthly feature updates and `long-term-support` which we recommend you use to build your projects, if you don’t rely on any of our (as of yet) unstable features.

Afraid the upgrade will break everything? Don’t be. With our native versioning of blockchain transactions, your information is guaranteed to be readable by downstream versions of Iroha.