Analog is partnering with Nubila to enable a smarter, more connected real world data ecosystem.

By integrating our flagship products, Analog Watch and General Message Passing (GMP), Nubila is expanding the reach of its decentralized Environmental, Social and Governance (ESG) data network and enhancing its ability to serve cross chain users with real time insights.

Here’s the scoop.

What Nubila Is Building

Nubila is creating a decentralized data network that specializes in ESG metrics.

It allows individuals and organizations to contribute real-time data, from weather sensors to agriculture and supply chain analytics, into a network where it can be validated, monetized, and used to drive smarter onchain decisions.

As demand for ESG aligned solutions grows across Web3, Nubila is making sure this type of data can be trusted, composable, and accessible across chains.

But to reach users across chains and deliver that data where it’s needed, Nubila needed more robust infrastructure.

How Analog Fits In

To power that next phase of growth, Nubila is integrating two core products from Analog:

• Analog Watch: Allows Nubila to tap into onchain data across ecosystems, price feeds, volume, market cap, circulating supply, and more. This allows Nubila to expand beyond ESG data and layer in other relevant cross-chain information for more complete insights.
• General Message Passing (GMP): Provides secure, permissionless execution of smart contracts across chains. While Nubila’s initial integration is focused on data access via Watch, GMP unlocks future interoperability and automation potential.

Together, these tools give Nubila the ability to scale its impact across multiple networks and make its data layer more composable for the broader Web3 ecosystem.

Why This Matters

Environmental and real world data are becoming increasingly important for both enterprise and onchain use cases. But if that data is locked to a single chain, or trapped in Web2 APIs, it can’t reach its full potential.

With Analog Watch, Nubila can now:

• Serve ESG data and analytics to more ecosystems
• Enhance its agent infrastructure with multichain data feeds
• Prepare for more advanced cross-chain applications via GMP

This is about making real-world data programmable, portable, and profitable.

Looking Ahead

This integration sets the foundation for Nubila’s next phase.

Whether it’s powering decentralized insurance products, building ESG dashboards for DAOs, or enriching AI agents like Caila, Nubila now has the tools to scale those efforts cross-chain.

And as new demands arise, from developers, users, and ecosystems, Analog will be there to help deliver real-time, high-fidelity data wherever it’s needed.

Real world data is finally going omnichain.

Let’s build.

Interoperability has come a long way, but liquidity remains scattered, bridging is costly, and token standards lack consistency. Builders face complexity, and users deal with inefficiencies.

That’s why we’re introducing OATS (Omnichain Analog Token Standard) a scalable and trustless solution for transferring fungible and non-fungible tokens across chains.

Leveraging Analog’s General Message Passing (GMP) and Timechain, OATS will become a key element in eliminating fragmentation and creating a unified liquidity hub through its role in cross-chain token transfers.

Why OATS?

Cross chain transactions today are inefficient. Liquidity is siloed, asset movement is costly, and developers must navigate a tangled web of interoperability solutions.

OATS changes this by providing a unified, trustless framework that removes unnecessary friction and enhances capital efficiency.

With OATS, expect:

• Seamless token movement without wrapped assets
• Lower costs by removing intermediaries
• Simplified development with a single omnichain standard

What This Means for dApps & Builders

For builders, OATS removes the complexity of omnichain token deployment and integration, making omnichain dApps more efficient and scalable.

Instead of juggling multiple bridge contracts and liquidity mechanisms, builders can now rely on a single, trustless framework that ensures easy asset movement across blockchains.

OATS provides plug-and-play omnichain compatibility without the need for wrapped assets, significantly reducing integration overhead with its standardized execution model.

The goal is to make cross-chain development feel as seamless as operating on a single network, without sacrificing efficiency, security, or decentralization.

A Glimpse at What’s Possible

OATS unlocks new opportunities across DeFi, NFTs, gaming, and RWAs:

• DeFi: Efficient cross-chain lending, staking, and liquidity aggregation
• NFTs: Uninterrupted movement between marketplaces
• Gaming & Metaverse: Cross-chain economies that maintain asset consistency
• RWAs: A framework for tokenized assets to flow freely between chains

What’s Next?

OATS isn’t just another omnichain standard, it’s the foundation for a more unified blockchain future. While other solutions are tied to specific ecosystems, OATS is designed for broad compatibility and long-term scalability.

This is just the beginning. Stay tuned for a full breakdown of how OATS will redefine cross-chain liquidity.

Big things are coming for Analog. Fragmented liquidity and inefficient asset movement are holding Web3 back, and our 2025 roadmap is built to change that.

This isn’t just about better interoperability, it’s about creating a unified liquidity hub where users and networks can connect and operate freely across chains without friction.

The future is omnichain, and this is how we’ll build it.

Let’s dive in.

Q1 2025: $ANLOG Staking Upgrades

Analog is launching a new staking interface with enhanced tracking, management, and optimization tools. Users will be able to monitor key metrics in real time, including total staked assets, APR, validator participation, and reward distribution.

