The crypto ecosystem has had to adapt to new realities—Initia was born in this context.

As an industry, we have to accept the fact that a single state machine cannot scale to match the ambitions of crypto. Expanding throughput while keeping costs low for users and operators, all 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 counterpoint. Earlier this year, the debate between modularity and monolithic chains became the focus. But most importantly: there is fundamentally no debate. 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 L1.

For example, in the Solana network, the advantages of a hybrid (or as we like to call it, "Interwoven") approach have become evident. Over the past six months, the team has begun building their own custom "network expansion" and has successfully done so on Solana. But wait, isn't Solana supposed to handle scaling on its own? Isn't that their entire brand?

You see, rollups are not just about scaling execution; they are about sovereignty—allowing builders complete control over their execution environment. Higher TPS, lower gas fees (or zero gas), control over tx ordering and processing, and ownership of the entire economic stack of their business, among other things.

It is clear that rollups are inevitable and will always exist.

The existence of Initia is built around this theme. Its purpose is to host a thriving ecosystem of Interwoven rollups, known as Minitia.

The Future Belongs to Interwoven

Initia offers diverse, powerful, and unique applications through the cohesive experience of Interwoven design.

So far, there are two ecosystems. One is specifically built for interconnected blockchain worlds (Cosmos), and the other has long existed as a staking rollup (Ethereum, now Solana). Each approach has achieved a certain level of success, but not without failures, which are valuable lessons to learn from when building new models for L1.

Initia connects these two ecosystems; it is an L1 designed to support interconnected L2 networks, ensuring that Minitia builders have everything they need for success. Initially, Initia insisted on asking questions to avoid the chaotic middle ground—what exactly does L2 want to gain from a hub?

On Initia, rollups are a given. Through Initia VIP, complete economic coordination between L1 and L2 is achieved, the product suite is clear, and the technology is specifically designed to ensure that Minitia has oracle, bridge, liquidity, interoperability, native stability, etc., from the very beginning. The Interwoven Stack allows teams to easily deploy Minitia using any VM of their choice (whether EVM, MoveVM, or CosmWasm).

Now, what is the most important component for implementing rollups on Initia? The Interwoven Stack—an Optimistic rollup framework built from the ground up for the Cosmos SDK. Let’s dive into this framework.

The Interwoven Stack

The Optimistic rollup framework on Initia consists of three components: OPHost, OPChild, and OPinit Bots; these three parts come together like a puzzle to form a whole that supports Minitia.

OPHost and OPChild are the Cosmos SDK modules that form the core of the Stack, existing on-chain. Since the OPinit Stack is implemented at the chain level rather than at the specific VM smart contract level, it allows builders to construct support for multiple VMs and provides Minitia builders with the freedom of choice.

On Initia, rollups are first-class citizens built directly into the chain, allowing us to flexibly fine-tune implementations and provide a better experience.

The OPHost module resides on Initia (L1). It is responsible for providing infrastructure services for all Minitia on Initia, with key tasks including:

Managing the Optimistic bridge (between L1 and L2) and its assets;

Overseeing the finalization of Minitia output proposals;

Handling disputes between challengers and proposers.

On the other hand, OPChild exists on each Minitia, like the heartbeat of each rollup, and is responsible for:

Managing rollup operators;

Executing messages received from L1;

Updating oracle price information;

Token withdrawals from L1.

OPHost and OPChild together form the Optimistic bridge for each Minitia. An OPHost on Initia acts as the L1 endpoint for multiple OPChild modules across various Minitia.

It is important to note that the role of the native bridge for rollups is not just message transmission; it also serves as the headquarters for rollups on L1. The two different consensus systems are unaware of each other's state machines, but the rollup's bridge acts as the true source of the rollup on L1 by submitting state roots or similar outputs, which can be verified against the rollup's state to ensure correctness. This is why L1 is often referred to as the settlement layer.

Now you might be wondering: "What connects OPHost and OPChild?" A relay? No, it’s the OPinit Bots, which serve as an extension of the above, allowing the two different consensus systems to communicate locally without an off-chain process as a physical link between their independent state machines.

OPinit Bots are off-chain processes that handle key operations between Initia and Minitias. There are two different bots: executors and challengers. In short, these two bots are jointly responsible for:

Executing token transfers;

