Nuffle Fast Finality Layer - NFFL

Introduction

Rollups on the Ethereum network are gaining traction, indicating a new phase in the development of decentralized applications (dApps) and smart contracts. However, as the ecosystem continues to evolve towards a rollup-centric roadmap, it confronts new challenges such as state and liquidity fragmentation and extended finality time.

In order to solve this problem, the Nuffle Fast Finality Layer (NFFL, formerly SFFL) was designed. Through it, various chains can, while supplying block data to NEAR DA, rely on the economic security of an EigenLayer AVS to provide a faster block finality to various protocols and use-cases while also including an additional public DA layer into their stack.

This universal, secure and fast finality leads to major advancements in interoperability protocols, enabling or improving designs such as general bridging and chain abstraction.

For more details, refer to Protocol Design. NFFL is under active development and is not yet available on any publicly accessible environments.

Getting Started

Running step-by-step

Through the project's make scripts, you can set up each actor of the environment individually.

Dependencies

In order to set up the AVS environments, you'll first need to install golang, rust, and node. Make sure you're in a unix environment, as this is a pre-requisite for running the NEAR indexer.

Then, install foundry, go install zap-pretty and npm install near-cli v3. One way of doing so would be:

curl -L https://foundry.paradigm.xyz | bash
foundryup

go install github.com/maoueh/zap-pretty@latest
npm install -g near-cli@3.5.0

You'll also need to install RabbitMQ.

Steps

First, initialize RabbitMQ. It will be necessary for the operator execution. This can be a bit different depending on how it was installed.

Then, start what should be the mainnet (i.e. AVS) network, with both EL and the AVS contracts already deployed, and also the 'rollup' network:

make start-anvil-chain-with-el-and-avs-deployed

make start-rollup-anvil-chain-with-avs-deployed

Then, start the aggregator:

make start-aggregator

Then, start the indexer, which already executes a NEAR localnet, and set up a NEAR DA contract:

make start-indexer

make setup-near-da

Then, start the operator:

make start-operator

Lastly, start the relayer. For this, certain native dependencies are required which need to be built at least once:

make near-da-rpc-sys

Once the dependencies are built, start the relayer

make start-test-relayer

And that's it! You should be able to see each of the actors messaging each other as expected. You can edit some of the test parameters in the /config-files.

Running through Docker Compose

You can also more easily run a similar testing environment through Docker Compose, in which each service is executed in a separate container.

Dependencies

In order to build and run the containers, you'll need to install Docker, as well as ko.

You should also have make for the build script, or examine and run the same steps.

Steps

First, build the containers:

make docker-build-images

Then, run:

docker compose up

This will execute all services in the correct order and let you examine the individual logs. You'll also be able to access each container's services from the host through their image name, if necessary. The config files used for this test are also at /config-files, denominated with docker-compose.

To terminate all services, simply run:

docker compose down

More Details

For more details, refer to Protocol Design.

The AVS implementation was based on the Incredible Squaring AVS project, from EigenLayer.