Introduction to Evernode

[wojake]

Evernode
Evernode is a layer 2 smart contract solution composed from the XRP Ledger. Evernode is a smart contract hosting platform consisting of off-chain nodes that directly run pieces of code, consensus and maintain a distributed, canonical state to provide flexible layer 2 smart contracts to the XRP Ledger.

Introduction

To achieve layer 2 smart contracts, Evernode combines multiple technologies together to form an off-chain solution that runs in parallel with the XRP Ledger. By operating as an off-chain solution, Evernode is able to have its own platform of nodes dedicated to operate and maintain smart contracts in a permissionless, flexible and scalable manner. This way, Evernode allows more flexible and advanced applications to be built on the platform rather than using lite smart contracts (Hooks) that can only facilitate a limited amount of capabilities within the bounds of the XRPL's native protocol, which was not created with customizability and flexibility in mind.

A node on a smart contract cluster is called a HotPocket node, it is a secured container in an Evernode Host which is autonomously managed by a daemon called Sashimono. The daemon has multiple responsibilities such as managing all incoming hosting requests (redeems) and provisioning smart contract instances in secured containers. HotPocket nodes are independent from the XRP Ledger, they're not a part of the XRP Ledger.

Diagram 1: An Evernode Host's high level structure (simplified)
 

The Evernode ecosystem consists of 4 parts to fully operate seamlessly:
1. Evernode Hook
2. HotPocket
3. Sashimono
4. The XRP Ledger's native DEX

We'll divide these complicated components into different sections and explain it to you in this post based on our own understanding.

Evernode's components

1. Evernode Hook

The Evernode Hook is one of the most essential parts of Evernode. With Hooks enabled on the XRPL mainnet, Evernode is able to establish an on-chain platform to connect all the participating parties, maintain a governance platform (DAO), and efficiently control the issuance and distribution of Evers to reliable hosts through audits.

The Evernode Hook has multiple responsibilities that are crucial to the ecosystem:

- controlling the issuance and distribution of Evers
- verifying node membership in Evernode
- tracking node performance through audits
- governing the servicing of smart contract Hosting Requests submitted by L1 Evernode users
- maintaining Evernode's configuration parameters

All participating parties on Evernode use XRPL transactions with attached memos to incorporate Evernode operation payloads:
- Evernode Hosts: host registration/deregistration
- Auditors: audit request/results
- Evernode users: redeem request/results

Utilizing memos allows participating parties to transmit data on the XRPL between each other. For instance, an Evernode Host will create an XRPL account and register to Evernode through the Hook, it'll look something like this:

Quote

From: Evernode Host's XRPL account
To: Evernode Hook
Evernode Host's registration memo: EvnHostReg: (Hosting Token Code);(Country Code);(CPU_micro_sec);(RAM_mb);(Disk_mb);Auto host

The Evernode Hook defines a set of tunable configuration parameters to govern the rules of the system, which can be changed in a permissionless manner via a governance vote on the XRPL. The following parameters are tunable via the governance system:

- max supply of Evers
- number of Evers rewarded per Moment
- number of ledgers per Moment
- host registration fee
- max number of ledgers within which a redeem request has to be serviced
- number of maximum hosts that can be audited by an Auditor per Moment
- and much more...

2. HotPocket

HotPocket is a UNL-based consensus engine. It manages all consensus related matters in a smart contract cluster with other nodes to maintain a distributed, canonical state of a smart contract. HotPocket allows smart contracts to operate within their own independent cluster with its own chain history and with its own set of nodes. This results in smart contracts being flexible as clusters may be configured to consist of a specific type of node to best fit their smart contract and its intended use case.

Diagram 2: Evernode Hosts that are hosting the same 3 smart contract instances

Each smart contract cluster operates independently and does not interfere with other clusters.

3. Sashimono

HotPocket converts any number of nodes into a smart contract cluster. The rollout of a HotPocket smart contract currently requires manual setup of a smart contract instance in each participating host, which presents scaling issues. From a production standpoint, it's preferable to dedicate a selection of servers for the collective purpose of running logical nodes from various different HotPocket contracts from time to time, and then coordinate these from a unified and decentralized command point.

Without Sashimono, HotPocket is a centralized smart contract solution. Generally, a single actor would be required to spin-up and configure the relevant nodes in a smart contract cluster. Sashimono is the daemon that allows smart contract clusters to be spun up in a permissionless and scalable manner without needing to manually setup a smart contract instance in every participating node.

4. The XRPL's DEX

The XRPL’s native decentralized exchange (DEX) plays a central role in how users and Evernode Hosts interact with one another, enabling the exchange of hosting services for units of value. Since each Evernode Host will offer its own unique set of performance characteristics fit for various use-cases, there needs to be a way for the market to distinguish the value of services offered by each Host. Evernode facilitates the differentiation of services each Host provides in a novel way through the use of Hosting Tokens, the value of which is determined by the free market on the XRPL DEX.

Hosting Tokens are non-divisible tokens minted by Evernode Hosts which can be redeemed in exchange for the services offered by the Host that minted them. The following steps are a high level summary of the flow and lifecycle of Hosting Tokens within the Evernode ecosystem:
1.    Hosts mint Hosting Tokens and list them on the XRPL DEX
2.    Users exchange $EVRs for Hosting Tokens
3.    User sends Hosting Tokens with memo describing instance requirements to the Hook
4.    Upon observing the user’s transaction to the Hook, the Host then sends a small XRP transaction to the Hook containing details of the created instance in the memo field
5.    The Hook sends the user’s Hosting Tokens to the Host, where the requested computational services are rendered (additional resources can be paid for in Evers)

The DEX's Quality Control

One important benefit of the DEX is its inherent capacity to police the quality of the nodes via the law of supply and demand. The best signal of a node’s quality and trustworthiness is the natural price discovery of its Hosting Tokens on the DEX. Unreliable nodes should quickly be exposed and their tokens shunned or under-priced relative to their peers' tokens. In this way, the DEX provides an important circuit-breaker function, allowing unreliable or poor quality nodes to be easily auto-identified by dApps and dApp developers.

------------------

Credits

Wo Jake - Author
effofexx - Reviewer

Note:

Quote

I'm trying my best to explain Evernode at a high level description, I might be wrong as I'm doing my own due-diligence and my own research. If I got anything wrong, please notify me and I'll happily re-edit the post. Thank you!

Learn more about Evernode:

- Hooks vs Evernode

Links and resources:

- Evernode Documentation
- Evernode Whitepaper v1.0
- Evernode Hook codebase
- Evernode Community (Reddit)
- Evernode Media (Twitter)
- Sashimono's Design

Edited February 16, 2022 by wojake