infrablockchain-docs
en
en
  • InfraBlockchain
    • Learn
      • Architecture
        • Architecture
        • Network Participants
        • Parachain
          • System Parachains
      • Protocol
        • System Token
        • Transaction Fee
        • Proof of Transaction
      • Substrate
        • Learn
          • Basic
            • Cryptography
            • Blockchain Basics
            • Consensus
            • Networks and Nodes
            • Blockchain Transaction
            • Transaction Life Cycle
            • Offchain Operations
            • Light Client
            • Rust for Substrate
            • Introduction to Library
            • Architecture and Rust Libraries
            • File Architecture
            • Accounts, Addresses, and Keys
            • Transaction Format
            • Blockchain Randomness
          • FRAME
            • FRAME Pallets
            • FRAME Macros
            • Custom Pallets
            • Pallet Coupling
            • Origin
            • Events and Erros
            • Runtime Storage
            • State Transitions and Storage
            • SCALE Encoding
            • Weight and Fee
            • Runtime API
            • Runtime Development
          • Account
          • Address Format
          • Glossary
          • CLI
            • Archive
            • Memory Profiler
            • Node Template
            • sidecar
            • srtool
            • Subkey
            • subxt
            • try-runtime
            • tx-wrapper
          • Runtime Development
            • Basics
              • Configure Genesis State
              • Configure Runtime Constants
              • Customize a Chain Spec
              • Import a Pallet
              • Use Helper Function
            • Consensus Model
              • PoW
              • Create a Hybrid Node
            • Offchain Worker
              • Request Offchain HTTP
              • Offchain Indexing
              • Offchain Local Storage
            • Pallet Design
              • Create a Storage Structure
              • Implement Lockable Currency
              • Incorporate Randomness
              • Loose Coupling
              • Tight Coupling
            • Parachain Development
              • Add HRMP Channel
              • Add Paranodes
              • Connect to a Local Relay Chain
              • Convert a Solo Chain
              • Prepare to Launch
              • Select Collator
              • Upgrade a Parachain
            • Storage Migration
              • Basics
              • Trigger Migration
            • Test
              • Basics
              • Test a Transfer Transaction
            • Tools
              • Create a TxWrapper
              • Use Sidecar
              • try-runtime
              • Verify WASM
            • Weigths
              • Benchmark
              • Calculate Fees
              • Use Conditional Weights
              • Use Custom Weights
        • Build
          • Decide What to Build
          • Build Process
          • Determinisitc Runtime
          • Chain Spec
          • Genesis Configuration
          • Application Development
          • RPC
          • Troubleshoot Your Code
        • Tutorials
          • Install
            • Developer Tools
            • Linux
            • macOS
            • Rust Toolchain
            • Issues
            • Windows
          • Quick Start
            • Explore the Code
            • Modify Runtime
            • Start a Node
            • Substrate Basics
          • Build a Blockchain
            • Add Trusted Nodes
            • Authorize Specific Nodes
            • Build a Local Blockchain
            • Simulate Network
            • Upgrade a Running Network
          • Build Application Logic
            • Add a Pallet
            • Add Offchasin Workers
            • Publish Custom Pallets
            • Specify Origin for a Call
            • Use Macros in a Custom Pallet
          • Integrate with Tools
            • Access EVM Accounts
            • EVM Integration
            • Explore Sidecar Endpoints
            • Integrate a Light Client Node
          • Smart Contracts
            • Strategy
            • Build a Token Contract
            • Develop a Smart Contract
            • Prepare Your First Contract
            • Troubleshoot Smart Contracts
            • Use Maps for Storing Values
      • XCM
        • XCM
        • XCM Format
    • Service Chains
      • InfraDID
      • InfraEVM
      • URAuth(Universal Resource Auth)
    • DevOps
      • Build
      • Deploy
      • Monitoring
      • Runtime Upgrade
    • Tutorials
      • Basic
        • How to Interact with System Token
        • How To Pay Transaction Fee
        • How To Vote with TaaV
        • Hot to Get Validator Reward
      • Build
        • Build InfraRelayChain
        • Build Parachain
        • Open Message Passing Channels
        • Transfer Assets with XCM
      • Test
        • Benchmark
        • Check Runtime
        • Debug
        • Simulate Parachains
        • Unit Testing
      • Service Chains
        • Play with InfraDID
          • Build
          • Add Keys
          • Add Service Endpoint
          • Create InfraDID
        • Play with InfraEVM
          • Build
          • Deposit and Withdraw Token
          • Deploy ERC20 Contract
          • Deploy ERC721 Contract
          • Deploy ERC1155 Contract
  • Newnal Data Market
