The crypto ecosystem had to adapt to the new reality — and Initia was born under these circumstances.
As an industry, we have had to accept the fact that a single state machine cannot scale to match the ambitions of crypto. Scaling throughput while keeping costs low for users and operators, while maintaining an acceptable level of decentralization, is a battle that is nearly impossible to win with a single approach.
The reality is that the success of pure monolithic chains has become a contrarian view. Earlier this year, the modular vs. monolithic debate took center stage. But the bottom line is: there is no debate at all. The future is not one or the other, but a fusion of both. A fast, programmable L1 paired with a set of application-specific rollups that can scale execution alongside the L1.
Look at the Solana network, and the advantages of a hybrid (or as we like to call it, “Interwoven”) approach become apparent. Over the past six months, teams have begun building their own custom “network extensions” and have been successfully doing so on Solana. But wait, isn’t Solana supposed to handle extensions themselves? Isn’t that their entire brand?
You see, rollups are not just about scaling execution, they are also about sovereignty - giving builders full control over their execution environment. Higher TPS, lower gas fees (or zero gas), control over tx ordering and processing, ownership of the entire economic stack of their business, etc.
It’s clear that rollups are inevitable and are here to stay.
Initia exists around this theme. Its purpose is to host a thriving ecosystem of interwoven rollups, called Minitia.
The future belongs to Interwoven
Initia delivers diverse, powerful and unique applications by designing a cohesive Interwoven experience.
So far, there are two ecosystems. One that is purpose-built for the world of interconnected blockchains (Cosmos), and the other that already exists for betting on rollups (Ethereum, and now Solana). Each approach has achieved some degree of success, but not without failures, which are valuable lessons to learn when building new models for L1.
Initia bridges these two ecosystems, it is a L1 designed to support interconnected L2 networks, ensuring that Minitia builders have everything they need to succeed. From the beginning, Initia sticks to its guns and asks questions to avoid the messy middle ground - what exactly does L2 want from a hub?
On Initia, rollups are a given. With Initia VIP, there is full economic coordination between L1 and L2, the product suite is clear, and technology is dedicated to ensuring Minitia has oracles, bridges, liquidity, interoperability, native stability, and more from the start. The Interwoven Stack makes it easy for teams to deploy Minitia using any VM of their choice, whether it’s EVM, MoveVM, or CosmWasm.
Now, what is the most important component to implement a rollup on Initia? Interwoven Stack — an Optimistic rollup framework built from scratch for the Cosmos SDK. Let’s take a deeper look at this framework.
The Interwoven Stack
The Optimistic rollup framework on Initia consists of three components: OPHost, OPChild and OPinit Bots; the three parts are put together like a puzzle to form a whole to provide support for Minita.
OPHost and OPChild are Cosmos SDK modules that form the core of the Stack and are the on-chain part. Since OPinit Stack is implemented at the chain level rather than at the specific VM smart contract level, it allows builders to build support for multiple VMs and provides freedom of choice for Minitia builders.
On Initia, rollups are first-class citizens built directly into the chain, allowing us the flexibility to fine-tune the implementation and provide a better experience.
The OPHost module is stored on Initia (L1). It is responsible for providing infrastructure services for all minitia in Initia. Its main tasks include:
Manage the Optimistic bridge (between L1 and L2) and its assets;
Oversee the finalization of Minitia output proposals;
Handle challenger and proposer debate cases.
On the other hand, OPChild exists on every Minitia, acting like the heartbeat of every rollup. OPChild is responsible for:
Manage rollup operators;
Execute the message received from L1;
Update oracle price information;
Token withdrawal from L1.
OPHost and OPChild together form the Optimistic bridge of each Minitia. One OPHost on Initia acts as the L1 endpoint for multiple OPChild modules on multiple Minitia.
It is important to note that for rollup, the role of the native bridge is not just message transmission, it also acts as the rollup headquarters on L1. The two different consensus systems are unaware of each others state machines, but the rollup bridge acts as the source of truth for the rollup on L1 by submitting state roots or similar outputs, which can be verified based on the state of the rollup to ensure correctness. This is why L1 is often called the settlement layer.
Now you might be thinking: “What is connecting OPHost and OPChild?” Relays? No, OPinit Bots. As an extension of the above, two different consensus systems cannot communicate locally without an off-chain process as a physical link between their independent state machines.
OPinit Bots are off-chain processes that handle critical operations between Initia and Minitias. There are two different bots: Executor and Challenger. In short, these two bots are jointly responsible for:
Perform token transfers;
Submit output proposals to Initia L1;
Submit transaction batches to Celestia for Data Availability (DA);
Forward oracle price feed updates to Minitias.
In the rest of this article, well delve deeper into how specific functionality is implemented in the Interwoven Stack, which should give you a clearer understanding of how all the pieces work together.
Token cross-bridge on Optimistic Bridge
One of the most important aspects of a rollup is that it inherits the security of the L1 it relies on.
A native bridge between L1 and rollup is often the most secure way to transfer assets between the two. This is because using a native bridge does not introduce any additional trust assumptions, only trusting the two chains involved.
Before we delve into how the bridge crossing is done, let’s address a problem that cannot be ignored.
Why not IBC?
So, all chains on the Interwoven Stack are built using the Cosmos SDK, so why can’t the native bridge use the IBC protocol?
Because IBC transfers are essentially instant, this is inconsistent with the trust assumptions of our protocol. One day a malicious Minitia operator might wake up and decide to maliciously insert a transaction to transfer the INIT balance on L2 and extract all INIT on Minitia back to L1. We dont want this to happen, and the mistake would be catastrophic.
However, there is a 7-day delay in withdrawing funds to Initia via the Optimistic bridge, during which a challenger can dispute and cancel the withdrawal if it is detected to be a malicious withdrawal.
On Initia, we still want to ensure a seamless user experience between Mintia and Initia L1 (transferring assets). In order to achieve fast transfers from L2 to L1, we built a secure custom solution called Minitswap, for more information, please refer to: (Minitswap - withdraw from L2 to L1 in seconds, not days )
Token deposit (L1-L2)
Depositing tokens from Initia to Minitia is almost instant. Deposits work as follows:
1. The user submits a deposit transaction on Initia, which locks their tokens on L1 and triggers a deposit event from the OPHost module;
2. The executor OPinit Bot keeps listening for new events on Initia. When it sees the initial_token_deposit event:
2.a—The executor constructs the corresponding FinalizeTokenDeposit message and submits it to Minitia.
3. After receiving the message, Minitia will mint the corresponding token on L2 and send it to the user.
Get the job done without compromising safety!
Token withdrawal (L2-L1)
Token withdrawals are a bit complicated, and while deposits from L1 to L2 are simple, the assumption that “Minitia can always trust L1” does not apply in other cases.
Here’s why: Initia is protected by a group of decentralized validators with economic interests, but Minitia is usually operated by a single or a small group of operators who have no economic interests. So when Minitia initiates a withdrawal to L1, it needs to prove that it is not acting maliciously.
The withdrawal process is as follows:
The user submits a withdrawal transaction on Minitia, causing the OPChild module to destroy their tokens and initiate an initial_token_withdrawal event;
The executor listens to all blocks on L2, it receives events and stores withdrawal requests, but does not forward them immediately, the Bot will wait for the checkpoint to be committed.
Once a commit checkpoint is reached, the executor:
3.a — Get all withdrawal requests within the interval;
3.b—Generate the sorted Merkle tree of withdrawals;
3.c — Create L2 output using the Merkle root of the tree;
3.d—Submit the output to OPHost on L1;
The withdrawal will then enter a withdrawal period, and if anything suspicious is detected, the challenger OPinit Bot can raise a dispute and cancel the withdrawal.
If the withdrawal period passes without any challenges, users can call finalize_withdrawal on Initia to unlock their tokens.
5.a — This function accepts a withdrawal request and its proof;
5.b—Verify the submitted proof;
5.c — If everything goes well, the tokens are sent to the user.
To ensure security, withdrawals take some time. However, in order to provide Interwoven users with a better user experience, Initia also built Minitswap - by leveraging IBC and OPinit Bridge, it allows instant withdrawals and provides a considerable degree of security guarantees.
Now that we know how the withdrawal process works, the challenge mechanism is still a black box, so let’s take a closer look.
What happens when Minitia cheats?
We have learned in the previous section that Minitia may lie and the withdrawal period exists to prevent fraudulent activities from stealing tokens on the OPinit bridge.
But who is responsible for stopping fraudulent withdrawals? That’s the job of challenger OPinit Bot.
1. The challenger monitors L2 output in real time and is submitted to L1;
2. At each commit, it gets the output from Initia and independently calculates the output based on the state of Minitia;
3. If the output submitted on Initia does not match the output calculated by the challenger, then the challenger will delete the output proposal by sending the DeleteOutput instruction. Only the challenger and are allowed to call this function.
Rollback state synchronization using Celestia
When you delete an invalid proposal, it means the current state of the rollup is now invalid, which is why we have a Rollback mechanism.
After a successful challenge, the Minitia node can synchronize the state based on the data previously published to Celestia, because all transaction batches of the rollup have been published to Celestia for DA, which is very convenient when a Rollback is needed.
To ensure the integrity of the Minitia state and to ensure that the executors do not behave maliciously, the two bots (executor and challenger) are designed as independent entities.
To prevent challengers from having too much power, including malicious operations and deleting valid outputs, Initia handles the checks and balances system through L1 governance.
If the challenger and proposer (the person who submitted the output) act maliciously, they can be replaced through governance proposals. For the challenger, malicious behavior means deleting valid outputs. For the proposer, it means submitting invalid outputs.
When a proposal is created, Initia’s L1 validators vote on it by running L2 nodes to verify who is right and who is wrong. This system ensures that no single entity can censor transactions or disrupt the withdrawal process.
More reasonable designs
If we just rest on our laurels and don’t take additional steps, then this is not the outcome of Initia moving forward.
Initia makes it very simple to build your own rollup. Now, there is a lot more to building a rollup than just hosting. As a creator, you also need to build a lot of infrastructure, such as indexers, oracles, bridges, etc. Interwoven Stack has done all of that.
Skip Connect — The Divine Oracle
Through Skip, Initia is able to provide fast and instant asset price data to Initia and every Minitia based on the Interwoven Stack.
Connect is an oracle sidecar service run by Initia validators to push price updates on-chain. This execution takes advantage of two new features introduced in Cosmos SDK version 0.50: ABCI++ and Vote Extensions, which allow validators to submit arbitrary data themselves, which is then stored on-chain to eliminate the possibility of price updates being censored by malicious parties by filling blocks with spam.
Once prices are updated on-chain, developers can query them via the CLI, API, or smart contract level.
But thats not the case. Connect prices are passed down to every Minitia on the Interwoven Stack, ensuring they have easy access to the latest prices on day one.
This way, Minitia does not need to bear the burden of running the necessary infrastructure, nor does it need to find a third-party oracle provider, reach an agreement with them, and invest resources in integration; everything is handled by them.
Cross-chain contract calls
In order to achieve a true Interwoven Stack, there must be a secure and efficient way to communicate across chains on Initia. There are several ways to do this, one of which is through Bridge hooks on the Optimistic Bridge. Bridge hooks are similar in function to IBC Hooks and are used to allow token transfers to initiate contract calls. OPinit Bridge Hooks are used to initiate contract calls while transferring assets through the OPinit bridge.
The Bridge Hooks on OPHost update the metadata of the bridge, and the Hooks on OPChild allow arbitrary execution of transactions on FinalizeTokenDeposit.
We built it in a way that supports multiple virtual machines, so whether its EVM, MoveVM or CosmWasm, Bridge Hooks can execute arbitrary transactions based on the data field in the message.
For example: EVM chain data format
Holy Index
Minitia also comes with a built-in indexer that automatically indexes and stores all relevant data on the chain. The data is then exposed through a REST API that can be used to query historical data.
Tokens classified by account, NFT information, transaction information, etc. are all built in.
Indexing is one of the biggest pain points when building on-chain applications. It really requires a lot of heavy lifting, and running your own indexer is expensive and cumbersome. With the Enshaled Indexer, developers can display token balances, NFTs, transaction history, and more without having to run their own indexer or get support from a third-party indexer.
The Enshrined indexer also supports Initia Scan (the block explorer provided by Initia for L1 and each L2).
in conclusion
The Interwoven Stack is a carefully crafted technology that powers the Initia Interwoven vision. By building the Interwoven Stack as a Cosmos SDK module, Initia repurposes the SDK to build the stack for Optimistic rollups while still retaining all the benefits of the Cosmos SDK.
There is still a lot to explore about The Interwoven Stack. I suggest you take a look at the code base and the Bot code base to understand it more deeply.
All in all, the fact is that Initia is where Rollup really belongs. From the beginning, Initia was built for Minitia to grow. Its ecosystem has already inspired innovative applications from Minitias like Blackwing, control, MilkyWay, Inertia, which are all application-specific rollups that will be available from day one of Initia’s launch, all of which are enabled by the Interwoven Stack.