Selendra is a next-generation Layer 1 blockchain that combines the best of Ethereum compatibility with Substrate's flexibility and performance. Built on Cardinal Cryptography's AlephBFT consensus, Selendra delivers sub-second finality, low transaction costs, and enterprise-grade reliability.

• ⚡ Blazing Fast: Sub-second finality with Aura block production + AlephBFT consensus
• 🔗 EVM Compatible: Full Ethereum compatibility via Frontier - deploy Solidity contracts seamlessly
• 🔐 Unified Accounts: Native ↔ EVM account mapping for superior user experience
• 💰 Low Fees: Optimized transaction costs with dynamic EVM base fee adjustment
• 🎯 Enterprise Ready: Advanced staking, governance tools, and institutional features
• 🛠️ Developer Friendly: Substrate pallets + EVM smart contracts in one platform

┌─────────────────────────────────────────────────────┐
│                    Selendra Network                 │
├─────────────────────────────────────────────────────┤
│  Consensus Layer                                    │
│  ├─ Aura (Block Production, 1s slots)               │
│  └─ AlephBFT (Byzantine Fault Tolerant Finality)    │
├─────────────────────────────────────────────────────┤
│  Execution Environments                             │
│  ├─ EVM (Ethereum Virtual Machine via Frontier)     │
│  ├─ WASM (WebAssembly Contracts via pallet-contracts)│
│  └─ Native Pallets (Substrate Runtime Logic)        │
├─────────────────────────────────────────────────────┤
│  Core Pallets (30 Total)                            │
│  ├─ Staking & Governance (DPoS, Treasury, Council)  │
│  ├─ EVM Integration (Ethereum, Dynamic Fees)        │
│  ├─ Unified Accounts (Native ↔ EVM Mapping)         │
│  └─ Utilities (Multisig, Proxy, Identity, Vesting)  │
└─────────────────────────────────────────────────────┘

selendra/
├── bin/                        # Executables
│   ├── node/                   # Selendra node implementation
│   ├── runtime/                # Selendra runtime (WASM + native)
│   ├── chain-bootstrapper/     # Network bootstrapping tool
│   └── client-runtime-api/     # Client-side runtime APIs
├── pallets/                    # Custom Substrate pallets
│   ├── aleph/                  # AlephBFT integration
│   ├── elections/              # DPoS validator elections
│   ├── committee-management/   # Validator committee management
│   ├── operations/             # Administrative operations
│   ├── dynamic-evm-base-fee/   # EVM fee adjustment
│   └── unified-accounts/       # Native ↔ EVM account mapping
├── crate/                      # Supporting libraries
│   ├── finality-aleph/         # AlephBFT finality gadget
│   ├── aggregator/             # Signature aggregation
│   ├── clique/                 # Peer discovery
│   └── rate-limiter/           # Network rate limiting
├── primitives/                 # Core primitive types
├── scripts/                    # Deployment & utility scripts
└── vendors/                    # Vendored dependencies
    ├── selendra-client/        # Rust client library (v3.16.0)
    ├── frontier/               # Ethereum compatibility (submodule)
    └── bind_account/           # Account binding utilities

• Rust: 1.75.0 or later (see rust-toolchain.toml)
• OS: Linux (recommended), macOS, or WSL2 on Windows
• Memory: 8GB RAM minimum, 16GB recommended
• Disk: 50GB+ free space

1. Install Rust & Dependencies

   # Install Rust (if not already installed)
   curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
   
   # Install build dependencies (Ubuntu/Debian)
   sudo apt update
   sudo apt install -y build-essential git clang curl libssl-dev llvm libudev-dev protobuf-compiler
   
   # Install build dependencies (macOS)
   brew install openssl cmake protobuf

2. Clone the Repository

   git clone https://github.com/selendra/selendra.git
   cd selendra
   
   # Initialize submodules (Frontier, etc.)
   git submodule update --init --recursive

3. Build the Node

   # Development build (faster compilation)
   cargo build --release
   
   # Production build (optimized for performance)
   cargo build --profile production

   The compiled binary will be at target/release/selendra-node (or target/production/selendra-node)

# Run a local development chain
./target/release/selendra-node \
  --dev \
  --tmp \
  --rpc-cors=all \
  --rpc-methods=unsafe

Access the node:

• RPC Endpoint: http://localhost:9944
• Ethereum RPC: http://localhost:9933 (Web3/Metamask compatible)