Powered by GitBook
On this page
  • System pallets
  • Functional pallets
  • Parachain pallets
  • Additional information
  1. InfraBlockchain
  2. Learn
  3. Substrate
  4. Learn
  5. FRAME

FRAME Pallets

Provides an overview of the most commonly-used predefined FRAME pallets.

PreviousFRAMENextFRAME Macros

Last updated 1 year ago

The FRAME development environment provides modules—called pallets—and support libraries that you can use, modify, and extend to build the runtime logic to suit the needs of your blockchain.

This section provides an overview of the predefined pallets and links to the Rust API reference documentation, where you can find details about each pallet's interfaces.

System pallets

The FRAME system pallets are integral to the Substrate runtime and provide core functionality that all other pallets depend on.

System pallet name
What it's for

Contains common runtime patterns for benchmarking and testing purposes.

Orchestrates incoming function calls by sending them to the appropriate pallets in the runtime.

Provides Rust macros, types, traits, and modules that generate boilerplate code for the pallet structure when compiled.

Defines low-level types for Substrate primitives, storage items, and core functions for the blockchain. All other pallets depend on the frame_system crate.

Functional pallets

The Substrate development framework includes many functional pallets that provide features you might find generally useful as composable components of your blockchain. These functional pallets are prebuilt and freely available to enable the community to share, reuse, and improve the interfaces to address common use cases.

The following table highlights some of the most commonly used pallets available. However, the number of pallets that provide specialized functionality and how they provide that functionality changes frequently. You should check the for the most up-to-date listing of pallets and for details about using them.

Prebuilt pallet name
What it's for

Initializes a collective for community members to join in an effort to establish rules against bad behavior and to provide recognition and influence for teams that contribute to the ecosystem.

Provides simple and secure methods for dealing with fungible assets.

Enables sending funds from an origin to a target. A proof is used to allow the target to claim the swap. If the swap is not claimed within a specified duration of time, the sender may cancel it.

Extends the authority round (Aura) consensus model by managing offline reporting.

Retrieves the current set of authorities, learns its own authority ID, and signs and verifies messages to and from other authorities.

Tracks the current author of the block and recent uncles.

Extends BABE consensus by collecting on-chain randomness from VRF outputs and managing epoch transitions.

Provides functionality for handling accounts and balances.

Manages rewards for performing specified work or for achieving a specified set of objectives.

Allows a set of account IDs to make their collective feelings known through dispatched calls from specialized origins.

Provides functionality for the runtime to deploy and execute WebAssembly smart contracts.

Provides common definitions that are used by the pallet_contracts crate for smart contracts.

Provides a democratic system that handles administration of general stakeholder voting.

Enables an election provider to conduct an election consisting of signed and unsigned phases.

Demonstrates concepts, APIs, and structures that are applicable for most pallets.

Demonstrates concepts, APIs, and structures that are applicable for most offchain workers.

Extends the GRANDPA consensus by managing the GRANDPA authority set ready for the native code.

Enables a federated naming system that allows multiple registrars to be added from a specified origin. Registrars can set a fee to provide identity-verification service.

