Architecture Overview

Monolythium is a Layer 1 blockchain built on Cosmos SDK v0.53.6 with full EVM compatibility via cosmos/evm v0.6.0 and LythiumBFT consensus. This page provides a high-level view of how the system is structured.

Overview

Monolythium combines three technology pillars into a single chain:

Cosmos SDK for modular application logic, staking, governance, and IBC
EVM engine (go-ethereum fork) for Solidity smart contract execution
LythiumBFT (CometBFT fork) for Byzantine fault-tolerant consensus with instant finality

The result is a chain where Cosmos-native modules and EVM smart contracts share the same state, the same validator set, and the same finality guarantees.

Layer Diagram

┌─────────────────────────────────────────────────────┐
│                  APPLICATION LAYER                   │
│                                                      │
│  ┌──────────────┐  ┌───────────┐  ┌──────────────┐ │
│  │  Cosmos SDK   │  │    EVM    │  │   Custom     │ │
│  │  Modules      │  │  Engine   │  │   Modules    │ │
│  │  (bank,stake) │  │ (geth)    │  │ (burn,valid) │ │
│  └──────────────┘  └───────────┘  └──────────────┘ │
├─────────────────────────────────────────────────────┤
│                  CONSENSUS LAYER                     │
│               LythiumBFT (CometBFT)                 │
│         Instant finality, 2-5s blocks               │
├─────────────────────────────────────────────────────┤
│                  NETWORKING LAYER                    │
│            P2P gossip, peer discovery                │
└─────────────────────────────────────────────────────┘

Application Layer

The application layer is where all transaction logic lives. It is composed of three subsystems.

Cosmos SDK Modules

Monolythium includes the standard Cosmos SDK module set along with custom extensions:

Module	Purpose
`auth`	Account management and transaction authentication
`bank`	Token transfers and balance tracking
`staking`	Validator bonding, delegation, and unbonding
`gov`	On-chain governance proposals and voting
`distribution`	Reward distribution to validators and delegators
`slashing`	Penalizing validator misbehavior (downtime, double signing)
`mint`	Block reward issuance (8% annual inflation)
`evidence`	Submitting and handling Byzantine evidence
`feegrant`	Fee allowances so one account can pay gas for another
`ibc`	Inter-Blockchain Communication for cross-chain transfers

EVM Engine

The EVM subsystem is a go-ethereum fork integrated via the cosmos/evm module. It provides:

Full Solidity smart contract execution (Paris EVM version)
Compatibility with standard tooling (Hardhat, Foundry, Remix, MetaMask)
Precompiled contracts that bridge EVM calls to native Cosmos functionality
JSON-RPC and WebSocket endpoints for dApp connectivity

bilgi

The EVM engine shares the same state database as the Cosmos modules. A LYTH balance is accessible from both Cosmos (mono1...) and EVM (0x...) address formats simultaneously.

Custom Modules

Monolythium extends the base Cosmos SDK with two protocol-specific modules:

Module	Purpose
`x/validator`	Gated validator registration requiring a LYTH burn to join the active set
`x/burn`	Fee split logic: 90% of transaction fees are burned, 10% go to the block proposer

Consensus Layer

Monolythium uses LythiumBFT, a fork of CometBFT v0.38 that modifies proposer selection to use quadratic weighting.

Key properties:

Property	Value
Fault tolerance	Byzantine fault tolerant (tolerates < 1/3 malicious validators)
Finality	Deterministic and instant (no reorgs, no confirmations needed)
Block time	2-5 seconds
Validator agreement	2/3+ of voting power must sign each block
Active validators	53

Unlike probabilistic finality chains, a block committed by LythiumBFT is final the moment it is produced. There is no risk of chain reorganization.

For a detailed explanation of the consensus mechanism, see Consensus.

How Cosmos and EVM Interact

Cosmos and EVM are not separate chains or layers. They share a single execution environment:

Shared state database -- Both Cosmos modules and the EVM engine read from and write to the same underlying key-value store. A token transfer via bank is visible to EVM contracts, and vice versa.
Dual address system -- Every account has both a Cosmos address (mono1..., Bech32) and an EVM address (0x..., hex). These are derived from the same public key and map to the same balance.
Transaction wrapping -- EVM transactions from MetaMask or other Ethereum tooling are wrapped in a Cosmos MsgEthereumTx message before entering the mempool. The Cosmos SDK processes the outer message; the EVM engine executes the inner payload.
Precompiled contracts -- Special contracts at fixed addresses allow Solidity code to call Cosmos-native operations (staking, governance, IBC transfers) directly from the EVM. See Precompiles.
Unified validator set -- The same 53 validators that run LythiumBFT consensus also secure all EVM contract execution. There is no separate sequencer or execution layer.

User sends EVM tx (MetaMask)
        │
        ▼
  JSON-RPC endpoint
        │
        ▼
  Wrapped in MsgEthereumTx
        │
        ▼
  Cosmos SDK processes message
        │
        ▼
  EVM engine executes contract
        │
        ▼
  State committed via LythiumBFT

Inter-Blockchain Communication (IBC)

Monolythium supports IBC for trustless cross-chain token transfers and data relay. IBC enables communication with any IBC-enabled chain in the Cosmos ecosystem without relying on centralized bridges.

uyarı

IBC activates at block 500,000 on both mainnet and testnet. Before that block height, IBC transactions will not be processed.

Key IBC capabilities:

ICS-20 token transfers between Monolythium and connected chains
EVM precompile allowing Solidity contracts to initiate IBC transfers directly
Permissionless relaying -- anyone can operate an IBC relayer

For the full IBC specification and configuration, see IBC Integration.

Overview​

Layer Diagram​

Application Layer​

Cosmos SDK Modules​

EVM Engine​

Custom Modules​

Consensus Layer​

How Cosmos and EVM Interact​

Inter-Blockchain Communication (IBC)​

Further Reading​