# Odra in 2026

The following document describes what Odra can look like at the beginning of
2026, given the support of the Casper Association. Already developed features
are described in the official Odra documentation: https://odra.dev/docs/. The
vision outlined below covers two years of development on top of the version of
Odra that is the result of Grant #507. The development is divided into two
possible tracks: BASE and FULL. The monthly cost of one developer is 15000 EUR.

## BASE Track
__Cost: 24 months x 3 developers = 1 080 000 EUR__

The BASE track focuses on maintaining the current course of Odra development, with
the goal of becoming the primary tool for building, testing, and interacting with
Casper smart contracts and attracting new developers to the Casper community by
providing the best developer experience.

### Maintenance
After the end of Grant #507, the core features of Odra are developed. Now they
need to be maintained and stabilized. It means:
- fixing bugs reported by developers,
- removing the technical debt from the codebase,
- improving in-code documentation,
- increasing the codebase test coverage,
- extending the CI pipeline with gas-cost benchmarks and cross-versions tests.

Upcoming changes in Casper 2.0 will require adjusting Odra to a new virtual machine.

### Documentation
Odra already provides documentation that covers most of its features. We want to
extend it with more granular articles and tutorials. There are many good
examples of great documentation in other ecosystems that we can take as
examples. Just to name two: https://solidity-by-example.org/ and
https://soroban.stellar.org/docs. We want to provide a similar level of quality
for Odra.

### Community Support
Odra is a community-driven project. Being in touch with teams that are using it and helping them with their problems is the best way to grow the product. So far we
responded to all the issues and questions we've had. We want to continue this
approach and be more active in the Casper popularization on events and social
media. We hope to team up with the Casper Association in those efforts. One of
areas we want to focus on are hackathons. It is a great way to attract new developers
to Casper. We think our team is well suited to be mentors in such events.

### Extending Existing Features
These are existing Odra features that can be taken to the next level.

#### Contract Metadata ABI
Many developers in the Casper community point out that Casper is missing a
standardized way of describing a contract's interface. It should include entry
points, events, custom type definitions, and storage layout. The Odra build
process already produces a simple version of it. We would like to expand on it
and propose it to the community as a Casper-wide standard that will
enable interoperability between all (not just Odra-based) Casper tools.

#### Gas Cost Optimizations
Odra relies on CasperLabs's `casper-contract` crate. It handles all the
communication with the host. Over time, we learned that it's not optimal, and
our initial experiments with replacing it with our own implementation reduced
gas costs by 50%. Pushing this feature forward will make using Odra the cheapest
approach for writing contracts. All the findings and patterns will be applicable
back to `casper-contract`, so non-Odra code will benefit from them.

Further gas cost optimizations can be achieved by using linear memory layouts.
The WASM tooling is constantly improving, and the Odra team should be up-to-date
with the latest advancements in this area, as it can have a huge impact on the
gas costs.

#### Odra Modules
Odra comes with a set of well-optimized, reusable smart contracts called __Odra
Modules__. Having such a library was always one of the primary goals of Odra. We
are highly influenced by Solidity's OpenZeppelin, which enabled Solidity smart
contract developers to quickly build complex products. So far, we have developed
`ERC20`, `ERC721`, `ERC1155`, `Ownable` and `AccessControl`. To meet industry
standards, we need to port most of OpenZeppelin's contracts and Casper's
existing standards: `CEP18` and `CEP78`.

#### Rust-based Contract Client
Odra includes a component for interacting with deployed contracts using the Rust
API. It enables developers to write contract clients using just the smart
contract code itself. It was not possible to do it easily before Odra. We have
tested it on the DAO project, and it saved us many hours of development and
debugging. As of now, it is still in the early stages of development. When done,
we see it as one of the most important features of Odra. It enables including
Casper contracts in larger off-chain Rust applications. Part of this feature is
its integration with Casper's speculative execution for gas cost estimation.

### New Features
The following are new features that will have a huge positive impact on the
quality of the developer experience delivered by Odra. These are already tested
ideas or community-requested features.

#### WASM-based JavaScript Client
Similarly to the Rust-based contract client, we can provide out-of-the-box
JavaScript clients that can run in the browser. It is a cornerstone for an
easy-to-develop fronted layer for Casper smart contracts. The current approach
requires manual writing of this code, and JavaScript developers often fail to
understand the nuances of data serialization and communication with the Casper
node and browser wallets.

