Why?

Because by providing pre-built templates and complex contracts that developers can use with 0 setup we supercharge the growth of the community and the Soroban ecosystem.

We have been watching closely since 2014 and even though Stellar is a solid foundation as it is with its scalability, interoperability and speed, Soroban will unlock so much more potential with Rust based smart contracts. We want to help build it.

Project Overview

The idea is to create a library for Soroban smart contracts similar to OpenZeppelin. In contrast to OpenZeppelin it will not have ERC-20 or Proxy contracts because those are available in the core Soroban offering but it will have additional mathematical, cryptographic components and on top of that it will have a showcase of complex systems like Stake controlled governance or yield bearing instruments.

Goals

• Attract rust developers from existing web3 ecosystems and potentially web 2
• Build a simple wizard for users to build their contract thru a pick and choose interface similar to OpenZeppelin contracts
• Make it easy for all developers to onboard and build with Soroban
• Build a complex stake controlled governance dao contract to showcase more advanced uses

This proposal also includes the beginning of another tool, due to lack of writing space in the form, Quasar details are attached at the bottom of the pitch deck:

Quasar - A Soroban indexer - GraphQL APIs, Indexing and analytics of the Soroban ecosystem

We believe that Nebula will be a valuable tool for the Stellar community, making it easier to get started and build commercial products on top of Soroban and thus strengthening its long term ecosystem.

Attached to this submission is a pitch deck, please use that one to get a comprehensive idea of the vision.

Here is a list of possible smart contracts/tools to add to the SDK they have noted down on our internal update yesterday on Friday:

1. Auction
2. Coin Flip
3. Lottery
4. MarketPlace
5. FundMe Contract
6. Raffle
7. Math (SafeMath + SafeDecimalMath)
8. Pause Contract - Allow pausing some transactional process
9. Payment splitter
10. Reverse billing splitting
11. Voting facilities

Other projects in this space we could collaborate with

• Tenzing Catalog - An excellent idea to showcase contracts. Different from Tenzing we will allow users to customize contracts through a no-code UI.
• Sorosorcerer - Another excellent tool. Different from Sorosorcerer we are not only building the UI but also adding new math/crypto modules and new complex contracts like stake controlled governance and yield bearing instruments.

Value Proposition

1. Security: Smart contracts handle transactions worth millions of dollars every day. If a smart contract is not coded properly, it can be exploited, leading to severe financial losses. Nebula is built with security in mind. Its contracts will be thoroughly reviewed by the community and regularly audited by professionals.
2. Reusable Code: Nebula provides pre-built, battle-tested implementations of modular unit contracts and many other complex built systems. By using Nebula, developers can reuse these standard contracts without having to write them from scratch, significantly reducing the time and effort required to develop a new smart contract.
3. Modularity: Nebula contracts are designed to be modular and composable, making it easy for developers to mix and match them to build complex systems.
4. Community Support: Nebula will be built with a vibrant community of developers who will use, improve, and provide support for the library. This means that you can get help quickly if you encounter any problems.
5. Interoperability: By using standardized contracts you ensure that your contracts will be compatible with a broad ecosystem of wallets, exchanges, and other smart contracts.
6. Development Efficiency: Nebula helps you avoid the reinvention of the wheel. By using the library, you can cut down on development time and focus on what makes your project unique.
7. Education: If you're new to smart contract development, reading and understanding Nebulas contracts code can be an excellent way to learn best practices for Soroban and smart contract programming.

Micro and Macro

This proposal has two main points of view that together build a comprehensive vision.

1. Micro

Import existing examples from stellar documentation, and build new components that can be used as modules to build more complex or advanced contracts

Contracts that exist already

• Token [based on Soroban example] - it implements Soroban token interface, contains methods to mint, burn, transfer etc.
• SingleOffer [based on Soroban example] - implements trading of one token pair between seller and multiple buyer
• ClaimableBalance [based on Soroban example] - implementation of a claimable balance

List of possible additions

• Math - some math functions (min, max, avg, div, …)
• Cryptography - cryptography algorithms (ECDSA, MerkeProof and more) - Soroban contains Crypto type with 2 algorithms sha256 and ed25519_verify

2. Macro

Build showcase contracts that may ask as template in the future, these are complex setups that show integrations between multiple parts and how it can be used.

We’d like to focus on two main subcategories in the initial phases of this project:

1. Governance and how DAOs can upgrade the code of the smart contract by voting on new changes
2. Yield bearing instruments and how we can build temples showcasing these functionalities

Technical journey

2 approaches for the implementation

1. Make an external library like OpenZeppelin:
2. each contract would be provided as a source file (or files, as contract can be made out of several files)
3. additionally each contract would have to be either provided as a compiled WASM or it would be compiled during user contracts compilation (library contracts would have to be compiled first)
4. some easy way should be thought of how to include those WASMs into user contracts to avoid specifying full path as it is currently in Soroban (maybe env var pointing to the directory with compiled library WASMs, e.g.:
   mod external_contract {
   soroban_sdk::contractimport!(file =
   "${CONTRACTS_LIB_DIR}/external_contract.wasm");
   })
5. Extend Soroban with additional types
6. instead of having external contracts library, each contract would be included into Soroban as a Rust module
7. that simplifies things a little bit:
8. user includes only Soroban into his project and can start writing his contracts
9. contracts could be imported just as other Rust modules
10. easy compilation process

Roadmap

Building this library is a long journey so we will start with an initial Milestone 1 which is the work we aim to do for this grant request and plan additional enhancements in future Milestones.

Milestone 1: Basic setup & governance

• Set up project and documentation
• Set up testing environment
• Build a user interface that lets you “build your own contract”, functionality will be basic but it should suffice as a building block for future expansion
• Build at least one new small contract from our list
• Build a basic stake controlled governance contract that lets holders vote on code upgrades, this will be a major win, to showcase such a use case
• Do some preliminary research on how to build yield bearing instruments
• Do internal audit

Future milestones

• Ability to export contracts to the Soroban IDE with one click, the same way you export Open Zeppelin contacts to remix, click and edit, fluid integration
• Build new cryptographic modules
• Build more governance models as listed above
• Build yield bearing instruments

We released the 0.1 version of Nebula https://github.com/eigerco/nebula/discussions/33

This contains the work done for the POI milestone (10%). The project is all public here https://github.com/eigerco/nebula and anyone can follow along. The readme is a good entrypoint.

Here are the logs of our testing in Futurenet Raffle and Voting contracts.

Here is a live version of Nebula with the POI milestone changes. https://eigerco.github.io/nebula/

How can a reviewer check you completed your first deliverable?

Here are the logs of our testing in Futurenet Raffle and Voting contracts.

Here is a live version of Nebula with the POI milestone changes. https://eigerco.github.io/nebula/

‍