Dev-Suite Grant Roadmap

Hey guys,

We want to share with you our ideas, goals and roadmap for the next few months. Feedback will be appreciated.

Dev-Suite Grant Roadmap

This grant outlines, what we believe we need to add to existing tools. The following improvements will be split into several different grant applications because these are for separate tools. If all grants are approved, prioritization will be done, and the team won’t work on all grant applications simultaneously.

Improvements list

1. Dev-tools Grant

  • Forgae

    • Transaction inspector
    • DAO Shape
    • Functionality to test compatibility with new versions of node and compiler
  • Minutae

    • Minutae Integration
    • Minutae Desktop
  • Contract Injector & Development Frameworks Library

  • VS Code / WebStorm plugings

    • update the highlighting plugins for Sophia with latest changes
  • Aeternity Environment Starter

    • middleware

2. Playground Grant

  • Import Configurations
  • Import/Export of Smart Contracts
  • Implement ACI’s

3. .Net Library Grant

  • .NET library
    • wallet management, signing transactions, encode functions

4. JS-SDK Contribution Grant

  • JS-SDK mappings

Dev-tools Grant

Forgae improvements

Transaction inspector

Currently, the only way to check if and why a transaction is failing is the Goggles application. For local development though, this is not available, that’s why we believe that integrating the transaction inspector in forgae is important. It will give the benefit to the users to easily inspect their transaction even on local. The goal here is to deliver a cli command into forgae which will give this functionality to inspect a transaction with forgae.

DAO Shape

DAO shape can be really helpful for the organizations and teams building applications on the blockchain. DAO’s are widely used among blockchain companies and projects. This can be one more advantage to aeternity than other blockchain networks. The shape will include a boilerplate project with the necessary smart contracts which are needed to create DAO, the shape will also have frontend with a smart contract attached to it.

Functionality to test compatibility with new versions of node and compiler

This functionality can be useful when there are breaking changes and hardforks. Developers can try to compile/deploy/test their projects against the new version provided in forgae and can get recommendations on what and how to change to easily transfer their projects onto the new versions. This functionality will have the ability to choose from predefined version of the node and compiler, with which the user will then run his tests or smart contracts. The output will be in the console with the result of the compiling/testing and with some recommendations.


Minutae integration & Minutae Desktop -

The current forgae node is just a docker image of the real AE node with automining on. This node comes with all features which are not ideal for local development. Some(most) of the features are resource consuming for local development and slow down the development process and hurt the development experience. In order to have faster and easier development we need a tool that will simulate a node but with a few changes and improvements. The core team will provide a fork of the current node, on which changes will be made to provide the immediate transaction mining. This forked version will go hand by hand with the other aeternity node, meaning that will all new updates will be provided to both versions of the nodes. This new node will be integrated into the existing tools and will also have a desktop version. Our working name for the node is Minutae.

Integration of the Minutae Node

Integration of Minutae node will be provided both for Forgae and ae-cli tools. This integration will bring the following benefits for the developers. With one simple command, the users will be able to spawn their own node. An easy way to connect to the node will be provided. One of the biggest benefits is the immediate transactions, which will lead to faster development of the aepps. Currently, transaction mining is one of the biggest bottlenecks while developing on aeternity. Using the Minutae will reduce the time for executing a project’s unit tests dramatically. This node will also provide predefined and funded accounts, which will be easy to use and integrate into the projects. This version of the node will also be lighter and with the other benefits will bring a smooth development experience.

Minutae Desktop

Minutae Desktop will share the same functionalities with the CLI one. The main difference will be that it will have easy to use and interactive GUI. The desktop version can also be used in the entire development process.

Contract Injector & Development Framework Library

The contract injector will be a tool that will inject selected smart contracts code snippets into an existing smart contract.

The Idea & The problem

Sophia being a functional language is one of the great advantages of Aeternity. This, however, poses its own limitations in terms of reusing code. While libraries solve half of the problem, code that needs storage is not reusable through them. This limitation impedes our ability to create a generalized development frameworks library. This library will provide the most common and widely used smart contract code snippets when developing aepps, e.g Ownable, Fungible Token, etc. This library will be really easy to install(via yarn/npm) and will expose a CLI command allowing you to inject the snippets into .aes file of your choice.

The solution - The Contract Injector

The contract injector has two main benefits - improves security and saves time. On one hand, it will provide an easy way to inject code snippets in your contracts, thus saving you time. Additionally, your contracts will leverage well-known and audited contract snippets, thus inheriting better security.

The tool itself will be integrated into forgae, allowing you to run commands like:

forgae inject --snippet=Ownable --dest=Token.aes

This command will take the Ownable smart contract snippet (that could be seen in the CLI contract snippets library code) and will inject it into the smart contract that the user had provided. The tool will also take care of the changes that need to be made when injecting smart contracts. Examples of this is changing the state of your contract, adding additional parameters to the init function (constructor), and more. After the completion of the injector work, the user will have smart contracts that have all the needed functions. Importantly the resulting code is correct Sophia code.

Library Contribution

The development frameworks library will be open source and community-driven. The Dev-Suite team, other aeternity members and core team members, will be responsible for auditing community pull request for code snippets. This is needed because we want to create well-audited library that can be trusted.

VS Code / WebStorm plugins

Currently, there are highlighting plugins for Sophia language available for VS code, all JetBrains products, and Monaco editor. The plugins must be updated because there are be breaking changes to the Sophia syntax.

Aeternity Environment Starter

Currently, forgae’s users have the ability to run their own local node and local compiler. There are missing tools though - middleware. We will provide a way - a Cli tool and/or integration with existing tools (forgae, ae-cli) which will simply run the middleware configured and ready for local development. The middleware will available to query, via REST calls. If UI for the middleware is available until we start the development, we will integrate it.

Playground Grant

Import Configurations

Currently, the Playground supports configurations, which are used for compiling/deploying and interacting with smart contracts. We will provide a way to import already existing configuration, which can be exported from forgae, and thus make the Playground easier to use for local development. The users will have the ability to use the predefined accounts, node, a compiler that are started with one simple command with forgae.

Import/Export of Smart Contracts

One main feature is currently missing in the Playground, which will bring better development experience. Saving the developed smart contracts on the local file system. With one simple click, the users will be able to save the contracts in the desired location on their machine. This is needed because a lot of users will start their aeternity journey with the playground. They need to have the ability to later save their work easily and if wanted to switch to their own IDE. Also, the ability to import already developed and saved smart contract will be present. Both functions will prompt the user where to save or from where import the smart contracts.

Implement ACIs

ACI’s are an important feature of Sophia smart contracts, and their functionality must be implemented in the Playground. The ACIs will give the ability to prepare function calls with return types and input parameters without the need to write them manually. This will save time and mistakes by developers.

.NET Library Grant

Provide a simple library that provides the ability to manage wallets and keys and also sign transactions.
This is requested by the ventures team and game developers like Cryptic Legends.

JS-SDK Contribution Grant

Provide typings for the current JS-SDK. The goal of this is to make the sdk more readable and easy to use by the developers. The typings will be provided in Typescript and will give the ability to developers to have autocomplete when developing and also to clearly see and know what are the function input arguments and description.

The Dev-Suite Team.