Documentation

Introduction

Coinkura ($KURA) is a shielded pool on Solana forked from Zcash's design. It does three things:

• Wraps ZEC. ZEC sent to the Coinkura reserve on Zcash comes out on Solana as zZEC, already shielded.
• Hides transfers. Inside the pool, a transfer hides the sender, the recipient and the amount.
• Hides who holds a memecoin's supply. Coins launched in hidden-supply mode have no public holder list from the first buy.

Quick start

This is what using Coinkura will look like at launch.

1. Connect a Solana wallet (Phantom, Solflare or Backpack). Connecting shares your public address only.
2. Create your Coinkura address. Your wallet derives a spending key from a signature you approve once. It never leaves your device.
3. Get value into the pool. Wrap ZEC, shield an SPL token you hold, or buy into a hidden-supply launch.
4. Send, hold or trade privately. Every action inside the pool is proved on your device and checked by the program.
5. Leave when you want. Unshield to any Solana wallet, or unwrap zZEC back to a Zcash address.

Glossary

Note

A private record of value: asset, amount, owner and a random seed. Only the owner can read it.

Commitment

A hash of a note. It goes into the tree and reveals nothing about the note.

Nullifier

A tag published when a note is spent. It stops double spends and can't be linked to its commitment.

Anchor

A recent root of the commitment tree that a proof refers to.

Shield / unshield

Moving value from a public Solana account into the pool, or back out.

zZEC

ZEC wrapped onto Solana, backed one to one by ZEC in the reserve.

Viewing key

A key that reads notes but can't spend them.

Relayer

A service that submits and pays for your transaction so your own wallet doesn't appear.

Anonymity set

The crowd of notes your note hides among. Bigger is better.

The shielded pool

A Zcash-style shielded pool needs two pieces of shared state: a Merkle tree of note commitments, and a set of nullifiers for notes that have been spent. On Zcash they live in the consensus rules that every node checks. On Solana, the Coinkura program keeps them in program accounts.

Your wallet does the heavy work. It picks notes to spend, builds new notes for the recipient and your change, encrypts them, and makes a zero-knowledge proof that the whole thing balances. The program checks the proof, records the nullifiers and appends the new commitments. It never learns amounts, assets or owners.

// what one private transfer asks the program to do
verify(proof, public_inputs = [anchor, nullifiers, new_commitments, value_balance])
require(anchor in recent_roots)
require(each nullifier not in nullifier_set)
nullifier_set.insert(nullifiers)
tree.append(new_commitments)
emit(encrypted_notes)   // recipients scan for these

Notes, commitments and nullifiers

A note holds an asset ID, an amount, the owner's address and a random seed. Your wallet encrypts it to the recipient, so only they can read it.

A commitment is a Poseidon hash of the note's fields. It goes into the tree when the note is created. Because of the random seed, two notes with the same amount and owner still have unrelated commitments.

A nullifier is derived from the note and the owner's nullifier key. Only the owner can compute it, and nobody else can link it to the commitment. The program refuses a nullifier it has already seen, so each note is spent once.

cm = Poseidon(asset_id, amount, owner_pk, rho, rseed)
nf = Poseidon(nk, rho, position)          // nk: owner's nullifier key

Proofs

The proof says, in effect: "the notes I'm spending are in the tree at this anchor, I own them, their nullifiers are correct, and the value that goes in equals the value that comes out, for each asset." It proves this without showing which notes, which asset or how much.

Why Groth16 on Solana

Zcash's newest pools use Halo 2, which needs no trusted setup but is expensive to verify outside Zcash. Solana has native syscalls for BN254 curve operations and for Poseidon hashing, which make a Groth16 proof cheap to check inside one transaction. Coinkura keeps Zcash's note model and proves it with Groth16 over BN254.

Proving on your device

Your wallet builds proofs locally, in the browser or the app. Your keys and your notes never leave your device.

One pool, many assets

Zcash's pools hold one asset, ZEC. Zcash coinholders turned down a token standard for shielded assets in a 2026 poll. Coinkura runs a multi-asset pool on Solana instead: zZEC, $KURA, any shielded SPL token and every hidden-supply launch share one commitment tree.

This matters for privacy. A small memecoin with 300 holders would have a tiny crowd on its own. In a shared pool, its notes hide among every note of every asset, because the asset ID is inside the encrypted note and the proof checks balance per asset without revealing which one.

Keys and addresses

Coinkura separates spending from seeing, like Zcash does.

Spending key

Moves your notes. Never share it.

Full viewing key

Reads everything you received and spent. Can't move funds.

Incoming viewing key

Reads only what you received.

Address

Starts with kura1. You can make as many as you like from one key, and nobody can tell they belong to the same person.

Share a viewing key with an accountant or auditor when you need to prove your history.

zZEC: the Zcash wrapper

zZEC is ZEC on Solana. Each zZEC is backed by one ZEC held in the Coinkura reserve, a shielded address on Zcash.

Wrapping

