From fdd7012f77f12e8862f8766ebd4b814f035c003a Mon Sep 17 00:00:00 2001 From: Kevin Neilson Date: Mon, 13 Jan 2025 15:35:54 -0800 Subject: [PATCH 1/9] relocate substrate page from Builders to learn --- learn/platform/.pages | 1 + builders/substrate/overview.md => learn/platform/substrate.md | 0 2 files changed, 1 insertion(+) rename builders/substrate/overview.md => learn/platform/substrate.md (100%) diff --git a/learn/platform/.pages b/learn/platform/.pages index 055eddc0e..868aa40cd 100644 --- a/learn/platform/.pages +++ b/learn/platform/.pages @@ -4,6 +4,7 @@ nav: - networks - 'Vision': 'vision.md' - 'Why Polkadot': 'why-polkadot.md' + - 'Substrate': 'substrate.md' - 'Technology & Architecture': 'technology.md' - 'Tokens': 'tokens.md' - 'Source Code': 'code.md' diff --git a/builders/substrate/overview.md b/learn/platform/substrate.md similarity index 100% rename from builders/substrate/overview.md rename to learn/platform/substrate.md From 592658af17afbbe7f3b5aa1d75af39006a9a4ca2 Mon Sep 17 00:00:00 2001 From: Kevin Neilson Date: Tue, 14 Jan 2025 10:35:32 -0800 Subject: [PATCH 2/9] rev --- learn/platform/.pages | 1 - learn/platform/substrate.md | 64 ------------------------- learn/platform/technology.md | 93 ++++++++++++++++++++++-------------- 3 files changed, 57 insertions(+), 101 deletions(-) delete mode 100644 learn/platform/substrate.md diff --git a/learn/platform/.pages b/learn/platform/.pages index 868aa40cd..055eddc0e 100644 --- a/learn/platform/.pages +++ b/learn/platform/.pages @@ -4,7 +4,6 @@ nav: - networks - 'Vision': 'vision.md' - 'Why Polkadot': 'why-polkadot.md' - - 'Substrate': 'substrate.md' - 'Technology & Architecture': 'technology.md' - 'Tokens': 'tokens.md' - 'Source Code': 'code.md' diff --git a/learn/platform/substrate.md b/learn/platform/substrate.md deleted file mode 100644 index e535cd6fc..000000000 --- a/learn/platform/substrate.md +++ /dev/null @@ -1,64 +0,0 @@ ---- -title: Polkadot's Substrate in Moonbeam -description: Discover Polkadot's Substrate developer framework and how it shapes blockchain development in both Moonbeam's networks and other parachains. ---- - -# Polkadot's Substrate on Moonbeam - -## What is Substrate? {: #what-is-substrate } - -Polkadot's Substrate is an open-source, modular SDK for building blockchains in Rust. It is developed by Parity Technologies, the same team behind Polkadot. - -Where Polkadot is a chain through which many blockchains are connected to, Substrate is the toolset that Moonbeam uses that provides the foundational building blocks for creating custom, domain-specific blockchains. Substrate's FRAME framework is designed to be flexible and forkless, allowing developers to choose the components that best suit their blockchain needs and perform runtime upgrades without requiring network forks like Ethereum does. Most developers will gravitate towards Substrate with the intention of integrating with the Polkadot ecosystem, but its flexibility allows users to create both solo-chains and parachains. - -This page will provide an overview of Polkadot's Substrate and how it relates to the Moonbeam ecosystem. If you're interested in developing on Polkadot yourself with Substrate and FRAME, the [Substrate Developer Hub](https://docs.substrate.io/learn/what-can-you-build){target=\_blank} provides comprehensive documentation, tutorials, and examples. - -## Substrate Pallets {: #substrate-pallets } - -Pallets are the fundamental building blocks of Substrate blockchains. They are modular components that encapsulate specific functionality. Each pallet is essentially a piece of Rust code that dictates how a particular feature or function operates within the blockchain's runtime. - -Pallets are used to customize and extend the capabilities of a Substrate-based blockchain. They can be thought of as plug-and-play modules that can be mixed, matched, and configured to create a bespoke blockchain. Each pallet is independent and designed to do one thing well, providing specific functionality such as managing balances, handling consensus, or facilitating on-chain governance. - -Some examples of open-source pallets that are available to all Substrate developers are: - -- **[Balances Pallet](https://crates.io/crates/pallet-balances){target=\_blank}** — manages the balance of accounts in a Substrate blockchain -- **[Assets Pallet](https://crates.io/crates/pallet-assets){target=\_blank}** — handles the creation and management of on-chain fungible assets -- **Consensus Pallets** — these pallets provide different consensus mechanisms, such as [AURA](https://crates.io/crates/pallet-aura){target=\_blank} and [BABE](https://crates.io/crates/pallet-babe){target=\_blank}, for block production -- **Governance Pallets** — these pallets, like [Referenda](https://crates.io/crates/pallet-referenda){target=\_blank} and [Collective](https://crates.io/crates/pallet-collective){target=\_blank}, provide on-chain governance mechanisms -- **[Frontier Pallets](https://polkadot-evm.github.io/frontier){target=\_blank}** — Ethereum compatibility layer pallets that allows Substrate-based blockchains to interact with Ethereum-based applications that the Moonbeam team pioneered. Includes pallets such as the [EVM Pallet](https://crates.io/crates/pallet-evm){target=\_blank} -- **[Parachain Staking Pallet](/builders/substrate/interfaces/features/staking/){target=\_blank}** - enables a delegated proof of stake (DPoS) system, a pallet that Moonbeam created - -In addition to the standard pallets provided by Polkadot's Substrate, developers can [create their own pallets](https://docs.substrate.io/tutorials/collectibles-workshop/03-create-pallet){target=\_blank} to add custom functionality to their own blockchains. - -!!! note - Developers can edit pre-existing pallets because they are all open source. This flexibility is one of the benefits of using Polkadot's Substrate, but it's also important to know that there are a few standards that are enforced across each of the parachains that are connected through the Polkadot relay chain. - -The Moonbeam runtime, built with Polkadot's Substrate, can be found in the [Moonbeam GitHub repository](https://github.com/moonbeam-foundation/moonbeam){target=\_blank}. Within this repository, you can see additional custom pallets that the Moonbeam team has written and edited within the [`pallets` folder](https://github.com/moonbeam-foundation/moonbeam/tree/master/pallets){target=\_blank}. You can also check out documentation on some Substrate pallets as they pertain to Moonbeam in the [Pallets section](/builders/substrate/interfaces/){target=\_blank} of our documentation. - -You can interact with Substrate features exposed by these pallets using development tools like the [Polkadot.js API](/builders/substrate/libraries/polkadot-js-api/){target=\_blank}, the [Python Substrate Interface](/builders/substrate/libraries/py-substrate-interface/){target=\_blank}, and the [Substrate API Sidecar](/builders/substrate/libraries/sidecar/){target=\_blank}. - -## Forkless Upgrades {: #forkless-upgrades } - -One of the best things about developing on Polkadot with Substrate is the ability to introduce [forkless upgrades](https://docs.substrate.io/maintain/runtime-upgrades){target=\_blank} to blockchain runtimes. In traditional blockchain architectures, making substantial changes to the blockchain's rules or logic often requires a hard fork. This process can be disruptive and contentious, potentially splitting the community and the blockchain itself into two separate entities. - -Substrate takes a different approach. It separates the blockchain's state (data) from its logic (rules). The logic is contained in the blockchain's runtime, which is itself stored on the blockchain. This design allows the runtime to be upgraded through a special kind of transaction, effectively changing the rules without disrupting the continuity of the blockchain. - -Whenever you build a blockchain with Substrate, you compile your Rust code into a build binary. This build can be uploaded into a pre-existing and running blockchain through [FRAME's `set_code` call](https://paritytech.github.io/substrate/master/frame_system/pallet/enum.Call.html#variant.set_code){target=\_blank}. When a new runtime is uploaded and approved (typically through an on-chain governance process), all nodes automatically switch to the new runtime at a specified block number. This process is smooth and automatic, with no need for node operators to manually upgrade their software. - -Moonbeam regularly uses the forkless upgrade system to add additional features to the Moonbeam ecosystem. You can keep track of and discuss Moonbeam's upcoming forkless upgrades on the [Moonbeam forum](https://forum.moonbeam.network){target=\_blank}. - -## Native Interoperability {: #native-interoperability } - -While Substrate allows developers to create blockchains, one of its biggest advantages is that it supports integration for native interoperability through relay chains like Polkadot and Kusama. - -A relay chain is a central chain that connects several blockchains, known as parachains. Each parachain is a distinct blockchain with its own runtime and state, but all are connected to and secured by the relay chain. Substrate-based blockchains can become parachains by connecting to the relay chain. Once connected, they can communicate with other parachains through a mechanism known as [Cross-Consensus Messaging (XCM)](/builders/interoperability/xcm/overview/){target=\_blank}. This allows them to exchange information and conduct transactions in the same language, enabling a wide range of interoperable applications. - -Native interoperability offers the following advantages: - -- **Shared security** — parachains share the security of the relay chain, reducing the resources each chain needs to secure itself -- **Interchain communication** — parachains can communicate with each other, enabling the transfer of data and assets between different blockchains -- **Asset transfers** — parachains that can communicate with each other can easily send native assets between each other - -By providing native interoperability, Substrate enables the creation of a diverse, interconnected ecosystem of blockchains. This aligns with the vision of a multi-chain future, where different blockchains can work together to provide a richer, more capable blockchain environment. - -Moonbeam's networks have a series of XCM connections with many other parachains. You can view upcoming XCM integrations in the [XCM section of the Moonbeam forum](https://forum.moonbeam.network/c/xcm-hrmp/13){target=\_blank}. diff --git a/learn/platform/technology.md b/learn/platform/technology.md index 8f20618c1..218ce55d5 100644 --- a/learn/platform/technology.md +++ b/learn/platform/technology.md @@ -1,13 +1,13 @@ --- title: Technology & Architecture -description: Moonbeam is built using Rust and the Substrate framework, enabling rich tools for implementation but also allowing for specialization and optimization. +description: Moonbeam is built using Rust and Polkadot's Substrate framework, enabling rich tools for implementation while allowing for specialization and optimization. --- # Technology & Architecture ## The Moonbeam Development Stack {: #the-moonbeam-development-stack } -Moonbeam is a smart contract blockchain platform built in the Rust programming language using the Substrate framework. +Moonbeam is a smart contract blockchain platform built in the Rust programming language using the Substrate framework. Substrate, developed by [Parity Technologies](https://www.parity.io/){target=_blank} (the original founding contributors of Polkadot), is an open-source, modular SDK for creating blockchains. Substrate allows developers to customize their blockchains while still benefiting from features such as forkless upgrades, shared security (when connected as a parachain to Polkadot or Kusama), and an extensive library of pre-built runtime modules known as pallets. ### Rust Programming Language {: #rust-programming-language } @@ -15,47 +15,70 @@ Rust is a good language for implementing a blockchain. It is highly performant l ### Substrate Framework {: #substrate-framework } -Substrate provides a rich set of tools for creating blockchains, including a runtime execution environment that enables a generic state transition function and a pluggable set of modules that implement various blockchain subsystems. +Substrate provides a rich set of tools for creating blockchains, including a runtime execution environment that enables a generic state transition function and a pluggable set of modules (pallets) that implement various blockchain subsystems. By using Substrate, Moonbeam can integrate with the Polkadot relay chain to become a parachain, which enables: -Moonbeam leverages multiple existing Substrate frame pallets to provide key blockchain services and functionality, including core blockchain data structures, peer-to-peer networking, consensus mechanisms, accounts, assets, and balances. Custom pallets and logic in the runtime implement Moonbeam-specific behavior and functionality, such as cross-chain token integration. For leveraged pallets, Moonbeam will strive to stay as close as possible to the upstream Substrate codebase and incorporate Substrate bug fixes, enhancements, and new features on an ongoing basis. +- **Shared security** — Polkadot's validators secure all parachains +- **Cross-Consensus Messaging (XCM)** — native interoperability with other parachains +- **Flexible Upgrades** — Substrate’s forkless upgrade mechanism + +Pallets are at the heart of Substrate-based chains, providing specific functionality in modular form. Examples include: + +- **Balances Pallet** — manages account balances and transfers +- **Assets Pallet** — handles the creation and management of on-chain fungible assets +- **Consensus Pallets** — provide mechanisms like AURA or BABE for block production +- **Governance Pallets** — facilitate on-chain governance +- **Frontier Pallets** — the Ethereum compatibility layer pioneered by the Moonbeam team +- **Parachain Staking Pallet** — enables Delegated Proof of Stake (DPoS) + +In addition to these pallets provided by Polkadot’s Substrate, developers can [create their own pallets](https://docs.substrate.io/tutorials/collectibles-workshop/03-create-pallet){target=_blank} to add custom functionality. Moonbeam leverages multiple existing Substrate frame pallets as well as several custom pallets for features such as cross-chain token integration, the [Orbiter Program](/node-operators/networks/collators/orbiter/){target=_blank}, and more. You can find the Moonbeam runtime (built using Substrate) and related pallets in the [Moonbeam GitHub repository](https://github.com/moonbeam-foundation/moonbeam){target=_blank}. + +Moonbeam also uses the Cumulus library to provide integration to the Polkadot relay chain. ### Frontier: Substrate's Ethereum Compatibility Layer {: #frontier } -[Frontier](https://polkadot-evm.github.io/frontier){target=\_blank} serves as Substrate's Ethereum compatibility layer, facilitating the seamless operation of standard Ethereum DApps on Substrate-based chains without requiring modifications. This compatibility is achieved by integrating specialized Substrate pallets into the Substrate runtime. These pallets include the EVM pallet, responsible for executing EVM operations; the Ethereum pallet, which manages block data storage and offers RPC compatibility; the Base Fee pallet, enabling support for EIP-1559 transactions and handling base fee calculations; and the Dynamic Fee pallet, responsible for computing dynamic minimum gas prices. +[Frontier](https://polkadot-evm.github.io/frontier){target=\_blank} serves as Substrate's Ethereum compatibility layer, facilitating the seamless operation of standard Ethereum DApps on Substrate-based chains without requiring modifications. This compatibility is achieved by integrating specialized Substrate pallets into the Substrate runtime. These pallets include: -Moonbeam uses the EVM and Ethereum pallets to achieve full Ethereum compatibility. Moonbeam does not use the Base Fee or Dynamic Fee pallets. Instead, Moonbeam has its own [dynamic fee mechanism](https://forum.moonbeam.network/t/proposal-status-idea-dynamic-fee-mechanism-for-moonbeam-and-moonriver/241){target=\_blank} for base fee calculations. +- **EVM pallet** — responsible for executing EVM operations +- **Ethereum pallet** — manages block data storage and offers RPC compatibility +- **Base Fee pallet & Dynamic Fee pallet** — provide EIP-1559 functionality (not used in Moonbeam) -By basing our EVM implementation on the Substrate EVM Pallet, we get a full Rust-based EVM implementation and support from the Parity engineering team. +Moonbeam uses the EVM and Ethereum pallets to achieve full Ethereum compatibility. Instead of the Base Fee or Dynamic Fee pallets, Moonbeam has its own [dynamic fee mechanism](https://forum.moonbeam.network/t/proposal-status-idea-dynamic-fee-mechanism-for-moonbeam-and-moonriver/241){target=\_blank} for base fee calculations. Basing the EVM implementation on the Substrate EVM Pallet provides a Rust-based EVM engine and support from the Parity engineering team. ## Blockchain Runtime {: #blockchain-runtime } -The core Moonbeam runtime specifies the state transition function and behavior of the Moonbeam blockchain. The Moonbeam runtime is built using [FRAME](/learn/platform/glossary/#substrate-frame-pallets){target=\_blank}. It includes several standard pallets as well as several custom ones. The runtime is compiled to a [WebAssembly (Wasm)](/learn/platform/glossary/#webassemblywasm){target=\_blank} binary as well as a native binary. These compiled versions are executed in the Polkadot relay chain and Moonbeam node environments. +The core Moonbeam runtime specifies the state transition function and behavior of the Moonbeam blockchain. The runtime is built using [FRAME](/learn/platform/glossary/#substrate-frame-pallets){target=\_blank}, compiled to a [WebAssembly (Wasm)](/learn/platform/glossary/#webassemblywasm){target=\_blank} binary as well as a native binary. These compiled versions are executed in the Polkadot relay chain and Moonbeam node environments. !!! note Substrate FRAME pallets are a collection of Rust-based modules that provide the functionality required when building a blockchain. WebAssembly is an open standard that defines a portable binary code format. Different programming languages, compilers, and browsers support it. Find more definitions [in our glossary](/learn/platform/glossary/){target=\_blank}. Some of the key Substrate FRAME pallets used in the Moonbeam runtime include: - - **Balances** — support for accounts, balances, and transfers - - **EVM** — full Rust-based EVM implementation based on SputnikVM. Provides the state transition logic for Moonbeam-based smart contracts (part of Frontier) - - **Ethereum** — provides emulation of Ethereum block processing for the EVM (part of Frontier) - - **Executive** — orchestration layer that dispatches calls to other runtime modules - - **Identity** — support for setting on-chain identities for account addresses - - **System** — provides low-level types, storage, and blockchain functions - - **Treasury** — on-chain treasury that can be used to fund public goods such as a parachain slot + - **Balances** — support for accounts, balances, and transfers + - **EVM** — a full Rust-based EVM implementation based on SputnikVM (part of Frontier) + - **Ethereum** — provides emulation of Ethereum block processing for the EVM (part of Frontier) + - **Executive** — orchestration layer that dispatches calls to other runtime modules + - **Identity** — support for setting on-chain identities for account addresses + - **System** — provides low-level types, storage, and blockchain functions + - **Treasury** — on-chain treasury that can be used to fund public goods such as a parachain slot In addition to these Substrate FRAME Pallets, Moonbeam implements custom pallets to achieve additional functionality, such as: -- **Parachain Staking** - enables a Delegated Proof of Stake (DPoS) system -- **Moonbeam Orbiters** - supports the [Orbiter Program](/node-operators/networks/collators/orbiter/){target=\_blank}, which diversifies the collator pool -- **XCM Transactor** - simplifies remote cross-chain calls via [Cross-Consensus Messaging (XCM)](/builders/interoperability/xcm/overview/){target=\_blank} -- **Asset Manager** - registers XCM assets +- **Parachain Staking** — enables a Delegated Proof of Stake (DPoS) system +- **Moonbeam Orbiters** — supports the [Orbiter Program](/node-operators/networks/collators/orbiter/){target=\_blank}, which diversifies the collator pool +- **XCM Transactor** — simplifies remote cross-chain calls via [Cross-Consensus Messaging (XCM)](/builders/interoperability/xcm/overview/){target=\_blank} +- **Asset Manager** — registers XCM assets -Moonbeam also uses the Cumulus library to provide integration to the Polkadot relay chain. +### Forkless Upgrades {: #forkless-upgrades } + +One of the best things about developing on Polkadot with Substrate is the ability to introduce [forkless upgrades](https://docs.substrate.io/maintain/runtime-upgrades){target=_blank} to blockchain runtimes. In traditional blockchain architectures, substantial changes to the blockchain’s rules often require a hard fork, which can be disruptive and contentious. + +Substrate takes a different approach by separating the blockchain’s state (data) from its logic (rules). Logic lives in the runtime, which is itself stored on-chain. Whenever a new runtime is uploaded (via FRAME’s `set_code` call) and approved through on-chain governance, all nodes automatically switch to the new runtime at a specified block. This process is seamless and does not split the network. + +Moonbeam regularly uses forkless upgrades to add features or fixes without requiring node operators to manually upgrade their software. You can keep track of and discuss upcoming Moonbeam upgrades on the [Moonbeam forum](https://forum.moonbeam.network){target=_blank}. ## Ethereum Compatibility Architecture {: #ethereum-compatibility-architecture } -Smart contracts on Moonbeam can be implemented using Solidity, Vyper, and any other language that can compile smart contracts to EVM-compatible bytecode. Moonbeam aims to provide a low-friction and secure environment for the development, testing, and execution of smart contracts, that is compatible with the existing Ethereum developer toolchain. +Smart contracts on Moonbeam can be implemented using Solidity, Vyper, and any other language that can compile smart contracts to EVM-compatible bytecode. Moonbeam aims to provide a low-friction and secure environment for the development, testing, and execution of smart contracts, while remaining compatible with the existing Ethereum developer toolchain. The execution behavior and semantics of Moonbeam-based smart contracts strive to be as close as possible to Ethereum Layer 1. Moonbeam is a single shard, so cross-contract calls have the same synchronous execution semantics as on Ethereum Layer 1. @@ -67,27 +90,17 @@ A high-level interaction flow is shown above. A Web3 RPC call from a DApp or exi The [Ethereum pallet](https://polkadot-evm.github.io/frontier/frame/ethereum.html){target=\_blank} is responsible for handling blocks and transaction receipts and statuses. It enables sending and receiving Ethereum-formatted data to and from Moonbeam by storing an Ethereum-style block and its associated transaction hashes in the Substrate runtime. -When a user submits a raw Ethereum transaction, it converts into a Substrate transaction through the pallet Ethereum's `transact` extrinsic. Using the Ethereum pallet as the sole executor of the EVM pallet forces all of the data to be stored and transacted in an Ethereum-compatible way. This enables block explorers such as [Moonscan](/builders/get-started/explorers/#moonscan){target=\_blank}, which is built by Etherscan, to be able to index block data. - -Along with support for Ethereum-style data, the Ethereum pallet combined with the [RPC module](https://github.com/polkadot-evm/frontier/tree/master/client/rpc){target=\_blank} provides RPC support. This enables usage of [basic Ethereum JSON-RPC methods](/builders/ethereum/json-rpc/eth-rpc/#basic-ethereum-json-rpc-methods){target=\_blank}, which ultimately allows existing Ethereum DApps to be deployed to Moonbeam with minimal changes. +When a user submits a raw Ethereum transaction, it converts into a Substrate transaction through the Ethereum pallet’s `transact` extrinsic. Using the Ethereum pallet as the sole executor of the EVM pallet forces all of the data to be stored and transacted in an Ethereum-compatible way, which is how explorers like [Moonscan](/builders/get-started/explorers/#moonscan){target=\_blank} (built by Etherscan) can index block data. ### EVM Pallet {: #evm-pallet } -The [EVM pallet](https://polkadot-evm.github.io/frontier/frame/ethereum.html){target=\_blank} implements a sandboxed virtual stack machine and uses the [SputnikVM](https://github.com/rust-ethereum/evm){target=\_blank} as the underlying EVM engine. - -The EVM executes Ethereum smart contract bytecode, typically written in a language like Solidity, and then compiles it to EVM bytecode. The EVM pallet aims to emulate the functionality of executing smart contracts on Ethereum within the Substrate runtime. As such, it allows existing EVM code to be executed in Substrate-based blockchains. - -Inside the EVM are standard H160 Ethereum-style accounts, with associated data such as the balance and nonce. All of the accounts in the EVM are backed by a configurable Substrate account type. Moonbeam has configured the Substrate account type to be a non-standard H160 account fully compatible with Ethereum. So, you only need a single account to interact with the Substrate runtime and the EVM. For more information on Moonbeam's account system, please refer to the [Unified Accounts](/learn/core-concepts/unified-accounts/){target=\_blank} page. - -With a unified accounts system, a mapped Substrate account can call the EVM pallet to deposit or withdraw balance from the Substrate-base currency into a different balance managed and used by the EVM pallet. Once a balance exists, smart contracts can be created and interacted with. - -The EVM pallet can also be configured so that no dispatchable calls can cause EVM execution, with the exception being from other pallets in the runtime. Moonbeam is configured this way, with the Ethereum pallet having sole responsibility for EVM execution. Using the Ethereum pallet enables EVM interactions through the Ethereum API. +The [EVM pallet](https://polkadot-evm.github.io/frontier/frame/ethereum.html){target=\_blank} implements a sandboxed virtual stack machine and uses the [SputnikVM](https://github.com/rust-ethereum/evm){target=\_blank} as the underlying EVM engine. It executes Ethereum smart contract bytecode in a manner similar to Ethereum mainnet, including gas metering and state changes. -If a blockchain doesn't need Ethereum emulation and only needs EVM execution, Substrate uses its account model fully and signs transactions on behalf of EVM accounts. However, Ethereum RPCs are unavailable in this model, and DApps must write their frontend using the Substrate API. +Moonbeam uses **unified accounts**, meaning an H160 (Ethereum-style) address is also a valid Substrate address, so you only need a single account to interact with the Substrate runtime and the EVM. Once a balance exists in the EVM, smart contracts can be created and interacted with through standard Ethereum RPC calls. -The EVM pallet should produce nearly identical execution results to Ethereum, such as gas cost and balance changes. However, there are some differences. Please refer to the [EVM module vs Ethereum network](https://polkadot-evm.github.io/frontier/frame/evm.html#evm-module-vs-ethereum-network){target=\_blank} section of the Frontier EVM Pallet documentation for more information. +The EVM pallet should produce nearly identical execution results to Ethereum, such as gas cost and balance changes. However, there are some differences. Please refer to the [EVM module vs Ethereum network](https://polkadot-evm.github.io/frontier/frame/evm.html#evm-module-vs-ethereum-network){target=\_blank} section of the Frontier EVM Pallet documentation for more information. Although the EVM pallet aims for near-identical behavior to Ethereum, some differences exist, for example, Moonbeam’s [dynamic fee mechanism](https://forum.moonbeam.network/t/proposal-dynamic-fee-mechanism-for-moonbeam-and-moonriver/241){target=\_blank}For more information, refer to the [Frontier EVM Pallet documentation](https://polkadot-evm.github.io/frontier/frame/evm.html#evm-module-vs-ethereum-network){target=\_blank}. -There are also some [precompiles](https://github.com/polkadot-evm/frontier/tree/4c05c2b09e71336d6b11207e6d12e486b4d2705c#evm-pallet-precompiles){target=\_blank} that can be used alongside the EVM pallet that extends the functionality of the EVM. Moonbeam uses the following EVM precompiles: +Moonbeam also includes additional EVM precompiles for functionalities like cryptographic operations (ECRecover, SHA256, BLAKE2, BN128) and dispatching Substrate calls directly from within the EVM. Moonbeam uses the following EVM precompiles: - **[pallet-evm-precompile-simple](https://polkadot-evm.github.io/frontier/rustdocs/pallet_evm_precompile_simple){target=\_blank}** - includes five basic precompiles: ECRecover, ECRecoverPublicKey, Identity, RIPEMD160, SHA256 - **[pallet-evm-precompile-blake2](https://polkadot-evm.github.io/frontier/rustdocs/pallet_evm_precompile_blake2/struct.Blake2F.html){target=\_blank}** - includes the BLAKE2 precompile @@ -97,3 +110,11 @@ There are also some [precompiles](https://github.com/polkadot-evm/frontier/tree/ - **[pallet-evm-precompile-dispatch](https://polkadot-evm.github.io/frontier/rustdocs/pallet_evm_precompile_dispatch/struct.Dispatch.html){target=\_blank}** - includes the dispatch precompile You can find an overview of most of these precompiles on the [Ethereum MainNet Precompiled Contracts](/builders/ethereum/precompiles/utility/eth-mainnet/){target=\_blank} page. + +## Native Interoperability {: #native-interoperability } + +While Substrate allows developers to create blockchains, one of its biggest advantages is that it supports integration for native interoperability through relay chains like Polkadot and Kusama. + +A relay chain is a central chain that connects several blockchains, known as parachains. Each parachain is a distinct blockchain with its own runtime and state, but all are connected to and secured by the relay chain. Once connected, parachains can communicate via [Cross-Consensus Messaging (XCM)](/builders/interoperability/xcm/overview/){target=_blank} to exchange information and conduct transactions in the same language, enabling a wide range of interoperable applications. + +Moonbeam’s networks have established or planned XCM connections with various parachains. You can view upcoming XCM integrations in the [XCM section of the Moonbeam forum](https://forum.moonbeam.network/c/xcm-hrmp/13){target=_blank}. \ No newline at end of file From c40fd1a75c4652ab1890430a4c151996fcafb243 Mon Sep 17 00:00:00 2001 From: Kevin Neilson Date: Tue, 14 Jan 2025 10:42:09 -0800 Subject: [PATCH 3/9] revision --- learn/platform/technology.md | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/learn/platform/technology.md b/learn/platform/technology.md index 218ce55d5..53e7fdb45 100644 --- a/learn/platform/technology.md +++ b/learn/platform/technology.md @@ -15,7 +15,7 @@ Rust is a good language for implementing a blockchain. It is highly performant l ### Substrate Framework {: #substrate-framework } -Substrate provides a rich set of tools for creating blockchains, including a runtime execution environment that enables a generic state transition function and a pluggable set of modules (pallets) that implement various blockchain subsystems. By using Substrate, Moonbeam can integrate with the Polkadot relay chain to become a parachain, which enables: +Substrate provides a rich set of tools for creating blockchains, including a runtime execution environment that enables a generic state transition function and a pluggable set of modules (pallets) that implement various blockchain subsystems. By using Substrate, Moonbeam can leverage a number of key features offered to parachains launched on the Polkadot Relay Chain, including: - **Shared security** — Polkadot's validators secure all parachains - **Cross-Consensus Messaging (XCM)** — native interoperability with other parachains @@ -96,8 +96,7 @@ When a user submits a raw Ethereum transaction, it converts into a Substrate tra The [EVM pallet](https://polkadot-evm.github.io/frontier/frame/ethereum.html){target=\_blank} implements a sandboxed virtual stack machine and uses the [SputnikVM](https://github.com/rust-ethereum/evm){target=\_blank} as the underlying EVM engine. It executes Ethereum smart contract bytecode in a manner similar to Ethereum mainnet, including gas metering and state changes. -Moonbeam uses **unified accounts**, meaning an H160 (Ethereum-style) address is also a valid Substrate address, so you only need a single account to interact with the Substrate runtime and the EVM. Once a balance exists in the EVM, smart contracts can be created and interacted with through standard Ethereum RPC calls. - +Moonbeam uses unified accounts, meaning an H160 (Ethereum-style) address is also a valid Substrate address, so you only need a single account to interact with the Substrate runtime and the EVM. Once a balance exists in the EVM, smart contracts can be created and interacted with through standard Ethereum RPC calls. The EVM pallet should produce nearly identical execution results to Ethereum, such as gas cost and balance changes. However, there are some differences. Please refer to the [EVM module vs Ethereum network](https://polkadot-evm.github.io/frontier/frame/evm.html#evm-module-vs-ethereum-network){target=\_blank} section of the Frontier EVM Pallet documentation for more information. Although the EVM pallet aims for near-identical behavior to Ethereum, some differences exist, for example, Moonbeam’s [dynamic fee mechanism](https://forum.moonbeam.network/t/proposal-dynamic-fee-mechanism-for-moonbeam-and-moonriver/241){target=\_blank}For more information, refer to the [Frontier EVM Pallet documentation](https://polkadot-evm.github.io/frontier/frame/evm.html#evm-module-vs-ethereum-network){target=\_blank}. Moonbeam also includes additional EVM precompiles for functionalities like cryptographic operations (ECRecover, SHA256, BLAKE2, BN128) and dispatching Substrate calls directly from within the EVM. Moonbeam uses the following EVM precompiles: @@ -117,4 +116,4 @@ While Substrate allows developers to create blockchains, one of its biggest adva A relay chain is a central chain that connects several blockchains, known as parachains. Each parachain is a distinct blockchain with its own runtime and state, but all are connected to and secured by the relay chain. Once connected, parachains can communicate via [Cross-Consensus Messaging (XCM)](/builders/interoperability/xcm/overview/){target=_blank} to exchange information and conduct transactions in the same language, enabling a wide range of interoperable applications. -Moonbeam’s networks have established or planned XCM connections with various parachains. You can view upcoming XCM integrations in the [XCM section of the Moonbeam forum](https://forum.moonbeam.network/c/xcm-hrmp/13){target=_blank}. \ No newline at end of file +Moonbeam and Moonriver have established XCM connections with a large number of parachains. You can see a visualization of all XCM integrations in this [XCM Channel Viewer](https://dotsama-channels.vercel.app/#/){target=_blank}. \ No newline at end of file From 5defbc44746b1046e551488276b22f12e8249b76 Mon Sep 17 00:00:00 2001 From: Kevin Neilson Date: Tue, 14 Jan 2025 10:44:47 -0800 Subject: [PATCH 4/9] run grammarly --- learn/platform/technology.md | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/learn/platform/technology.md b/learn/platform/technology.md index 53e7fdb45..a64c3da03 100644 --- a/learn/platform/technology.md +++ b/learn/platform/technology.md @@ -15,7 +15,7 @@ Rust is a good language for implementing a blockchain. It is highly performant l ### Substrate Framework {: #substrate-framework } -Substrate provides a rich set of tools for creating blockchains, including a runtime execution environment that enables a generic state transition function and a pluggable set of modules (pallets) that implement various blockchain subsystems. By using Substrate, Moonbeam can leverage a number of key features offered to parachains launched on the Polkadot Relay Chain, including: +Substrate provides a rich set of tools for creating blockchains, including a runtime execution environment that enables a generic state transition function and a pluggable set of modules (pallets) that implement various blockchain subsystems. By using Substrate, Moonbeam can leverage several key features offered to parachains launched on the Polkadot Relay Chain, including: - **Shared security** — Polkadot's validators secure all parachains - **Cross-Consensus Messaging (XCM)** — native interoperability with other parachains @@ -32,7 +32,7 @@ Pallets are at the heart of Substrate-based chains, providing specific functiona In addition to these pallets provided by Polkadot’s Substrate, developers can [create their own pallets](https://docs.substrate.io/tutorials/collectibles-workshop/03-create-pallet){target=_blank} to add custom functionality. Moonbeam leverages multiple existing Substrate frame pallets as well as several custom pallets for features such as cross-chain token integration, the [Orbiter Program](/node-operators/networks/collators/orbiter/){target=_blank}, and more. You can find the Moonbeam runtime (built using Substrate) and related pallets in the [Moonbeam GitHub repository](https://github.com/moonbeam-foundation/moonbeam){target=_blank}. -Moonbeam also uses the Cumulus library to provide integration to the Polkadot relay chain. +Moonbeam also uses the Cumulus library to facilitate integration with the Polkadot relay chain. ### Frontier: Substrate's Ethereum Compatibility Layer {: #frontier } @@ -74,23 +74,23 @@ One of the best things about developing on Polkadot with Substrate is the abilit Substrate takes a different approach by separating the blockchain’s state (data) from its logic (rules). Logic lives in the runtime, which is itself stored on-chain. Whenever a new runtime is uploaded (via FRAME’s `set_code` call) and approved through on-chain governance, all nodes automatically switch to the new runtime at a specified block. This process is seamless and does not split the network. -Moonbeam regularly uses forkless upgrades to add features or fixes without requiring node operators to manually upgrade their software. You can keep track of and discuss upcoming Moonbeam upgrades on the [Moonbeam forum](https://forum.moonbeam.network){target=_blank}. +Moonbeam regularly uses forkless upgrades to add features or fixes without requiring node operators to upgrade their software manually. You can keep track of and discuss upcoming Moonbeam upgrades on the [Moonbeam forum](https://forum.moonbeam.network){target=_blank}. ## Ethereum Compatibility Architecture {: #ethereum-compatibility-architecture } -Smart contracts on Moonbeam can be implemented using Solidity, Vyper, and any other language that can compile smart contracts to EVM-compatible bytecode. Moonbeam aims to provide a low-friction and secure environment for the development, testing, and execution of smart contracts, while remaining compatible with the existing Ethereum developer toolchain. +Smart contracts on Moonbeam can be implemented using Solidity, Vyper, and any other language that compiles smart contracts to EVM-compatible bytecode. Moonbeam aims to provide a low-friction and secure environment for the development, testing, and execution of smart contracts while remaining compatible with the existing Ethereum developer toolchain. The execution behavior and semantics of Moonbeam-based smart contracts strive to be as close as possible to Ethereum Layer 1. Moonbeam is a single shard, so cross-contract calls have the same synchronous execution semantics as on Ethereum Layer 1. ![Diagram showing the interactions made possible through Moonbeam's Ethereum compatibility](/images/learn/platform/technology-diagram.webp) -A high-level interaction flow is shown above. A Web3 RPC call from a DApp or existing Ethereum developer tool, such as Hardhat, is received by a Moonbeam node. The node has both Web3 RPCs and Substrate RPCs available, meaning you can use Ethereum or Substrate tools when interacting with a Moonbeam node. These RPC calls are handled by associated Substrate runtime functions. The Substrate runtime checks signatures and handles any extrinsics. Smart contract calls are ultimately passed to the EVM to execute the state transitions. +A high-level interaction flow is shown above. A Web3 RPC call from a DApp or existing Ethereum developer tool, such as Hardhat, is received by a Moonbeam node. The node has both Web3 RPCs and Substrate RPCs available, meaning you can use Ethereum or Substrate tools when interacting with a Moonbeam node. Associated Substrate runtime functions handle these RPC calls. The Substrate runtime checks signatures and handles any extrinsics. Smart contract calls are ultimately passed to the EVM to execute the state transitions. ### Ethereum Pallet {: #ethereum-pallet} The [Ethereum pallet](https://polkadot-evm.github.io/frontier/frame/ethereum.html){target=\_blank} is responsible for handling blocks and transaction receipts and statuses. It enables sending and receiving Ethereum-formatted data to and from Moonbeam by storing an Ethereum-style block and its associated transaction hashes in the Substrate runtime. -When a user submits a raw Ethereum transaction, it converts into a Substrate transaction through the Ethereum pallet’s `transact` extrinsic. Using the Ethereum pallet as the sole executor of the EVM pallet forces all of the data to be stored and transacted in an Ethereum-compatible way, which is how explorers like [Moonscan](/builders/get-started/explorers/#moonscan){target=\_blank} (built by Etherscan) can index block data. +When a user submits a raw Ethereum transaction, it converts into a Substrate transaction through the Ethereum pallet’s `transact` extrinsic—using the Ethereum pallet as the sole executor of the EVM pallet forces all of the data to be stored and transacted in an Ethereum-compatible way, which is how explorers like [Moonscan](/builders/get-started/explorers/#moonscan){target=\_blank} (built by Etherscan) can index block data. ### EVM Pallet {: #evm-pallet } @@ -99,7 +99,7 @@ The [EVM pallet](https://polkadot-evm.github.io/frontier/frame/ethereum.html){ta Moonbeam uses unified accounts, meaning an H160 (Ethereum-style) address is also a valid Substrate address, so you only need a single account to interact with the Substrate runtime and the EVM. Once a balance exists in the EVM, smart contracts can be created and interacted with through standard Ethereum RPC calls. The EVM pallet should produce nearly identical execution results to Ethereum, such as gas cost and balance changes. However, there are some differences. Please refer to the [EVM module vs Ethereum network](https://polkadot-evm.github.io/frontier/frame/evm.html#evm-module-vs-ethereum-network){target=\_blank} section of the Frontier EVM Pallet documentation for more information. Although the EVM pallet aims for near-identical behavior to Ethereum, some differences exist, for example, Moonbeam’s [dynamic fee mechanism](https://forum.moonbeam.network/t/proposal-dynamic-fee-mechanism-for-moonbeam-and-moonriver/241){target=\_blank}For more information, refer to the [Frontier EVM Pallet documentation](https://polkadot-evm.github.io/frontier/frame/evm.html#evm-module-vs-ethereum-network){target=\_blank}. -Moonbeam also includes additional EVM precompiles for functionalities like cryptographic operations (ECRecover, SHA256, BLAKE2, BN128) and dispatching Substrate calls directly from within the EVM. Moonbeam uses the following EVM precompiles: +Moonbeam includes additional EVM precompiles for functionalities like cryptographic operations (ECRecover, SHA256, BLAKE2, BN128) and dispatching Substrate calls directly from within the EVM. Moonbeam uses the following EVM precompiles: - **[pallet-evm-precompile-simple](https://polkadot-evm.github.io/frontier/rustdocs/pallet_evm_precompile_simple){target=\_blank}** - includes five basic precompiles: ECRecover, ECRecoverPublicKey, Identity, RIPEMD160, SHA256 - **[pallet-evm-precompile-blake2](https://polkadot-evm.github.io/frontier/rustdocs/pallet_evm_precompile_blake2/struct.Blake2F.html){target=\_blank}** - includes the BLAKE2 precompile @@ -112,8 +112,8 @@ You can find an overview of most of these precompiles on the [Ethereum MainNet P ## Native Interoperability {: #native-interoperability } -While Substrate allows developers to create blockchains, one of its biggest advantages is that it supports integration for native interoperability through relay chains like Polkadot and Kusama. +While Substrate allows developers to create blockchains, one of its most significant advantages is that it supports integration for native interoperability through relay chains like Polkadot and Kusama. -A relay chain is a central chain that connects several blockchains, known as parachains. Each parachain is a distinct blockchain with its own runtime and state, but all are connected to and secured by the relay chain. Once connected, parachains can communicate via [Cross-Consensus Messaging (XCM)](/builders/interoperability/xcm/overview/){target=_blank} to exchange information and conduct transactions in the same language, enabling a wide range of interoperable applications. +A relay chain is a central chain that connects several blockchains, known as parachains. Each parachain is a distinct blockchain with its runtime and state, but all are connected to and secured by the relay chain. Once connected, parachains can communicate via [Cross-Consensus Messaging (XCM)](/builders/interoperability/xcm/overview/){target=_blank} to exchange information and conduct transactions in the same language, enabling a wide range of interoperable applications. Moonbeam and Moonriver have established XCM connections with a large number of parachains. You can see a visualization of all XCM integrations in this [XCM Channel Viewer](https://dotsama-channels.vercel.app/#/){target=_blank}. \ No newline at end of file From 8290dda9d01bfb16613a7f80a1c5093003ad3da7 Mon Sep 17 00:00:00 2001 From: Kevin Neilson Date: Tue, 14 Jan 2025 10:52:08 -0800 Subject: [PATCH 5/9] add --- learn/platform/technology.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/learn/platform/technology.md b/learn/platform/technology.md index a64c3da03..4ba2787c4 100644 --- a/learn/platform/technology.md +++ b/learn/platform/technology.md @@ -42,7 +42,7 @@ Moonbeam also uses the Cumulus library to facilitate integration with the Polkad - **Ethereum pallet** — manages block data storage and offers RPC compatibility - **Base Fee pallet & Dynamic Fee pallet** — provide EIP-1559 functionality (not used in Moonbeam) -Moonbeam uses the EVM and Ethereum pallets to achieve full Ethereum compatibility. Instead of the Base Fee or Dynamic Fee pallets, Moonbeam has its own [dynamic fee mechanism](https://forum.moonbeam.network/t/proposal-status-idea-dynamic-fee-mechanism-for-moonbeam-and-moonriver/241){target=\_blank} for base fee calculations. Basing the EVM implementation on the Substrate EVM Pallet provides a Rust-based EVM engine and support from the Parity engineering team. +Moonbeam uses the EVM and Ethereum pallets to achieve full Ethereum compatibility. Instead of the Base Fee or Dynamic Fee pallets, Moonbeam has its own [dynamic fee mechanism](https://forum.moonbeam.network/t/proposal-dynamic-fee-mechanism-for-moonbeam-and-moonriver/241){target=\_blank} for base fee calculations. Basing the EVM implementation on the Substrate EVM Pallet provides a Rust-based EVM engine and support from the Parity engineering team. ## Blockchain Runtime {: #blockchain-runtime } @@ -97,7 +97,7 @@ When a user submits a raw Ethereum transaction, it converts into a Substrate tra The [EVM pallet](https://polkadot-evm.github.io/frontier/frame/ethereum.html){target=\_blank} implements a sandboxed virtual stack machine and uses the [SputnikVM](https://github.com/rust-ethereum/evm){target=\_blank} as the underlying EVM engine. It executes Ethereum smart contract bytecode in a manner similar to Ethereum mainnet, including gas metering and state changes. Moonbeam uses unified accounts, meaning an H160 (Ethereum-style) address is also a valid Substrate address, so you only need a single account to interact with the Substrate runtime and the EVM. Once a balance exists in the EVM, smart contracts can be created and interacted with through standard Ethereum RPC calls. -The EVM pallet should produce nearly identical execution results to Ethereum, such as gas cost and balance changes. However, there are some differences. Please refer to the [EVM module vs Ethereum network](https://polkadot-evm.github.io/frontier/frame/evm.html#evm-module-vs-ethereum-network){target=\_blank} section of the Frontier EVM Pallet documentation for more information. Although the EVM pallet aims for near-identical behavior to Ethereum, some differences exist, for example, Moonbeam’s [dynamic fee mechanism](https://forum.moonbeam.network/t/proposal-dynamic-fee-mechanism-for-moonbeam-and-moonriver/241){target=\_blank}For more information, refer to the [Frontier EVM Pallet documentation](https://polkadot-evm.github.io/frontier/frame/evm.html#evm-module-vs-ethereum-network){target=\_blank}. +The EVM pallet should produce nearly identical execution results to Ethereum, such as gas cost and balance changes. However, there are some differences. Please refer to the [EVM module vs Ethereum network](https://polkadot-evm.github.io/frontier/frame/evm.html#evm-module-vs-ethereum-network){target=\_blank} section of the Frontier EVM Pallet documentation for more information. Although the EVM pallet aims for near-identical behavior to Ethereum, some differences exist, for example, Moonbeam’s [dynamic fee mechanism](https://forum.moonbeam.network/t/proposal-dynamic-fee-mechanism-for-moonbeam-and-moonriver/241){target=\_blank}. For more information, refer to the [Frontier EVM Pallet documentation](https://polkadot-evm.github.io/frontier/frame/evm.html#evm-module-vs-ethereum-network){target=\_blank}. Moonbeam includes additional EVM precompiles for functionalities like cryptographic operations (ECRecover, SHA256, BLAKE2, BN128) and dispatching Substrate calls directly from within the EVM. Moonbeam uses the following EVM precompiles: From 8cb8587442e1df4536f950311399f977954e1963 Mon Sep 17 00:00:00 2001 From: Kevin Neilson Date: Fri, 17 Jan 2025 10:44:47 -0800 Subject: [PATCH 6/9] Update learn/platform/technology.md Co-authored-by: Erin Shaben --- learn/platform/technology.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/learn/platform/technology.md b/learn/platform/technology.md index 4ba2787c4..ffdec9844 100644 --- a/learn/platform/technology.md +++ b/learn/platform/technology.md @@ -15,7 +15,7 @@ Rust is a good language for implementing a blockchain. It is highly performant l ### Substrate Framework {: #substrate-framework } -Substrate provides a rich set of tools for creating blockchains, including a runtime execution environment that enables a generic state transition function and a pluggable set of modules (pallets) that implement various blockchain subsystems. By using Substrate, Moonbeam can leverage several key features offered to parachains launched on the Polkadot Relay Chain, including: +Substrate provides a rich set of tools for creating blockchains, including a runtime execution environment that enables a generic state transition function and a pluggable set of modules (pallets) that implement various blockchain subsystems. By using Substrate, Moonbeam can leverage several key features offered to parachains launched on the Polkadot relay chain, including: - **Shared security** — Polkadot's validators secure all parachains - **Cross-Consensus Messaging (XCM)** — native interoperability with other parachains From 701cdec8f3a320f2f81b5d8efeab2b0fd0e78dcb Mon Sep 17 00:00:00 2001 From: Kevin Neilson Date: Fri, 17 Jan 2025 10:44:56 -0800 Subject: [PATCH 7/9] Update learn/platform/technology.md Co-authored-by: Erin Shaben --- learn/platform/technology.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/learn/platform/technology.md b/learn/platform/technology.md index ffdec9844..12cb1db8d 100644 --- a/learn/platform/technology.md +++ b/learn/platform/technology.md @@ -19,7 +19,7 @@ Substrate provides a rich set of tools for creating blockchains, including a run - **Shared security** — Polkadot's validators secure all parachains - **Cross-Consensus Messaging (XCM)** — native interoperability with other parachains -- **Flexible Upgrades** — Substrate’s forkless upgrade mechanism +- **Flexible upgrades** — Substrate’s forkless upgrade mechanism Pallets are at the heart of Substrate-based chains, providing specific functionality in modular form. Examples include: From 1e6913d38ff30157557ddc596be996ced21e53f4 Mon Sep 17 00:00:00 2001 From: Kevin Neilson Date: Fri, 17 Jan 2025 10:45:03 -0800 Subject: [PATCH 8/9] Update learn/platform/technology.md Co-authored-by: Erin Shaben --- learn/platform/technology.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/learn/platform/technology.md b/learn/platform/technology.md index 12cb1db8d..da4eef9b5 100644 --- a/learn/platform/technology.md +++ b/learn/platform/technology.md @@ -23,12 +23,12 @@ Substrate provides a rich set of tools for creating blockchains, including a run Pallets are at the heart of Substrate-based chains, providing specific functionality in modular form. Examples include: -- **Balances Pallet** — manages account balances and transfers -- **Assets Pallet** — handles the creation and management of on-chain fungible assets -- **Consensus Pallets** — provide mechanisms like AURA or BABE for block production -- **Governance Pallets** — facilitate on-chain governance -- **Frontier Pallets** — the Ethereum compatibility layer pioneered by the Moonbeam team -- **Parachain Staking Pallet** — enables Delegated Proof of Stake (DPoS) +- **Balances pallet** — manages account balances and transfers +- **Assets pallet** — handles the creation and management of on-chain fungible assets +- **Consensus pallets** — provide mechanisms like AURA or BABE for block production +- **Governance pallets** — facilitate on-chain governance +- **Frontier pallets** — the Ethereum compatibility layer pioneered by the Moonbeam team +- **Parachain Staking pallet** — enables Delegated Proof of Stake (DPoS) In addition to these pallets provided by Polkadot’s Substrate, developers can [create their own pallets](https://docs.substrate.io/tutorials/collectibles-workshop/03-create-pallet){target=_blank} to add custom functionality. Moonbeam leverages multiple existing Substrate frame pallets as well as several custom pallets for features such as cross-chain token integration, the [Orbiter Program](/node-operators/networks/collators/orbiter/){target=_blank}, and more. You can find the Moonbeam runtime (built using Substrate) and related pallets in the [Moonbeam GitHub repository](https://github.com/moonbeam-foundation/moonbeam){target=_blank}. From b14b75d05a81689c5232ea44765a7027c5828bfc Mon Sep 17 00:00:00 2001 From: Kevin Neilson Date: Fri, 17 Jan 2025 10:45:10 -0800 Subject: [PATCH 9/9] Update learn/platform/technology.md Co-authored-by: Erin Shaben --- learn/platform/technology.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/learn/platform/technology.md b/learn/platform/technology.md index da4eef9b5..647d4c38f 100644 --- a/learn/platform/technology.md +++ b/learn/platform/technology.md @@ -40,7 +40,7 @@ Moonbeam also uses the Cumulus library to facilitate integration with the Polkad - **EVM pallet** — responsible for executing EVM operations - **Ethereum pallet** — manages block data storage and offers RPC compatibility -- **Base Fee pallet & Dynamic Fee pallet** — provide EIP-1559 functionality (not used in Moonbeam) +- **Base Fee pallet and Dynamic Fee pallet** — provide EIP-1559 functionality (not used in Moonbeam) Moonbeam uses the EVM and Ethereum pallets to achieve full Ethereum compatibility. Instead of the Base Fee or Dynamic Fee pallets, Moonbeam has its own [dynamic fee mechanism](https://forum.moonbeam.network/t/proposal-dynamic-fee-mechanism-for-moonbeam-and-moonriver/241){target=\_blank} for base fee calculations. Basing the EVM implementation on the Substrate EVM Pallet provides a Rust-based EVM engine and support from the Parity engineering team.