Submitting output proposals to Initia L1;

Submitting transaction batches to Celestia for data availability (DA);

Forwarding oracle price feedback updates to Minitias.

In the remainder of this article, we will delve into how specific functionalities are implemented within the Interwoven Stack, which should give you a clearer understanding of how all the parts work together.

Token Cross-Bridge on the Optimistic Bridge

One of the most important aspects of rollups is that they inherit the security of the L1 they depend on.

The native bridge between L1 and rollup is usually the safest way to transfer assets between the two. This is because using a native bridge does not introduce any additional trust assumptions; you only need to trust the two chains involved.

Before we dive into how cross-bridging works, let’s address an undeniable question.

Why Not IBC?

So, all chains on the Interwoven Stack are built using the Cosmos SDK; why can’t the native bridge use the IBC protocol?

Because IBC transfers are essentially instantaneous, which does not align with the trust assumptions of our protocol. One day, a malicious Minitia operator might wake up and decide to maliciously insert a transaction, transferring the INIT balance on L2 and withdrawing all INIT from Minitia back to L1. We do not want this to happen; such a mistake would be catastrophic.

However, withdrawing to Initia through the Optimistic bridge has a 7-day delay, during which, if a malicious withdrawal is detected, challengers can dispute and cancel the withdrawal.

On Initia, we still want to ensure a seamless user experience (transferring assets) between Mintia and Initia L1. To achieve fast transfers from L2 to L1, we built a secure custom solution called Minitswap; for more information, refer to: (Minitswap—Withdrawals from L2 to L1 in seconds, not days)

Token Deposits (L1—L2)

Depositing tokens from Initia to Minitia is almost instantaneous. The deposit process works 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 continuously listens for new events on Initia, and when it sees the initialtokendeposit event:

2.a—The executor constructs the corresponding FinalizeTokenDeposit message and submits it to Minitia.

3. Upon receiving the message, Minitia mints the corresponding tokens on L2 and sends them to the user.

It gets the job done without compromising security!

Token Withdrawals (L2—L1)

Token withdrawals are a bit more complex; while deposits from L1 to L2 are straightforward, the assumption that "Minitia can always trust L1" does not apply in other scenarios.

The reasons are as follows: Initia is protected by a group of decentralized validators with economic stakes, while Minitia is typically operated by a single or a small number of operators who do not have economic stakes. Therefore, when Minitia initiates a withdrawal to L1, it needs to prove that it is not acting maliciously.

The withdrawal process is as follows:

1. The user submits a withdrawal transaction on Minitia, which causes the OPChild module to destroy their tokens and initiate an initialtokenwithdrawal event;

2. The executor listens for all blocks on L2, receiving the event and storing the withdrawal request, but it does not forward it immediately; the bot waits for the submission checkpoint.

3. Once the submission checkpoint is reached, the executor:

   3.a—Collects all withdrawal requests within the interval;

   3.b—Generates a sorted Merkle tree of the withdrawals;

   3.c—Creates an L2 output using the Merkle root of that tree;

   3.d—Submits the output to the OPHost on L1;

Then the withdrawal enters a withdrawal period, during which, if any suspicious activity is detected, the challenger OPinit Bot can dispute and cancel the withdrawal.

If the withdrawal period passes without any challenges, the user can call finalize_withdrawal on Initia to unlock their tokens.

5.a—This function accepts the withdrawal request and its proof;

5.b—Validates the submitted proof;

5.c—If everything checks out, the tokens are sent to the user.

To ensure security, withdrawals take some time. However, to provide a better user experience for Interwoven users, Initia has also built Minitswap—by leveraging IBC and the OPinit Bridge, it allows for instant withdrawals while providing a considerable degree of security assurance.

While we understand how the withdrawal process works, the challenge mechanism remains a black box; let’s delve deeper into it.

What Happens When Minitia Lies?

As we learned in the previous section, Minitia may lie, and the existence of a withdrawal period is to prevent fraudulent activities from stealing tokens on the OPinit bridge.

But who is responsible for stopping fraudulent withdrawals? That is the job of the challenger OPinit Bot.

1. The challenger monitors L2 outputs being submitted to L1 in real-time;

2. With each submission, it retrieves the output from Initia and independently calculates the output based on Minitia's state;

