Fluence JS v0.23.0 released!

This update gets one step closer to universal Marine runtime for browser peers on user devices. Now you can execute Wasm services on Fluence JS peers and bring computation to user devices for data privacy use cases and better decentralization.

This is made possible thanks to Marine-JS (milestone 2). The provided API allows hosting marine services on js peer and making them accessible from aqua code. This feature blurs the line between two types of peers and enables service reuse between them.

Please note that a little upgrade is required to switch to v0.23.0.
If you want to learn more - check out the documentation,
and the demo project.

Aqua 0.7.2 complements the recent Fluence JS update.

In addition to updated dependencies and a long list of bugfixes, the release provides new Aqua CLI capabilities, including better JSON data's type derivation for aqua run, array arguments support, and more.

See the full list of changes in the Changelog.

If you thought we took the summer off, think again. The core team's been super busy and has major updates across the stack. Get ready to rev your dependencies.

AquaVM updates

This release includes several major updates of AquaVM, which has achieved a major milestone and is now convergent. That is, AquaVM can merge traces from every possible AIR script. Convergence was achieved by introducing a new instruction canon and a new value type canonicalized stream. The former allows fixing a state of AquaVM's CRDT-like streams at the particular moment of execution on the specific peer producing a canonicalized stream that can be used like an ordinary AIR scalar value. For more info, see the explanation on GitHub.

Please note that the introduction of convergence prohibits using streams in certain positions of AIR instructions, such as a match or call arguments.

The second major improvement concerns the fold operator, whose signature has been extended to support an additional instruction executed on the last step of a recursive next call. This allows carefully adjusted behavior of fold with all combinators. And to make the old scheme with fold par work, the new instruction never has been introduced.

Finally, a lot of bugs have been fixed. See more updates in the change log.

Rust peer updates

Since the last announcements, we have had a lot of updates for Rust Peer.

The Rust peer is now available in three docker flavors: minimal, ipfs, and rich. See the repo for all the images.

- The minimal version provides the Rust Peer executable with builtins, and the curl binary
- The ipfs edition comes with all the features of minimal plus an IPFS daemon
- The rich version provides all the features of the ipfs edition plus Ceramic (Glaze) binaries, the Bitcoin CLI and the Geth CLI.

In addition

- Metrics were added for Wasm services and libp2p in Prometheus
- Logs for Loki were set up
- libp2p was migrated from forked to upstream
- json builtin was added

Fluence CLI updates

For the past months, there has been a lot of work put into Fluence CLI - a tool that makes it easier to work with Fluence Network. We tested the tool on our internal hackathon and found a lot of improvements that can be done, but generally decided that it's almost ready to be used by the developers.

It is designed to manage Fluence decentralized application lifecycle and assist developers. Currently, it can:

- Install all the required dependencies for working with Fluence Network
- Install aqua libraries and help Aqua VSCode plugin to find them
- Store and manage keypairs
- Store and provide ids of the deployed services to aqua and js/ts
- Create services and template modules
- Define deployment config and deploy
- Run and compile Aqua and Marine

The tool is actively developed, and we will soon roll out a lot of updates related to what we found out during the Hackathon (e.g., easier quick start workflow, etc.)

Currently, all the existing docs for Fluence CLI are available in the repo or when running --help with any of the Fluence CLI commands.

Fluence CLI configs are written in YAML format, and info about the configs is currently available only in comments inside of the configs themselves and in JSONSchemas that each config has (you can use redhat.vscode-yaml extension for autocomplete)

Aqua updates

Announcing Aqua 0.7.7

A language server was developed, and we introduced a VSCode extension to support Fluence’s Aqua language. Compile-on-save, compilation error hints, and go-to-definition features were added.

New features in Aqua CLI include:

- Running services directly from CLI
- Running builtin services without any input
- Testing your code with plugins for local js services (experimental!)

Additional advances have been realized in the Aqua compiler:

- AIR generation was updated to support the latest AquaVM version (0.31.0)
- Data structures are now not allowed to have fields of stream type

Also, there were a lot of bug fixes both in CLI and the compiler. See the list of updates.

Fluence JS updates

Fluence JS v0.27.0 was released and the following updates

- Implemented a new builtin json to work with JSON-like structures
- Added v4 version of compiler support making it possible to use any name for functions and data structures in Aqua without colliding with variable names in FluenceJS
- Renamed toB58String to getPeerId for fluence-keypair
- Updated libp2p to v0.36.2

Registry updates

We refactored Registry’s Resources API by removing ambiguous names to make it a bit easier for developer use and to reduce API size. Also, we add the ability to remove service records.
For further details, check out our last community call, README, and API reference, and try Registry and Fluence CLI with a new step-by-step example.

Fluence network updates

We have added end-to-end tests for every build of AquaVM, Marine, Fluence JS, Aqua, Rust Peer, and builtin services, so it will be easier to develop and test every commit. For example, an AquaVM update triggers a rebuild of the whole stack and executes tests in aqua-playground and Registry.