#### Casper Source Validation Service
The Teonite company will soon release a tool for validating that the WASM file
was compiled from the given source code. For the first time, it will be possible
to verify that the contract has not been tampered with and is secure to use. We
want every Odra-based repository to be integrated with this tool.

#### Contract Upgrades
Casper provides a way to upgrade a contract to a new version. Unfortunately, it
requires such a contract to be owned by a single account. This allows for all
sorts of attacks. Hopefully, Casper 2.0 will address this issue. Before that
happens, we want to provide a way to upgrade a contract securely using a
combination of Casper's multisig, smart contracts with proxy-pattern and the
Casper Source Validation Service.

#### Multisig Tooling
Casper provides a way to create multisig accounts. It is a great feature to
distribute access to a single account between multiple parties. Unfortunately,
it lacks the tools for managing such accounts. We want to provide a set of
CLI-based tools for managing multisig accounts and a standard for easy exchange
of the deploy signatures.

## FULL Track
__Cost: 24 months x 5 developers = 1 800 000 EUR__

All the features from the BASE track are included. The FULL track focuses on
making Odra the best tool for development teams that want to deliver full stack
DApps on Casper. The goal is providing E2E solution for teams that never worked
in the blockchain industry before.

#### Behavior Driven Development (BDD)
BDD is a software development approach that has been proven to be very effective
in the industry. It is based on writing tests in a human-readable language. It
is a great way to write tests for smart contracts, as it allows describing the
contract's behavior in a way that is easy to understand by non-technical
stakeholders. In the DAO project, we used it with great success, and we would
like to make it a part of Odra. This means providing `cucumber-rs` bindings for
contract testing.

#### Static Code Analysis Tool
Ethereum ecosystem provides a few very useful tools for static code analysis. It
helps developers avoid common mistakes and write more secure and gas-efficient
code. We should have similar tools for Odra.

#### Solidity On Casper
Solidity is the most popular smart contracting language. It has a huge
ecosystem, and many developers are already familiar with it. Enabling it for
Casper will have a huge impact and will bring many projects to our chain.
Knowing that, we have developed a prototype of a transpiler that can convert
Solidity to Rust. We called it Nysa. Our initial experiments already proved, it
can handle most of the Solidity code. Our current goal is to cover all the
features required to transpile the Uniswap V4 codebase. We are working on
scoping its features with Mark Greenslade and Mel Padden. We would like to make
it part of the Odra development. More info on Nysa:
- https://github.com/odradev/nysa
- https://odra.dev/blog/Nysa/

#### NCTL Integration
The NCTL is a great tool for setting up a local Casper network. Odra should be
able to use it for running tests, benchmarks, CI pipelines, and most
importantly, the local DApp development environments. The best would be using
Make's NCTL Docker image.

#### DApp Templates
Odra should provide a set of configurable templates with the full-stack DApp
ready for development. It should include:
- smart contract code,
- BDD and unit tests,
- CI pipeline with a static code analysis tool enabled,
- Rust off-chain CLI app that can deploy, upgrade, and report on the state of
smart contracts,
- Frontend JavaScript/TypeScript layer already integrated with contracts and
browser wallets: Metamask and Casper Wallet.

To simplify the bootstrapping process for a new project, we will provide a
wizard for customizing the template, like choosing what contracts should be
included in the beginning and how they should be connected and governed. It
should be optional to use the front-end templates provided by Make.

#### Workshops
We would like to prepare a set of workshops for developers in the spirit of
"zero to hero" method. In the one day of intensive training, they will learn how
to design and build complex smart contract systems using Odra. We should be able
to run such a workshop for 10-20 developers at once, online or on-site. It
should be applicable to hackathons, conferences, or companies that want to
accelerate their teams and quickly start building.

#### Complex Tutorials
Even if we provide a set of templates, it is still a good idea to provide
step-by-step tutorials with non-trivial projects that show the nature of web3
projects. We propose to create two large tutorials:
- __RPG-like game__ - a project with a complex smart contract system, that
includes NFTs, fungible token, DAO governance, and items marketplace.
- __ZK-based NFTs__ - a project that uses ZK proofs for massive NFTs storage as
a merkle tree. It will be a great way to show the power of ZK proofs and how
to use them with Casper.