load.network
  • Load Network
  • Quickstart
  • About Load Network
    • Overview
    • Network Releases Nomenclature
    • Load Network Alphanets
    • Key Features
    • ELI5
  • Using Load Network
    • Compatibility & Performance
    • Network configurations
    • Load Network Bundler
    • 0xbabe2: Large Data Uploads
    • Load Network Bundler Gateways
    • Load Network Precompiles
    • LN-Native JSON-RPC Methods
    • load:// Data Protocol
    • Self-Hosted RPC Proxies
      • Rust Proxy
      • JavaScript Proxy
    • Code & Integrations Examples
      • ethers (etherjs)
      • Deploying an ERC20 Token
  • Load Network Cloud Platform
    • Cloud Platform (LNCP)
    • Load S3 Protocol
    • load0 data layer
  • Load Network for evm chains
    • Ledger Archiver (any chain)
    • Ledger Archivers: State Reconstruction
    • DA ExEx (Reth-only)
    • Deploying OP-Stack Rollups
  • Load Network ExEx
    • About ExExes
    • ExEx.rs
    • Load Network ExExes
      • Google BigQuery ETL
      • Borsh Serializer
      • Arweave Data Uploader
      • Load Network DA ExEx
      • Load Network WeaveDrive ExEx
  • Load Network Arweave Data Protocols
    • LN-ExEx Data Protocol
    • Load Network Precompiles Data Protocol
  • DA Integrations
    • LN-EigenDA Proxy Server
    • LN-Dymension: DA client for RollAP
  • load hyperbeam
    • About Load HyperBEAM
Powered by GitBook
On this page
  • About HyperBEAM
  • load_hb: Load Network HyperBEAM node with custom devices
Export as PDF
  1. load hyperbeam

About Load HyperBEAM

Load Network custom HyperBEAM devices

PreviousLN-Dymension: DA client for RollAP

Last updated 7 days ago

About HyperBEAM

HyperBeam is a client implementation of the AO-Core protocol, written in Erlang. It can be seen as the 'node' software for the decentralized operating system that AO enables; abstracting hardware provisioning and details from the execution of individual programs.

HyperBEAM node operators can offer the services of their machine to others inside the network by electing to execute any number of different devices, charging users for their computation as necessary.

Each HyperBEAM node is configured using the ~meta@1.0 device, which provides an interface for specifying the node's hardware, supported devices, metering and payments information, amongst other configuration options. For more details, check out the HyperBEAM codebase:

load_hb: Load Network HyperBEAM node with custom devices

EVM Device

Starting with the current and defacto ethereum’s virtual machine (EVM), we have created a hyperbeam device that port Revm (Rust implementation of the Ethereum Virtual Machine) as a NIF (Native Implemented Function) in the hyperbeam codebase.

The evm device is designed to take an EVM appchain configuration (gas limit, chain id, chain name) , interpret a given signed raw transaction (Create or Call transaction kind), and update the appchain’s state given the results from the state transitions.

Therefore, this evm device not just offers EVM execution, but also statefulness of a given context. As an implementation example, we have deployed an appchain with a deployed Uniswap V2, another with layer, and a basic appchain with basic Ethereum functionalities.

For example, with the Uniswap V2 appchain we deployed a wrapped native gas token, multicall33 contract, uniswap factory contract, router contract, and tested the contracts stack. With zama’s fhevm, we deployed all of the zama L2 smart contracts: proxy contract, ACL, fhevm executor, KMS verifier, fhevm gaslimit, inputverifier, decryption oracle, we initialied all of the contracts then deployed and minted EncryptedERC20 token. Check the full set of tests

EVM device source code:

RISC-V Device

we have developed a custom fork of (an Ethereum Execution Environment that seamlessly integrates RISCV smart contracts alongside traditional EVM smart contracts) to input and return the resulted computed EVM db.

After getting R55 to work with the OOTB interpretation of signed raw transaction, we built on top of it a hyperbeam device offering RISC-V compatible Ethereum appchains. For example, this erc20.rs Rust smart contract was deployed on a hb risc-v appchain:

RISC-V custom device source code:

https://github.com/permaweb/HyperBEAM
zama fhevm smart contracts
here
https://github.com/loadnetwork/load_hb/tree/main/native/load_revm_nif
R55
handle signed raw transaction
github.com/loadnetwork/r55
https://github.com/loadnetwork/load_hb/tree/main/native/riscv_em_nif