Libra's detailed roadmap is open: developers focus on the Libra main online line

Lead: For Roadmap 1, the team is focused on safety and reliability and is committed to integrating other partners into the upcoming Libra main network.

Since the official release of the Libra project in June, the response of the developer community has been very enthusiastic. Developers have released several blockchain exploration projects (libranaut, libraview, librabrowser and libexplorer) and integrated the Libra test network into their own wallet (ZenGo, including Libra Core) project. There are also other blockchain projects that integrate Move into their systems (Solana). Calibra will continue to develop Libra Core on GitHub.

The team also released two new development guides: a guide to running the Move app locally and a guide to how to run your own network. The topic of trading scripts on Libra's forum is very active, and developers' interest in client development and Libra development continues to increase. Stable technical iterations and open and transparent decision-making are key to developers' growing interest in the project.

More than Testnet

After launching the Testnet project, the team can easily troubleshoot, diagnose, and resolve software edge issues to quickly improve Libra Core. Testnets can be used to demonstrate Libra networking capabilities and provide access testing for developers.

Following Testnet, we hope to further launch the Libra Mainnet . Through Mainnet we can track how many deployed nodes in a successful project are managed by a partner. The ultimate goal of Mainnet is to have all partners deploy nodes on the network. Each node can run on infrastructure such as local clusters and cloud hosts. We believe that the diversity of infrastructure will provide greater flexibility for Libra networks.

GitHub update

To help users better track development progress, we added a kanban (visual task board) that includes all major project progress.

The progress of this roadmap can be tracked at https://github.com/orgs/libra/projects/1.

Like many open source projects, developers must contribute in accordance with the signed Contributor License Agreement (CLA). We are discussing some scenarios to simplify the existing manual CLA approval process.

The current development process enforces high-level code quality checks. The team manages with the homu tool. Homu is an open source robot that works with our Continuous Integration/Continuous Deployment (CI / CD) system to ensure that testing passes. Our homu robots will continuously verify that the tests have passed after the PR versions and after other PR merges. The user can see the commands and tag marks sent on the PR indicating that the robot is performing work. Using robots to manage code merging is a common practice in large projects, and only then can the test be "green." This adds a layer of security to the project, and by performing branch protection, changes to the protected branch can only be performed by the robot.

The engineering team has begun publishing its design notes in the GitHub problem sheet. If you're looking for ways to participate, or want to track specific features and provide feedback, you can focus on the GitHub Question Table page.

We are working hard to provide a clearer, more diverse approach to help you stay involved in the long term. We hope to provide guidance and an understanding of the upcoming Libra Core features by publishing a product's roadmap, synchronizing high-priority development states, and sharing design notes.

Sprint-based development

Since the start of the project, the team has used a 60-day sprint time to help guide the planning and development of Libra Core. Each sprint phase has a set of prioritized functional plans. For Roadmap 1, the team is focused on security and reliability and is committed to integrating other partners into the upcoming Libra Mainnet.

The goal of Libra Core in Roadmap 1 is to focus on security and reliability and integrate our first partner into the pre-Mainnet of the Libra network.

Road map 1

Current progress

We will continue to work on the design of all priority features. We have made good progress in implementing functions such as "full node." We are working hard to define a node reconfiguration specification that will take effect before the final definition of the Libra protocol is finalized.

Libra Core

Addressing / Interoperability

  • Interoperability between multiple wallets is key to the success of the Libra network. The team is working on a simple solution to support sending/sending mail to sub-accounts.

Full node

  • The Libra blockchain will consist of a single node type that can be configured differently. This requires the node to be allowed to act as a verifier or non-authentic node (full node) that stores the full history. We will also try to make it easier to upgrade the entire node to the verifier and vice versa.

Libra's protocol definition

  • The team is working hard to define APIs, message standards, addressing/interoperability, and other protocol dependencies.

Authenticator reconfiguration

  • The validator set contains a unique identifier for the active validator in the system. As time passes, the validator set needs to support changes. From the perspective of the blockchain system, changing the set of validators affects each component. The block needs to be revalidated, the network needs to be reconfigured, the storage needs to persist LedgerInfo, and the client needs a way to verify the read data between the validator changes.

Waypoint

  • Waypoint will provide customers with an external source of information about blockchain history.

TCB (Trusted Computing Library)

  • The Trusted Computing Library (TCB) defines a subset of components that are critical to system security and stability. Minimize hardware and software dependencies for critical components to help avoid accidental errors and malicious attacks.

Serialization

  • The team is looking to implement deterministic serialization to share RawTransactions between verifier nodes. To see more discussion on this topic, see https://github.com/libra/libra/issues/454.
    Move
  • Memorabilia
    • Explored the design used to represent events in Move.
    • A stable event API for developers.
    • Provides an example of how developers can record events that occur on the chain.
  • Collection / generic
    • Implement the vector and explore other supported collection types.
  • #597 Functional landing, it cancels the management of the verification assembly. There is additional work in the verification program to support this operation, and this is part of the accuracy guarantee.
    Libra Pre-Mainnet

As the project moves toward the Mainnet milestone, we need to bring more nodes online while keeping testnet running. To help with this, we created a caching environment called Pre-Mainnet. Currently, only partner nodes can access Pre-Mainnet to allow them to connect to each other. A few partners have deployed nodes and started communicating with each other. We hope that more partners will be online soon. We also ensure that the Libra network meets stringent performance standards and overall operational stability before opening all access rights.

Author: Libra Association

Translation: Xiao Dafei

Source: Blockchain Outpost (Public Number)