Web2 To Web3: Bridging The Gap From The Developers’ Perspective

How Did We Get to Web3?

To understand how we got to the Web3 era, it is essential to recognize where all this movement started. Think back to the internet’s earliest days, with Netscape, instant messaging (IM), and GeoCities as the underlying technologies. This era — also called the Web 1.0 period — was revolutionary because you could communicate in real-time and read web content more dynamically than paper-based documents.

Web 1.0 had only one major challenge: user experience was clunky and slow. It was also relatively difficult to manage. In the early and mid-2000s, we witnessed the rise of what we now call Web 2.0, with platforms like Google, Apple, and Amazon taking the basic principles of Web 1.0 but making it more social, mobile, and user-friendly. These platforms empowered users not just to read the content but also to interact with it collaboratively and in a seamless manner.

Web3 has emerged as a revolutionary concept that blends Web 1.0 ideas with Web 2.0, spreading the decision-making processes and data ownership to the internet community instead of the centralized few. It promises to offer data ownership to the parties that use it securely and transparently.

Even though the Web3 concept has been around for over a decade now, and visible strides have been made to enhance the underlying technologies within the space, the adoption process is still slower than we would have expected or desired. The DeFi space is exploding, with new DApps hitting the marketplace on a daily basis.

We are also witnessing the rise of new blockchains — whether these networks are Layer 1 (L1) or Layer 2 (L2) — that promise to diversify user experience and use cases. Despite this growth, user activities on different chains are still very much constrained by individual blockchain limitations. For example, users can only do what the platform allows them to do.

In a perfect Web3 environment, you would expect interoperability and cross-chain composability to be the underlying technologies behind blockchain adoption. However, this is not the case because each blockchain network operates in an isolated environment. Solving the interoperability challenge has increasingly become a focal point for platform and DApp developers worldwide.

To date, these innovations have centered mainly around simplistic modes of bridging assets between chains. For example, centralized bridges have allowed users to transfer assets from one chain to another via intermediate tokens — also called wrapped assets — that involve multiple hops with varying user experiences.

Besides poor user experiences, bridges have a scalability challenge. For example, as more L1s and L2s are created, the number of bridges required to ensure that tokens on one chain can easily be transferred to every other chain increases exponentially. All these challenges hinder cross-chain composability.

But What Exactly Is Cross-Chain Composability?

Cross-chain composability is the ability of DApps, such as automated market makers (AMMs) and decentralized autonomous organizations (DAOs), built on heterogeneous chains to communicate and seamlessly interoperate. Specifically, this means that DApp developers can freely reassemble, duplicate, and integrate code from other applications into their products because smart contracts are open-source and available to the public.

Cross-chain composability allows DApp builders to combine powerful components and design new applications that unlock value and greater opportunities for users. For example, Yearn Finance is a popular AMM within decentralized finance (DeFi). The platform can automatically scan multiple DeFi platforms and move users’ tokens to ecosystems where they can gain the most profit (through earning trading fees, for example).

However, Yearn Finance can only operate if DApp builders can attach the cross-chain request to a value (token) from a source chain. For example, in the case of Yearn Finance, composability can only work if:

• The platform can seamlessly access information about token prices on different DeFi-based blockchain ecosystems. Yearn Finance cannot compare token prices across multiple blockchain ecosystems if each blockchain operates in a siloed environment.

• DApp developers can combine different components of the DeFi ecosystem within the same transaction. For example, developers can program the Yearn trading bot to use ETH as collateral for borrowing DAI tokens from MakerDAO, using DAI tokens to earn CRV coins on Curve Finance, selling CRV for ETH, and returning ETH to the MakerDAO.

Existing Cross-Chain Composability Challenges

When the Ethereum blockchain launched in 2015, most of us believed that DApps would be the logical building blocks of Web3. We imagined that having DApps would enable us to connect to the blockchain ecosystem and smart contract logic and unlock the promises of Web3. Since its launch, Ethereum has moved quickly to become the de facto platform for DeFi, with applications such as Uniswap, MakerDAO, and Compound amplifying its network effects.

The composability function, exemplified by open-source applications, has reinforced the cooperative infrastructure of Ethereum’s ecosystem. Unfortunately, this model has not worked. The current Web3 environment consists of multiple DeFi-based applications only created for one blockchain ecosystem, with Ethereum taking the lion’s share of the total DeFi market size.

Early attempts at making an application span multiple blockchain ecosystems arose with the explosion of L1s and L2s. DApp developers operating in such an environment would be forced to deploy the same smart contract on multiple heterogeneous chains. They would then create a front-end application that connects each blockchain’s respective smart contract, as shown below:

As shown above, Uniswap has been built on four Ethereum-based networks, e.g., Polygon, Optimism, Arbitrum, and Celo. While this approach allows users to connect to different chains from a single front-end application, it is still siloed. For example, neither the smart contract, the user’s wallet(s), nor the network span multiple blockchain ecosystems. In Web2, this is akin to having an application where a user has numerous logins with varying levels of user experience.

Besides the cross-chain challenges, the Web3 landscape has complicated and confusing layers of the technology stack that make it hard for Web2 developers wanting to transition to Web3 to navigate and interact with. For example, while permissionless blockchain data is purposed to be public, accessing it in a granular format is prohibitively difficult, especially at the speed and detail most DApp builders expect from a developer’s experience.

Unlike Web2 application programming interfaces (APIs) that largely operate as plug-and-play components, querying blockchains can be compute-intensive and time-consuming. In addition, refining and manipulating the data adds another layer of complexity to an already complex problem.

An omnichain interoperability protocol such as the one Analog is building can help alleviate these challenges while providing DApp developers with a turnkey technology stack for building cross-chain applications. With Analog’s omnichain protocol, DApp developers can easily deploy a single smart contract on the Timechain — the platform’s ledger — that orchestrates whatever logic that an application requires.

Under this scenario, cross-chain transactions between the source and destination chains occur in a single hop, with all the underlying functionality of the DApp spanning multiple heterogeneous networks. Besides facilitating the development of cross-chain applications, Analog also provides a simple, easy-to-use, and unified API — also called the Timegraph API — that DApp builders and users can leverage to fetch cross-chain requests.

Join Our Community of Developers

Visit /Analog-Timepaper.pdf to learn more about the Analog network, including its novel proof-of-time (PoT) and omnichain interoperability architecture. Join our Discord to get access to Analog’s Development zone channels. Here, you will get technical feedback from the team and other DApp developers.