sei-protocol · alexander-sei · Jan 8, 2026 · Jan 9, 2026 · Jan 9, 2026 · Jan 9, 2026
@@ -22,5 +22,13 @@ export default {
 	node: {
 		title: 'Operate',
 		type: 'page'
+	},
+	'ai-answers': {
+		display: 'hidden',
+		type: 'page',
+		theme: {
+			sidebar: true,
+			toc: true
+		}
 	}
 };
@@ -0,0 +1,10 @@
+export default {
+	'*': {
+		theme: {
+			sidebar: false,
+			toc: true,
+			breadcrumb: false,
+			pagination: false
+		}
+	}
+};
@@ -0,0 +1,13 @@
+---
+title: 'Blockchain Glossary & Concepts'
+description: 'AI-assisted explanations of blockchain concepts, DeFi terms, and crypto fundamentals for the Sei ecosystem.'
+keywords: ['sei', 'blockchain', 'glossary', 'crypto', 'defi', 'concepts']
+---
+
+import { Callout } from 'nextra/components';
+
+# Blockchain Glossary & Concepts
+
+<Callout type="info" emoji="🤖">
+  This section contains AI-assisted explanations of common blockchain and crypto concepts. While we strive for accuracy, please verify information independently before making decisions.
+</Callout>
@@ -0,0 +1,204 @@
+---
+title: 'Rollup Vs Sidechain: Key Differences Explained'
+description: 'Learn about what is rollup vs sidechain and how it works in blockchain and on Sei Network.'
+keywords: ['sei', 'blockchain', 'glossary', 'what', 'rollup', 'sidechain', 'differences', 'explained']
+---
+
+import { Callout } from 'nextra/components';
+
+export const jsonLd = {
+  '@context': 'https://schema.org',
+  '@graph': [
+    {
+      '@type': 'FAQPage',
+      mainEntity: [
+        {
+          '@type': 'Question',
+          name: 'Rollup Vs Sidechain: Key Differences Explained',
+          acceptedAnswer: {
+            '@type': 'Answer',
+            text: 'Rollups and sidechains are scaling approaches that move transaction execution off a main chain to improve throughput and lower fees, but they differ fundamentally in how they inherit security. Rollups post transaction data (or proofs) to a base layer and rely on that layer for settlement and, largely, security. Sidechains are separate blockchains with their own consensus that connect to a main chain via a bridge, so their security depends on the sidechain validator set and bridge design.'
+          }
+        }
+      ]
+    },
+    {
+      '@type': 'TechArticle',
+      headline: 'Rollup Vs Sidechain: Key Differences Explained',
+      description: 'Learn about what is rollup vs sidechain and how it works in blockchain and on Sei Network.',
+      author: {
+        '@type': 'Organization',
+        name: 'Sei Network',
+        url: 'https://sei.io'
+      },
+      publisher: {
+        '@type': 'Organization',
+        name: 'Sei Network',
+        url: 'https://sei.io'
+      },
+      about: {
+        '@type': 'Thing',
+        name: 'what is rollup vs sidechain'
+      },
+      articleSection: 'glossary',
+      inLanguage: 'en'
+    }
+  ]
+};
+
+<head>
+  <script type="application/ld+json" dangerouslySetInnerHTML={{ __html: JSON.stringify(jsonLd) }} />
+</head>
+
+# Rollup Vs Sidechain: Key Differences Explained
+
+<Callout type="info" emoji="🤖">
+  This content was generated with the assistance of AI and is intended for informational purposes only. Please verify all information independently before making decisions based on this content.
+</Callout>
+
+## Overview
+
+Rollups and sidechains are scaling approaches that move transaction execution off a main chain to improve throughput and lower fees, but they differ fundamentally in how they inherit security. **Rollups** post transaction data (or proofs) to a base layer and rely on that layer for settlement and, largely, security. **Sidechains** are separate blockchains with their own consensus that connect to a main chain via a bridge, so their security depends on the sidechain validator set and bridge design.
+
+## How It Works
+
+### Rollups (General Blockchain Context)
+
+Rollups execute transactions off-chain (or “off the base layer”) and then commit results back to a base chain. The base chain acts as the settlement layer and provides a security anchor.
+
+Key properties:
+
+- **Security inheritance:** Rollups derive security from the base chain because the base chain enforces finality/validity (directly or via dispute/proof systems).
+- **Data availability:** Many rollups publish enough data on the base chain so anyone can reconstruct the rollup state and verify behavior.
+- **Two main types:**
+  - **Optimistic rollups:** Assume batches are valid by default; allow a **challenge window** where fraud proofs can revert invalid state transitions.
+  - **ZK rollups:** Provide **validity proofs (ZK proofs)** that the batch is correct; typically faster finality once proofs are verified.
+
+Typical flow:
+
+1. Users send transactions to the rollup.
+2. A sequencer/validator orders and executes them off the base chain.
+3. The rollup posts transaction data and/or state commitments to the base chain.
+4. The base chain finalizes the commitment (with fraud-proof window for optimistic, proof verification for ZK).
+
+### Sidechains (General Blockchain Context)
+
+Sidechains are independent L1/L2-style blockchains that run their own consensus, produce blocks, and finalize transactions separately. They connect to another chain (often Ethereum) through a **bridge** that locks assets on one chain and mints/releases representations on the other.
+
+Key properties:
+
+- **Independent security:** Sidechains do **not** inherit the base chain’s security; they rely on their own validator set and consensus mechanism.
+- **Bridging trust assumptions:** The bridge can be a major security component (multi-sig, light-client-based, or validator-based bridges each have different risk profiles).
+- **Performance flexibility:** Sidechains can tune block times, gas parameters, and execution environments, but the trade-off is separate security.
+
+Typical flow:
+
+1. User locks tokens on Chain A via a bridge contract.
+2. Bridge relayers/validators confirm the lock and mint wrapped tokens on the sidechain.
+3. User transacts on the sidechain.
+4. To return, tokens are burned on the sidechain and released/unlocked on Chain A.
+
+## Key Differences
+
+### 1) Security Model
+
+- **Rollup:** Anchored to the base chain; validity and settlement ultimately depend on the base chain rules.
+- **Sidechain:** Secured by its own validators and consensus; compromise of the sidechain or its bridge can lead to loss of funds.
+
+### 2) Settlement and Finality
+
+- **Rollup:** Final settlement happens on the base chain; optimistic rollups may have delayed “economic finality” due to challenge windows.
+- **Sidechain:** Finality is determined by the sidechain itself (often faster), but it’s not base-chain finality unless bridged back.
+
+### 3) Data Availability and Verifiability
+
+- **Rollup:** Often publishes data to the base chain, enabling independent verification and state reconstruction (depending on design).
+- **Sidechain:** Data typically lives on the sidechain; base chain doesn’t necessarily have enough info to verify sidechain execution.
+
+### 4) Bridge Complexity and Risk
+
+- **Rollup:** Bridge is often simpler because the base chain can verify rollup commitments/proofs.
+- **Sidechain:** Bridge can be a primary risk surface; many sidechain bridges depend on external validator signatures or relayers.
+
+### 5) EVM and Developer Experience
+
+- **Rollup:** Many are EVM-compatible; deploying feels like deploying to an EVM chain but with different settlement mechanics.
+- **Sidechain:** Often EVM-compatible too; behaves like an independent EVM chain with its own RPC, explorers, and fee market.
+
+## Practical Comparison Table
+
+| Dimension         | Rollup                                                    | Sidechain                                                  |
+| ----------------- | --------------------------------------------------------- | ---------------------------------------------------------- |
+| Security          | Inherits from base layer (to varying degrees)             | Independent validator set; bridge trust is crucial         |
+| Settlement        | Base chain                                                | Sidechain (base chain only when bridging)                  |
+| Finality          | Base chain finality (plus rollup mechanics)               | Sidechain finality; not automatically base-chain final     |
+| Data availability | Often on base chain                                       | Typically on sidechain                                     |
+| Bridge risk       | Generally lower (base chain verifies proofs/commitments)  | Often higher (validator/multisig/light client assumptions) |
+| Performance       | High; depends on rollup design and base chain constraints | Can be very high; bounded by sidechain design              |
+
+## On Sei Network
+
+Sei is a high-performance Layer 1 with **parallelized execution**, **~400ms finality**, and **EVM compatibility**, which changes how teams think about scaling options:
+
+- **When you might not need a rollup/sidechain:**  
+  Many applications can run directly on Sei’s L1 and still achieve high throughput and low latency, thanks to Sei’s parallelization and fast finality. This reduces operational complexity (sequencers, challenge/proof systems, separate validator sets) while preserving a unified liquidity and security domain.
+
+- **Sei as a base layer for rollup-like designs:**  
+  If you build a rollup that settles to Sei, the rollup can use Sei as its settlement layer—benefiting from fast finality and EVM tooling. The exact security properties depend on whether the rollup publishes data to Sei and how validity is enforced (optimistic vs ZK).
+
+- **Sei and sidechain-style deployments:**  
+  You can deploy application-specific chains or separate EVM chains and bridge to Sei. In that model, the sidechain’s security remains independent, and bridge design becomes the key risk/engineering focus. Sei’s fast finality can improve bridge UX (faster confirmations on the Sei side), but it does not automatically “secure” the sidechain.
+
+### EVM Compatibility Example (Deploying to Sei)
+
+For teams choosing to deploy directly to Sei’s EVM instead of introducing a separate rollup/sidechain, the workflow is similar to other EVM networks.
+
+```bash
+# Example: add Sei EVM RPC to your tooling (use the correct endpoint for your environment)
+export RPC_URL="https://<sei-evm-rpc-endpoint>"
+export PRIVATE_KEY="0x..."
+
+# Example using Foundry
+forge create --rpc-url "$RPC_URL" --private-key "$PRIVATE_KEY" src/MyContract.sol:MyContract
+```
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+contract Counter {
+    uint256 public value;
+
+    function inc() external {
+        value += 1;
+    }
+}
+```
+
+## Choosing Between Rollup and Sidechain
+
+Use a **rollup** when:
+
+- You want stronger security guarantees tied to a base chain’s settlement.
+- You can accept constraints like posting data/proofs and (for optimistic rollups) challenge windows.
+
+Use a **sidechain** when:
+
+- You need maximum customization over consensus, block parameters, or app-specific rules.
+- You’re comfortable managing separate security and the bridge trust model.
+
+On **Sei**, also consider:
+
+- Deploying directly on Sei L1 to leverage **parallel execution** and **~400ms finality** without introducing cross-domain complexity.
+- If you must separate execution, treat bridges and independent validator sets as core design and risk components.
+
+## Related Documentation
+
+- [Getting Started](/learn)
+- [Token Standards](/learn/dev-token-standards)
+- [Staking](/learn/general-staking)
+- [Oracles](/learn/oracles)
+
+---
+
+_Have a question that's not answered here? Join our [Discord](https://discord.gg/sei) community._