Understanding the Initia Interwoven Stack: Building a Truly Interconnected Rollup Ecosystem
TechFlow Selected TechFlow Selected
Understanding the Initia Interwoven Stack: Building a Truly Interconnected Rollup Ecosystem
Initia is the true home of aggregated technology.
Navigating Web3 tides with focused insightsAuthor: Initia
Translation: TechFlow
The crypto ecosystem has had to adapt to new realities of development, and Initia was born precisely in this environment.
Our industry must acknowledge that a single state machine cannot fulfill the ambitious goals of cryptocurrency. It's nearly impossible to achieve high transaction throughput while maintaining low costs for users and operators and preserving a reasonable degree of decentralization through a monolithic approach.
In fact, the idea that a single chain can succeed is no longer mainstream. Earlier this year, debates around modular versus monolithic architectures gained traction. But the key point is: it’s not an either-or choice. The future lies in combining both—a fast, programmable Layer 1 (L1) paired with a suite of application-specific rollups that scale execution capabilities in coordination with the L1.
Looking at Solana reveals the advantages of this hybrid—what we call interwoven—approach. Over the past six months, many teams have begun building their own custom "network extensions" on Solana. But isn’t Solana known for its native scalability? Isn’t that core to its brand?
In reality, rollups are about more than just scaling execution—they’re also about sovereignty, giving developers full control over their execution environment. This includes higher TPS, lower or even zero gas fees, control over transaction ordering and processing, and complete ownership of their business economics.
Clearly, rollups have become indispensable and will continue to exist.
Initia exists based on one foundational belief: it is purpose-built to support a thriving ecosystem of interconnected rollups called Minitias.
The Future is Interwoven
Initia is designed to be home to thousands of Minitias—cooperating chains that together deliver diverse, powerful, and unique applications through organic design. Currently, there are two types of ecosystems: those built from the start for an interconnected chain world (like Cosmos), and those that later bet on rollups (like Ethereum and now Solana). Each model has seen some success but also shortcomings—lessons that are invaluable when constructing a new L1 paradigm.
Initia bridges these two extremes: it is an L1 designed to support a network of interconnected L2s, ensuring Minitia developers have everything they need to succeed. From day one, Initia avoids mid-layer confusion through deliberate design by asking a simple question: what does an L2 actually need from a hub?
On Initia, rollups integrate naturally. Through Initia VIP, L1 and L2 are economically aligned. The product suite is clean and technically tailored so that Minitias launch with essential features like oracles, bridges, liquidity, interoperability, and native stablecoins out of the box. The Interwoven Stack allows teams to easily deploy a Minitia using any VM of their choice—be it EVM, MoveVM, or CosmWasm.
So, what key components make rollups possible on Initia? The answer is the Interwoven Stack, an Optimistic Rollup framework built from scratch for the Cosmos SDK. Want to uncover how this framework works? Let’s dive in.
The Interwoven Stack
Initia’s Optimistic Rollup framework consists of three tightly integrated components: OPHost, OPChild, and OPinit Bots.
These three pieces fit together like a puzzle, forming a cohesive whole that empowers every Minitia.
OPHost and OPChild are modules of the Cosmos SDK and form the core of the Interwoven Stack, running on-chain. Since the OPinit stack is implemented at the blockchain level rather than relying on smart contracts within a specific virtual machine (VM), we can support multiple VMs, giving Minitia developers greater freedom of choice.
On Initia, rollups are first-class citizens on-chain. This gives us flexibility in implementation details, leading to a better user experience.
OPHost resides on Initia (the L1) and serves as the base for all Minitias running on Initia. Its main responsibilities include:
-
Managing the optimistic bridge (connecting L1 and L2) and associated assets.
-
Confirming output proposals from Minitias.
-
Acting as an arbitrator between challengers and proposers to resolve disputes.
OPChild, on the other hand, exists within each Minitia—like the heartbeat of each rollup. Its duties include:
-
Managing the rollup operator
-
Executing messages from L1
-
Updating oracle price data
-
Handling token withdrawals from L1
Together, OPHost and OPChild form the optimistic bridge for each Minitia. One OPHost on Initia acts as the L1 endpoint, connected to multiple OPChild modules across different Minitias.
It’s important to note that for rollups, a native bridge is not just for message passing—it effectively serves as the headquarters of the rollup on L1. Since two different consensus systems cannot understand each other’s state machines, the rollup’s bridge becomes the source of truth on L1 by submitting state roots or similar verifiable outputs, ensuring correctness. This is why L1 is often referred to as the settlement layer.
You might ask: “What connects OPHost and OPChild? Is it a relayer?” Not quite—that’s exactly where OPinit Bots come in! As an extension, two distinct consensus systems cannot communicate directly without off-chain processes, which act as the physical link between their independent state machines.
OPinit Bots are off-chain processes responsible for critical operations between Initia and Minitias. They come in two types: Executor and Challenger. In short, these two bots jointly handle the following tasks:
-
Executing token transfers
-
Submitting output proposals to Initia L1
-
Submitting transaction batches to Celestia for data availability (DA)
-
Delivering oracle price updates to Minitias
In the remainder of this article, we’ll explore how specific functions in the Interwoven Stack are implemented, helping you better understand how all parts work together!
Token Transfers via the Optimistic Bridge
One of the most crucial aspects of rollup technology is its ability to inherit security from its parent L1 settlement layer.
Did you know? The native bridge between L1 and rollup is typically the safest way to transfer assets because it introduces no additional trust assumptions—only trust in the two chains themselves.
Before diving into the transfer mechanism, let’s address an obvious question:
Why not use Inter-Blockchain Communication (IBC)?
Although all chains on the Interwoven Stack are built on the Cosmos SDK, the native bridge cannot simply function as an IBC channel. This is because IBC’s instant transfers conflict with our protocol’s trust assumptions. Imagine a malicious Minitia operator inserts fraudulent transactions, manipulates INIT balances on L2, and withdraws all INIT back to L1. We cannot allow such catastrophic errors.
Withdrawals from Minitias to Initia via the optimistic bridge undergo a 7-day challenge period. During this time, the Challenger can dispute suspicious withdrawals and cancel them if malicious activity is detected.
On Initia, we aim to provide a seamless user experience during asset movement between Minitia and Initia L1. To this end, we’ve developed Minitswap, a secure custom solution enabling near-instant L2-to-L1 withdrawals. Learn more here: Minitswap — L2 to L1 withdrawals in seconds, not days.
Token Deposit (L1 → L2)
Depositing tokens from Initia to Minitia is nearly instantaneous. Here’s how it works:
1. The user submits a deposit transaction on Initia, locking their tokens on L1 and triggering a deposit event from the OPHost module.
2. The Executor OPinit Bot continuously monitors new events on Initia. Upon detecting the initiate_token_deposit event:
2.a — The Executor constructs a FinalizeTokenDeposit message and submits it to the Minitia.
3. Once received, the Minitia mints the corresponding tokens on L2 and sends them to the user.
This process is simple and secure, ensuring smooth operation!
Now, onto token withdrawals (L2 → L1).
Withdrawals are slightly more complex. While deposits from L1 to L2 are straightforward, L1 cannot easily trust Minitias in return.
The reason: Initia is secured by a decentralized set of validators with economic stakes, whereas Minitias are typically managed by a single or few operators without economic skin in the game. Therefore, when a Minitia initiates a withdrawal request to L1, it must prove it hasn't acted maliciously.
The withdrawal flow works as follows:
1. The user submits a withdrawal transaction on the Minitia, causing the OPChild module to burn their tokens and trigger an initiate_token_withdrawal event. Meanwhile, the Executor monitors all blocks on L2. When it detects this event, it stores the withdrawal request but does not immediately relay it—instead, waits until a checkpoint submission.
3. At the checkpoint, the Executor performs the following:
3.a — Collects all withdrawal requests during that period.
3.b — Generates a sorted Merkle Tree to organize these requests.
3.c — Creates an L2 output containing the root of this Merkle Tree.
3.d — Submits this output to the OPHost on L1.
4. The withdrawal then enters a challenge period. During this time, if the Challenger OPinit Bot detects anything suspicious, it can challenge the withdrawal and cancel the operation.
5. If no challenges occur during the period, the user can call finalize_withdrawal on Initia to unlock their tokens.
5.a — The function receives the withdrawal request and its proof.
5.b — Verifies whether the submitted proof is valid.
5.c — If verification passes, tokens are sent to the user!
While withdrawals take time, this is a necessary cost for security. However, to enhance the experience for Interwoven users, Initia developed Minitswap. By leveraging IBC and the OPinit Bridge, Minitswap enables instant withdrawals while maintaining strong security guarantees.
Now that you understand how withdrawals work, the challenge mechanism may still seem unclear—let’s dive deeper.
What Happens When a Minitia Tries to Cheat?
Earlier, we mentioned that Minitias could potentially cheat. That’s exactly why we have the challenge period—to prevent fraudulent withdrawals through the OPinit Bridge from stealing tokens.
Who ensures fraudulent withdrawals are blocked? This responsibility falls to the Challenger OPinit Bot.
1. Challenger continuously monitors L2 outputs submitted to L1.
2. For each submission, it retrieves the output from Initia and independently recomputes it based on the Minitia’s state.
3. If the output submitted on Initia doesn’t match the Challenger’s computation, the Challenger deletes the proposal by sending a DeleteOutput message. Only the Challenger can invoke this function.
Additionally, state rollback via Celestia is supported.
Yes, when an invalid proposal is deleted, does that mean the current state of the rollup becomes invalid? Indeed—and that’s why we have a robust rollback mechanism.
After a successful challenge, Minitia nodes can resync state from previously published data on Celestia, since all transaction batches from the rollup are published to Celestia for data availability (DA), making rollbacks feasible when needed.
To ensure the integrity of the Minitia state and prevent malicious actions by the Executor, the Executor and Challenger bots are designed as separate entities.
But doesn’t this give the Challenger too much power? What if the Challenger acts maliciously and starts deleting valid outputs?
To prevent this, Initia establishes a checks-and-balances system through L1 governance.
If the Challenger or Proposer (the entity submitting outputs) behaves maliciously, they can be replaced via a governance proposal. For the Challenger, malicious behavior means deleting valid outputs; for the Proposer, it means submitting invalid ones.
When a governance proposal is created, Initia’s L1 validators vote by running L2 nodes to verify who misbehaved. This system ensures no single entity can censor transactions or disrupt the withdrawal process.
Polishing Features
If we stopped at just the basics, it wouldn’t truly be an Initia creation.
Initia makes building your own rollup exceptionally easy. Many people know that building a rollup involves more than just hosting it—you need to build supporting infrastructure like indexers, oracles, and bridge connectors.
Here’s the good news: the Interwoven Stack provides everything you need.
Skip Connect—Built-in Oracle Service
Through Skip, Initia delivers fast, up-to-date asset price data to itself and all Minitias built on the Interwoven Stack.
Connect is a built-in oracle sidecar service operated by Initia validators, pushing price updates on-chain. This implementation leverages two new features introduced in Cosmos SDK v0.50: ABCI++ and vote extensions. These allow validators to submit arbitrary data and store it on-chain, preventing malicious actors from blocking price updates with spam-filled blocks.
Once prices are on-chain, developers can query them via CLI, API, or directly in smart contracts.
Moreover, Connect prices are propagated to every Minitia on the Interwoven Stack, ensuring immediate access to fresh pricing from day one.
This means Minitias don’t need to run their own infrastructure, find third-party oracle providers, negotiate agreements, or invest resources in integration. It’s all taken care of!
Cross-Chain Contract Calls
To enable true interoperability, Initia needs secure and efficient cross-chain communication. Developers can choose multiple methods, one of which is using hooks on the Optimistic Bridge. These bridge hooks function similarly to IBC hooks, allowing contract calls to be triggered during token transfers. OPinit bridge hooks enable contract execution when assets are transferred via the OPinit Bridge.
On OPHost, the hook updates bridge metadata; on OPChild, the hook allows arbitrary transaction execution during the FinalizeTokenDeposit phase.
Our system supports multiple VMs, so whether EVM, MoveVM, or CosmWasm, bridge hooks can execute arbitrary transactions based on data fields in the message.
For example, this is the data format used for EVM chains.
Built-in Indexer
Minitia comes with a built-in indexer that automatically indexes and stores all relevant on-chain data. Through a REST API, this data can be queried for historical lookups.
Whether it’s token balances, NFT information, or transaction history—all these capabilities are included by default.
Indexing is one of the biggest hurdles in building on-chain applications, and this built-in indexer greatly simplifies the process! Running your own indexer is usually expensive and cumbersome. With this feature, developers can display token balances, NFTs, and transaction histories without building or relying on third-party indexers.
This built-in indexer also powers Initia Scan with plug-and-play support—an explorer for both L1 and each L2.
Conclusion
Diving deep into the Interwoven Stack has been a delightful experience. The technical design is elegant and underpins Initia’s interwoven vision. By building the Interwoven Stack as Cosmos SDK modules, Initia successfully transforms the SDK into a tech stack for building optimistic rollups while retaining all the benefits of the Cosmos SDK—an impressive achievement.
There’s much more to the Interwoven Stack that we haven’t covered today. I highly recommend exploring its codebase and the related bot repositories to gain a deeper understanding of this technology.
In the end, one thing remains certain: Initia is the true home of rollup technology. Designed from the ground up for Minitias, the Interwoven ecosystem has already sparked innovation. Novel application-specific rollups like Blackwing, Contro, MilkyWay, and Inertia will be available on day one! All of this innovation is made possible by the foundation of the Interwoven Stack.
Join TechFlow official community to stay tuned
Telegram:https://t.me/TechFlowDaily
X (Twitter):https://x.com/TechFlowPost
X (Twitter) EN:https://x.com/BlockFlow_News
@initiaFDN
