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 Token Identifier
  • Features of the System Token
  • Wrapped System Token
  • Oracle
  • Next Steps
  1. InfraBlockchain
  2. Learn
  3. Protocol

System Token

Covers the overall content regarding the system token.

PreviousProtocolNextTransaction Fee

Last updated 1 year ago

InfraBlockchain does not have its own native virtual currency token (e.g., BITCOIN for Bitcoin, ETHER for Ethereum) and instead issues a System Token pegged to legal currency for use as transaction fees. It is also based on a multi-chain architecture, allowing it to use system tokens issued on other networks as transaction fees. To facilitate this, the system token's identification system is designed to reflect this concept in a multi-chain environment:

System Token Identifier

All entities (e.g., tokens, accounts, etc.) existing in a multi-chain have relative positions. For example, the position of token X as seen from Parachain A and the position of token X as seen from the Relay Chain are expressed differently. To reflect this, the position of the system token issued on each chain is also expressed to reflect this concept.

pub struct MultiLocation {
	parents: u8,
	interior: Junctions,
}
  • parents: Represents the depth of the network with different consensus, similar to the concept of a parent folder. For example, the position of token X is parents = 1 within the Parachain, but parents = 0 from the perspective of the Relay Chain. In InfraBlockchain, the Relay Chain always exists as a higher concept than the Parachain.

  • interior: Represents the depth within the same network, similar to the concept of a subfolder. For example, the position of token X can be expressed as interior = PalletInstance(0) -> GeneralIndex(0).

When considering the relative position of token X,

  • Relay Chain:

MultiLocation {
	parents: 0,
	interior: Junctions::X2(PalletInstance(0), GeneralIndex(0))
};
  • Parachain:

MultiLocation {
	parents: 1,
	interior: Junctions::X2(PalletInstance(1), GeneralIndex(0))
};```

Features of the System Token

  • The system token is a fiat-pegged token, and only the amount backed by real currency can be issued on the chain.

  • The system token reflects different values for different legal currencies based on real-time exchange rate information provided by an oracle.

Wrapped System Token

The term "wrapped" refers to the system token adopted by the Relay Chain validators. To use wrapped tokens, approval from the Relay Chain governance is required. Once approved, a wrapped token is created for the network that wants to use the token, including metadata for the system token (e.g., decimal places, token symbol, token name, etc.).

Foreign Asset

After the registration for wrapped tokens is completed, the token received through XCM is stored as a ForeignAsset. ForeignAsset is a module that manages external assets, not the token it created, and manages the token with SystemTokenId(=MultiLocation) as the ID. This module can accept any external asset, not just the system token.

Oracle

Next Steps

eps

Users can use the system token to pay transaction fees, and these fees are converted into a .

The system token, as a fiat-based token, has different values based on the exchange rate. The exchange rate information is off-chain data provided by an oracle selected by the Relay Chain governance. At specific intervals, it provides exchange rate information for the system token legal currency in circulation, and each time, it recalculates and reflects the .

The oracle node in the Asset Hub, the system chain of InfraBlockchain, periodically (usually daily) updates the exchange rate information for the token against the oracle node, and this information is then transmitted to the Relay Chain. The exchange rate is updated each time it is updated for the currency used by the chain. All matters related to the system token are managed in the Relay Chain's pallet.

voting form for validators
SystemTokenManager
Proof of Transaction (PoT)
SystemTokenManager Module
weight of each system token
SystemTokenId
Wrapped System Token
Oracle Node