Check out this blog post in 中国人, 日本, and Tieng Việt

We are excited to announce the public release of our developer documentation, which will allow you to build the first omnichain dApps on top of ZetaChain’s Sparta (devnet) network. Last month, we opened early access to Sparta to a select cohort of developer teams and have since seen impressive progress. With all of the positive feedback, we’ve decided to open it up so that anyone can take a look and easily start building on top of ZetaChain. In the docs, you’ll find an overview of the following:

• ZetaChain’s blockchain architecture with examples and reference docs for building on top of the protocol.

• Live Sparta addresses for testing cross-chain functionality.

• A library of use case examples to help kickstart your contract development (growing based on new features and community requests).

• ZetaChain ecosystem FAQ and glossary of relevant terms.

This is Sparta!

At this time, the Sparta devnet is where developers will find the latest features and API updates on ZetaChain. Note, we will maintain, test, and experiment with different features on multiple versions of ZetaChain blockchain before we launch the mainnet. Here is a brief description of ZetaChain’s network development stages:

• Troy (localnet): Troy is a private, local multi-chain environment with multiple nodes allowing developers to quickly test out new ideas before launching on a public network. This network will be open-sourced in the future so that anyone can contribute to ZetaChain’s development easily.

• Sparta (devnet): Sparta is ZetaChain’s actively-developed devnet. The protocol connects testnet networks so that you can pass data and value between them using ZetaChain contracts deployed on each chain. This is a public experimental development network that will experience frequent updates. Developers can build omnichain dApps using Sparta, leveraging ZetaChain’s latest features.

• Athens (testnet): Athens is a more stable testnet for developers to test and finalize their dApps prior to releasing them on mainnet. This network will be upgraded less frequently than Sparta, with features that are staged for mainnet release. Athens will be fully transparent and explorable, just as mainnet.

• ZetaChain (mainnet): ZetaChain’s mainnet transacts real data and assets. The validator network will be fully public, transparent, and decentralized.

A glimpse of the development experience

With the Message Passing Interface (MPI) APIs now deployed on Sparta, you can build dApps that send value and data across chains, simply. In this section, we show how easy it is for developers to add cross-chain functionality to their dApps. Of course, check out the full docs site for more details.

Sparta is currently live with Goerli, BSC Testnet, and Polygon Mumbai. More chain support will be added over time, as ZetaChain is chain-agnostic.

The interfaces

First, let’s take a look at the interfaces you’ll be using. For EVM contracts, they look like:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;interface ZetaInterfaces {
/**
* @dev Use SendInput to interact with our Message Passing Interface: zeta.send(SendInput)
*/
struct SendInput {
uint256 destinationChainId;
bytes destinationAddress;
/// @dev Total gas including the transactions on every chain
uint256 gasLimit;
/// @dev An encoded, arbitrary message to be parsed by the destination contract
bytes message;
/// @dev The amount of Zeta that you wanna send cross-chain, greater than or equal to 0
uint256 zetaAmount;
/// @dev Optional parameters for the Zeta protocol
bytes zetaParams;
} /**
* @dev Our Message Passing Interface will call your contract's onZetaMessage using this interface
*/
struct ZetaMessage {
bytes originSenderAddress;
uint256 originChainId;
address destinationAddress;
uint256 zetaAmount;
bytes message;
} /**
* @dev Our Message Passing Interface will call your contract's onZetaRevert using this interface
*/
struct ZetaRevert {
address originSenderAddress;
uint256 originChainId;
bytes destinationAddress;
uint256 destinationChainId;
uint256 zetaAmount;
bytes message;
}
}interface ZetaReceiver {
/**
* @dev onZetaMessage will be called when a cross-chain message is delivered to your contract
*/
function onZetaMessage(ZetaInterfaces.ZetaMessage calldata zetaMessage) external; /**
* @dev onZetaRevert will be called when a cross-chain message reverts
* It's useful to rollback your contract's state
*/
function onZetaRevert(ZetaInterfaces.ZetaRevert calldata zetaRevert) external;
}interface ZetaMPI {
/**
* @dev Sending value and data cross-chain is as easy as calling zeta.send(SendInput)
*/
function send(ZetaInterfaces.SendInput calldata input) external;
}

With these in mind, you have all you need to implement fully-fledged cross-chain functionality.

Sending a message

To use the MPI to send a message across chains, all your smart contract needs to do is call the send function from the ZetaMPI smart contract like so:

zeta.send(
ZetaInterfaces.SendInput({
destinationChainId: _crossChainId,
destinationAddress: _crossChainAddress,
gasLimit: 2500000,
message: abi.encode(CROSS_CHAIN_MESSAGE, msg.sender),
zetaAmount: 0,
zetaParams: abi.encode("")
})
);

Handling messages

Your contract needs to also handle messages that are sent from other chains. To do this, all you need to do is implement onZetaMessage and onZetaRevert:

function onZetaRevert(ZetaInterfaces.ZetaRevert calldata _zetaRevert) external { ... }
function onZetaMessage(ZetaInterfaces.ZetaMessage calldata _zetaMessage) external { ... }

With reverts built-in, you can have powerful cross-chain applications where you don’t have to deal with the poor UX and DevX of stuck transactions. Transactions will revert if the destination transaction cannot be created (i. e. out of funds/gas, unexpected errors, etc.), providing a more streamlined developer experience similar to developing on a single chain.

Sending value

Note that you can send both arbitrary message data and zetaAmount. zetaAmount denominates value in the form of ZETA that you want to pass with your message. This ZETA is burned on the sending source and then minted to be sent to the destinationAddress.

// e.g. trade X for ZETA -> zetaSendAmount_zeta.send(
ZetaInterfaces.SendInput({
destinationChainId: _crossChainId,
destinationAddress: _crossChainAddress,
gasLimit: 2500000,
message: abi.encode(CROSS_CHAIN_MESSAGE, msg.sender),
zetaAmount: zetaSendAmount,
zetaParams: abi.encode("")
})
);// your onZetaMessage implementation
function onZetaMessage(ZetaInterfaces.ZetaMessage calldata _zetaMessage) external {
// e. g. trade zetaAmount for target asset Y
}

You could easily swap assets for ZETA (source) and then swap ZETA for assets (destination) to have fully asset-agnostic value transfer and arbitrary message passing. With this functionality, one could easily build a token bridge, NFT, DEX, or DeFi product (or something else? 😎) that spans across chains.

Kickstart your development with our growing library of examples

In the docs, you’ll find a number of example projects that you can use to kickstart your omnichain dApp development.

Your First Cross-Chain Message

This example is the most rudimentary, showing how you would emit a Hello World event from chain-to-chain. Simple, but a great start!

Docs

Sending Value Across Chains

With this example, you see how you’d send any value between any connected chain by using the ZETA token.

Docs

Code

Cross-Chain Counter

In this example, you can see how one would build a counter based on passing messages between two contracts on different chains.

Docs

Code

Cross-Chain NFT

With this example, you can build an NFT that can be sent across all chains natively with ZetaChain.

Docs

Code

How to get test ZETA

In our Discord you can acquire ZETA for use on Sparta via the #zeta-faucet channel. To get some ZETA, use the command zeta faucet drip [address] in #zeta-faucet, replacing [address] with your EVM-compatible address. As we add support for additional chains, we'll allow you to get ZETA for various other networks and addresses. The faucet will also drip some native gas assets so you can get started transacting immediately!

After requesting ZETA from the bot, you will receive ZETA on each connected chain. Right now, these networks are: Goerli, Polygon Mumbai, and BSC Testnet. With this ZETA in your wallets, you have all you need to start building on ZetaChain! Get started here.

If you need gas assets for the respective testnet networks, you can try the following faucets:

• Paradigm (Goerli, Polygon Mumbai, etc.)

• Goerli Authenticated Faucet (Goerli)

• Polygon Faucet (Polygon Mumbai)

• Binance Smart Chain Faucet (BSC Testnet)

If you need additional ZETA or testnet gas assets, ask in Discord and we’ll help you out.

Join our community of builders

Join our Discord to get access to the DEVELOPMENT ZONE channels. Here, you’ll be able to collaborate with early omnichain dApp builders in #protocol and get technical feedback from the team in #dev-support.

We’re always looking for ways to improve the experience of our developer ecosystem. If you have any thoughts or ideas on the above or ZetaChain in general, hit us up!

What’s next?

The ZetaChain team is actively developing the protocol to prepare for the launch of Athens (our more stable, explorable testnet), and subsequently, our mainnet where you’ll be able to transact real data and assets seamlessly. Stay tuned on the usual channels for more updates.

Follow ZetaChain on Twitter @zetablockchain and join the conversation on Discord and Telegram

Categories