CILA - Omnichain Infrastructure
- Team Name: Collective Intelligence Labs
- Payment Address: bc1qff0kjc6pyjkneyt3pctm5nahjpd9f774avz55x (BTC)
- Level: 2
- Status: Terminated
Project Overview πβ
Overviewβ
The goal of this project is to implement an omnichain smart contract infrastructure support for Substrate framework. ππ€ This will include the implementation of CQRS + Event Sourcing execution environment plus an example smart-contract. The implementation will be done using WASM and/or native Rust Substrate implementation as a pallet. The implementation will include implementing Protobuf support on-chain, serialization/deserialization, aggregated repository, event store, command/operations dispatcher, and events emitter. π οΈπ¨βπ»
Introductionβ
This project aims to add an omnichain smart contract infrastructure support for Substrate framework by implementing a CQRS + Event Sourcing execution environment. CQRS (Command Query Responsibility Segregation) is a design pattern that separates the command and query responsibilities of an application. Event Sourcing is a design pattern that represents the state of an application as a series of events that are stored in an event store. π§¬π»
Implementationβ
The implementation of the omnichain smart contract infrastructure will be done using WASM and/or native Rust Substrate implementation as a pallet. The implementation will include the following components:
Protobuf support on-chainβ
Protobuf is a language-agnostic binary serialization format that allows developers to define structured data schemas. The implementation will include support for Protobuf on-chain, which will enable developers to define smart contract interfaces using Protobuf. π€πΎ
Aggregate Repositoryβ
Aggregate Repository is a data storage module that manages the state and storage of aggregate objects. It provides methods for creating, reading, updating, and deleting aggregates. ππ
Event Storeβ
An event store is a database that stores events in the order they occurred. The implementation will include an event store, which will store all the events generated by the smart contract. ποΈπ
Command/operations Dispatcherβ
A command/operations dispatcher is a component that receives commands/operations and dispatches them to the appropriate handler. The implementation will include a command/operations dispatcher, which will enable developers to define command/operation handlers for the smart contract. ππ¨ββοΈ
Events Emitterβ
An events emitter is a component that emits events. The implementation will include an events emitter, which will enable developers to define event handlers for the smart contract. π£π
Conclusionβ
The completion of this project will provide a powerful infrastructure for developers to build customized omnichain smart contracts on the Substrate framework. πͺπ¨βπΌ
π Technology Stackβ
Programming Language - Rust π¦
Blockchain Framework - Substrate βοΈ
Virtual Machine - WebAssembly (WASM) πΈοΈ
Serialization - Protocol Buffers (protobuf) π: a language-agnostic data serialization format that allows for efficient and interoperable communication between different services and systems.
Design Patterns:
- Event Sourcing π: a pattern that captures all changes to an application state as a sequence of events, which can be used to reconstruct the state at any point in time.
- Command Query Responsibility Segregation (CQRS) π§¬: a pattern that separates the read and write concerns of an application, using separate models and interfaces for each.
- Saga pattern π: a pattern for coordinating distributed transactions across multiple services, ensuring consistency and reliability.
- Domain-Driven Design (DDD) π°: a design approach that emphasizes the importance of the domain model in shaping the architecture of a software system.
Database - MongoDB ποΈ: a NoSQL document database that provides scalability, flexibility, and high availability.
Testing Framework - Rust Testing π§ͺ: Rust has an inbuilt testing framework that enables testing of units of code in isolation.
CI/CD - GitHub Actions π: a continuous integration and continuous deployment service that can automate the build and deployment processes.
Containerization - Docker π³: a tool that allows for the creation, deployment, and running of applications in containers, providing a consistent runtime environment across different platforms.
Documentation for Core Copmpontents
Dispatcher
The Dispatcher
is a component of the omnichain smart contract infrastructure that receives commands/operations and dispatches them to the appropriate handler. The Dispatcher
class enables developers to define command/operation handlers for the smart contract.
Usageβ
The Dispatcher
can be used in the implementation of the CQRS + Event Sourcing execution environment for Substrate framework. It receives commands/operations from external sources, such as a client or a node, and routes them to the appropriate command/operation handler.
To use the Dispatcher
, developers first define a set of command/operation handlers for the smart contract. These handlers can be implemented as methods in a Rust struct. The Dispatcher
class then instantiates this struct and routes commands/operations to the appropriate method based on the type of command/operation.
Benefitsβ
The Dispatcher
provides a simple and flexible way to handle commands/operations in the smart contract. By defining a set of command/operation handlers, developers can easily add new functionality to the smart contract without having to modify the Dispatcher
class itself.
In addition, the Dispatcher
enables developers to implement complex business logic in the smart contract by routing commands/operations to the appropriate handler. This allows for a more modular and maintainable codebase.
Conclusionβ
The Dispatcher
is a crucial component of the omnichain smart contract infrastructure. By enabling developers to define command/operation handlers for the smart contract, it provides a simple and flexible way to handle commands/operations. Its usage in the implementation of the CQRS + Event Sourcing execution environment for Substrate framework enables developers to implement complex business logic in a modular and maintainable codebase.
EventStore
Descriptionβ
The EventStore
is a database that stores events in the order they occurred. It is a crucial component of the omnichain smart contract infrastructure support for Substrate framework. The EventStore
class enables the storage of all events generated by the smart contract, allowing for a complete historical record of all transactions and changes to the smart contract's state.
Implementationβ
The EventStore
is implemented using an internal Substrate database. The EventStore
stores events in the form of serialized binary data plus metadata, which can be easily deserialized for querying and analysis.
Featuresβ
The EventStore
includes the following features:
-
Event storage: The
EventStore
stores all events generated by the smart contract in the order they occurred, allowing for a complete historical record of all transactions and changes to the smart contract's state. -
Querying: The
EventStore
allows for easy querying of events using various criteria, such as time range, event type, or specific parameters. -
Deserialization: The
EventStore
can easily deserialize stored binary data for querying and analysis. -
Scalability: The
EventStore
can handle large volumes of events and is designed for scalability.
Benefitsβ
The EventStore
provides several benefits to developers building smart contracts on the Substrate framework, including:
-
Transparency: The
EventStore
provides a complete historical record of all transactions and changes to the smart contract's state, ensuring transparency and accountability. -
Auditability: The
EventStore
allows for easy querying and analysis of events, enabling developers to audit the smart contract's behavior and ensure compliance with regulations and business rules. -
Flexibility: The
EventStore
can handle a wide range of event types and is designed for scalability, providing flexibility for developers building smart contracts on the Substrate framework.
Conclusionβ
The EventStore
is a crucial component of the omnichain smart contract infrastructure support for Substrate framework. It provides event storage, querying, deserialization, and scalability features, enabling developers to build transparent, auditable, and flexible smart contracts on the Substrate framework. The completion of this project will provide a powerful infrastructure for developers to build customized smart contracts on the Substrate framework, with the EventStore
serving as a key component of this infrastructure.
Snapshot Store
Overviewβ
The Snapshot Store
is a component of the omnichain smart contract infrastructure that provides a way to store and retrieve snapshots of the smart contract state. A snapshot is a read-only view of the smart contract state at a particular point in time. Snapshots are useful for optimizing the performance of the smart contract by reducing the amount of data that needs to be read from the event store.
Implementationβ
The implementation of the Snapshot Store
includes the following components:
Snapshot Store
: The Snapshot Store is the primary component. It provides an interface for storing and retrieving snapshots of the smart contract state.Snapshot Index
: The Snapshot Index is a data structure that is used to index snapshots by their version. It allows for efficient retrieval of the latest snapshot.Snapshot Writer
: The Snapshot Writer is a component that is used to write snapshots to the Snapshot Store. It receives the current state of the smart contract and writes it to the Snapshot Store as a snapshot.Snapshot Reader
: The Snapshot Reader is a component that is used to read snapshots from the Snapshot Store. It receives a snapshot version and returns a read-only view of the smart contract state at that version.
Conclusionβ
The Snapshot Store
provides a way to store and retrieve snapshots of the smart contract state, which can be used to optimize the performance of the smart contract. The implementation includes the Snapshot Store
, Snapshot Index
, Snapshot Writer
, and Snapshot Reader
components. The completion of this component will provide a pefrormance optmization for omnichain smart contracts on the Substrate framework.
Aggregate
The Aggregate
is a core component of the CQRS + Event Sourcing design pattern. It represents the current state of an entity and is responsible for handling commands and producing events.
Descriptionβ
An Aggregate
is a stateful object that represents a single entity in the system. It maintains its state by applying events to its internal state. A new state can be generated by applying new events to the existing state.
In the context of the Substrate framework, an Aggregate
is implemented as a Rust struct that contains its internal state and a set of methods to apply events and handle commands.
Implementationβ
The Aggregate
is implemented using the following components:
Internal stateβ
The internal state of an Aggregate
is represented as a Rust struct. The struct contains all the data necessary to represent the current state of the entity.
Command handlingβ
The Aggregate
contains a set of methods to handle commands. These methods accept a command object as input and return a set of events that represent the result of executing the command.
Event sourcingβ
The Aggregate
implements event sourcing by maintaining a list of events that have been applied to the internal state. When a new command is received, the Aggregate
applies the appropriate events to generate a new state.
Snapshottingβ
The Aggregate
implements snapshotting by periodically storing a snapshot of its internal state. When an Aggregate
is retrieved from its event stream, it can be initialized with the latest snapshot and then apply only the events that occurred after the snapshot.
Conclusionβ
The Aggregate
is a core component of the CQRS + Event Sourcing design pattern. It represents the current state of an entity and is responsible for handling commands and producing events. The implementation of the Aggregate
in the Substrate framework provides a powerful mechanism for building complex and scalable smart contracts.
AggregateState
The AggregateState
represents the state of an aggregate object in the event sourcing pattern. It is responsible for maintaining the current state of the aggregate object by processing the events that have occurred in the past.
Propertiesβ
id
: The unique identifier of the aggregate object.version
: The version of the aggregate object.events
: The list of events that have occurred in the past.
Methodsβ
apply_event(event)
: Applies the given event to the current state of the aggregate object. This method updates the state of the aggregate object based on the event that occurred.get_version()
: Returns the version of the aggregate object.get_events()
: Returns the list of events that have occurred in the past.
Usageβ
To use the AggregateState
, you must first create an instance of it and initialize it with the current state of the aggregate object. You can then apply events to the aggregate object by calling the apply_event()
method.
Diagrammβ
Architecture Overview Diagram
Flow Diagramm
Command Processing Flow Diagramm
+------------+ +------------+ +-----------------+ +-------------------+ +------------+
| Application| | Router | | Execution Chain | | Event Relay Node | | Aggregation|
+------------+ +------------+ +-----------------+ +-------------------+ +------------+
| | | | |
| Command Request | | | |
|------------------>| | | |
| | | | |
| Command Handler | | | |
|------------------>| | | |
| | Command Request | | |
| |------------------->| | |
| | | Execute Command (CQRS) | |
| | |--------------------------->| |
| | | | Store Event (ES) |
| | | |----------------------------->|
| | | | |
| | | | Broadcast Event to |
| | | | Other Chains |
| | | |--------------------------->|
| | | | |
| | | | Transmit Event to |
| | | | Aggregation Cluster |
| | | |----------------------------->|
| | | | |
| | | | Process Events and |
| | | | Produce Aggregated Data |
| | | |<-----------------------------|
| | | | |
| | | | Return Aggregated Data |
| | | |<-----------------------------|
| | | | |
API Documentation
Domainβ
Aggregateβ
AggregateState
β
Methodsβ
new() -> Self
: Creates a new instance ofAggregateState
.apply_events(&mut self, events: Vec<DomainEvent>) -> Result<(), String>
: Applies a list of domain events to the aggregate state.clear(&mut self)
: Clears the state of the aggregate.
DomainEvent
β
Methodsβ
new(evnt_type: DomainEventType, evnt_payload: Vec<u8>) -> Self
: Creates a new instance ofDomainEvent
.serialize(&self) -> Result<Vec<u8>, String>
: Serializes the domain event to a byte array.
DomainEventType
β
Variantsβ
NFT_MINTED
NFT_TRANSFERED
Entitiesβ
NFT
β
Fieldsβ
hash: [u8; 32]
: The unique hash of the NFT.owner: Address
: The address of the owner of the NFT.
Methodsβ
new(hash: [u8; 32], owner: Address) -> Self
: Creates a new instance ofNFT
.get_hash(&self) -> [u8; 32]
: Returns the hash of the NFT.get_owner(&self) -> Address
: Returns the owner of the NFT.transfer(&mut self, new_owner: Address)
: Transfers the ownership of the NFT to a new owner.
Applicationβ
Commandβ
Command
β
Fieldsβ
cmd_type: CommandType
cmd_payload: Vec<u8>
Methodsβ
new(cmd_type: CommandType, cmd_payload: Vec<u8>) -> Self
: Creates a new instance ofCommand
.serialize(&self) -> Result<Vec<u8>, String>
: Serializes the command to a byte array.
CommandType
β
Variantsβ
MINT_NFT
TRANSFER_NFT
Serviceβ
CommandDispatcher
β
Methodsβ
dispatch(command: Command) -> Result<(), String>
: Dispatches a command to the appropriate handler.
NFTService
β
Fieldsβ
state: NFTsState
event_store: Box<dyn EventStore>
dispatcher: Box<dyn CommandDispatcher>
Methodsβ
new(state: NFTsState, event_store: Box<dyn EventStore>, dispatcher: Box<dyn CommandDispatcher>) -> Self
: Creates a new instance ofNFTService
.handle_command(&mut self, command: Command) -> Result<(), String>
: Handles a command by dispatching it to the appropriate handler.get_nft_owner(&self, hash: [u8; 32]) -> Option<Address>
: Returns the owner of an NFT with the given hash.
Eventβ
DomainEventType
β
Variantsβ
NFT_MINTED
NFT_TRANSFERED
DomainEvent
β
Fieldsβ
evnt_type: DomainEventType
evnt_payload: Vec<u8>
Methodsβ
new(evnt_type: DomainEventType, evnt_payload: Vec<u8>) -> Self
: Creates a new instance ofDomainEvent
.serialize(&self) -> Result<Vec<u8>, String>
: Serializes the domain event to a byte array.
Storeβ
AggregateRepository
β
Fieldsβ
event_store: Box<dyn EventStore>
Methodsβ
new(event_store: Box<dyn EventStore>) -> Self
: Creates a new instance of `AggregateRepository
π Ecosystem Fit: π
πΉ Project's Fit: CILA will provide an infrastructure for building efficient omnichain smart contracts that can be integrated into the Polkadot ecosystem, offering a unique solution in the Substrate/Polkadot/Kusama landscape.
πΉ Target Audience: Developers interested in building omnichain smart contracts on Substrate, Polkadot, and Kusama, particularly those looking to develop cross-chain applications and interact with multiple blockchain networks.
πΉ Project's Purpose: The infrastructure will enable developers to build more efficient and scalable omnichain smart contracts, making it easier to create cross-chain applications that interact with multiple blockchain networks. This will help solve the problem of siloed blockchains and allow developers to take advantage of the benefits of multiple chains.
πΉ Similar Projects: We are not aware of any other projects similar to OmniChain in the Substrate/Polkadot/Kusama ecosystem, offering a unique solution for building omnichain smart contracts.
Team π¦Ύβ
Team membersβ
- π¨βπ» Alex Shkor - Architect, Developer, Team Lead
- π¨βπ» Alexey Kulik - Architect, Developer
- π©βπΌ Julia Shinkevich - Project Manager
- π§β πΌ Max Slyzkoukh - Product Manager
- π¨βπ§ Yahor Tsaryk - Engineer
Contactβ
- Contact Name: Alex Shkor
- Contact Email: alex@cilabs.ai
- Website: https://collectiveintelligence.dev/
Legal Structureβ
- Registered Address: 16192 Coastal Highway, Lewes, DE 19958, United States.
- Registered Legal Entity: Collective Intelligence Labs Inc.
Team's experienceβ
Our team's extensive experience in blockchain development and past successful projects make us well-suited for this project. We have developed several blockchain-based platforms, including DeSci, which offers a decentralized scientific communication infrastructure, and IPledger, which registers intellectual property assets on the blockchain. We have also built a Proof of Share protocol for verification on a chain that specific files have been shared between parties, an on-chain grants distribution platform, a decentralized technology transfer platform, F-NFT and Event Proxy for Substrate, and other projects.
Our team members have also contributed to open-source blockchain projects, demonstrating our commitment to the development of the blockchain ecosystem as a whole.
Our Team Lead is distributed systems architect and has over 14 years of experience in this field, with one of our team members being the inventor of omnichain smart-contracts protocol, which is an important aspect of this project. Our Software Engineer has over 10 years of experience in distributed systems engineering and was the ex-CTO at DEIP and the creator of the Economy Protocol. Our Tech Lead has experience in distributed system and blockchain R&D and was the ex-Head of R&D at Paralect, while also having experience as an ex-CPO at DEIP. Our Head of Marketing has 9 years of experience in PR and communications, having worked with micromobility and web3 startups. Our Product Manager expert in digital transformation has 6 years of experience in the procurement of 50+ leading private and state Ukrainian enterprises.
As a team, we have previously applied for a grant from the web3 foundation grants program for our DEIP project (DEIPWORLC Inc. legal entity). However, due to the constantly evolving market landscape and changing needs of the industry, we decided to pivot multiple times, and therefore did not deliver original proposal fully (only about 50% of it - onchain part). During the process we realized that on-chain IP management would not be possible without other infrastructure part. Therefore we decided to completely stop previous project, change our focus and start working on a diferent solution, the core solution that will make possible to implement DEIP and other our projects that rely on omni-chain infrastructure and onchain IP management - omni-chain infrastructure
We believe that being transparent about our previous application and pivot is important. We want to assure the committee that we are committed to delivering the proposed solution for our current application, and that we are passionate about creating value in the blockchain ecosystem.
We are confident that our team's expertise and experience in developing distributed systems and infrastructure will enable us to successfully execute our proposed CILA omnichain infrastructure project. We believe that this infrastructure is crucial for the growth and adoption of blockchain technology, and we are excited about the opportunity to contribute to this space.
Team Code Reposβ
Team GitHub Profilesβ
- https://github.com/alexshkor
- https://github.com/aliakseikulik
- https://github.com/yahortsaryk
- https://github.com/juliacil
Team LinkedIn Profilesβ
- https://www.linkedin.com/in/alexshkor/
- https://www.linkedin.com/in/alexeykulik/
- https://www.linkedin.com/in/julia-shinkevich/
- https://www.linkedin.com/in/max-slyzkouh/
- https://www.linkedin.com/in/yahor-tsaryk-92032a68/
Development Status πβ
CILA omnichain infrastructure for Substrate is currently in the research and planning phase. We have conducted extensive research on the existing smart contract infrastructure and identified the need for an omnichain smart contract solution. Our team has also analyzed the capabilities of the Substrate/Polkadot/Kusama ecosystem and determined that it is the ideal platform for building this solution.
We have created a detailed project plan that outlines the development roadmap and milestones. This plan includes research and development of the necessary components.
- Draft of solidity implementation: https://github.com/Collective-Intelligence-Labs/cila-sol-contracts
- Vision Paper: https://docsend.com/view/eqt2iazwmff3jikh
Development Roadmap π©β
Overviewβ
- Total Estimated Duration: 3 months
- Full-Time Equivalent (FTE): 2 FTE
- Total Costs: 30,000 USD
Milestone 1 β Design and Implementationβ
- Estimated duration: 1 month
- FTE: 2
- Costs: 10,000 USD
Number | Deliverable | Specification |
---|---|---|
0a. | License | Apache 2.0 |
0b. | Documentation | We will ensure comprehensive documentation of the code by providing both inline comments and a step-by-step tutorial. This tutorial will guide the user through spinning up a Substrate-based execution environment for the CILA Omnichain Infrastructure and testing omnichain transactions, showcasing the new functionality. |
0c. | Testing and Testing Guide | We will conduct comprehensive unit testing on the core functionalities including Aggregate, Event Store, Aggregate Repository, Snapshot Store, and Dispatcher, to ensure optimum functionality and robustness. The testing guide will contain instructions on how to execute these tests. |
0d. | Docker | We will deliver Dockerfiles for testing all the functionality included in this milestone. |
1. | Substrate module: Aggregate | The Aggregate pallet provides the base functionality for implementing the Command Query Responsibility Segregation (CQRS) pattern on a Substrate-based blockchain. It defines the Aggregate trait, which is used to define the state and behavior of an Aggregate. |
2. | Substrate module: AggregateState | The AggregateState pallet provides a default implementation of the AggregateState trait, which stores the current state of an Aggregate in the blockchain's storage. This pallet is responsible for managing the state of an Aggregate and updating it based on incoming commands. |
3. | Substrate module: AggregateRepository | The AggregateRepository pallet provides an implementation of the AggregateRepository trait, which is responsible for retrieving and storing Aggregates in the blockchain's storage. It allows developers to easily store and retrieve Aggregates from the blockchain's storage. |
4. | Substrate module: CommandDispatcher | The CommandDispatcher pallet provides a way to dispatch incoming commands to the appropriate Aggregates based on their type. It uses a HashMap to store the mapping between command types and the Aggregates that handle them. |
5. | Substrate module: EventStore | The EventStore pallet provides a way to store and retrieve events that have been emitted by Aggregates. It allows developers to easily retrieve the events emitted by a specific Aggregate and replay them to reconstruct the current state of the Aggregate. |
6. | Substrate module: EventsEmitter | The EventsEmitter pallet provides a way for Aggregates to emit events. It defines a trait that Aggregates can implement to specify the types of events they emit, and provides a way to subscribe to events emitted by specific Aggregates. |
Milestone 2 β Testing and Documentationβ
- Estimated duration: 1 month
- FTE: 2
- Costs: 10,000 USD
Number | Deliverable | Specification |
---|---|---|
0a. | License | Apache 2.0 |
0b. | Documentation | We will ensure comprehensive documentation of the code by providing both inline comments and a step-by-step tutorial. This tutorial will guide the user through spinning up a Substrate-based execution environment for the CILA Omnichain Infrastructure and testing omnichain transactions, showcasing the new functionality. Special attention will be given to documenting the setup and testing of multiple Substrate chains running simultaneously, to test the synchronization of the state smart contract between them. |
0c. | Testing and Testing Guide | We will conduct comprehensive unit testing on the core functionalities including Aggregate, Event Store, Aggregate Repository, Snapshot Store, and Dispatcher, to ensure optimum functionality and robustness. In particular, we will place emphasis on testing the infrastructure running with multiple chains to ensure that the synchronization mechanism is functioning as intended. The testing guide will contain instructions on how to execute these tests. |
0d. | Docker | We will deliver Dockerfiles for testing all the functionality included in this milestone, including orchestration with multiple chains. For orchestration purposes we might use Kubernates. |
0e. | Article | We will publish a technical article that details the implementation of the Command-Query Responsibility Segregation (CQRS) and Event Sourcing architecture on the Substrate framework. The article will provide an in-depth explanation of the design choices made and the challenges faced during the implementation. It will also include a detailed walkthrough of the codebase, highlighting key areas of interest and how they fit into the overall architecture. The article will be written in a technical language that targets developers with experience in blockchain and distributed systems. |
1. | Substrate chain | Set up and run multiple Substrate chains simultaneously to test the synchronization of a state smart contract between them. This will involve deploying the omnichain smart contract infrastructure to each chain and executing transactions on each chain to ensure that the contract state is properly synchronized between them. Additionally, various network conditions such as network latency and node failures will be simulated to test the robustness and reliability of the synchronization mechanism. The results of these tests will be recorded and analyzed to identify any potential issues and ensure that the synchronization mechanism is functioning as intended. |
2. | Automated Tests | We will create and publish automated tests for critical infrastructure parts of Substrate-based CQRS + Event Sourcing execution enviroment. The aim of this test will be to test two cases - non conflicting execution (changes coming to one chain and transmitted to the other one), and conflicting transactions when the same aggregate is updated with two conflicing state changes that simuntaniusly come to different chans. |
Milestone 3 β Example Smart Contracts and Enhancementsβ
- Estimated duration: 1 month
- FTE: 2
- Costs: 10,000 USD
Number | Deliverable | Specification |
---|---|---|
0a. | License | Apache 2.0 |
0b. | Documentation | Provide inline documentation of the NFTAggregate pallet and NFTAggregateState pallet code, as well as a basic tutorial that explains how a user can set up a Substrate node and send test transactions to test the NFT functionalities provided by these modules. Additionally, comprehensive unit tests will be developed and documented to ensure the functionality and robustness of the NFTAggregate pallet and NFTAggregateState pallet. A testing guide will also be provided, describing how to run the tests. |
0c. | Testing and Testing Guide | For this milestone, we will develop comprehensive unit tests to cover the core functions of the NFTAggregate module and the NFTAggregateState pallet. These tests will be designed to ensure the functionality and robustness of the code. The unit tests will be included in the code repository and will cover a range of scenarios to ensure that the code is thoroughly tested. For example, we will test the minting, burning, and transferring of NFTs, as well as error handling and edge cases. In the testing guide, we will provide detailed instructions on how to run these tests, including any required dependencies and setup steps. We will also include information on how to interpret the test results and what to do in the case of failures or errors.. |
0d. | Docker | In order to facilitate testing and deployment of the NFTAggregate pallet and NFTAggregateState pallet, we will provide Dockerfiles that can be used to easily set up and configure a development environment. These Dockerfiles will include all the necessary dependencies and configuration to run the Substrate-based blockchain with the new functionalities. |
1. | Substrate module: NFTAggregate | The NFTAggregate pallet provides a way to implement Non-Fungible Tokens (NFTs) on a Substrate-based blockchain. It defines a trait that NFT Aggregates can implement to specify the behavior of NFTs, including minting, burning, and transferring. |
2. | Substrate module: NFTAggregateState | The NFTAggregateState pallet provides a default implementation of the state of an NFT Aggregate, which stores the current state of NFTs in the blockchain's storage. This pallet is responsible for managing the state of NFTs and updating it based on incoming commands. |
3. | Report: Substrate Ecosystem NFT standards | To choose the most optimal standard for omnichain implementation we will conduct research and assess all the available NFT standards against two major criteria: popularity and technical quality. Popularity will be measured by the number of stars on the GitHub repository and how many projects are actually using it (usage assesment will be done on a best effort basis), and the technical quality will be assessed by analyzing if a specific standard satisfies SOLID design principles. |