Finally, we have migrated our documentation from Gitbook to Docusaurus.

Also, you can read about our latest updates in this article. Stay tuned!

Hello, Fluencers!

We're about to roll a breaking update to Kras environment.

This release is a step towards native fault tolerant deployments managed from the chain. It brings better performance and introduces Spells: the new feature implementing stateful recurring computations. Spells are services that can be scheduled similarly to cron-jobs and maintain state between executions. Spells are essential to deliver consistent application-specific Subnets (we explain our vision regarding Subnets here https://medium.com/fluence-network/fluence-2022-update-a8a5b0b25f48)

Also the update changes particle data format: now all service call results have a corresponding CID, making the execution content-addressable! It enables better compatibility with content-addressable storage (such as IPFS, Filecoin) and composition with other compute protocols that support CID.

If you use Kras environment, you should update your tools. Here's a list of compatible versions of our tooling and links to changelogs:

rust-peer = 0.0.77 https://github.com/fluencelabs/rust-peer-distro/releases/tag/distro-v0.0.77
aqua = 0.9.4 https://github.com/fluencelabs/aqua/releases/tag/aqua-v0.9.4
fluence-cli = 0.2.37 https://github.com/fluencelabs/fluence-cli/releases/tag/fluence-cli-v0.2.37
fluence-js = 0.28.0 https://github.com/fluencelabs/fluence-js/releases/tag/v0.28.0
marine = 0.12.6 https://github.com/fluencelabs/marine/releases/tag/marine-v0.12.6
mrepl = 0.19.0 https://github.com/fluencelabs/marine/releases/tag/mrepl-v0.19.0

Kindly note that our tooling is compatible with node.js 16.x, and will not work on node.js 18.x.

Computing Marketplace on Testnet

We are excited to announce the launch of Computing Marketplace and fault tolerant deployments on our private testnet. If you are using the latest Fluence CLI, your deployments are rolled out to ad-hoc subnetworks formed from marketplace nodes. You can edit and configure Aqua to manage subnetworks operating workflows and implement failover, load balancing, consensus or other algorithms you need for your app backend.

The testnet is private: community nodes are not yet participating in the marketplace. As we move towards delivery of verifiable proofs of compute, the testnet will be open for any compute providers.

Deployments now require testnet payment to nodes. Get started here to receive testnet tokens from faucet, test it out and provide feedback!

💬 Major Network Update

Hey Fluencers,

A huge update has been rolled out to the Kras network, that includes all the latest features we’re been working on throughout the year. The protocol became more secure, performant, and closer to feature completeness. See about updates below and join the upcoming community call to learn about progress and the roadmap.

Subnets

We are introducing updated subnets: replicated deployments for your applications. Subnets allow to add qualities like fault tolerance, consensus or load balancing to your functions.

Every time you deploy an application to the Fluence network, you are defining a subnet configuration (amount of peers, acceptable pricing, etc) and have your code deployed to specified amount of peers. Subnet peers follow the coordination code that you write in Aqua, which could implement failovers, consensus or quorum algos, load balancing across peers, and any other distributed workflow.

Subnets are tied to on-chain marketplace deals, where all the participating peers and subnet configuration are managed. You can check out deployment quickstart to get some practical knowledge about deploying to subnets.

Fluence Peer (Nox)

We’ve done a significant revamp of the rust-peer, that is now called Nox. We also added arm64/aarch64 support to it, so devs could reliably run development environments on Arm based machines (M-series macs & alike). It is now comes with a set of monitoring and healthcheck http endpoints, so it could be properly run in production grade environments.

Additionally, we’ve introduced the ability to run your own private compute provider or local development environment in order to prepare to join the Fluence Mainnet network and earn by providing their CPU compute capacity after the Mainnet launch.

Please note that we are going remove all the services from Kras environment that were deployed before, so you’ll have to redeploy ’em if you wanna keep using ’em.

Developer Features

- Aqua
- We’ve Added Aqua tracing - we introduce fluence aqua --tracing compiler flag to Fluence CLI, that would augment AIR produced from Aqua with tracing logs that is integrated.
Logs will be inserted on each Aqua function enter and exit. Logs will be sent back to original producer of particle. Be sure to check our aqua changelog
- AIR beautifier tool was included into fluence air commandlet of Fluence CLI that helps to explore compiled air scripts in a human-readable format
- Abilities in Aqua - a way to organise code in modules and implement inversion of control pattern in Aqua.
- Lots of small quality of life improvements
- Marine and MarineJS. Introduced multi-module feature to MarineJS. Now Marine JS re-uses the same code as Rust Marine implementation, only giving it a Wasm VM interface for accessing it via browser.
- Fluence CLI
- Moved our CLI tooling to Node 18.
- CLI automagically checks for updates
- Projects that are scaffolded with Fluence CLI now have detailed annotations in configuration files

Core Protocol

- Aqua VM
- CRDT maps. We added two new key values types: mutable maps and canonicalized immutable maps. They are intended to improve structures handling as well as provide high-level map-like primitives to the Aqua language.
- Particle Signatures (proof carrying data for Proof of Execution) - we are driving Fluence towards the fully trustless computation model, where every code execution will be provided with an verifiable and auditable proof that this computation was done correctly. Computation proofs are distinct for Aqua and for Marine: by introducing Particle signatures, we’re advancing the implementation for Proof of Processing in Aqua and are in the research stages for Proof of Execution for Marine.
The particle signatures mechanism is a cornerstone of all security guarantees which Aqua/AIR brings. One of the main guarantees is that if a peer-in-the-middle changes a particle content, e.g. results of services execution, then it will be eventually revealed by other peers. This introduces mechanisms of both signatures generation and checking and is the essential building block of the computation verifiability.

Build with Fluence

🗓️ Join us at the upcoming community call on Oct 5th, 5pm UTC to walk through all the exciting updates and watch presentations from the teams buildings on Fluence. Sign up here.

Stay updated by following Fluence on Twitter, Telegram, or Blog.

Hello developers, here’s an update from our CTO which we'll be sharing regularly from now on.

These weeks our main focus is preparing Fluence Network for launch. Big time. We are running Fluence’s DAR testnet together with our launch partners to make sure everything works well, making last tuning to various components:

- Fluence’s IPC blockchain,
- Compute Marketplace smart contracts,
- Capacity Commitments Prover that ensures availability of Compute Units on Fluence peers,
- Fluence CLI, especially the Provider flow,
- Managed Effects – security of effects for Nox
- Nox’s resources isolation for Workers
- Effectors: Wasm modules for Developers to access managed effects, namely IPFS and curl
- Aqua patterns to simplify development of Cloudless functions

Effectors are now being collected here: https://github.com/fluencelabs/effectors – better documentation will appear in the following weeks.

Aqua framework is being developed there: https://github.com/fluencelabs/aquaduct – not yet packaged for reuse, but you can learn some patterns from the PR.

To play with effectors and aquaduct, you may use stable Fluence CLI (install Fluence CLI, then do fluence update stable`) with `fluence local up. Deployment on DAR should also work. Please reach out to us on Discord or Telegram if you have any issues.

We will switch focus towards improving developer experience once Fluence Network is up and running.

Hello Fluencers, here's another update from our CTO Dmitry.

Read on, and join us later today in the Twitter Space with Fluence network capacity providers, starting at 3PM UTC https://twitter.com/i/spaces/1ypKdkrVwbyxW?s=20

***

Over the past few weeks, we have been focusing on the launch of the Fluence Mainnet, codenamed Kras. This milestone was successfully reached on March 20. Congratulations to the entire Fluence community!

From a technical standpoint, the Fluence Mainnet includes:

- Ethereum smart contracts (deployed a few weeks prior)
- Filecoin smart contracts
- The Axelar bridge between Ethereum and Filecoin
- The Fluence IPC Blockchain, anchored to Filecoin
- The Compute Marketplace and Capacity Commitments smart contracts on the Fluence blockchain
- A block explorer and network explorer
- Noxes, which are Fluence offchain peers
- Compute Capacity Proovers, which are companions to every Nox to prove available compute capacity
- The Fluence CLI and other tools
- And numerous other small components

I want to thank the entire Fluence team for their hard work in bringing all these moving parts together. It was an incredible effort with a fantastic result.

Now that the network is live, we are being cautious about adding compute capacity to it. Currently, only a limited number of compute providers and peers are available.

In the coming weeks, our main focus will be ensuring everything operates smoothly, fixing any bugs that may arise, and gradually increasing the network's compute capacity.

You can find resources for the Fluence Kras mainnet at https://kras.fluence.dev

The public Fluence testnet, codenamed Dar, is available at https://dar.fluence.dev

The successful launch of the Fluence mainnet would not have been possible without our launch partners, the first Fluence compute providers.

Later today at 3PM UTC, we are hosting a Twitter Space to meet the hidden heroes of the DePIN, Fluence compute providers. Join us if you're interested!

https://twitter.com/i/spaces/1ypKdkrVwbyxW?s=20

Fluence CTO Update

Hello Fluencers

The Fluence mainnet has been live for the past couple of weeks, and we've been absolutely focused on improving stability and preparing to scale the network.

It included many updates in all the main components, mostly the ones the developers almost do not see - but providers do.

See the fresh releases:

- nox 0.24.0
- Fluence CLI 0.16.3
- Capacity Commitments Prover (CCP) 0.10.0
- Explorer: https://explorer.fluence.dev for Kras, https://explorer.dar.fluence.dev for Dar

You can find a lot of fixes and changes in the respective release notes.

Stay tuned for more updates next week!

Don’t forget about our DePIN Evening taking place in Austin today, and tune into the livestream on our YouTube channel.