The updated UI will provide a clear view of individual staking activity, showing staked balances, claimable rewards, and available actions like re-staking or withdrawing earnings.

Users will also have improved validator selection tools, allowing them to filter by commission rate, self-staked amount, and total nominations.

Q2 2025: GMP V2, Zenswap, Solana & EVM Compatibility

GMP V2 goes live this quarter, bringing tighter security, faster cross-chain transactions, and even deeper interoperability.

We’re also launching Zenswap, a next-gen DEX within the Analog ecosystem, designed for seamless, cross-chain trading.

With a streamlined UI and one-click swap system, it removes complexity while leveraging our GMP and Circle’s CCTP for secure, near-instant asset transfers across multiple networks.

Beyond that, we’ll be expanding into Solana and EVM to make Analog even more efficient and interoperable.

With the Solana integration, users get:

• High-speed, low-cost cross-chain transactions
• Direct movement of assets between Solana and parallel chains
• More DeFi opportunities, bridging Solana-native assets to deeper liquidity pools

On the EVM side, compatibility unlocks:

• Access to Ethereum’s now $16 billion daily trading volume
• Direct integration with top DeFi protocols like Aave, Curve, and Uniswap
• A smoother experience for developers deploying omnichain dApps

More speed, more efficiency, and fewer barriers, this is what’s next for Analog in Q2.

Q3 2025: Analog Stablecoin & Liquidity Provider Program

In Q3 Analog will launch its very own ecosystem stablecoin!

This will serve as a core liquidity asset of the network, and facilitate smooth and efficient cross-chain transactions.

In addition, we’re also rolling out a Liquidity Provider Program to deepen liquidity and improve capital efficiency throughout the network.

More details on how to get involved coming soon.

Q4 2025: Liquid Staking & Analog Governance

Liquid staking is coming.

Staking shouldn’t mean locking up your assets. With liquid staking, users can stake while still using their assets in DeFi and earn rewards without giving up liquidity.

And lastly, governance is at the heart of Analog’s evolution and we’re working hard to get it live for our community.

Our upcoming governance module puts decision-making in the hands of the community, allowing token holders to vote on key decisions, propose upgrades, and shape the protocol’s future

Conclusions and Things to Keep in Mind

The blockchain space moves fast, and so does Analog.

While this roadmap outlines the key milestones we’re building toward, details like features, timelines, and priorities may shift based on development progress, market conditions, and emerging opportunities.

New initiatives could also be introduced as we continue refining and expanding Analog’s ecosystem.

That said, this roadmap reflects what’s locked in so far and provides a clear vision of where we’re headed. Expect ongoing updates as we push forward because building the future of cross-chain liquidity is an evolving process.

Let’s get it Timekeepers. It’s time to build.

As the Web3 ecosystem expands, the need for cross-chain interoperability solutions has significantly increased. However, like any technology, cross-chain interoperability solutions present several challenges, with the chief one being the need for a cost-effective gas payment mechanism.

This is especially true in the Ethereum ecosystem, which has long been associated with high gas fees. In a multi-chain world where many blockchains interact with Ethereum, the cross-chain solution you choose should not only abstract gas payments but also allow users to pay as cheaply as possible.

Analog GMP is a secure messaging protocol that allows users to interact with any asset or DApp on any supported chain with a one-click UX. It is designed so that users only pay the gas fees once in native currency on the origin chain without requiring them to post additional transactions on the target chains or perform relays.

In this post, we explore how Analog has applied practical optimization strategies to achieve gas efficiency in a cross-chain environment.

Gas estimation in cross-chain environments

Insufficient gas on target chains is a major reason why DApp users often abandon cross-chain transactions. To solve this challenge, some cross-chain solutions allow users to pay gas fees in multiple tokens. However, this process can become cumbersome and costly for users.

In an ideal setup, you want to build your DApp on an ecosystem that completely abstracts the issue of gas payment from users. The idea behind the cross-chain gas abstraction mechanism is simple: gas fees should be abstracted away from the UX. In other words, DApp users should only pay the gas fees in native currency on the origin chain and leave the cross-chain solution to handle the execution process on the destination chains.

To achieve gas abstraction, the cross-chain solution must implement accurate gas estimation mechanisms, enabling users to leverage a prepaid fee payment model. This mechanism should help ensure the reliable execution of the cross-chain transaction on the destination chain regardless of gas spikes on that chain.

However, in a cross-chain environment, estimating cross-chain gas fees is more complicated than gas computation, which you’re accustomed to in a single blockchain ecosystem. The true cost of the cross-chain gas consists of three fees:

1. The gas fee a user is required to pay on the origin chain.
2. The gas fee it takes for the validators to attest to the transaction on the source chain.
3. The gas fee it takes to relay and execute the transaction on the destination chain.

Fee (3) is the most complex to estimate because of the different tokens that may exist on the destination chains. In Analog GMP, for example, a decentralized oracle service adjusts the gas fees for each deployed Gateway Smart Contract (GSC) based on Ethereum gas prices whenever possible.