Allows validators to gossip a heartbeat transaction with each new session to signal that the node is online.

Allocates indices for newly created accounts. An index is a short form of an address.

Configures a lottery that enables network participants to purchase tickets.

Allows control of membership of a set of AccountIds, useful for managing the membership of a collective.

Enables multi-signature dispatches.

Demonstrates simplified account naming on-chain. It makes no effort to create a name hierarchy, be a DNS replacement, or provide reverse lookups.

Tracks reported offences.

Allows accounts to give permission to other accounts to dispatch types of calls from their signed origin.

Provides a random function that can be used in tests and generates low-influence random values based on the block hashes from the previous 81 blocks. This pallet is not intended for use in production.

Provides a social recovery tool for users to gain access to their accounts if their private key or other authentication mechanism is lost. This pallet enables an account owner to identify trusted parties who can act on the owner's behalf to recover access to an account.

Exposes capabilities for scheduling dispatches to occur at a specified block number or at a specified period. These scheduled dispatches can be named or anonymous and can be canceled.

Maintains a scored membership pool where the highest scoring entities are made members.

Allows validators to manage their session keys, provides a function for changing the session length, and handles session rotation.

Provides economic incentives for users to participate and maintain a membership society.

Manages funds that have been staked by network maintainers.

Allows for a single account—called the sudo key—to execute dispatchable functions that require a Root origin or designate a new account to replace them as the sudo key.

Provides functionality to get and set the on-chain time.

Provides the basic logic to compute pre-dispatch transaction fees.

Provides a reserve of funds that can be managed by stakeholders in the system and a structure for making spending proposals from this reserve.

Provides methods for managing non-fungible collections and items.

Provides a stateless helper module for managing dispatches.

Places a linear curve on an account's locked balance. This module ensures that there is a lock in place to prevent the balance to drop below the unvested amount for any reason other than transaction fee payment.

Parachain pallets

In addition to the functional pallets that are generally useful for any blockchain, there are prebuilt pallets that provide features specifically for blockchains that are intended to connect to a relay chain. The following pallets provide features for parachain development.

Prebuilt pallet name
What it's for

Provides AURA consensus for parachains.

Manages collators in a parachain.

Implements a message queue for receiving messages from the relay chain.

Provides basic functionality for cumulus-based parachains.

Enables migration from a solo chain to a parachain.

Adds support for cross-chain message passing (XCMP) to a parachain.

Enables the XCMP transport layer to handle both incoming and outgoing message sending and dispatch, queuing, signalling, and backpressure.

Additional information

Provides an election module based on .

For detailed information about any pallet, refer to the documentation or the source code for the individual pallet.

Rust documentation
Rust-generated API
frame_benchmarking
frame_executive
frame_support
frame_system
pallet_alliance
pallet_assets
pallet_atomic_swap
pallet_aura
pallet_authority_discovery
pallet_authorship
pallet_babe
pallet_balances
pallet_bounties
pallet_collective
pallet_contracts
pallet_contracts_primitives
pallet_democracy
pallet_election_provider_multi_phase
pallet_elections_phragmen
sequential Phragmén
pallet_example_basic
pallet_example_offchain_worker
pallet_grandpa
pallet_identity
pallet_im_online
pallet_indices
pallet_lottery
pallet_membership
pallet_multisig
pallet_nicks
pallet_offences
pallet_proxy
pallet_randomness_collective_flip
pallet_recovery
pallet_scheduler
pallet_scored_pool
pallet_session
pallet_society
pallet_staking
pallet_sudo
pallet_timestamp
pallet_transaction_payment
pallet_treasury
pallet_uniques
pallet_utility
pallet_vesting
cumulus-pallet-aura-ext
pallet-collator-selection
cumulus-pallet-dmp-queue
cumulus-pallet-parachain-system
cumulus-pallet-solo-to-para
cumulus-pallet-xcm
cumulus-pallet-xcmp-queue