Zord Protocol
ZORD is an ordinal‑style metaprotocol on Zcash
Created on 4th December 2025
•
Zord Protocol
ZORD is an ordinal‑style metaprotocol on Zcash
The problem Zord Protocol solves
ZORD Protocol
Ordinals‑style inscriptions, NFTs, and tokens on Zcash
by Zatoshi Labs
1. Abstract
ZORD is an ordinal-style metaprotocol for Zcash that serializes the smallest units of ZEC (“zatoshis” or zats), lets you attach arbitrary data to individual zats as inscriptions, and defines standards for ZRC‑20 fungible tokens, ZRC‑721 NFTs, and ZNS namespaces.(1, 2) ZORD is implemented in Zord, a Rust indexer and explorer that follows Casey Rodarmor’s original ord conventions adapted to Zcash and lives entirely at the indexing layer, so Zcash consensus and node software do not change.(5)
ZORD leverages Zcash’s architecture, with a Bitcoin‑style transparent UTXO set and zk‑SNARK‑based shielded pools. It currently indexes transparent transactions only, but inscriptions and tokens can still benefit from Zcash’s privacy when users keep addresses unlinkable to their identities and use shielded pools for funding, settlement, and long‑term storage.
2. Ordinals & Inscriptions on Zcash
ZORD assigns every zat a stable ordinal index based on block height, transaction position, output index, and value, following ord’s assignment semantics where possible but using Zcash’s monetary schedule and timing.(5) Each zat is always owned by a single transparent UTXO; as UTXOs are spent, zats move in a deterministic order, and ZORD tracks the current owner of each ordinal.
An inscription is arbitrary data bound to a specific zat at the moment that zat first reveals a valid ZORD inscription envelope on‑chain. A transaction publishes a small envelope (typically UTF‑8 JSON) using a Zcash‑native carrier such as an OP_RETURN output; ZORD binds the envelope to a zat in one of the outputs, and the UTXO holding that zat owns the inscription. Moving the UTXO transfers the inscription; sending it to an unspendable script burns it.
3. ZRC Standards (Zord Repository of Coin Standards)
- ZRC‑20 – minimal JSON fungible token standard defined by three inscription operations, deploy, mint, and transfer, from which indexers deterministically derive balances.(1)
- ZRC‑721 – NFT inscription standard where each mint inscription is the NFT (supply 1), a deploy inscription defines the collection and metadata root IPFS CID, and ownership is transferred by moving the mint inscription’s UTXO; metadata JSON (e.g. ipfs://<meta_cid>/<id>.json) follows ERC‑721‑style conventions.(2)
- ZNS – simple name system built on text inscriptions: UTF‑8 strings ending in .zec or .zcash (e.g. anon.zec, zatoshi.zcash) with a first‑inscription‑wins rule, where the UTXO holding the inscription owns the name and moving or burning that UTXO transfers or destroys it.
4. Reference Implementation & Ecosystem
The zord repository is the reference implementation: a Rust indexer with built‑in explorer and APIs that connects to a Zcash full node via JSON‑RPC, replays the transparent chain, assigns ordinal indices to zats, extracts inscriptions, and applies ZRC‑20, ZRC‑721, and ZNS rules. It exposes JSON APIs and powers our explorer, wallet and marketplace.(5)
Zatoshi Labs maintains a full ZORD stack around this core:
- Zatoshi RPC – public Zcash RPC endpoint for ZORD indexing: https://rpc.zatoshi.market/ (8)
- Zatoshi Mempool – mempool explorer with ZORD‑aware views: https://mempool.zatoshi.market/
- Zord Explorer – web UI for browsing inscriptions, collections, tokens, and names.
- Zatoshi Market – inscription marketplace and launchpad for ZRC‑20 and ZRC‑721 assets.(9)
- Zatoshi Wallet – in‑browser built into Zatoshi Market currently, non‑custodial ZORD‑aware wallet that displays ZRC‑20/ZRC‑721 holdings and lets users inscribe and trade directly from their browser. Browser Extensions & iOS app coming soon.
5. Privacy, Security & Summary
ZORD does not modify Zcash consensus and operates entirely on the transparent layer. Zcash’s shielded pools and privacy protocols remain intact, and users can fund their ZORD‑facing transparent addresses from shielded addresses and re‑shield proceeds afterward, enabling NFT and token ownership that can be significantly more private than on fully transparent chains.
Security comes from deterministic, well‑specified indexing rules—first valid deploy wins, strict JSON validation, hard supply limits, and reproducible chain replay—so independent indexers converge on the same state. Together, ZORD, the Zord indexer, Zatoshi RPC and mempool, Zord Explorer, Zatoshi Market, and Zatoshi Wallet form a complete ecosystem for minting, trading, and holding Zcash‑native NFTs, memecoins, and namespaces.
Challenges I ran into
One of the most interesting and painful challenges was discovering that our original idea for putting high resolution NFT art directly on Zcash was fundamentally incompatible with how Zcash treats standard transactions.
When we first started experimenting, we tried to do the Ordinals style thing on Zcash and push large image blobs straight into transparent script outputs. On Bitcoin, people get away with big witness payloads and clever Taproot tricks. On Zcash there is no SegWit or Taproot, and transparent outputs are subject to strict standardness rules, including a hard cap on how much arbitrary data you can stuff into an OP_RETURN and how large a standard transaction can be before peers refuse to relay it. As soon as we tried to inscribe anything that looked like real, high resolution art, our transactions either never made it into public mempools or came back with the Zcash equivalent of “non standard script, too much data in scriptPubKey.”
That produced a nasty combination of symptoms. Some mints would work on a node where we had tweaked policy flags, but the same transactions would be rejected by other nodes and never propagate. The indexer would see inscriptions on our local node, but they did not exist from the point of view of the wider network, so we could not rely on them. We ended up running our own RPC node with custom settings just to debug what was actually happening, and even there we could see that pushing big payloads to the edge of the 20 kilobyte range per transaction was fragile. Anything that depended on non default relay policy was essentially dead on arrival as a long term protocol.
That is what pushed us to invent ZRC721 as a minimal inscription standard instead of trying to force full image files on chain. We went back to first principles and asked what is the smallest possible envelope that still gives you deterministic NFT ownership in a UTXO system. The result is the current ZRC721 spec: a tiny JSON object with a protocol field set to “zrc 721”, an op field that is either “deploy” or “mint”, a collection string, a numeric supply cap for the deploy, an IPFS CID in the meta field that points to the metadata root, and an optional royalty field in basis points. A mint inscription is even smaller, just protocol, op, collection, and id. The actual media and rich metadata live at predictable paths like ipfs://<meta_cid>/<id>.json and ipfs://<image_cid>/<id>.png. On chain we only ever store the minimum needed for indexers to reconstruct the state machine and for wallets and marketplaces to agree on who owns which token id.
Designing ZRC721 this way solved several problems at once. The deploy and mint strings are comfortably under the OP_RETURN and script size limits, so transactions are standard and relay cleanly across unmodified Zcash nodes. Because each mint inscription is bound to a specific transparent output, we can map ownership directly onto the UTXO set: moving that output moves the NFT with no extra contract logic. And because the envelopes are so small, minting whole collections is cheap in fees and easy for the Zord indexer to parse and replay from raw blocks.
So the “bug” we ran into was really the network telling us that our first approach to on chain art was non standard. The way we got over it was by internalizing Zcash’s standardness and UTXO rules, building our own RPC to verify exactly where the limits were, and then using those constraints to drive us toward what is probably one of the leanest NFT inscription standards in use anywhere.
Tracks Applied (12)
General Bounty
Network School
Self-Custody & Wallet Innovation
Osmosis
Private Payments & Transactions
Osmosis
Creative Privacy Applications
Fhenix
Zcash Data & Analytics
Gemini
Private DeFi & Trading
Zcash Community Grants
Privacy Infrastructure & Developer Tools
Zcash Community Grants
Self-Custody & Wallet Innovation
Unstoppable Wallet
Private DeFi & Trading
Unstoppable Wallet
Zcash Data & Analytics
Raybot
Privacy Infrastructure & Developer Tools
Raybot
General Bounty
Project Tachyon