How Analog GMP optimizes cross-chain gas fees

When designing Analog GMP, we meticulously scrutinized the code to optimize cross-chain gas consumption as much as possible. Here are some optimizations that bring the GMP on-chain logic close to its optimal performance:

Optimizing the upgradable proxy

The upgradable proxy is a proxy contract that DApp users use to interact with the deployed GSCs. It is EIP-1167 and EIP-1967-compliant (i.e., popular Solidity patterns that create cheap and minimal proxy clones of contracts). This provides users with as many efficient mechanisms for gas consumption as possible. In addition, the upgradable proxy is ERC-1967 compliant, so Etherscan and other block explorers can recognize it as a proxy.

Use of branchless algorithms to replace conditionals and loops

Using many branches in Solidity can become more expensive because the EVM needs to predict the correct execution path for the code, leading to unpredictable gas costs. For a cross-chain solution like Analog GMP, unpredictable gas costs are problematic for the following reasons:

• Users are required to buy a specific quantity of gas on the origin chain to execute a message on the target chain. As such, the GSC must be certain that the amount of gas is sufficient to execute the message on that chain.
• Blockchain networks often charge users based on the worst-case scenario for gas costs. As a result, users will incur high gas costs when sending cross-chain messages if your code has many branches.

Because of the above reasons, Analog GMP is designed with branchless algorithms that consider the worst-case scenario costs. Our BranchlessMath.sol is an extreme optimization library that consumes constant gas cost for any input and generates significant gas savings compared to OpenZeppelin’s Math library.

In addition, Analog GMP is the only granular cross-chain solution when it comes to cross-chain gas costs. As of this writing, Analog GMP is the only solution considering Ethereum calldata cost in gas cost computations. For example, Analog GMP can calculate the calldata cost as 21000 + (16 * non_zeros) + (4 * zeros), while others calculate 21000 + (zeros + non_zeros) * 16, as illustrated here.

Minimal on-chain storage

Store and read operations are by far the most expensive on Ethereum (and any other blockchain). To minimize gas costs for Analog GMP, we compressed as much data as possible into a single 256-bit storage slot. Executing a cross-chain message with a single storage slot is gas efficient because each additional slot costs users between $0.05 and $1.00 per message, making it expensive.

Get started with Analog GMP

You can quickly get started with Analog GMP by visiting this link, where you’ll learn how to dispatch messages using the deployed GSCs.

Here are other quick links to get you started with Analog GMP:

• Track GMP Messages | Track your cross-chain messages with Timechain Explorer.
• Supported Networks | Discover a list of supported networks, gateway addresses, and network IDs.
• Protocol Overview | Learn more about the architectural components of Analog GMP.

Each deployed GSC comes bundled with the estimateMessageCost method, which you can implement or directly call to receive a quote for the gas fees required to execute your message on the destination chain.

function estimateMessageCost(uint16 networkid, uint256 messageSize, uint256 gasLimit)
        external
        view
        returns (uint256)
    {
        NetworkInfo storage network = _networkInfo[networkid];
        uint256 baseFee = uint256(network.baseFee);
        UFloat9x56 relativeGasPrice = network.relativeGasPrice;
// Verify if the network exists
        require(baseFee > 0 || UFloat9x56.unwrap(relativeGasPrice) > 0, "unsupported network");
        // if the message data is too large, we use the maximum base fee.
        baseFee = BranchlessMath.ternary(messageSize > MAX_PAYLOAD_SIZE, 2 ** 256 - 1, baseFee);
        // Estimate the cost
        return GasUtils.estimateWeiCost(relativeGasPrice, baseFee, uint16(messageSize), 0, gasLimit);
    }sol

estimateMessageCost has the following parameters:

• networkid: The destination chain where the contract call will be made.
• messageSize: The size of the payload in bytes.
• gasLimit: The gas limit required to execute the payload on the destination chain.

The estimateMessageCost returns a value that serves as a msg.value parameter of the gateway’s submitMessage function. You can use this value (i.e., msg.value) to pass in the native token of your origin chain as the gas fee. For example, you can call the submitMessage function like this:

gateway.submitMessage{value: msg.value}(dest_address, dest_network, GMP_GAS_LIMIT, payload);

Build with us!

Join us on our cross-chain journey and become part of the hundreds of developers building unique projects with Analog GMP. Stay up-to-date with Analog:

• Discord: https://discord.com/invite/analog
• X: https://x.com/OneAnalog
• Telegram: @analogannouncements| https://t.me/analogtimer

Non-fungible token (NFT) technology is rapidly evolving, with new daily developments and trends. One such trend gaining popularity is the ERC-404 standard and cross-chain NFTs. These NFTs offer unique features and capabilities not found in standard NFTs, thanks to their interoperability.

In this post, we’ll explore the concept of cross-chain NFTs and explain how Analog GMP’s secure cross-chain NFT design fosters innovation in the Web3 space.

What is a Cross-chain NFT?