# Sync with Selendra mainnet
./target/release/selendra-node \
  --chain=mainnet \
  --pruning=archive \
  --rpc-cors=all \
  --rpc-external \
  --ws-external \
  --rpc-methods=safe \
  --name="MySelendraNode"

# Run a validator (requires staking)
./target/release/selendra-node \
  --chain=mainnet \
  --validator \
  --name="MyValidator" \
  --rpc-methods=safe \
  --prometheus-external

For detailed validator setup, see Validator Guide

Add Selendra to Metamask:

• Network Name: Selendra Mainnet
• RPC URL: https://rpc.selendra.org
• Chain ID: 1961
• Currency Symbol: SEL
• Block Explorer: https://scan.selendra.org

Connect via Polkadot.js Apps:

• Custom Endpoint: wss://rpc.selendra.org

// Coming soon: @selendra/sdk
// For now, use @polkadot/api or web3.js

// Option 1: Polkadot.js API (for Substrate calls)
import { ApiPromise, WsProvider } from '@polkadot/api';

const provider = new WsProvider('wss://rpc.selendra.org');
const api = await ApiPromise.create({ provider });

// Query balance
const balance = await api.query.system.account('ACCOUNT_ADDRESS');
console.log('Balance:', balance.data.free.toHuman());

// Option 2: Web3.js (for EVM calls)
import Web3 from 'web3';

const web3 = new Web3('https://rpc.selendra.org');
const balance = await web3.eth.getBalance('0xEVM_ADDRESS');
console.log('Balance:', web3.utils.fromWei(balance, 'ether'), 'SEL');

1. Using Hardhat

   // hardhat.config.js
   module.exports = {
     networks: {
       selendra: {
         url: 'https://rpc.selendra.org',
         chainId: 1961,
         accounts: [process.env.PRIVATE_KEY]
       }
     },
     solidity: "0.8.20"
   };

   npx hardhat deploy --network selendra

2. Using Remix IDE

   • Set Metamask to Selendra network
   • Compile contract in Remix
   • Deploy via "Injected Provider - Metamask"

# Install cargo-contract
cargo install cargo-contract

# Create new contract
cargo contract new my_contract
cd my_contract

# Build contract
cargo contract build

# Deploy via Polkadot.js Apps
# 1. Upload WASM & metadata.json
# 2. Instantiate contract

Modify or add pallets in pallets/:

# Create a new pallet
cargo new --lib pallets/my-pallet

# Add to workspace in Cargo.toml
# [workspace]
# members = [
#   ...
#   "pallets/my-pallet"
# ]

# Include in runtime (bin/runtime/src/lib.rs)
construct_runtime!(
    pub struct Runtime {
        ...
        MyPallet: pallet_my_pallet,
    }
);

# Run all tests
cargo test --workspace

# Run specific pallet tests
cargo test -p pallet-elections

# Run runtime tests
cargo test -p selendra-runtime

# Run with output
cargo test -- --nocapture

Selendra provides custom precompiles for accessing Substrate functionality from EVM:

Coming Soon:

• 0x0402 - Oracle Price Feeds
• 0x0403 - Staking Interface
• 0x0404 - Governance Interface
• 0x0405 - Unified Accounts

• System - Core blockchain functionality
• Aura - Block production (Authority Round)
• Aleph - AlephBFT finality consensus
• Timestamp - Block timestamps
• Balances - Native token management
• TransactionPayment - Fee handling
• Scheduler - Delayed/scheduled calls

• Staking - Proof-of-Stake validation
• Elections - DPoS validator elections
• CommitteeManagement - Validator committee
• Session - Session management
• History - Historical session data
• Treasury - Community fund management (Council-approved)
• NominationPools - Liquid staking pools
• Council - Community governance collective (13 members)
• TechnicalCommittee - Technical governance collective (7 members)
• Democracy - Public referendums and proposals
• CouncilElections - Phragmen-based council elections
• Preimage - Proposal preimage storage

• Ethereum - Ethereum compatibility layer
• EVM - EVM execution environment
• DynamicEvmBaseFee - Dynamic EVM fee adjustment
• UnifiedAccounts - Native ↔ EVM account mapping

• Contracts - WASM smart contracts (ink!)

• Utility - Batch calls, multi-operations
• Multisig - Multi-signature accounts
• Proxy - Proxy accounts & delegation
• Identity - On-chain identity
• Vesting - Token vesting schedules

