Search the Community
Showing results for tags 'hooks'.
With the Evernode Foundation announcing the start of their public beta test phase, they're inviting every interested individual to participate in the beta test and run a server on their test platform, with zero additional cost to participate. The Foundation's official announcement: https://twitter.com/EvernodeXRPL/status/1540901839570620417 Each participant must have their own server and a registered GitHub account to be apart of the beta test, the GitHub account will be used to join the Foundation's private repository which contains the installation link and the necessary info/updates on the public beta test phase. Participants will send out their GitHub username to the team (via Twitter) and the team will then invite you to their private repository via GitHub entirely. No participation fee is needed, test EVRs will be provided via their test faucet to register on their test platform (test EVRs have no absolute value!). Best of luck to everyone. Here we are, reaching a small yet important milestone for the project. The Foundation's twitter account: https://twitter.com/evernodexrpl The Foundation's GitHub organization: https://github.com/HotPocketDev The Foundation's Website: https://evernode.wordpress.com/
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: 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: 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
The Hooks amendment, if approved, will provide smart contract capabilities to the XRP Ledger by allowing pieces of code to execute logic before and/or after transactions, controlling their flow and behavior. Hooks are powerful if used and developed properly combined with the XRPL's features, Evernode is offering a unique flexible solution to smart contract developers. Evernode allows complex business ideas and smart contracts like Chainlink, NuCypher and Storj to be deployed and hosted by leveraging the flexibility of its off-chain solution. The off-chain solution allows developers to be more flexible with their smart contract as the underlying network itself is dedicated to serve its kind. Evernode is very flexible compared to Hooks, Hooks can only execute logic on the XRPL because the XRPL's validators are not oracle providers or storage nodes but HotPocket nodes can be. A Hook is a layer 1 smart contract because the XRP Ledger is the underlying protocol 'hosting' it; it's decentralized and secure but not flexible. A Hook can perform mathematics, store small bits of data, and execute logic but can't go beyond a certain limit as the XRP Ledger's validators' main purpose is to validate transactions. XRPL validators are not designed to store massive amounts of data, perform complex computation, or access off-chain data on behalf of smart contracts. Evernode utilizes Hooks as a way to connect all the participating parties together on-chain. A HotPocket smart contract can store massive amounts of data, perform complex computations, act as an oracle solution, or even act as a decentralized bridge between payment networks (xrpl<->eth). A Hook is very powerful combined with the XRP Ledger's features and Evernode is very flexible as developers have a plethora of options when configuring their smart contract's cluster. This means that developers will be able to select nodes fit for their purpose, selecting from options including: - large storage space - high RAM - large computational resources (CPU) - reliability and trustworthiness (consensus agreement and decentralization) - nodes owned by the developer (centralized solution) HotPocket smart contract developers have a choice to configure how many nodes are constitute of their smart contract's cluster, which nodes belong to their cluster and, whether the cluster is permissioned or permissionless to best fit their smart contract and its intended use case. With layer 1 smart contracts or Hooks, this is not possible as the underlying network (XRPL) is in charge of custody. Developers wishing to create smart contracts directly on the XRPL must work within the bounds of the native protocol which was not created with customizability in mind, whereas Evernode is being created to extend the usefulness of the XRPL by enabling developers to create and deploy any smart contract that they can think of on a flexible layer 2 solution. HotPocket smart contracts can be written in any POSIX compliant programming language, whereas Hooks can only be written in any language compilable to WebAssembly.