A cross-chain NFT refers to an NFT for which ownership rights can be sent/received across multiple chains using a blockchain interoperability solution. For example, you could deploy an NFT collection on Astar and move it to the Ethereum blockchain. In the current Web3 ecosystem, most NFT projects are limited to a single blockchain on which they are minted, hindering their adoption and utility.

For example, in a multi-chain ecosystem, such NFTs cannot be used across different blockchains, and users on different networks can only interact with your NFT if they switch to the underlying chain hosting the NFT.

This constraint not only creates a barrier for newcomers, hindering the adoption of NFTs, but it also causes liquidity issues in NFT marketplaces by isolating assets on their respective blockchain networks. This is why it is crucial for a developer to have a clear focus on which chain will host your NFT collection.

For a deeper dive into cross-chain NFTs, check out our blog: NFTs Cross-Chain? What Are the Possibilities?

Fortunately, with Analog GMP and NFT standards like ERC-404, you can now implement a cross-chain NFT that users can leverage across different chains, promoting greater interoperability and collaboration in the NFT markets.

For more details about ERC-404, check out our blog: What is ERC 404 and How It May Be Changing The Game | Analog Insights.

What Is Analog GMP?

Analog GMP is a chain-agnostic, secure, and modular framework for cross-chain interoperability, enabling seamless state transitions across connected blockchain networks. Utilizing the Timechain as its underlying infrastructure, Analog GMP enables a smart contract on one chain to pass messages (e.g., data and tokens) to other smart contracts on other blockchains.

It has two essential functions you can leverage to build a cross-chain NFT project:

• submitMessage(), which sends the GMP message from the source contract to the Gateway Smart Contract (GSC) on the source chain. The GMP message is then forwarded to the destination chain.
• onGmpReceived(), which receives and processes the GMP message on the destination chain.

For a detailed overview of Analog GMP, check out our documentation.

Implementation mechanics for a cross-chain NFT with Analog GMP

An NFT project can utilize Analog GMP’s messaging capabilities to mint their NFTs on a single chain, pay once, and have those assets distributed to users across multiple chains. This allows users to own and share their assets regardless of the chain they are using.

Here’s how you could implement such a project. Let’s say you have a simple NFT contract with this mint function:

function mint(address to, uint256 tokenId) public
{
	unchecked {
		tokenId+=1;
	}
	_safeMint(to, tokenId);
}

To proceed, you need to implement two contracts: SourceNFTMinter on the source chain and DestNFTMinter on the target blockchain. For cross-chain functionality, the mint function in the SourceNFTMinter contract must include logic for sending a cross-chain request to DestNFTMinter with an ABI-encoded payload, as shown here:

function mint(address recipient, uint16 destinationNetwork, uint256 executionGasLimit, uint256 tokenId) external payable (bytes32 messageID) 
{
	// Create the payload
	bytes32 memory payload = abi.encode(“mint(address)”, msg.sender);
	messageID = _trustedGateway.submitMessage(address(recipient), destinationNetwork, MSG_GAS_LIMIT, payload);
	emit MessageSent(messageID);
}

The logic for this smart contract has two basic steps. First, it creates a payload from the caller (i.e., msg.sender) and recipient. Next, it creates a messageID and calls the gateway contract on the source chain, specifying details such as recipient address, destinationNetwork, execution gas limit, and payload.

Now, let’s take a look at what happens at the destination chain.

The DestNFTMinter contract inherits from the IGmpReceiver interface to handle messages on the destination chain. This interface includes a function named onGmpReceived(), which receives the GMP message from the source chain containing an ABI-encoded mint function as its payload.

When invoked, the contract mints a new NFT to the msg.sender account, which is the same account that minted the NFT on the source chain:

function onGmpReceived(bytes32, uint128, bytes32, bytes calldata) external payable returns (bytes32) 
  {
// Validate the GMP message
 require(msg.sender == address(_trustedGateway), "Unauthorized: only the gateway can call this method");
 require(network == _recipientNetwork, "Unauthorized network");
 require(senderAddr == address(_recipient), "Unauthorized sender");
 
 address user = abi.decode(messageID, (address));
 _safeMint(user, cur_tokenId);
 cur_tokenId++;
}

In this implementation, the contract first validates the message, ensuring that only the gateway can call this method and verifying the validity of the network and sender address. Afterward, the payload is decoded to retrieve the source chain’s caller address, enabling an NFT to be minted at the specified address.

With this implementation, users who minted their NFTs on one chain can now own their assets across multiple chains by paying just once on the original chain. NFT projects aiming to maintain non-fungibility can adapt this implementation by burning the asset on the source chain, guaranteeing that only a single version of the asset exists across various blockchains.

Build With Us!

Are you excited to explore the new realm of cross-chain DApps and discover the innovative applications you can create? We invite you to explore our extensive documentation, which will guide you through building your first cross-chain DApp. NFT projects like PixelPort are already utilizing Analog GMP to develop cross-chain NFTs. You can learn more about this advancement here.

