# Introduction ## What is Lumio? Lumio is a rollup technology suite that enables developers to build with any VM on any chain. With Lumio rollups, developers can deploy applications with SVM, Move VM, and parallelized EVM that settle to Solana, Ethereum and other L1s. This allows applications to use native L1 assets like ETH and SOL with minimized trust assumptions secured by zk and fraud proofs. Lumio currently supports: Solana VM, EVM, and Aptos Move VM. With VM equivalences, Lumio enables 100% compatibility, enabling app migrations that don't require code changes. Lumio will be integrated into the shared sequencer of popular L2s on Ethereum such as Optimism to enable shared security, composability and liquidity within those ecosystems. On L1s with no L2 ecosystems such as Solana, Lumio will be deployed as its own L2. Together, these separate instances of Lumio will be called the Lumio Chain Collective.
## Lumio Chain Collective Lumio will deploy a collective of Lumio rollup chains across various ecosystems starting with Solana and Ethereum. This is currently represented by several L2 testnet/devnet networks, as well as a canary network on the mainnet. Before diving into development, it's important to understand the [differences between them](https://docs.lumio.io/start-building). Each network represents separate instances of Lumio. Each instance will have the name of the network where it will be deployed, for example 'Lumio on Optimism' and 'Lumio on Solana'. ## Perfomance The VMs are optimized for peak performance and flexibility, allowing devs to reuse their code across chains. > Achieve up to 3k TPS with <100 ms latency, scalable to a maximum of 10k TPS with the potential to expand to 30k TPS. Read our research on the successful modifications we've implemented in the Move VM, which can also be applied to other virtual machines like the Solana VM (SVM). {% file src="/files/MVqBGvGegdgEHfvDzgWf" %} ## Sequencer The sequencer works like an orchestration node which makes it possible for the altVMs to function correctly, in the same time being connected to the L1 network and processing deposit transactions, state roots, cross VM calls, and finalizing state. ## Data Availability Lumio uses EigenDA or the L1 itself for hard finalization, with replication of community nodes for soft finalization. The rationale is that high TPS may introduce delays in transaction finalization, so employing soft commitments can expedite the process. This approach will enable the community to leverage their replication nodes and stakes to enhance the data availability of the network. ## Cross-VM Calls The Lumio framework facilitates calls between different Virtual Machines (VMs). This is achieved through specialized smart contracts/modules, which are integral parts of the framework (Move VM, Solana) and pre-deployed smart contracts (EVM). ## Proofs Lumio v2 supports a wide range of optimistic and zk fault proofs. We have successfully compiled Move VM into Optimism Cannon MIPS to enable the execution of optimistic proofs. Plans are underway to integrate either Arbitrum Stylus or risc0, depending on the VM and performance requirements. # Sequencer The main difference between the OP sequencer and the Lumio sequencer is as follows: * The Lumio sequencer supports multiple execution layers, or VMs. * Unlike traditional sequencers that solve when generating a block, the Lumio sequencer executes transactions as soon as they are submitted to an execution layer for optimal performance. * This approach prevents the sequencer from becoming a bottleneck in orchestrating all the VMs, as they all operate in parallel independently. However, the Lumio sequencer still commits deposit transactions, provides transaction confirmations, works closely with the batcher and proposer, and organizes cross-VM calls. ## VMs The supported virtual machines include Solana VM, Aptos Move VM, and EVM. Each VM operates as a module that can be connected to the sequencer without necessitating hard forks.During our optimization of the Move VM, we eliminated various elements such as P2P, blocks, and consensus, and optimized the mempool, among other improvements. We believe that additional optimizations and parallel processing for other virtual machines like EVM and Solana will achieve higher performance, with the goal of pushing towards hardware limits. For instance, BlockSTM implemented for EVM.Each VM runs in parallel, meaning they do not obstruct each other. Transactions are executed immediately, with each VM maintaining its own mempool and state.
When the batcher submits transactions to Data Availability (DA), it generates a mega block containing transactions from all VMs. Since this operation occurs off-chain, it does not slow down other processes. Additionally, due to the potential high volume of transactions that DA may not be able to process quickly, we propose implementing a replication nodes solution. # Cross VM Calls Each VM operates independently, and messaging between them is facilitated by the sequencer. At a high level, each VM has its own contract, which serves a similar function. These contracts emit an "event" containing the call data and the sender's information, which is then executed on the target VM. For Solana VM, a program is deployed; for Move VM, a module is included in the standard framework; and for EVM, a smart contract is used. All are deployed on the chain. Essentially, a developer only needs to query a specific function to send a message to another virtual machine, similar to how it's done in LayerZero, but within the same execution environment. Example of a loan/trade from EVM to Move VM: 1. Loan USDC for ETH on AAVE. 2. Transfer USDC to Move VM. 3. Sell USDC for ETH on Liquidswap. 4. Return ETH to close the loan.
If we simplify the logic, it can be represented as follows:
Calls can essentially follow the same path back, allowing for the transfer of results or assets back to the initial contract. Let's delve deeper into the implementation of cross-VM calls between Move VM and EVM: 1. **Move VM Implementation**: 1. Implemented as a native function to streamline the serialization process. 2. As part of default framework. 3. Data is passed as objects, and serialization/deserialization is managed. At a high level, both contracts, implemented on each VM, serve a similar purpose. They emit an "event" containing the call data and the sender's information, which is then executed on the target VM. ```java /// EVM Communication Module /// This module enables the execution of smart contracts within the EVM-compatible layer of the Layer 2 (L2) infrastructure. /// Designed as a key component of our L2 solution, this module facilitates seamless interaction with the EVM ecosystem. /// It acts as a bridge, allowing users and other smart contracts to initiate and execute smart contract functions /// that reside on the EVM side of the L2 platform. This integration ensures compatibility and extends /// the functionality of L2 solutions within the diverse Ethereum ecosystem. module framework::evm { /// Facilitates the execution of a function in an EVM contract from within the current VM environment. /// This native function signals the VM to initiate a call to a specified contract in the EVM layer. /// It's an integral part of cross-VM communication, enabling interoperability between different blockchain protocols. /// /// * `account`: The sender's account, which will be used for authorization and executing the call on the EVM side. /// * `to`: The target EVM contract's address to which the call is directed. /// * `fn_abi`: The ABI signature of the function to be called in the EVM contract, for example, `transfer(address,u256)`. /// * `calldata`: The arguments to be passed to the function. This can be a single primitive type or multiple parameters packed in an object. native fun evm(account: &signer, to: address, fn_abi: vector, calldata: &T); } ``` 2. **EVM implementation** In the EVM part of the genesis block and deployed on the address, similar functionalities are achieved, but with a focus on utilizing events for efficient cross-VM communication. ```solidity // SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.13; import {IMoveVM} from "src/interfaces/IMoveVM.sol"; /// @title MoveVM /// @notice This contract implements the cross-VM messaging protocol within the Ethereum Virtual Machine (EVM) environment. contract MoveVM is IMoveVM { /// @notice Executes a call to a specified virtual machine (Move VM), targeting a specific module and function. /// The `msg.sender` is used as the initiator of the call. /// Emits a communication event to facilitate interaction between EVM and MoveVM. /// @dev This function facilitates interaction between Solidity contracts and modules deployed in a Move VM. /// It encodes the call data for compatibility with Move VM standards and handles the complexities /// of cross-VM communications. /// @param _moduleAddress The hexadecimal address of the module in the Move VM to which the call is directed. /// Example: `0x1` for a core module in Move VM. /// @param _moduleId The identifier of the module within the Move VM. For instance, `coin` for a module handling /// cryptocurrency operations. /// @param _functionId The identifier of the function within the specified module to be called, e.g. `transfer`. /// @param _callData ABI-encoded data to be passed to the function. This data should be formatted according /// to the requirements of the target function and should only include supported primitive types. /// @param _generics A list of fully qualified paths of any generics involved in the function call. /// Use the format `module_path::module_name::GenericType` for single generics. /// For multiple generics, separate them with commas and detail nested generics where necessary. function call( bytes calldata _moduleAddress, bytes calldata _moduleId, bytes calldata _functionId, bytes calldata _callData, bytes calldata _generics ) external { emit Call(msg.sender, _moduleAddress, _moduleId, _functionId, _callData, _generics); } } ``` ## Concurrency Note Multiple calls can be queued sequentially; however, execution on the target VM commences only after the current runtime completes. This process isn't fully synchronous, but enhancing this aspect is a priority for future updates. Calls are executed in a sequencer, one after another, following the order in which they were initiated. # Start Building We currently have several environments available, including one mainnet. Ultimately, all of them will be merged into one Layer 2 (L2) solution. ## **Whitelisting** You can use SuperLumio canary mainnet without whitelisting, while other testnets/devnets (Optimism testnet and Solana devnet) require [whitelisting](/start-building/get-whitelisted). Choose the one you prefer: * [**Optimism SuperLumio**](/start-building/lumio-on-optimism-canary-mainnet): the canary mainnet, available on Ethereum, and supports just EVM. It is a pure optimistic rollup based on the Optimism stack. * [Optimism Testnet](/start-building/lumio-on-optimism-testnet): the testnet network environment combines Move VM and EVM in the same execution environment. It is launched with a modified Reth and Optimism stack. This one will be replaced with a new architecture once the Solana devnet matures. * [**Solana Devnet**](/start-building/lumio-on-solana-devnet): new architecture (Lumio v2), which supports SVM, EVM, and Move VM. This is the final version of how Lumio will function as described in the current documentation. # Get Whitelisted You can use SuperLumio canary mainnet without whitelisting, while other testnets/devnets (Optimism testnet and Solana devnet) require whitelisting. ## How to get whitelisted? To get whitelisted, go to our [website](https://lumio.io) and use the whitelisting form by clicking the "Join Waitlist" button. ## When will I be whitelisted? We whitelist people in stages, so your turn will come eventually. Being a member of the [Pontem Community](https://pontem.network) and using its products can also increase your chances of being whitelisted. # Lumio on Optimism Canary Mainnet ## A Gateway to the Optimism Superchain SuperLumio (сanary mainnet) marks the initial phase of the Lumio Layer 2 on the Optimism Superchain, launched as a pure Ethereum Virtual Machine fork with the support of Conduit technology. This platform is designed to serve as a testnet-in-production, akin to Kusama for Polkadot, allowing for active engagement, TVL growth, and project launches. The foundation of Lumio on Optimism paves the way for future releases to introduce a cross-VM heterogeneous block space, expanding its capabilities.\ \ In anticipation of future developments, Lumio on Optimism's roadmap includes the integration of both Move VM and SVM into the current mainnet implementation that is using EVM only. Currently, Lumio on Optimism employs a centralized sequencer for transaction processing (like any other OP L2s), with plans to adopt a shared sequencer model. This transition towards a shared sequencer across the Optimism chains is a crucial step towards achieving greater security and interoperability within the ecosystem. Importantly, Lumio on Optimism has been deployed on the Ethereum mainnet, operating with real assets, which sets it apart from traditional testnets. Users and developers engaging with Lumio on Optimism should be aware of its real-stakes environment. ## Use Lumio on Optimism Canary Mainnet ### Metamask [Download & Install Metamask](https://metamask.io/) Visit the [Lumio](https://lumio.io) website and simply click the "Connect to Mainnet" button, or proceed with the following instructions for alternative methods. To add Lumio on Optimism L2 as a custom network to MetaMask: 1. Open the MetaMask browser extension. 2. Click the network selection dropdown button at the top of the extension. 3. Select **Add network**. 4. Choose **Add a network manually**. 5. In the **Add a network manually** dialog, enter the following information: 1. **Network Name:** SuperLumio 2. **RPC Endpoint**: `https://mainnet.lumio.io` 3. **Chain ID:** 8866 4. **Currency Symbol:** ETH 5. **Block Explorer:** `https://explorer.lumio.io`
### Other wallets You can do the same with other EVM based wallets. Additionally, support for the Pontem wallet is on the horizon, further enhancing accessibility and user experience right from the start. ## Bridge The bridging process can take anywhere from 1 minute to 30 minutes. Please plan accordingly. Lumio on Optimism enables users to deposit ETH and other tokens, such as USDC, USDT, and more, from the Ethereum L1 mainnet. This can be accomplished through the native L1 to L2 bridge. Currently supported assets: ETH, USDC, USDT, Pepe. Visit [Bridge](https://superbridge.lumio.io/). **Tokens mappings:** | Name | L1 Contract Address | L2 Contract Address | | ----------------- | ------------------------------------------ | ------------------------------------------ | | USD Coin (USDC) | 0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48 | 0x1C93569537a52c144b6B24640F72d74b6c1B0f3C | | Tether USD (USDT) | 0xdac17f958d2ee523a2206206994597c13d831ec7 | 0xA5fB245fb37663F3C97F3000A4eEB6497AB6e3dd | | Pepe | 0x6982508145454ce325ddbe47a25d4ec3d2311933 | 0xd08a2917653d4e460893203471f0000826fb4034 | | Pork | 0xb9f599ce614Feb2e1BBe58F180F370D05b39344E | 0x7c6b91D9Be155A6Db01f749217d76fF02A7227F2 | Over time, additional non-native bridges, such as LayerZero or Wormhole, may be integrated, enabling the deposit of both wrapped and native assets. ## :droplet: Dashboard Our dashboard is currently operating in silent mode, meticulously recording all user actions on the L2, including deposits and transfers. With the upcoming launch of DApps, such as Narswap, we will soon expand our monitoring to cover swaps, liquidity provisions, and more. Visit [Dashboard](https://dashboard.lumio.io/) ## Network Information | | | | --------------- | --------------------------- | | Network Name | SuperLumio | | RPC Endpoint | | | Chain ID | 8866 | | Currency Symbol | ETH | | Block Explorer | | | Bridge | | | Block Time | 2 seconds | | L1 | Ethereum Mainnet | ## Contracts #### L1 The contracts deployed on the Ethereum Mainnet are: | Contract Name | Deployment Addresses | | --------------------------------- | ------------------------------------------ | | SystemConfigProxy | 0xFb252d6199AEfeE6938a1c57213AAd96ecD2650c | | L2OutputOracleProxy | 0xffB004874CbBF8692B5f397B602f4B8a630aeD59 | | OptimismPortalProxy | 0x9C93982cb4861311179aE216d1B7fD61232DE1f0 | | OptimismMintableERC20FactoryProxy | 0xccc6Fc5B866D34a7A4C40455a3cCfaa0cbFc145B | | L1StandardBridgeProxy | 0xdB5C6b73CB1c5875995a42D64C250BF8BC69a8bc | | L1CrossDomainMessengerProxy | 0x6c10d7e5750b21729Eb863Cf89E5b48850E6d97D | | L1ERC721BridgeProxy | 0x9bF59F099d4306B52C7624c90B6d5FD75ab8513b | #### L2 The deployment addresses for L2 contracts are consistent across the entire Optimism stack. You can find these addresses as constants in the Optimism [repository](https://github.com/ethereum-optimism/optimism/blob/c87a469d7d679e8a4efbace56c3646b925bcc009/packages/core-utils/src/optimism/constants.ts#L11). ## Fees The fee model is akin to Optimism's, based on the Data Availability (DA) costs of transactions and execution expenses. For more details on L2 fees, please refer to our further [documentation](https://docs.optimism.io/stack/transactions/fees). With the recent update to [span batches](https://x.com/optimism/status/1760711365168353442?s=46\&t=IPOCXW0FiDbuT5rNrxqOLA), fees have become relatively more affordable. Moreover, the impending integration of ProtoDankSharding promises to further reduce costs once activated on SuperLumio # Lumio on Optimism Testnet This is the Lumio testnet deployed on the Ethereum Sepolia testnet. In the near future, it will be upgraded with a new architecture derived from the implementation of MultiVM. The main difference is that this is the first implementation of EVM and Move VM within the same execution environment. It is considered legacy compared to the devnet, which is represented as Lumio v2. The reason for migrating to a new architecture, which also allows the addition of SVM into the L2, is highlighted: > At that juncture, our resolution was to integrate the EVM and Move VM, aiming for minimal modifications to either, thereby enabling deployment on both platforms without necessitating any changes. This concept piqued our interest, leading us to harness the capabilities of Reth as our foundation. Through this innovative approach, we crafted what is now known as Lumio V1, a unique solution that marries the best of both worlds. > > Yet, this integration posed several challenges, especially when prioritizing performance enhancements. The Move VM, as utilized in Aptos, exhibits exceptional efficiency, outshining other virtual machine solutions with benchmarks showing 30-60k transactions per second (TPS). Our recent tests affirm this impressive performance. On the contrary, Ethereum nodes fail to approach these figures, and the melding of Reth with the Move VM does not support achieving such rapid execution rates. The significant time and resources invested in merging these two technologies could arguably be better spent on more innovative projects. Our goal is to offer an incredibly fast solution, a target that becomes elusive within the constraints of the current framework. Also, contemplating the future integration of more execution runtimes, like the Solana VM, poses a significant challenge. Merging these different environments while striving to boost performance will be a complex task if ever possible. > > In today's modular world, the ideal scenario is for modules to easily interconnect without requiring extensive modifications. Theoretically, numerous distinct execution environments can coexist on the same layer, and integrating them shouldn't demand significant effort—merely orchestration. This vision emphasizes simplicity and efficiency in creating a cohesive system, where the heavy lifting is done through smart orchestration rather than extensive customization or redevelopment. We plan to phase out the current testnet shortly and replace it with the devnet, which provides a shared execution environment. If you have used the testnet, your account address will be remembered and will be eligible for future initiatives. # Network Information Currently, only the devnet is available. We plan to launch our testnet once the network reaches a sufficient level of stability. ### Testnet (Sepolia) The current devnet is deployed on the Ethereum Sepolia testnet network. **Important:** the chain IDs for the Move VM and EVM currently differ. We are aware of this issue and are actively working on a resolution, which will be implemented shortly. | Network Name | Lumio L2 | | ------------------------ | ----------------------------------- | | Description | Lumio L2 | | RPC Endpoint (EVM) | | | RPC Endpoint (Move VM) | | | Chain ID (EVM / Move VM) | 9990 / 2 | | Currency Symbol | ETH | | Coin type (Move VM) | 0x1::native\_coin::NativeCoin | | Block Explorer | | | Faucet (EVM) | | | Faucet (Move VM) | | # Contracts The contracts currently relate to the OP stack, as described here. All of them are for the EVM. For the Move VM, certain contracts (such as bridges) will be implemented at a later stage. ### Testnet (Sepolia) #### L2 addresses | Contract | Address | | ----------------------------- | ------------------------------------------ | | L2CrossDomainMessenger | 0x4200000000000000000000000000000000000007 | | L2StandardBridge | 0x4200000000000000000000000000000000000010 | | SequencerFeeVault | 0x4200000000000000000000000000000000000011 | | OptimismMintableERC20Factory | 0x4200000000000000000000000000000000000012 | | GasPriceOracle | 0x420000000000000000000000000000000000000F | | L1Block | 0x4200000000000000000000000000000000000015 | | L2ToL1MessagePasser | 0x4200000000000000000000000000000000000016 | | L2ERC721Bridge | 0x4200000000000000000000000000000000000014 | | OptimismMintableERC721Factory | 0x4200000000000000000000000000000000000017 | | L2ERC721Bridge | 0x4200000000000000000000000000000000000014 | | ProxyAdmin | 0x4200000000000000000000000000000000000018 | | BaseFeeVault | 0x4200000000000000000000000000000000000019 | | L1FeeVault | 0x420000000000000000000000000000000000001a | | EAS | 0x4200000000000000000000000000000000000021 | | EASSchemaRegistry | 0x4200000000000000000000000000000000000020 | | WETH9 | 0x4200000000000000000000000000000000000006 | #### L1 addresses | Contract | Address | | ---------------------------- | ------------------------------------------ | | AddressManager | 0x354E7c391F0665ba48afE4F41a789D0A7b2EeB51 | | L1CrossDomainMessenger | 0xAAeCAF9E8b590b6d6bccBB73A2d3E9A5e41e275a | | L1ERC721Bridge | 0xDEb8D50bbAD470A552664D12A0914b3DB913B76b | | L1StandardBridge | 0x8BEa1cDccA49435B76292c34563d49F38cae355e | | L2OutputOracle | 0x2d9acF190c9c77EcC51A8141e12b5C53cFB786F2 | | OptimismMintableERC20Factory | 0xb10AB31Bf6416db6513a2BC207bC4Bc1bbdC4A75 | | OptimismPortal | 0xB62dFdFd325859dFe8e686FBDBb38Dc995a8C42A | | ProxyAdmin | 0x2D781D5C3AE257EeE89ABD9613b5e90E3f44dB28 | | SystemConfig | 0xaa38Cd51C4911d9eC12eef2dd7c6a5136c663358 | # Use Testnet To be able to use the faucet and native bridge on Solana, you need to get [whitelisted](/start-building/get-whitelisted). Lumio L2, now live on the Ethereum Sepolia Testnet, invites users and developers to start their journey. **Important:** The L2 is designed to be compatible with both EVM RPC and Move VM RPC. This means it allows the use of EVM RPC for Move VM calls. However, at this stage, to interact with both supported VMs, users will need to use the Pontem Wallet as a unified solution, or two separate wallets (such as Petra and Metamask). These wallets must be connected to the appropriate RPCs to fully experience the integration of the two VMs. ### Pontem Wallet **Both EVM & Move VM** [Download & Install Pontem Wallet](https://chromewebstore.google.com/detail/pontem-aptos-wallet/phkbamefinggmakgklpkljjmgibohnba) This method of connection has been available since the release of **Pontem Wallet v2.5.4**. Be prepared to update the extension manually or wait for Chrome to update it automatically. If you need to update wallet manually see the [following instruction](https://support.cloudhq.net/how-to-manually-update-chrome-extensions/). **Unlock EVM features** First of all, let's unlock EVM features in the Pontem Wallet. 1. Click on 'Create Wallet'. 2. Select 'Ethereum' as your wallet type. 3. Proceed by following the on-screen instructions. **Connect** 1. Open the Pontem Wallet. 2. Select **“Settings”**. 3. Choose **“Network Mode”**. 4. From the list of supported networks, select **“Lumio L2”**. 5. Your wallet will switch to the **“Lumio L2”** network. To return to the Aptos mainnet, simply go back to the same menu and select **“Mainnet”**.
**Only Move VM** This method allows you to connect to Lumio L2 using earlier versions of the **Pontem Wallet**. 1. Open the Pontem Wallet. 2. Access the menu by clicking the 4-dot button in the top right corner. 3. Select **“Expand View”**. 4. Reopen the menu. 5. Choose **“Settings”**. 6. Navigate to **“Networks”**. 7. Select **“Custom”**. 8. Update the fields as follows: * **Network Name**: Lumio L2 * **Network Short Name:** Lumio L2 * **ChainId:** 2 * **API URL**: `https://mvm.testnet.lumio.io/v1` * **Indexer URL**: `https://indexer.testnet.lumio.io/v1/graphql` * **Explorer URL for account:** `https://explorer.testnet.lumio.io/address/` * **Explorer URL for transaction**: `https://explorer.testnet.lumio.io/tx/` * **Explorer GET params:** `?` 9. Click the “Save” button. 10. Return to the “Settings” menu and switch the network in **“Network Mode”** to “Lumio L2”. **Important:** Note: In this mode, it is essential to manually request funds from the faucet. See [Faucet](/start-building/lumio-on-optimism-testnet/use-testnet/faucet). *** ### Other wallets #### Metamask In this mode, only the EVM part will be supported. [Download & Install Metamask](https://metamask.io/) To add Lumio L2 as a custom network to MetaMask: 1. Open the MetaMask browser extension. 2. Click the network selection dropdown button at the top of the extension. 3. Select **Add network**. 4. Choose **Add a network manually**. 5. In the **Add a network manually** dialog, enter the following information: * **Network Name:** Lumio L2 Testnet * **RPC Endpoint**: `https://testnet.lumio.io` * **Chain ID:** 9990 * **Currency Symbol:** ETH * **Block Explorer:** `https://explorer.testnet.lumio.io`
#### Petra In this mode, only the Move VM part will be supported. [Download & Install Petra](https://chromewebstore.google.com/detail/petra-aptos-wallet/ejjladinnckdgjemekebdpeokbikhfci) **Important:** The Petra wallet is highly efficient, particularly for operations involving Decentralized Applications (DApps). However, for transferring funds to another account, the Pontem wallet is the recommended choice due to its optimized features for such transactions. 1. Open the Petra wallet. 2. Access Settings from the bottom menu. 3. Select “Network”. 4. Click the “Add” button at the bottom. 5. Enter the following parameters: * **Name**: Lumio L2 * **Node URL**: `https://mvm.testnet.lumio.io/v1` * **Faucet URL:** `https://faucet.testnet.lumio.io` * Click on “Add Network”. 6. Finally, select “Lumio L2” from the list of networks.
# CLI You can also interact with the L2 using CLI tools for both Move VM and EVM. * For the Move VM, the Aptos CLI is supported. * For the EVM, any compatible CLI tool can be used. ### Move VM [Download & install](https://aptos.dev/tools/aptos-cli/install-cli/) the Aptos CLI. Ensure to adhere to the instructions for a proper installation of the CLI. During the `init` command, configure the following RPC and faucet URLs: * RPC: `https://mvm.testnet.lumio.io/v1` * Faucet: `https://faucet.testnet.lumio.io` Additionally, these URLs can be used as parameters in the CLI with the `--url` or `--faucet-url` options. ### EVM Any EVM-compatible CLI or tool can be utilized for this purpose. Commonly, we use the `cast` CLI from [Foundry](https://book.getfoundry.sh/cast/). To use `cast`, simply include the RPC URL as a parameter `--rpc-url`. For example: ```jsx cast ... --rpc-url https://testnet.lumio.io ``` \
# Faucet ### Move VM #### Wallet In case of wallet, just add the faucet link in the network settings like on the screenshot. It supported by most of the wallets. Copy the faucet URL: ``` https://faucet.testnet.lumio.io ``` #### CLI When using the CLI, provide the faucet link during the `aptos init` command: ```sh https://faucet.testnet.lumio.io ``` Executing this command will automatically fund your account. #### CURL You can also use `curl` for the same purpose: ```sh curl -X POST "https://faucet.testnet.lumio.io/mint?amount=1000000&address=43417434fd869edee76cca2a4d2301e528a1551b1d719b75c350c3c97d15b8b9" ``` ### EVM To request funds on the EVM, first create a new account in MetaMask or any other EVM-compatible wallet. Ensure that the wallet is connected to the Supercharger network. Once set up, you can use the public faucet to obtain funds. [Visit EVM faucet](https://claim.lumio.network) \
# Bridging To transfer ETH from the Sepolia Testnet, utilize the bridge portal developed by Pontem. The bridging process typically completes within a few minutes. To request funds you can use [Sepolia Faucet](https://sepoliafaucet.com) ( or other providers) As of now, the portal supports bridging of testnet ETH, with the addition of ERC-20 token support anticipated soon. Please be aware that withdrawals from L2 are currently not functioning. We are actively working on resolving this issue and expect to have it fixed shortly. Thank you for your understanding and patience. **Important Note:** When bridging ETH, you are transferring it to the EVM. If you need to move it to the Move VM, please await further instructions, which will be provided shortly. To proceed, visit the [Bridge Portal](https://bridge.lumio.io). # Whitelist At present, access to both the faucets and the bridge is restricted to a select group of whitelisted users. We plan to expand availability to all users in the near future. Additionally, those who currently have access to Lumio are empowered to invite others to join our community program. If you extend an invitation or receive access, please inform us. This allows us to monitor and support your involvement more effectively. Keep us updated by notifying us of your address. # Deploy on Move VM Download the Aptos CLI and follow the installation instructions as described in the [section](/start-building/lumio-on-optimism-testnet/use-testnet/cli). For an optimized development experience, consider using the IntelliJ plugin developed by Pontem. To create a new Aptos project, use your IDE. Typically, selecting the Move project type will automatically generate a new project for you. In the project directory, run the following command: ```sh aptos move init --name l2_coin ``` Feel free to replace `l2_coin` with any name you prefer. You'll need the Aptos CLI. Initialize your account as described in the relevant section: ```sh aptos init ``` When prompted for the network, choose `custom`. For the RPC and faucet, use the following URLs: ```sh RPC endpoint: https://mvm.testnet.lumio.io/v1 Faucet: https://faucet.testnet.lumio.io ``` You can opt to use a newly generated private key or, alternatively, copy your private key from an existing account. The `init` command will create a new account, deposit funds from the faucet, and display the address of the newly created account. Navigate to the newly created `Move.toml` file and define the new account as follows: ```toml [addresses] l2_coin = "your address" ``` Replace `your address` with the address you created. Next, create a new module in the `sources/` folder named `coin.move`: ```rust module l2_coin::coin { use std::string::utf8; use std::signer; use aptos_framework::coin; // Coin Type. struct MyCoin {} // Initialize function. public entry fun initialize(account: &signer) { let (burn_cap, freeze_cap, mint_cap) = coin::initialize( account, utf8(b"Coin Name"), utf8(b"SYMBOL"), 6, // Decimals true, // Limited supply ); coin::destroy_freeze_cap(freeze_cap); coin::destroy_burn_cap(burn_cap); // Mint 100 million coins. let minted_coins = coin::mint(100000000000000, &mint_cap); // Deposit coins into the minter's account. coin::register(account); coin::deposit(signer::address_of(account), minted_coins); coin::destroy_mint_cap(mint_cap); } } ``` This module, when deployed, will create a new coin type `MyCoin` and deposit 100 million coins into the creator's account. Now, let's move on to publishing our module. ```sh aptos move publish ``` You should see a status message `"vm_status": "success"`, indicating that the module was deployed correctly. Next, let’s initiate the minting of your new coin by running the `initialize` function: ```sh aptos move run --function-id ::l2_coin::initialize ``` Make sure to replace `` with your actual address before executing the call. Upon successful completion of this call, you will see a success status along with a transaction ID. You can verify the result in the explorer. To confirm that your coin has been deployed, access the API and substitute the URL with your address: ```sh aptos move run --function-id ::coin::initialize ``` Search for the `::l2_coin::MyCoin` type associated with your account. Alternatively, you can import your account into a wallet like Pontem, Petra, etc., using the private key found in the `.aptos/config.yml` directory. If your coin doesn’t automatically appear in the wallet, you can manually import it using its path: ```sh ::l2_coin::MyCoin ``` # Deploy on EVM (Hardhat) Create a wallet using Metamask ([see how to configure](/start-building/lumio-on-optimism-testnet/use-testnet#metamask)) and request funds from the [faucet](/start-building/lumio-on-optimism-testnet/use-testnet/faucet) for your new account. Once your account is funded, download Node.js: * [Nodejs v18+](https://nodejs.org/en/download/) required ### Create a project Let's create a project with Hardhat. Create a new folder and run the following command inside: ``` npm init --y npm install --save-dev hardhat ``` \ The command will initialize a new `npm` project and install Hardhat locally. Initialize a new Hardhat project ``` npx hardhat ``` Select `TypeScript` as the project type, and for the rest of the questions, such as .gitignore and sample project, choose `y` or `yes` ### Configure Hardhat with Lumio Open the `hardhat.config.ts` file generated by the previous command, and replace its content with the following: ```typescript import { HardhatUserConfig } from "hardhat/config"; import "@nomicfoundation/hardhat-toolbox"; require('dotenv').config(); const config: HardhatUserConfig = { solidity: "0.8.20", networks: { 'lumio-testnet': { url: 'https://testnet.lumio.io', accounts: [process.env.WALLET_KEY as string], gasPrice: 3000000000, }, }, defaultNetwork: 'hardhat', }; export default config; ``` ### Install toolbox To install `hardhat-toolbox`, run the following command: ```sh npm install --save-dev @nomicfoundation/hardhat-toolbox ``` ### Install dotenv To install the `dotenv` dependency, use the following command: ```sh npm install --save-dev dotenv ``` Once the dependency is installed, let's create a new file named `.env` and place the private key inside it: ``` export WALLET_KEY= ``` See [how to export your private key](https://support.metamask.io/hc/en-us/articles/360015289632-How-to-export-an-account-s-private-key#:~:text=Click%20the%20three%20vertical%20dots,to%20display%20your%20private%20key.) from Metamask. ### ERC20 Contract Let's deploy an ERC-20 contract on the testnet. First, navigate to the `contracts/` folder and remove the `Lock.sol` file from the sample project as it is not needed. Now, let's install the [OpenZeppelin](https://www.openzeppelin.com/) framework: ``` npm install --save @openzeppelin/contracts ``` Create a new file in the `contracts/` directory and name it `Token.sol` . Then, put the following code inside: ```solidity //SPDX-License-Identifier: Unlicense pragma solidity ^0.8.20; import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; contract Token is ERC20 { uint constant _initial_supply = 100000000 * (10**18); constructor() ERC20("MyToken", "TOKEN") { _mint(msg.sender, _initial_supply); } } ``` Let's compile the code by running the following command: ```sh npx hardhat compile ``` After successful compilation, let's deploy the contract. Open the `scripts/deploy.ts` file and replace its contents with the following code: ```typescript import { ethers } from "hardhat"; async function main() { const token = await ethers.deployContract('Token', { gasLimit: 1000000 }); await token.waitForDeployment(); console.log(`Token contract deployed at ${token.target}`); } // We recommend this pattern to be able to use async/await everywhere // and properly handle errors. main().catch((error) => { console.error(error); process.exitCode = 1; }); ``` **Important:** Reth L2 doesn't support the "block tag pending." So, in case you encounter issues with block tags while using Hardhat, try adding the parameter `blockTag: "latest"`. This may be particularly relevant, especially when estimating gas. For deploy run the following command: ``` npx hardhat run scripts/deploy.ts --network lumio-testnet ``` Awesome, after deployment you would see message: ``` Token contract deployed at
``` Copy the address and go to [block explorer](/start-building/lumio-on-optimism-testnet/block-explorer), that's all! Now you can continue develop your contract/project on the EVM part of the L2. # Deploy on EVM (Foundry) Foundry is an exceptionally fast, portable, and modular toolkit designed for Ethereum application development, and it's written in Rust – a choice we highly appreciate! Requirements: * [Rust](https://www.rust-lang.org/tools/install) If Rust is not already installed on your local system, simply follow the provided link to get started. Now, let's proceed with installing Foundry: ```sh curl -L https://foundry.paradigm.xyz | bash ``` Start by establishing a new project folder on your system. After this folder is set up, proceed to initialize it with Forge: ``` forge init ``` The command will populate the directory with various files, including an example contract, deployment scripts, and tests. We will need OpenZeppelin for our ERC20 development: ``` forge install OpenZeppelin/openzeppelin-contracts ``` Finally, let's create the contract. Add a new file into the `src/` directory and name it `Token.sol`. Use the following code for this file: ```solidity //SPDX-License-Identifier: Unlicense pragma solidity ^0.8.20; import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; contract Token is ERC20 { uint constant _initial_supply = 100000000 * (10**18); constructor() ERC20("MyToken", "TOKEN") { _mint(msg.sender, _initial_supply); } } ``` Now, let's proceed with building the project: ``` forge build ``` The command mentioned above will download the Solc compiler and build the contracts. To deploy our Token, let's create a new file named `Token.s.sol` in the `script/` directory. Then, insert the following code into this file: ```solidity // SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.20; import {Token} from "../src/Token.sol"; import {Script, console2} from "forge-std/Script.sol"; contract TokenScript is Script { function run() public { vm.startBroadcast(); Token token = new Token(); console2.log("Token deployed at: ", address(token)); vm.stopBroadcast(); } } ``` We're almost there. Now, we need to execute a script to deploy everything: {% code overflow="wrap" %} ``` forge script script/Token.s.sol --private-key= --rpc-url https://testnet.lumio.io --broadcast ``` {% endcode %} Remember to replace the placeholder for the private key with your actual private key. Upon successful deployment, you will receive a message confirming that the contract has been deployed successfully. To simulate the execution before broadcasting the transaction, simply remove the `--broadcast` flag from the command above. You will see the following message: ``` Token deployed at:
``` Copy the address and go to [block explorer](/start-building/lumio-on-optimism-testnet/block-explorer), that's all! Now you can continue develop your contract/project on the EVM part of the L2. # Block Explorer The block explorer is currently launched in beta mode, which means you can view both EVM and Move VM transactions in the blocks. However, please note that Move VM transactions are displayed without detailed information at this time. Visit the [Block Explorer](https://explorer.testnet.lumio.io) # Lumio on Solana Devnet The current devnet runs without guarantees: it can be taken down, restarted, or redeployed from scratch. It implements the latest architecture described in the current documentation and supports three VMs: SVM, EVM, and Move VM. Once the devnet is stable enough, we will replace the current testnet with it and launch it with settlement on Solana. For now, you can connect and explore it on your own. # How to connect To be able to use the faucet and native bridge on Solana, you need to get [whitelisted](/start-building/get-whitelisted). A Devnet is available equipped with Solana VM, Move VM, and EVM on board. ## Solana VM RPC endpoint + faucet: ``` https://svm.devnet.lumio.io ``` The RPC is fully compatible with Solana API v2.0.2. Use with Solana CLI: 
solana config set --url https://svm.devnet.lumio.io
Create a new key if needed: ``` solana-keygen new -o ./keypair.json ``` Request faucet: ``` solana airdrop 1 ``` {% hint style="warning" %} If you see an error like this, it means your account needs to be whitelisted first:\ \ Error: airdrop request failed. This can happen when the rate limit is reached. {% endhint %} ## Move VM The Move VM will be available once the native bridge starts working with it, expected in June-July. ## EVM The Ethereum VM support is coming soon. ## Universal RPC Cross-chain calls will enable a universal RPC, allowing the use of Metamask or Phantom to execute a Move VM transaction. This universal RPC will operate by utilizing cross-VM call functionality, where call data needs to be serialized into a byte format recognized by the specific VM targeted for the call. Using the cross-VM calls module on the initial chain, the call is then executed on another chain. # Native Bridge ## Use Bridge To be able to use the native bridge you need to get [whitelisted](/start-building/get-whitelisted). Native bridging is available on Solana devnet. The bridge deposits funds only to SVM for now and uses SVM addresses. Programs addresses: ``` # Portal program is the main contract that is used to interact with the Lumio network. # It is used to deposit and withdraw funds from the Lumio network. 5EBHJtUkiN5j2vCtF7MM34W6qnyb2wKbcrL1VmMrYFvh # Oracle program is used to store the l2 block headers. 8ymtXnUXPvKuvLtoNRdk5VcVFvxReAgSFyjcweNibZ12 # Whitelist program is used to store the list of whitelisted users. Ccd88Zbbr2oWqoEqoLrZzvbSGMRS3Bs9BKrN4WwPPTrF # DA DJf4d9eNT1aLhHnvvMSPut4yYyob86dVTtwY8tdBF35a ``` Currently, it's possible to bridge only using the Lumio CLI, so download it from our [GitHub](https://github.com/pontem-network/lumio-tools/releases/tag/testnet-v0.1). After downloading, unpack the archive. The **lumio-cli** executable will appear. In your terminal, run the following in the directory with the CLI: ``` chmod +x ./lumio-cli ``` Now you can move the CLI to your binary path. Configure your Solana CLI to Devnet: ``` solana config set --url https://api.devnet.solana.com ``` Create an account if needed: ``` solana-keygen new -o ./keypair.json ``` Request some Devnet SOL: ``` solana airdrop 1 ``` Now we are ready to bridge. Run the following command: ``` lumio-cli deposit-sol 1 ``` Switch your CLI back to the Lumio Devnet: ``` solana config set --url https://svm.devnet.lumio.io ``` Query the account: ``` solana account
``` It should show the deposited balance on your account. ## Architecture The bridge is scheduled to launch in early summer. The native bridge will operate similarly to other L2 native bridges: 1. Send a transaction containing SOL, an SPL token, or an NFT to a Solana Program. 2. Provide a recipient address. 3. Specify the VM for the deposit. 4. The smart contract emits an event. 5. A sequencer picks up the event and proposes a new deposit transaction to the VM node. 6. The balance appears on the provided address.
### Withdrawals Withdrawals are expected to experience a delay of 3-7 days with Optimism and approximately 7-24 hours with risc0. Initially, before rollup challenging is enabled, there will be a fixed delay of 7 days from the initiation of a withdrawal. # Deploy on SVM This is a brief tutorial on how to use SVM on the current Lumio on Solana devnet. For EVM and Move VM, you can refer to the tutorials from the Lumio on Optimism testnet, but be sure to use the correct RPC and faucet RPC endpoints. ### Config * Solana CLI required. Configure RPC URL: ```bash solana config set --url https://svm.devnet.lumio.io ``` If you need a new key: ```bash solana-keygen new -o ./keypair.json ``` ### Faucet Get some SOL: ```bash solana airdrop 1 ``` ## Create Token ```bash # Install cargo install spl-token-cli # Create token spl-token create-token ``` After you got token address: ```bash # Check supply spl-token supply
# Create an account to hold balance spl-token create-account
# Check balance spl-token balance
# Mint some spl-token mint
# Check supply again spl-token supply
``` ## Create a program Be sure CLI is configured and account funded. Create a new project: ```bash cargo init hello_world --lib cd hello_world ``` Add deps: ```bash cargo add solana-program ``` Open `Cargo.toml` and add the following: ```toml [lib] name = "hello_world" crate-type = ["cdylib", "lib"] ``` Replace src/lib.rs with the following code: ```rust use solana_program::{ account_info::AccountInfo, entrypoint, entrypoint::ProgramResult, pubkey::Pubkey, msg, }; // declare and export the program's entrypoint entrypoint!(process_instruction); // program entrypoint's implementation pub fn process_instruction( program_id: &Pubkey, accounts: &[AccountInfo], instruction_data: &[u8] ) -> ProgramResult { // log a message to the blockchain msg!("Hello, world!"); // gracefully exit the program Ok(()) } ``` Build: ```bash cargo build-bpf ``` Deploy: ```bash solana program deploy ./target/deploy/hello_world.so ``` # Ecosystem ## Block Explorer This is the explorer for the Lumio network. You can use it to view transactions, blocks, and other information about the network. ## Bridge The bridge DApp is comming soon, so for now use [Native Bridge](/start-building/lumio-on-solana-devnet/native-bridge). ## Pyth Pyth is currently deployed for test purposes, including a Wormhole test deployment. It contains some basic price feeds. If you need something specific, feel free to contact us. | Program name | Address | | --------------------- | -------------------------------------------- | | Pyth Push Oracle | EtvdJGkAybA9rLPRKVwbcUbJ2up4ZTPqdaPT8AMQZeFb | | Pyth Solana Receiver | AjqmKW5naeNyyRoVLHLvL9igTsLivqurfaJ9PJDHhUeD | | Wormhole Token Bridge | C1LpSR8nMhYo5trzsj4dqEe9Vjfzxra6fg95ymuCLLSp | | Wormhole Core Bridge | 9qZgPC39BfU33NbwJtoevYqxAEVsRKXYpzwfpn2Pcb3A | # Fees The network fees are not yet finalized and will be subject to change after successful testing. For the EVM, the fees might align with those used in OP. The transaction fee on L2 comprises two components: an execution fee and a storage fee. This is because virtually every transaction must be posted to the settlement layer, enabling the recovery of transaction history and verification of L2 transactions. The fees also depend on the load of the settlement layer, meaning they can fluctuate, sometimes being lower or higher. For more details, refer to the OP [documentation](https://community.optimism.io/docs/developers/build/transaction-fees/). Furthermore, as Pontem L2 is settlement-agnostic, in V0 transactions will initially be settled on Ethereum. However, future plans involve using Aptos and other protocols to store transaction data, potentially reducing transaction costs significantly. This approach also allows for a fallback to Ethereum if the primary settlement layer encounters issues. # VMs Differences ## EVM The Ethereum Virtual Machine (EVM) implementation in Lumio closely resembles the standard Ethereum mainnet and other networks. However, there are some differences that you should be aware of. For detailed information, visit the [Optimism (OP) portal](https://stack.optimism.io/docs/releases/bedrock/differences/#), where these differences are thoroughly explained. Most of these variations are implemented to maintain compatibility with standard EVM protocols, which can be slightly different in the context of L2, as L2 is not a Layer 1 (L1) protocol and often requires specific workarounds. An important aspect to note is that the default deployment of L2 includes a Cross VM contract in the genesis block, which is not typically found in the standard OP stack L2. Considering the presence of two virtual machines and the mapping between accounts, it's crucial to understand that direct access from an EVM account to a Move VM account using a private key is not possible. Instead, connecting accounts across these VMs can only be achieved through the use of smart contracts. ## SVM Similar to EVM and Move VM, the Solana VM updated with L2 primitives, which allows to bridge assets, finalize blocks and required workgrounds. We also got rid of not-needed primitives in case of L2, and some other optimizations in progress. ## Move VM The Move VM in our system is implemented using the standard [Aptos framework](https://github.com/aptos-labs/aptos-core/tree/main/aptos-move/framework), albeit with some modifications that we detail in this section. Essentially, it’s a fork of the Aptos Move VM, adhering to the same design principles. The majority of the changes were implemented to enable the compilation of the Move VM into MIPS, as required by Cannon for generating fault proofs in the future, which we have successfully accomplished. #### Optimization We eliminated the concept of blocks, optimized the mempool, and removed P2P and other unnecessary primitives for L2. This approach enabled us to achieve 3k TPS with under 100 ms latency using Move VM, significantly improving the TPS. Read more about our research in this paper. {% file src="/files/gFZMksfdy3Fbh5cnSKQr" %} #### ZK Primitives The ZK primitives have been removed from the Move VM, primarily because most of them operate using threads, and integrating them currently requires additional effort. The specific modules that have been removed include: ```jsx ristretto255_bulletproofs ristretto255 bls12381 crypto_algebra ``` #### Framework In our L2, the native coin within the Move VM is ETH, and we plan to enable gas payments in various types of coins in the future. Currently, the coin representing ETH in the Move VM is `0x1::native_coin::NativeCoin`. This implementation is similar to the native coin concept in the Aptos framework. However, this abstraction has been chosen for simplicity and to facilitate future adaptability. We have also removed contracts related to staking or governance initially implemented in the framework. These may be reintroduced after reworking, but at this stage, as the L2 sequencer is singular and a shared sequencer is not yet operational, they have been omitted. The list of removed modules includes: ```jsx aptos-framework/sources/aptos_governance.move aptos-framework/sources/configs/staking_config.move aptos-framework/sources/delegation_pool.move aptos-framework/sources/governance_proposal.move aptos-framework/sources/stake.move aptos-framework/sources/staking_contract.move aptos-framework/sources/staking_proxy.move aptos-framework/sources/vesting.move aptos-framework/sources/voting.move ``` Additionally, some logic has been modified, such as aspects related to gas, block production (especially concerning validator checks), and genesis. A comprehensive list of these changes will be detailed later. **Important:** The use of `0x1::aptos_coin::AptosCoin` in your transactions or API calls is still possible, as it is proxied at the VM level.
# Running a Node Instructions on how to set up your own node for read-only operations will be announced after Lumio v2 (devnet) merge into testnet. # Ecosystem The network uniquely enables the simultaneous deployment of projects on both the SVM, EVM and Move VM. This dual compatibility allows developers to seamlessly migrate their projects from EVM-based ecosystems such as Solana, Ethereum, Binance Smart Chain and Aptos. ## Disperse Deployed at [canary mainnet](/start-building/lumio-on-optimism-canary-mainnet). Send Ethereum or any ERC20 tokens to multiple addresses on SuperLumio. [Visit Disperse](https://disperse.lumio.io) ## Liquidswap Deployed at [testnet](/start-building/lumio-on-optimism-testnet). The Pontem Network's Liquidswap DEX stands as the most prominent exchange protocol on the Aptos network, commanding over 50% of the total trading volume. To experience its capabilities firsthand, explore Liquidswap on the L2. [Visit Liquidswap on the L2](https://lumio.liquidswap.com) ## Pontem Wallet Supports testnet and canary mainnet. One of the most popular Aptos wallets offers native support for the L2, enabling seamless access to both the SVM, EVM and Move VM from a single wallet. This integration enhances the user experience by providing a smooth and unified interface. **Important:** Please note that support is currently available exclusively in the desktop version (browser extension) of the wallet. [Download Pontem Wallet](https://pontemwallet.xyz/) ## Coin Crusade It's the first gaming project built on the Optimism Сanary Mainnet, offering thrilling PVP battles with unique characters, each boasting their own superpowers: — Knight — Warrior — Wizard
[Play](https://coincrusade.chainwars.io)