1. Your wallet gives you a one-time memo tied to your Coinkura address.
2. You send ZEC to the reserve's address with that memo, from any Zcash wallet.
3. After the required confirmations, the reserve signers approve a mint, and a zZEC note lands in the pool for you.

Unwrapping

1. You burn zZEC in the pool and give a Zcash address.
2. The program records the burn, and the reserve signers release the same amount of ZEC, minus the Zcash network fee.

Proof of reserves

Anyone can check that zZEC is fully backed without trusting this site.

• The ZEC side. The reserve publishes its Zcash viewing key. Load it in any Zcash wallet that supports viewing keys to see the reserve's balance. It can't spend anything.
• The Solana side. The total zZEC in existence is a public counter in the program. Wraps add to it and unwraps subtract from it.
• The check. ZEC held should be at least zZEC in existence. The explorer shows both numbers side by side.

Hidden-supply launches

A hidden-supply launch creates a memecoin whose holdings live only in the pool. It is the "hide your supply" feature: nobody can read how the supply is split up.

What happens at launch

1. The program creates the coin with a fixed total supply and burns the mint authority, so nothing more can be printed.
2. The whole supply sits in the program's bonding curve. No wallet holds any.
3. Each buy pays SOL into the curve and returns a private note for the tokens. The dev's buy works the same way.
4. Each sell spends a note with a proof and pays SOL to any address, including a fresh one.

What this hides, and what it can't

Shield any SPL token

Coins launched elsewhere, on pump.fun or any Solana launchpad, can be shielded too. Shielding moves tokens into the pool's vault account for that mint and gives you a note. On that coin's public holder list, you disappear into one vault account.

Unshield anytime to get the real tokens back in a Solana wallet. Shielding and unshielding are public. What you do in between is not.

Private sends

A private send spends up to two notes and creates up to two: one for the recipient and one for your change. Every send looks the same size on chain, so the shape of a transaction says nothing about what's inside.

You can attach an encrypted memo of up to 512 bytes. Only the recipient can read it.

What stays visible

Some things are always public on Solana:

• That the Coinkura program was called, and when.
• The fee payer of each transaction. Use a relayer to keep your wallet out of it.
• Shield, unshield, wrap and unwrap edges, with their amounts.
• The total supply of each asset, and bonding-curve prices and trade sizes.
• The number of commitments and nullifiers, which roughly shows how busy the pool is.

Privacy tips

• Don't unshield what you just shielded. Moving 1,337 tokens in and 1,337 out a minute later links the two.
• Wait a little. The longer your note sits in the pool, the more notes join after it.
• Use fresh exit addresses. Unshield to a wallet that has never touched your buy wallet.
• Use a relayer when one exists. Then your own wallet never appears as the fee payer.
• Guard your viewing keys. Anyone with one can read your history.

Risks

• Smart contract risk. A bug in the program or the circuits could lose funds or break privacy. No audit has been done yet. Audits will be listed here when they are.
• Reserve risk. zZEC depends on the reserve signers, as the wrapper section explains.
• Setup risk. If every ceremony participant kept their share, fake proofs would be possible.
• Small pool risk. Privacy is weaker while the pool is young and the crowd is small.
• Rules. Privacy tools can face legal limits where you live. Check before you use one.
• Market risk. Memecoins are highly speculative and can go to zero.

Program accounts

The program keeps its state in a few accounts. Sizes are targets and may change before launch.

Instructions

SDK

A TypeScript SDK will ship with mainnet. Until then the site uses placeholder calls that all answer "not live".

import { Coinkura } from "@coinkura/sdk";   // not published yet

const kura = await Coinkura.connect(wallet);
const addr = await kura.address();            // "kura1..."
await kura.shield({ mint, amount });
await kura.send({ to: "kura1...", asset: "zZEC", amount: 1.5, memo: "gm" });
await kura.unshield({ asset: mint, amount, to: freshWallet });

// today, on this site:
await window.Coinkura.api.shield();  // { ok: false, code: "NOT_LIVE" }

Errors

NOT_LIVE

Coinkura hasn't launched. Every call returns this today.

STALE_ANCHOR

Your proof used a tree root older than the last 100. Your wallet rebuilds the proof.

NULLIFIER_SPENT

That note was already spent. Your wallet refreshes your notes.

BAD_PROOF

The proof didn't verify. Usually an out-of-date wallet.

POOL_PAUSED

The pool is paused for an emergency fix. Funds stay in their notes.

Launch status

Origin

Zcash pioneered shielded payments and has run them in production for years. Its designs and code are open source. Zakura, a newer Zcash node, is pushing that network toward payments at global scale.

Coinkura takes the shielded design over to Solana, where transactions are fast and cheap but public by default, and adds shielded tokens and memecoins. The name is a nod to Zakura. Coinkura is not part of Zcash or Zakura.

Questions

References

Background reading on the technology Coinkura builds on:

• Zcash protocol specification
• zcash/orchard on GitHub
• zakura-core/zakura on GitHub
• Solana runtime and syscalls
• Solana confidential token docs