Join us on our cross-chain-verse journey and become part of the hundreds of developers building unique Analog GMP projects. Stay up-to-date with Analog:

Discord: https://discord.com/invite/analog

X: https://twitter.com/OneAnalog

Telegram: @analogannouncements | https://t.me/analogtimer

The NFT space is sure exciting and unique, but this excitement often comes with fragmentation across different blockchains. This disjointed space poses huge challenges for NFT communities striving for cohesion and growth. Belong is a platform dedicated to fostering token-gated communities, events, and even tokenized physical properties, recognized this problem. To bridge the gap, Analog partnered with Belong, leveraging our cross-chain data query solution, Analog Watch.

About Belong

Belong is the go-to platform for creating and managing private community spaces, whether on iOS, Android or the broader web. From crypto projects and NFT collections to groups of friends with shared interests, Belong provides the necessary tools to connect, collaborate, and thrive. The platform features custom branding and is designed to cater to a wide array of communities.

The Challenge: Fragmented NFT Communities

As mentioned, the NFT space suffers from fragmentation across various blockchains. This hampers the ability of communities to come together, limiting their potential for collaboration and growth. Recognizing this challenge, Belong sought an innovative solution to unify these disparate elements.

The Solution: Analog Watch

Analog Watch is the true solution to the problem. It essentially taps into real-time NFT ownership data from the Astar network, enabling Belong to manage community access and automate token-gating based on members’ NFT holdings, irrespective of the blockchain.

Further Possibilities

This integration is just the beginning. Belong is exploring various innovative use cases with Analog Watch, including:

• Cross-chain identity verification for NFT memberships
• Cross-chain NFT auctions with real-time price data
• Advanced cross-chain analytics for community organizers
• On-chain loyalty programs based on user behavior across multiple chains

The Benefits?

The integration with Analog Watch provides Belong with several key advantages:

• Data Accuracy: Ensures accurate and reliable community management with real-time NFT ownership data.
• Automation: Streamlines token-gating, saving time and effort for community organizers.
• Flexibility: Opens up new possibilities for community engagement and growth by querying data across multiple chains.

Security

Analog’s infrastructure prioritizes the safety and privacy of user data, providing a secure environment for all participants. We conduct regular audits to identify and mitigate vulnerabilities, risks and bugs. The latest audit by @hackenclub highlighted 0 critical errors and confirmed our approach to cross-chain security in our set of products. Read the full audit report.

Conclusion

By integrating Analog Watch, Belong is setting a new standard for building cohesive and dynamic NFT communities across multiple blockchains. This partnership exemplifies the potential for growth and collaboration in the Web3 ecosystem, paving the way for more integrated and engaging NFT and Web3 communities.

Analog is excited to share the latest metrics from our ongoing incentivized testnet, showcasing a significant increase in user engagement and a growing interest from potential validators.

Key Highlights:

• Watch Portal:
• 2.15 million visiting users (22.4% increase)
• 94,983 connected wallets (13.01% increase)
• 202,437 Views created (43.17% increase)
• 74,910 smart contracts listed (30.08% increase)
• Incentivized Testnet:
• 228,251 unique accounts (12.55% increase)
• 312,819 visiting users (16.06% increase)
• 81,148 weekly active users (11.72% increase)
• 42,359 weekly new users (39.95% increase)
• Community and Developer Quests:
• 226,817 participants on Galxe (15.80% increase)
• 119,453 ATP claims (9.41% increase)
• 96,885 participants in Watch Quests (14.24% increase)
• Validator Interest:
• Over 1,000 potential validators are eager to join the active set, as shown on https://telemetry.analog.one/#/0x0614f7b74a2e47f7c8d8e2a5335be84bdde9402a43f5decdec03200a87c8b943

Community Growth Across the Globe

The Analog community is growing rapidly across the globe, with Vietnam, Japan, and India leading the way in terms of user participation. This diverse and global community is a testament to the growing interest in Analog’s cross-chain technology and its potential to revolutionize the Web3 landscape and the future of interoperability.

Looking Ahead:

These metrics underscore the increasing momentum and excitement surrounding Analog’s testnet. We’re thrilled by the growing interest from validators and look forward to their participation as we progress towards mainnet launch!

Stay tuned for more updates as we continue to build a stronger, more secure, and more interoperable blockchain future.

Analog is proud to announce a strategic integration with XION, a leading layer-one blockchain simplifying blockchain interactions through its Generalized Abstraction infrastructure. This collaboration aims to seamlessly integrate XION’s user-friendly L1 with Analog’s powerful cross-chain infrastructure, expanding the reach and capabilities of both platforms.

XION: Empowering Users in a Complex Web3 Landscape

XION is on a mission to make blockchain technology accessible to everyone. Their L1 empowers users to interact with the Web3 ecosystem without requiring in-depth technical knowledge. Through a combination of intuitive interfaces and its Generalized Abstraction infrastructure, XION simplifies complex processes and opens up blockchain technology to a wider audience. It is now expanding these seamless user experiences to connected ecosystems through Chain Abstraction.

