Development Roadmap

Introduce a block reward mechanism to the Lisk protocol which adds an milestone based LSK incentive for every block an active delegate forges.

Add support for a 64 byte data field to the type 0 transaction type so that custom identifiers, hashes and other pieces of metadata can be optionally attached to every balance transfer on the network.

Significantly reduce the probability of fork or chain splits and introduce a consistent way for the Lisk protocol to react to forks through valid block determination and windowed rollback.

Introduce a mechanism for version controlled block generation when a distinct change is made to the Lisk protocol.

Introduce a new API to Lisk Core which conforms to RESTful design principles and integrates Swagger as a tool for designing, building, documenting, testing, and standardising the API across the entire application architecture.

Change the database engine used by Lisk Core from SQLite to PostgreSQL, introducing the use of PG-Promise as its primary interface for reading and writing to the database system.

Rewrite the database module of Lisk Core so that it supports a repository design pattern as recommended by PG-Promise.

Add database migration system for version controlled atomic schema changes between Lisk Core releases.

Ensure blocks are persisted atomically and that data corruption never can occur when the Lisk Core application is interrupted or processing fails.

Add support to Lisk Core for creating verified blockchain snapshots of the existing blockchain and the ability to restore them on demand.

Add a transaction pool system to Lisk Core for receiving and processing transactions from peers in a more controlled, efficient and scalable manner.

Add a broadcasting mechanism to Lisk Core for propagating blocks, transactions and multi-signatures in a more controlled, efficient and scalable manner.

Rewrite the P2P module of Lisk Core so that it utilises the SocketCluster.io framework for maintaining data connections, broadcasts and receipts between peers on the network.

Complete the multi-signature solution provided by Lisk Core, so that transactions initiated by a multi-signature group owner can be reliably created, pooled and included into the blockchain when all required accounts have signed a transaction.

Add delegate passphrase encryption so that plain text passphrases are never propagated or stored when managing a Lisk Core delegate node.

Add support for setting a minimum application version accepted by new Lisk Core release proposals made to the network.

Allow node operators to connect with different networks (devnet, testnet or mainnet) using a single Lisk Core installation.

Add configuration migration system for easy tracking of configuration changes between Lisk Core releases and migrating existing configurations to the latest release.

Replace Lisk Build with an inbuilt system for building Lisk Core.

Replace Lisk Docker with an inbuilt integration for running Lisk Core using Docker.

Add Lisk Core application benchmarking using NewRelic (https://newrelic.com/), helping to identify API bottlenecks, database query performance problems and potential stack overflows.

Improve performance in Lisk Core for
1) Poor performing API endpoints and
2) Vote transaction verification.

Change the repository structure of Lisk Elements to conform with the "mono" repository ideal. Reference: https://ai.google/research/pubs/pub45424.

Add optional support to Lisk Elements for the sodium-native (https://github.com/sodium-friends/sodium-native) cryptography library, as a backend alternative to TweetNaCl (https://tweetnacl.js.org/#/).

Implement consistent handling of error message propagation throughout the entire Lisk Elements library.

Add static type checking to Lisk Elements by migrating the codebase to: https://www.typescriptlang.org/.

Change the application framework used to create Lisk Commander from https://github.com/dthree/vorpal to https://github.com/oclif/oclif.

Add static type checking to Lisk Commander by migrating the codebase to: https://www.typescriptlang.org/.

Add new commands to Lisk Commander for:
1) Fetching a pending multi-signature transaction and
2) Signing a pending multi-signature transaction. In support of the existing multi-signature transaction broadcast command. This will complete the fetch, sign and broadcast workflow.

Add new commands to Lisk Commander for:
1) Listing votes placed by an account and
2) Listing votes placed for a delegate.

Introduce two distinct versioning schemes, one for the Lisk Core application and one for the Lisk protocol. This will allow, for instance, a better overview when updating to a new Lisk Core release is optional or mandatory.
LIP draft on GitHub

Introduce a new application architecture for Lisk Core, one which provides:
1) Looser coupling between modules through functional isolation
2) Optional elastic scaling for modules over multiple cores, threads or machines
3) Easier extensibility through the use of a plugin pattern and a supporting API
4) Increased resilience to individual module processing failure. The new architecture will form the framework which new Lisk applications will inherit from.
LIP draft on GitHub

Implement a design pattern for the database component outlined by the new Lisk Core application architecture proposal. The database component will provide an abstraction layer for Lisk applications for reading and persisting objects.

Implement a design pattern for elegant handling of protocol change in the Lisk Core codebase. One which provides a consistent and straight-forward approach to dealing with protocol changes on an existing blockchain.

Consolidate transaction processing so that the majority of operations are performed in-memory and expensive database operations are minimised. This will bring significant efficiency improvements to transaction processing in Lisk Core.
LIP draft on GitHub

Extract logic from Lisk Core to Lisk Elements with the code rewritten in TypeScript. In support of:
1) Migrate elements to TypeScript and
2) Improve transaction processing efficiency.

Extract logic from Lisk Core to Lisk Elements with the code rewritten in TypeScript. In support of:
1) Migrate elements to TypeScript and
2) Improve transaction processing efficiency.

Add new commands to Lisk Commander for:
1) Ensuring node dependencies are met
2) Managing node processes and
3) Configuring code parameters.
4) Upgrading node version

Enable developers to write custom transaction types using a standardised interface, making it easy to extend the default set of transaction types provided by the Lisk Protocol with new network functionalities.

Refactor the codebase of the Lisk Core chain module to reduce the amount of technical debt.