3. If the output submitted on Initia does not match the output calculated by the challenger, the challenger will delete the output proposal by sending a DeleteOutput command; only the challenger is allowed to call this function.

Rollback State Synchronization with 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, Minitia nodes can synchronize their state based on the data previously published to Celestia, as all transaction batches of the rollup have been published to Celestia for data availability (DA), making it very convenient when a Rollback is needed.

To ensure the integrity of Minitia's state and to ensure that the executor is not acting maliciously, the two bots (executor and challenger) are designed as independent entities.

To prevent the challenger from having too much power, including malicious operations and deleting valid outputs, Initia handles the checks and balances through L1 governance.

If the challenger and the proposer (the one submitting 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 review transactions or disrupt the withdrawal process.

More Reasonable Design

If we were to simply settle for the status quo without taking additional measures, it would not be the outcome that Initia should strive for.

Initia makes it very easy to build your own rollup. Now, establishing a rollup involves much more than just hosting. As a creator, you also need to build a lot of infrastructure, such as indexers, oracles, bridges, etc. The Interwoven Stack has everything ready.

Skip Connect—The Sacred Oracle

Through Skip, Initia is able to provide fast and instant asset price data for 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 process utilizes two new features introduced in Cosmos SDK version 0.50: ABCI++ and Vote Extensions, which allow validators to submit arbitrary data themselves and then store it on-chain, eliminating the possibility of price updates being censored by malicious parties filling blocks with spam.

Once the price updates are on-chain, developers can query them through CLI, API, or at the smart contract level.

But that’s not all. The prices from Connect are passed to every Minitia on the Interwoven Stack, ensuring they can easily access the latest prices from day one.

This way, Minitia does not have to bear the burden of running the necessary infrastructure, nor do they need to seek third-party oracle providers, negotiate with them, and invest resources in integration; everything is handled for them.

Cross-Chain Contract Calls

To achieve a truly Interwoven Stack, there must be a secure and efficient way of cross-chain communication on Initia. There are several ways to accomplish this, one of which is through Bridge hooks on the Optimistic Bridge. Bridge hooks function similarly to IBC Hooks, allowing token transfers to initiate contract calls. OPinit Bridge Hooks are used to initiate contract calls while transferring assets through the OPinit bridge.

Bridge Hooks on OPHost update the bridge's metadata, while Hooks on OPChild allow arbitrary transactions to be executed on FinalizeTokenDeposit.

We built it in a way that supports multiple virtual machines, so whether it’s EVM, MoveVM, or CosmWasm, Bridge Hooks can execute arbitrary transactions based on the data fields in the message.

For example: Data format for EVM chains

The Sacred Indexer

Minitia also comes with a built-in indexer that automatically indexes and stores all relevant data on-chain. The data is then made public through a REST API available for querying historical data.

Token balances categorized by account, NFT information, transaction information, etc., are all built-in.

Indexing is one of the biggest pain points when building applications on-chain, as it indeed requires a lot of heavy lifting, and running your own indexer is both expensive and cumbersome. With the Enshrined indexer, developers can display token balances, NFTs, transaction history, and more without running their own indexer or relying on third-party indexer support.

The Enshrined indexer also supports Initia Scan (the block explorer provided for L1 and each L2).

Conclusion

The Interwoven Stack is a meticulously designed technology that supports the vision of Initia Interwoven. By building the Interwoven Stack as Cosmos SDK modules, Initia repurposes the SDK to construct a stack for Optimistic rollups while retaining all the advantages of the Cosmos SDK.

There is still much to explore about The Interwoven Stack, and we recommend checking out the codebase, as well as the Bot codebase, for a deeper understanding of how it all works together.

In summary, the fact is that Initia is the true home of Rollup. From the very beginning, Initia was built for the development of Minitia. Its ecosystem has inspired innovative applications of Minitias like Blackwing, Control, MilkyWay, and Inertia, all of which are application-specific rollups that will be available from day one on Initia, all made possible by the Interwoven Stack.

免责声明：本文章仅代表作者个人观点，不代表本平台的立场和观点。本文章仅供信息分享，不构成对任何人的任何投资建议。用户与作者之间的任何争议，与本平台无关。如网页中刊载的文章或图片涉及侵权，请提供相关的权利证明和身份证明发送邮件到support@aicoin.com，本平台相关工作人员将会进行核查。