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.