1) Removing callbacks, and replacing with async/await
2) Removing circular dependencies
3) Reducing 3rd party usage

Introduce a robust peer selection with periodic shuffling together with a banning mechanism. Further refine the gossip-based flooding mechanism for blocks, transactions and signatures in order to improve information propagation. The changes are intended to make the Lisk peer-to-peer network ready to scale to a large number of nodes and further increase the robustness of the network.
LIP draft on GitHub

Change the consensus algorithm in order to add block finality guarantees based on classic Byzantine fault tolerance (BFT) research, i.e. guarantees that a block is never reverted. Block finality and a robust consensus are one of the key requirements for introducing sidechains and communication between different chains in Lisk.

LIP draft on GitHub

Bind each transaction to a specific chain by using unique chain identifiers. In general, this will prevent that transactions get replayed on other chains. For instance, a transaction from the testnet cannot be replayed on the mainnet. Also, a transaction on a specific sidechain cannot be replayed on another sidechain.
LIP draft on GitHub

Remove redundant properties in transactions that are not needed for certain transaction types.

LIP draft on GitHub

Extract logic from Lisk Core to Lisk Elements with the code rewritten in TypeScript.

Remove the limit on the number of transactions per block, and introduce a limit on the overall size of the block. This will increase the maximum rate of transactions per second for most transaction types while keeping the growth of the blockchain at a reasonable level.
LIP draft on GitHub

Introduce a dynamic fee system as a free fee market where the fixed fee for all transaction types will be removed and a minimum fee will be set in the protocol. This minimum fee will be given in terms of LSK per byte used by transactions and any transactions broadcast with a fee below that value will be rejected. For each transaction, it will be up to each user to choose the fee.

LIP draft on GitHub

Implement an algorithm that recommends a fee for a transaction depending on the preceding network usage demand and the desired maximum time for the transaction to be included into a block.

Change the multisignature process so that nodes can handle a sufficient number of pending multisignatures.

Introduce a transaction invalidation mechanism that will improve the usability of the dynamic fee system.

LIP draft on GitHub

Create a new fee estimation element. In support of: Implement fee estimation algorithm for dynamic fee system.

Change the address system such that:
1) registrations are not needed
2) the address space is sufficiently large to avoid collisions of addresses
3) sending money to a black hole due to user failure (mistyping an address) is mitigated.

Increase the length of the block IDs to secure the immutability of the blockchain also for next decade(s).

LIP draft on GitHub

Increase the length of transaction IDs to avoid collisions.

Remove the pre-hashing step from the block and transaction signature processes. This will simplify the protocol since hashing a message (transaction or block header) before signing the resulting hash digest is a redundant step.
LIP draft on GitHub

Introduce a decentralized way of writing the account states to the blockchain in order to avoid the maintenance of all past versions of the protocol by Lisk Core. This re-genesis will allow nodes to synchronize from a new genesis checkpoint while only requiring compatibility with the latest protocol version.

Extract logic from Lisk Core to Lisk Elements with the code rewritten in TypeScript. In support of: Introduce decentralised re-genesis.

Add new commands to Lisk Commander for:
1) Performing blockchain snapshots and
2) Restoring blockchain snapshots.

Improve the current delegate scheduling process in the block generation rounds. Scheduling a delegate round will be done by hashing each delegate’s unique ID together with a unique ID for the round. Then, the delegates will be unequivocally ordered according to these hash values.
LIP draft on GitHub

Change the voting system in accordance with the Lisk values of accessibility, simplicity and decentralization. A simple voting system encourages a high participation of all stakeholders of the ecosystem. Moreover, this new voting system is expected to encourage decentralization and a healthy competition for active delegate slots.

Allow standby delegates to participate in the block forging depending on their delegate weight. This way there will be an incentive for standby delegates to also run Lisk nodes.

Add the possibility of punishing delegates for protocol violations such as forging multiple conflicting blocks in the same time slot or not forging for an extended period of time.

Extract logic from Lisk Core to Lisk Elements with the code rewritten in TypeScript. In support of:

1) Perform uniform ordering of delegates list
2) Change vote system
3) Incentivise standby delegates and
4) Punish delegates who double forge

Create a new application bootstrap element. This will allow the Lisk Core framework and existing elements to be initialised as skeleton applications.

Create a new genesis block element. In support of: Create genesis block from ICO proof.

Add new commands to Lisk Commander for: Bootstrapping new applications.

Add new commands to Lisk Commander for: Creating a genesis block for new applications.

Upon completion of the logic extraction from Lisk Core to Lisk Elements. Rewrite the remaining Lisk Core in TypeScript.

Add a transaction type to the Lisk protocol that will allow ICOs to be conducted on the Lisk mainchain.

Implement a mechanism that will create a genesis block derived from an ICO previously.

Implement a custom token system that will allow to registration and transfer of custom tokens on the Lisk main chain. It is yet to be decided if the permanent usage of custom tokens will be allowed, or only a temporary usage, e.g. until a genesis block based on an ICO is created.

Add new commands to Lisk Commander for: Creating ICO transactions for new applications.

Add new commands to Lisk Commander for:
1) Registering custom tokens and
2) transferring custom tokens.

Establish a bond between mainchain and sidechains in order to form an authenticated network of Lisk applications.

Implement a decentralized and trust-less way to transfer tokens between chains. Allowing the transfer of LSK between the Lisk mainchain and sidechains. If custom tokens are to be transferable is not decided yet.

Create a new sidechain element. In support of:
1) Establish bond between mainchain and sidechains and
2) Facilitate decentralised and trust-less token transfers.