Summary
Here are some of the main things to highlight since the last dev update:
- We have built a testnet automation tool that will fully automate the creation of droplets, deployment of vaults and introduction of churn on the network.
- Work has continued on design and implementation of a prototype to demonstrate the feasibility of using the crdt-tree datatype as the basis for a locally mountable filesystem (via FUSE).
- Community member @happybeing forked the Rust polyfuse project and created a FUSE wrapper that can serve as a starting point for calling into our Rust filesystem code when it is ready.
Thanks to @Sascha for providing this week’s cover photo!
Vaults Phase 2
Over the past week, we have built a testnet automation tool that will fully automate the creation of droplets, deployment of vaults and introduction of churn on the network. We will be using this tool for testing any new features that we implement in vaults before community testnets.
The next step in vaults will be to handle data operations on section splits and handling of message routing across multiple sections. With a significant amount of work being done on farming already, we are syncing up with the features already implemented and basing all work on top of the farming branch. We are debugging some issues seen during integration, with those resolved these features will be underway.
CRDT
safe-fs
Work has continued on design and implementation of a prototype to demonstrate the feasibility of using the crdt-tree datatype as the basis for a locally mountable filesystem (via FUSE).
A particular design challenge centered around how to support hard-links, a key feature of Unix filesystems which allow multiple filenames to reference a single file inode (metadata and content). A solution was proposed here.
We then discovered that the ino (u64) do not need to persist between mounts, so they can be kept in a local data structure outside the (shared) crdt-tree.
With such issues worked through, an experimental (quick/dirty) prototype filesystem class was built that implements the main features of a filesystem, and thus demonstrates that the design works in practice.
Community member @happybeing forked the Rust polyfuse project and created a FUSE wrapper that can serve as a starting point for calling into our Rust filesystem code when it is ready.
Going forward, our next high-level goal is to create a locally mountable filesystem using the crdt-tree for storage. This will be a single replica without any networking or policy code. With this in place, we can actually mount the filesystem and then run benchmarking tests, identify any problem areas, and hopefully demonstrate that design and performance is adequate to justify further development. The nice thing is that the CRDT properties mean that once networked together, the replicas will always converge without conflict.
Reaching this goal will entail implementing both the crdt-tree and filesystem API in Rust, then integrating with the FUSE wrapper.
Farming
SAFE Transfers Project plan
SAFE Client Libs Project plan
SAFE Vault Project plan
SAFE Client Libs and Vault integration
We’ve been steadily progressing the integration here with the latest farming changes and tweaks. We’ve updated both vaults and SCL with the latest changes from master branches, which introduced some issues as we moved to the new XorName crate. But we tracked that down and after another wee to do with AT2 transaction history retrieval for clients, we have an almost complete message flow between the two.
Right now we’re looking into some issues client-side, where the client hangs while waiting for TransferValidation responses. It looks like this is related to our use of quic-p2p, which is slightly outdated in Rust terms, so we’ve also been upgrading this lib to be fully async, which should hopefully unblock us in the client, and also simplify some of the safe_core code significantly.
Store cost and Rewards
We have so far investigated a farming algo with adaptive store cost, essentially based on network size and amount of money in circulation, and a rate at which network owned money is transferred to farmers, a rate that was steadily declining until all network money had been transferred.
For the first testnets with farming, we’re going to use a much simpler approach, where there is a simple static store cost (1 byte = 1 nanosafecoin), and a simple age-based reward, paid out at every relocation (2^age safecoins).
The work now continues with ironing out the initial few moments of a network, and the solidity of the distributed AT2 actor, also known as the section funds.
Routing
First of all this update will be to celebrate the good news that Adam managed to spare some time (usually a half-day) every day to get back to work. Welcome back to the team, Adam! (he even apparently got some sleep)
So with Adam back, we are first reviewing the work during his leave. There are a couple of improvements spotted, and we have merged the work of only send promotion to correct new elders, sending DKG message to the participants directly, and Remove Genesis event handling. And the on-going work of remove bounced_unknown_messages cache
shall be merged soon.
We also started investigating the last remaining feature refactoring work (Remove relocate_queue and make relocation independent on the order of churn events) before moving forward to PARSEC removal. There was a fruitful debate on the potential approach on relocation and we got that documented and updated.
Useful Links
Feel free to reply below with links to translations of this dev update and moderators will add them here:
As an open source project, we’re always looking for feedback, comments and community contributions - so don’t be shy, join in and let’s create the SAFE Network together!
an now to read it
really so super exited for the next testnet… 