Unlocking New Possibilities: A Shared Vision

XION has been rapidly expanding its Chain Abstraction solution to major ecosystems through strategic integrations, such as Injective, SAGA, BNB Chain, and the AVAX ecosystem. The goal of Chain Abstraction is to make Web3 more accessible and intuitive for all users by abstracting away cross-ecosystem complexities through XION’s Generalized Abstraction. This allows it to serve as an extension to all major blockchain networks, reshaping the historically competitive nature of L1s, which typically compete for users, liquidity, and developers, to enable true mainstream adoption.

By joining Analog’s Launch Partners Program, XION will leverage a suite of tools and services designed to enhance cross-chain capabilities and further scale its Chain Abstraction solution:

• Analog’s General Message Passing (GMP): This enables XION’s Meta Accounts to function seamlessly across multiple blockchains, unifying the user experience and expanding the reach of XION’s ecosystem.
• Analog Watch: This powerful data querying tool allows XION to efficiently access and compare information from various chains, improving the accuracy and effectiveness of their services.
• Automation and Cross-Chain Ideation: Analog’s expertise and support will empower XION to design and implement innovative cross-chain solutions, further simplifying the blockchain experience for users.
• Timechain Integration: XION can now tap into the liquidity and functionality of multiple blockchains through Analog’s Timechain, expanding the scope and potential of their platform.

This integration represents a significant step forward for both companies. XION’s dedication to accessibility and Analog’s robust cross-chain infrastructure combine to create a powerful synergy that will unlock new possibilities for users and developers alike across a variety of ecosystems.

Key Highlights:

• XION to integrate Analog’s GMP to enable seamless cross-chain Meta Account functionality to new ecosystems.
• Analog Watch to enhance data querying and comparison for XION’s services.
• Collaboration on cross-chain ideation and use case designs.
• XION to leverage the Timechain for expanded multi-chain capabilities.
• Joint commitment to creating a more user-friendly and accessible Web3 ecosystem to continue driving mainstream adoption.

About Analog Network:

Analog is creating the building blocks for a multi-chain-verse, with its Layer-0 blockchain that powers cross-chain communication and toolkits for seamless deployment and querying of Web3 data from supported chains. Analog is at the forefront of addressing the pressing need for seamless interoperability among the multitude of siloed blockchains. Dedicated to bridging gaps and fostering true connectivity, Analog is reshaping how blockchains communicate and collaborate.

About XION:

XION is the first modular Generalized Abstraction layer one blockchain, purpose-built for consumer adoption by enabling seamless user experiences for everyday users. XION’s Generalized Abstraction layer includes protocol-level abstractions across Accounts, Signatures, Gas, Interoperability, Pricing, Devices, Payments, and more. By abstracting away all crypto complexities, XION allows the development of next-generation projects bringing Web3 to mainstream audiences worldwide. XION has raised over $30M from industry leaders Animoca, Circle, Multicoin, and more.

Analog: https://x.com/OneAnalog

XION: https://x.com/burnt_xion

For further insights or collaborative opportunities, please reach out to collaborations@analog.one.

Check out what we were up to in the first quarter of the year

Analog had a spectacular first quarter of 2024!

Let’s take a look at the key moments we experienced throughout the three-month period.

Testnet tidings

We opened our Testnet for registration, inviting developers, community members and validators to sample our platform!
👉 https://www.analog.one/testnet

Fruitful funding

We successfully raised over 16 million USD in our latest funding round thanks to a group of awesome investors, led by Tribe Capital!
👉 https://twitter.com/OneAnalog/status/1757126550380826987

Partner pursuits

We debuted the Analog Partner Spotlight Series! Check out the first two partners we highlighted ⬇️

• Dmail 👉 https://twitter.com/OneAnalog/status/1753091614879420823
• Cryfi 👉 https://twitter.com/OneAnalog/status/1773587059120423022

Common Wealth collab

We were a part of Common Wealth’s investment round this quarter, with rewards on offer for those involved! ⬇️

• Investment announcement
  👉 https://twitter.com/OneAnalog/status/1760890903408124008
• Analog project highlight
  👉 https://twitter.com/joincommonwlth/status/1761002249914892307
• Talk with Analog’s Head of BD, Eric Wang
  👉https://twitter.com/OneAnalog/status/1764855089993527596

Valentine venture

We launched a special TaskOn campaign during Valentine season, with special rewards for grabs
👉 https://twitter.com/OneAnalog/status/1755083666072695202

Follower feat

We celebrated an amazing community milestone — over 200k followers on X!
👉 https://twitter.com/OneAnalog/status/1765325897329156123

Security specialist

Analog’s Senior Security Engineer, Alp Onaran, dispensed invaluable insights on crypto security — first in an informative article and then at a Polkadot event! ⬇️

• Coindesk article 👉 https://www.coindeskturkiye.com/yazarlar/alp-onaran/kripto-para-ve-defi-guvenligi-5671
• Sub0 speaking engagement 👉 https://twitter.com/foreseon_/status/1768613775945433360

