ZetaChain RPC: One Contract That Touches Native Bitcoin

Most "cross-chain" really means "wrap the asset and trust a bridge." ZetaChain takes a different swing: a smart contract on ZetaChain can read from and write to other chains directly — including chains that have no smart contracts of their own, like Bitcoin — while controlling the native asset, no wrapped token in sight. You write one Solidity contract, and it orchestrates value across many chains. The contract layer (ZetaEVM, chain ID 7000) is standard eth_*, so viem/ethers/foundry work unchanged — but the omnichain machinery underneath is what makes it interesting. Here's the map.

The essentials

ZetaChain mainnet is chain ID 7000, an EVM (ZetaEVM) with an unusual foundation:

• Cosmos-SDK L1 with CometBFT consensus — validators stake ZETA; ~5-second blocks with instant, non-reversible BFT finality.
• ZETA as the gas token (18 decimals).
• Omnichain by design — cross-chain interoperability is a protocol feature, managed by a distributed TSS (threshold signature scheme) validator set.
• EVM-compatible — deploy Solidity with standard tooling.

Connecting to the ZetaEVM is boringly standard:

import { createPublicClient, http, defineChain } from "viem";

const zeta = defineChain({
  id: 7000,
  name: "ZetaChain",
  nativeCurrency: { name: "ZETA", symbol: "ZETA", decimals: 18 },
  rpcUrls: { default: { http: ["https://rpc.swiftnodes.io/rpc/zetachain?key=YOUR_API_KEY"] } },
});

const client = createPublicClient({ chain: zeta, transport: http() });
await client.getBlockNumber();   // just works

The headline: omnichain contracts over native assets

Here's what makes ZetaChain different from a bridge or a wrapped-asset chain. Its validator set collectively controls addresses on external chains via a threshold signature scheme — no single party holds the keys. That lets the chain itself hold and move native assets on Bitcoin, Ethereum, and other connected networks. So a contract on ZetaChain can:

• React to a deposit on another chain (including a native BTC transfer) and run logic in response.
• Move native assets on external chains as an outcome of that logic — without a centralized bridge operator and without minting a wrapped representation.

The concrete payoff developers point to: native Bitcoin DeFi. Instead of building on WBTC (a wrapped IOU with its own trust assumptions), a ZetaChain contract can work with actual BTC, because the TSS network can custody and release it. It's a genuinely different model from, say, Rootstock, which brings smart contracts to Bitcoin via merge-mining and a pegged BTC — ZetaChain instead reaches out to native Bitcoin (and other chains) from an omnichain hub.

How you actually use it from the RPC

For the developer, the good news is that this power is exposed through standard EVM calls. You interact with ZetaChain's cross-chain system contracts (its gateway and related protocol contracts) the same way you'd call any contract — eth_call to read, eth_sendRawTransaction to write. The omnichain behavior is what those system contracts do; the interface is ordinary EVM:

• Deploy your omnichain contract with foundry/hardhat like any Solidity contract.
• Read cross-chain state and balances with eth_call.
• Trigger cross-chain actions by calling the gateway; the TSS network carries them out on the target chain.
• Watch results with eth_getLogs / eth_subscribe on ZetaEVM, plus the connected-chain confirmations.

You don't need a special RPC namespace for the cross-chain part — it's all Solidity and eth_*, which is why standard tooling works. (Under the hood it's a Cosmos-SDK chain, like the "EVM cockpit over a Cosmos engine" pattern we covered on Kaia and Story; the native Cosmos layer is reachable via CometBFT RPC as in the Cosmos RPC explainer, but for EVM work you stay on chain 7000.)

Finality: instant, so index the head

CometBFT gives instant, single-slot BFT finality — a committed block is final, no reorgs. That matters doubly for an omnichain chain: a cross-chain action you observed as final won't be undone on the ZetaChain side. The whole class of reorg-handling defenses collapses to "confirm once" on ZetaEVM. (The connected chains keep their own finality characteristics — a native BTC leg still follows Bitcoin's probabilistic confirmations — so cross-chain flows are as final as their slowest chain, which is worth designing around.)

What carries over unchanged

On the ZetaEVM (chain 7000), treat it as a standard EVM chain:

• eth_call, eth_getBalance, eth_getLogs, eth_getTransactionReceipt, eth_estimateGas, eth_sendRawTransaction, eth_subscribe all behave normally.
• Solidity contracts, ABIs, and the viem/ethers/hardhat/foundry toolchain deploy and run as-is.
• ZETA is the gas token with 18 decimals; WebSocket subscriptions (newHeads, logs) work.

If your app spans native UTXO chains too (ZetaChain famously connects to Bitcoin), it's worth understanding the UTXO side as well — see the Litecoin/Blockbook spotlight for how non-account chains are queried.

The short version

ZetaChain (EVM chain ID 7000) is an omnichain L1: a single Solidity contract can read and write across connected chains — including native Bitcoin, with no wrapping and no centralized bridge — because a TSS validator set lets the chain custody and move native assets on external networks. The ZetaEVM is standard eth_* (viem/ethers/foundry unchanged) and you drive the cross-chain machinery through ordinary contract calls; underneath it's a Cosmos-SDK chain with instant BFT finality (confirm once on ZetaEVM). Build the EVM side like any EVM chain, and reach out to other chains through the omnichain gateway.

Building omnichain apps, native Bitcoin DeFi, or bridgeless cross-chain flows? A flat-rate ZetaChain RPC endpoint gives you chain 7000 over HTTP and WebSocket alongside 75+ other chains under one key. Grab a free key and point your stack at:

https://rpc.swiftnodes.io/rpc/zetachain?key=YOUR_API_KEY