• Operations - Admin operations
• Sudo - Superuser access (transition period, to be removed post-governance maturity)
• SafeMode - Emergency chain halt
• TxPause - Transaction filtering

• 2019: Project started
• 2020: First testnet launched
• 2022: v1 mainnet launch
• 2025: v3 mainnet launch (current)

• ✅ Full EVM compatibility via Frontier
• ✅ AlephBFT consensus (sub-second finality)
• ✅ Unified accounts (native ↔ EVM)
• ✅ DPoS staking with nomination pools
• ✅ Dynamic EVM fee adjustment
• ✅ Council governance (13-member council)
• ✅ Democracy & referendum system
• ✅ Treasury with Council approval
• ✅ 35 runtime pallets
• ✅ Mainnet live and operational

• 🔧 Fix critical security issues (randomness, storage bounds)
• 📦 TypeScript SDK development
• 🏛️ Transition governance (reduce sudo, increase council powers)
• 🗳️ First council elections
• 🛠️ Enhanced developer tooling
• 💱 DeFi infrastructure (DEX, oracles)
• 📚 Comprehensive documentation

• 🌉 Cross-chain bridges
• 🏦 Expanded DeFi ecosystem
• 🎯 Developer adoption in Cambodia and Southeast Asia
• 🏢 Real-world use cases (remittance, supply chain)

See docs/chain-dev.md for detailed technical roadmap.

We welcome contributions! Here's how to get involved:

1. Fork & Clone

   git clone https://github.com/YOUR_USERNAME/selendra.git
   cd selendra
   git remote add upstream https://github.com/selendra/selendra.git

2. Create a Branch

   git checkout -b feature/my-awesome-feature

3. Make Changes & Test

   cargo test --workspace
   cargo fmt
   cargo clippy

4. Submit Pull Request

   • Push to your fork
   • Open PR against master branch
   • Include clear description & tests
   • Link related issues

• 🐛 Bug Fixes: Report or fix bugs
• ✨ Features: Propose new functionality
• 📖 Documentation: Improve guides & docs
• 🧪 Testing: Add test coverage
• 🔍 Security: Report vulnerabilities (security@selendra.org)
• 🌍 Translations: Translate documentation

• Follow Rust API Guidelines
• Use cargo fmt for formatting
• Pass cargo clippy with no warnings
• Write tests for new functionality
• Document public APIs with /// comments

DO NOT open public issues for security vulnerabilities.

• Email: security@selendra.org
• PGP Key: Download
• Bug Bounty: Up to $500K via Immunefi (coming soon)

• Status: In progress
• Firms: CertiK, Trail of Bits
• Scope: Runtime, custom pallets, EVM integration
• Reports: Published at selendra.org/security

• ⚠️ Randomness: Currently using insecure collective flip (fix in progress)
• ⚠️ Sudo: Superuser key present during governance transition period (removal planned after 6 months)
• ⚠️ Contract Calls: Wasm contracts have limited runtime call access
• ℹ️ Governance: Council system implemented, undergoing testing before sudo removal

See Security Advisory for details.

This project is licensed under the GNU General Public License v3.0 - see LICENSE file.

Copyright (C) 2019-2025 Selendra

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

• Website: selendra.org
• Documentation: docs.selendra.org
• Block Explorer: scan.selendra.org
• GitHub: github.com/selendra

• Discord: discord.gg/selendra
• Telegram: t.me/selendra
• Twitter: @selendra
• Forum: forum.selendra.org

• RPC Endpoint: https://rpc.selendra.org
• WebSocket: wss://rpc.selendra.org
• Testnet RPC: https://rpc-testnet.selendra.org
• Faucet: faucet.selendra.org (coming soon)
• Governance Guide: docs/GOVERNANCE_SETUP.md
• Governance Quick Start: docs/GOVERNANCE_QUICK_START.md

• Substrate Docs: docs.substrate.io
• Polkadot.js: polkadot.js.org
• Frontier: github.com/paritytech/frontier
• AlephBFT: github.com/Cardinal-Cryptography/AlephBFT

Selendra is built on the shoulders of giants:

• Cardinal Cryptography - AlephBFT consensus & Polkadot SDK fork
• Parity Technologies - Substrate framework & Frontier EVM
• Polkadot - Shared security model & ecosystem
• Ethereum Foundation - EVM specification & tooling
• Community Contributors - Bug reports, features, and support

Special thanks to all validators, developers, and community members making Selendra possible.