ETH experience

We made an appearance at ETH Denver, Colorado’s top Web3 event! ⬇️

• The team who attended 👉 https://twitter.com/OneAnalog/status/1762486252501180775
• Thoughts of Analog’s Founder, Victor Young, on the event 👉 https://twitter.com/VictorYoungMe/status/1769926110656311762

Superb spotlight

We were featured by Joshua of Contango Digital! Discover the insights he shared on Analog. 👉https://twitter.com/contangojosh/status/1763621507832467884

Blog bonanza

We posted a number of thought-provoking articles on our blog! ⬇️

• Liquidity fragmentation 👉 https://www.analog.one/blog/what-is-liquidity-fragmentation-and-why-its-killing-defi
• Crypto data aggregators 👉 https://www.analog.one/blog/what-are-crypto-data-aggregators-and-how-do-they-work
• GMP protocol 👉 https://www.analog.one/blog/5-cross-chain-defi-use-cases-unveiled-analogs-general-message-passing-protocol
• Analog Watch 👉 https://www.analog.one/blog/enhancing-data-retrieval-for-dapps

You can learn more about Analog Network on our official channels:

• Discord: Analog (Official) Server
• Medium: @analogtime
• Twitter: @OneAnalog
• Telegram: Community Channel
• Reddit: r/AnalogToken
• Facebook: @analogpost
• LinkedIn: @analogone

Enhancing Efficient Data Retrieval for DApps | Analog Watch Insights

Blockchains have radically redefined our interaction with the digital world. Decentralized applications (DApps) are proliferating, creating fresh opportunities and complexities for developers. In this post, we’ll delve into the challenges of accessing Web3 data and examine why Analog Watch stands out as an innovative service designed to cater to developers’ unique needs in DApp development.

Understanding Web3 data accessibility problem

Imagine you’re a developer building a DApp that requires real-time access to smart contract data and user interactions. Navigating this ocean is arduous, much like searching a vast library with millions of books but lacking a cataloging system.

Below are common challenges you’re likely to face when trying to access data from a blockchain:

• Slow syncing speeds: Blockchain networks often emit vast amounts of data. Staying in sync with such data is crucial for DApps, particularly those that power Decentralized Finance (DeFi) markets. However, traditional querying methods such as JSON-RPC calls can prove sluggish and request-heavy, causing delays in both real-time and historical data.
• Data fragmentation: Blockchain networks write data to their ledgers in a sequence, one block after another, as the chain is constructed. This often results in fragmented, unorganized, and underutilized data, making it hard for users to query efficiently.
• Multi-chain indexing and aggregation: While the shift to a multi-chain future has created more possibilities for scalability and innovation, it has also created fragmented data for DApps that intend to go multi-chain. For example, Uniswap is currently deployed across over eight blockchains, including Ethereum, Celo, Avalanche, Optimism, and Arbitrum. This deployment strategy can quickly lead to developing and maintaining multiple infrastructure components, increasing operational costs. Besides, you have to implement additional logic on the client side (e.g., SUM, AVG, PROD, multi-chain, etc.) for advanced DApps that require aggregation across multiple chains.
• Lack of standardization mechanisms: Unlike traditional database management systems that support query languages such as SQL, blockchain networks are designed to be sovereign, with varying data structures, APIs, and no standardized query language. This makes it hard for blockchain indexers and users to query the required smart contract data.

Existing approaches for indexing Web3 data

A Web3 indexer is a specialized service that plays an essential role in DApp development by simplifying the application’s access to blockchain data. It fetches data stored on blockchain networks and organizes it into a relational database, making it more accessible for developers and other users to efficiently query and use.

To use a Web3 indexer, all you need to do is define the data types and relationships in the smart contract(s) you would like to query and how such data should be stored in the database. The indexing service can then provide a standard REST API or custom GraphQL endpoint for users to leverage when querying the smart contract data.

There are three common approaches you can use to index blockchain data:

• Dedicated node: You can run your own node as local, co-located, or use a cloud service provider.
• RPC node provider: You can use an RPC provider as a public or private node.
• Back-end as a service (BaaS): You can leverage a BaaS provider with custom specifications to query blockchain data.

The table below provides a summary of the pros and cons of each method:

Exploring Analog Watch for your Web3 data needs

Analog Watch is a low-code, developer-friendly, and multi-chain indexing platform. It is fully customizable and streamlines the process of retrieving data from any supported network, providing developers with a seamless way to access fragmented data across multiple blockchains.

Here are some notable features that make Analog Watch the “go-to” solution for Web3 data retrieval:

• Low-code capabilities: Analog Watch provides automatic code generation via a View Builder, minimizing the complexities of interacting with smart contracts. You can leverage the View Builder to generate Views quickly, saving the time required to deploy and query data from a listed smart contract.
• Prioritized UX/DevEx: A seamless UX is necessary for onboarding users into the Web3 ecosystem. Analog Watch UI is a hosted service that plays a crucial role by allowing users — regardless of their technical expertise — to publish and explore smart contracts and Views. Developers can also leverage the Watch SDK’s Quickstart Guide to help them onboard to the platform and start deploying Views.
• Multi-chain indexing and data aggregation: Analog Watch natively supports multi-chain indexing and data aggregation into a unified relational database. This feature lets you query a single endpoint when fetching data from multiple smart contracts on supported chains. Check out “Aggregated Price Feeds” to learn more.
• GraphQL API support: Analog Watch UI and the Watch SDK provide an intuitive and ready-to-use GraphQL endpoint, making it easier for users to query published Views.

How to deploy Views and query data with Analog Watch

Now that you’ve understood why Analog Watch is an efficient Web3 indexing platform, what next? It’s time to take a deep dive into the steps you need to follow to build Views and query data with Analog Watch. There are two ways to interact with Analog Watch:

1. Analog Watch UI: This is a hosted service that leverages drag-and-drop interfaces to allow developers to deploy and explore smart contracts/Views. Currently, the Analog Watch UI doesn’t permit direct querying of data from the GraphQL endpoint. As such, we’ll not cover the details of using Analog Watch UI in this post. However, you can check out “Watch UI (View Builder)” to learn more about deploying and exploring Views with Analog Watch UI.
2. Watch SDK: This is a JavaScript SDK that serves as a Client by abstracting all the details about authentication, deployment, and querying Views. Analog Watch also uses the watch command-line interface (CLI)—a lightweight wrapper around the Watch SDK—to generate the session keys and scaffold smart contracts and Views from templates. See “Watch CLI” for more details.

How to deploy and query Views with the Watch SDK

Here are steps you can follow to deploy and query Views with the Watch SDK:

Step 1: Install the Watch SDK

The Watch SDK lets you generate session keys and interact with Analog Watch. You can install it in two ways depending on the choice of your package manager as follows:

npm i @analog-labs/timegraph-js//if you’re using npm

or

yarn i @analog-labs/timegraph-js// for yarn

Step 2: Generate the session keys

The Watch SDK supports two environments: the web environment, which requires @polkadot/extension-dapp, and the node environment, which requires the [@polkadot/Keyring](<https://polkadot.js.org/docs/api/start/keyring/>) package.

To use the web environment, type the following commands:

npm i @polkadot/extension-dapp

import { keygen } from "@analog-labs/timegraph-js/keygen/web";

import { web3FromAddress } from "@polkadot/extension-dapp"; // init signer based on polkadot/extension-dapp

const { signer } = await web3FromAddress( < "wallet address"> );// pass signer and address to get keygen instance

const _keygen = new keygen({ signer: signer.signRaw,address: <"address">});// generate api key i.e role is optional default will be developer

const apikey = await _keygen.createApiKey();// generate the session key

const sessionKey = await _keygen.createSessionkey();

For the node environment, type the following commands:

npm i @polkadot/keyring

import Keyring from "@polkadot/keyring";

import { keygen } from "@analog-labs/timegraph-js";// init polkadot keypair for node environ

const keyring = new Keyring({ type: "sr25519" });

const keypair =  keyring.add...( ... ));// pass signer and address to get keygen instance

const _keygen = new keygen({ signer: keypair.sign, address: keypair.address });// generate API key, i.e. role is optional default will be developer

const apiKey = await _keygen.createApiKey( <"Role"> );// generate session key

const sessionKey = await _keygen.createSessionkey( <"Expiration in ms ");

Step 3: Initialize the Client

Initialize and configure the Client as follows:

import { TimegraphClient } from "@analog-labs/timegraph-js";

const timeGraphClient = new TimegraphClient({

url: "<URL>", // url to Watch GraphQL instance

sessionKey: "<SSK>", // session key created by user wallet using WASM SDK

});

Step 4: Deploy the View

Use the generated session keys to create and deploy Views that interact with listed smart contracts on the Analog Watch. Check out “Publish Views with Watch SDK” to learn more.

Step 5: Query Views

With your Views published, you can now begin querying the smart contract data using a unified GraphQL endpoint. Visit https://docs.analog.one/documentation/developer-guide/query-data/watch-sdk to learn more about querying Views.

Step 6: Build your DApp

Once you have access to smart contract data, you can now start building applications, services, or analytics customized to your business requirements. Check out https://www.analog.one/?section=usecases to learn more about what you can build with Analog Watch.

Conclusion

Retrieving data from blockchains is complex and challenging. However, with Analog Watch, you can effortlessly overcome these challenges. Analog Watch’s low-code capabilities, prioritized UX/DevEx, multi-chain indexing, and GraphQL integration make it a powerful tool for efficiently deploying and querying data from supported chains.

If you’re a developer looking to streamline your DApp’s access to Web3 data, look no further. Visit our docs to get started and join the technical discussion in the Discord channel. You can also join our Launch Partners Program or sign up for the Grants Program.