PLANT A COIN.
GROW IT IN ZEC.

A fair-launch bonding curve paired with $ZEC instead of SOL. Every trade routes a protocol-enforced cut into a shared on-chain vault. Burn your tokens through one atomic instruction and your pro-rata share settles back in ZEC — plus a Memo-tagged stamp on Zcash mainnet, in the same transaction.

EXAMPLE · THE HERD

Hover any number. That's the whole interaction — nothing hidden forever, nothing shown by default.

HERD BALANCE412.80 ZEC

YOUR TOKENS1,204,500

YOUR SHARE ON BURN3.91 ZEC

Illustrative example — the herd, wallet holdings and payout math are all real on-chain values once a coin is live.

PLANT

Launch a coin on an AMM-style bonding curve paired with $ZEC instead of SOL. Same constant-product mechanics, same graduation threshold — every trade routes a protocol-defined cut into the herd vault underneath it.

GROW

A floor of every trade — encoded in the program's fee split, not a promise — flows into the herd: a shared PDA-owned ZEC vault that compounds as the coin trades.

HARVEST

Burn your tokens on Solana with a single SPL burn instruction. Your pro-rata share of the herd — herd × your tokens ÷ circulating supply — settles back in ZEC atomically, in the same transaction. Attach a Zcash address and a Memo-program stamp lands on Zcash mainnet, sized to what you destroyed.

WHY ZEBRA

FAIR LAUNCH

No presale, no team allocation. Everyone starts on the same bonding curve.

◆

ON-CHAIN, NOT A PROMISE

The fee split and payout formula are enforced by the program, not a policy someone can quietly change.

▸

PERMISSIONLESS HARVEST

No keeper, no admin, no backend that could intercept your payout or just not send it.

STAMPED ON ZCASH

Every harvest can carry a permanent, Memo-tagged record onto Zcash mainnet.

⟡

ATOMIC BY DESIGN

Burn and payout happen in one instruction — no separate claim step to fail or front-run.

∑

CHECKABLE MATH

herd × your tokens ÷ supply. Anyone can verify the payout themselves, no trust required.

SOLANA

ZCASH

PUMP.FUN

WHY STRIPES

HIDDEN BY DEFAULT.
YOURS TO REVEAL.

Every balance and payout on ZEBRA renders behind the same pattern the mascot wears — hover, and the stripes part to reveal the real number underneath. Nothing is encrypted by this; it's a UI mask, not a cryptographic one. Actual privacy is a separate, harder problem — solved by Zcash's zk-SNARK shielded pool once a stamp lands there, not by this interface.

pub fn harvest_burn(ctx: Context<HarvestBurn>, burn_amount: u64, zcash_address: Option<[u8; 64]>) -> Result<()> {
    let herd = &mut ctx.accounts.herd;
    let supply_before = ctx.accounts.coin_mint.supply;

    let payout = (herd.total_zec_deposited as u128)
        .checked_mul(burn_amount as u128).unwrap()
        .checked_div(supply_before as u128).unwrap() as u64;
    require!(payout > 0, ErrorCode::DustPayout);

    token::burn_checked(ctx.accounts.burn_ctx(), burn_amount, ctx.accounts.coin_mint.decimals)?;
    token::transfer(ctx.accounts.payout_ctx(), payout)?;
    herd.total_zec_deposited = herd.total_zec_deposited.checked_sub(payout).unwrap();

    if let Some(addr) = zcash_address {
        memo::stamp(ctx.accounts.memo_ctx(), &herd.coin_mint, burn_amount, payout, &addr)?;
    }
    Ok(())
}
pub struct Herd {
    pub coin_mint: Pubkey,
    pub zec_vault: Pubkey,
    pub total_zec_deposited: u64,
    pub cap: u64,
    pub payee_mode: PayeeMode,
    pub paused: bool,
    pub bump: u8,
}
require!(herd_bps >= HERD_BPS_MIN, ErrorCode::HerdFloorViolated);
require!(treasury_bps <= TREASURY_BPS_MAX, ErrorCode::TreasuryCeilingViolated);

pub fn harvest_burn(ctx: Context<HarvestBurn>, burn_amount: u64, zcash_address: Option<[u8; 64]>) -> Result<()> {
    let herd = &mut ctx.accounts.herd;
    let supply_before = ctx.accounts.coin_mint.supply;

    let payout = (herd.total_zec_deposited as u128)
        .checked_mul(burn_amount as u128).unwrap()
        .checked_div(supply_before as u128).unwrap() as u64;
    require!(payout > 0, ErrorCode::DustPayout);

    token::burn_checked(ctx.accounts.burn_ctx(), burn_amount, ctx.accounts.coin_mint.decimals)?;
    token::transfer(ctx.accounts.payout_ctx(), payout)?;
    herd.total_zec_deposited = herd.total_zec_deposited.checked_sub(payout).unwrap();

    if let Some(addr) = zcash_address {
        memo::stamp(ctx.accounts.memo_ctx(), &herd.coin_mint, burn_amount, payout, &addr)?;
    }
    Ok(())
}
pub struct Herd {
    pub coin_mint: Pubkey,
    pub zec_vault: Pubkey,
    pub total_zec_deposited: u64,
    pub cap: u64,
    pub payee_mode: PayeeMode,
    pub paused: bool,
    pub bump: u8,
}
require!(herd_bps >= HERD_BPS_MIN, ErrorCode::HerdFloorViolated);
require!(treasury_bps <= TREASURY_BPS_MAX, ErrorCode::TreasuryCeilingViolated);

pub fn harvest_burn(ctx: Context<HarvestBurn>, burn_amount: u64, zcash_address: Option<[u8; 64]>) -> Result<()> {
    let herd = &mut ctx.accounts.herd;
    let supply_before = ctx.accounts.coin_mint.supply;

    let payout = (herd.total_zec_deposited as u128)
        .checked_mul(burn_amount as u128).unwrap()
        .checked_div(supply_before as u128).unwrap() as u64;
    require!(payout > 0, ErrorCode::DustPayout);

    token::burn_checked(ctx.accounts.burn_ctx(), burn_amount, ctx.accounts.coin_mint.decimals)?;
    token::transfer(ctx.accounts.payout_ctx(), payout)?;
    herd.total_zec_deposited = herd.total_zec_deposited.checked_sub(payout).unwrap();

    if let Some(addr) = zcash_address {
        memo::stamp(ctx.accounts.memo_ctx(), &herd.coin_mint, burn_amount, payout, &addr)?;
    }
    Ok(())
}
pub struct Herd {
    pub coin_mint: Pubkey,
    pub zec_vault: Pubkey,
    pub total_zec_deposited: u64,
    pub cap: u64,
    pub payee_mode: PayeeMode,
    pub paused: bool,
    pub bump: u8,
}
require!(herd_bps >= HERD_BPS_MIN, ErrorCode::HerdFloorViolated);
require!(treasury_bps <= TREASURY_BPS_MAX, ErrorCode::TreasuryCeilingViolated);

pub fn harvest_burn(ctx: Context<HarvestBurn>, burn_amount: u64, zcash_address: Option<[u8; 64]>) -> Result<()> {
    let herd = &mut ctx.accounts.herd;
    let supply_before = ctx.accounts.coin_mint.supply;

    let payout = (herd.total_zec_deposited as u128)
        .checked_mul(burn_amount as u128).unwrap()
        .checked_div(supply_before as u128).unwrap() as u64;
    require!(payout > 0, ErrorCode::DustPayout);

    token::burn_checked(ctx.accounts.burn_ctx(), burn_amount, ctx.accounts.coin_mint.decimals)?;
    token::transfer(ctx.accounts.payout_ctx(), payout)?;
    herd.total_zec_deposited = herd.total_zec_deposited.checked_sub(payout).unwrap();

    if let Some(addr) = zcash_address {
        memo::stamp(ctx.accounts.memo_ctx(), &herd.coin_mint, burn_amount, payout, &addr)?;
    }
    Ok(())
}
pub struct Herd {
    pub coin_mint: Pubkey,
    pub zec_vault: Pubkey,
    pub total_zec_deposited: u64,
    pub cap: u64,
    pub payee_mode: PayeeMode,
    pub paused: bool,
    pub bump: u8,
}
require!(herd_bps >= HERD_BPS_MIN, ErrorCode::HerdFloorViolated);
require!(treasury_bps <= TREASURY_BPS_MAX, ErrorCode::TreasuryCeilingViolated);

pub fn harvest_burn(ctx: Context<HarvestBurn>, burn_amount: u64, zcash_address: Option<[u8; 64]>) -> Result<()> {
    let herd = &mut ctx.accounts.herd;
    let supply_before = ctx.accounts.coin_mint.supply;

    let payout = (herd.total_zec_deposited as u128)
        .checked_mul(burn_amount as u128).unwrap()
        .checked_div(supply_before as u128).unwrap() as u64;
    require!(payout > 0, ErrorCode::DustPayout);

    token::burn_checked(ctx.accounts.burn_ctx(), burn_amount, ctx.accounts.coin_mint.decimals)?;
    token::transfer(ctx.accounts.payout_ctx(), payout)?;
    herd.total_zec_deposited = herd.total_zec_deposited.checked_sub(payout).unwrap();

    if let Some(addr) = zcash_address {
        memo::stamp(ctx.accounts.memo_ctx(), &herd.coin_mint, burn_amount, payout, &addr)?;
    }
    Ok(())
}
pub struct Herd {
    pub coin_mint: Pubkey,
    pub zec_vault: Pubkey,
    pub total_zec_deposited: u64,
    pub cap: u64,
    pub payee_mode: PayeeMode,
    pub paused: bool,
    pub bump: u8,
}
require!(herd_bps >= HERD_BPS_MIN, ErrorCode::HerdFloorViolated);
require!(treasury_bps <= TREASURY_BPS_MAX, ErrorCode::TreasuryCeilingViolated);

pub fn harvest_burn(ctx: Context<HarvestBurn>, burn_amount: u64, zcash_address: Option<[u8; 64]>) -> Result<()> {
    let herd = &mut ctx.accounts.herd;
    let supply_before = ctx.accounts.coin_mint.supply;

    let payout = (herd.total_zec_deposited as u128)
        .checked_mul(burn_amount as u128).unwrap()
        .checked_div(supply_before as u128).unwrap() as u64;
    require!(payout > 0, ErrorCode::DustPayout);

    token::burn_checked(ctx.accounts.burn_ctx(), burn_amount, ctx.accounts.coin_mint.decimals)?;
    token::transfer(ctx.accounts.payout_ctx(), payout)?;
    herd.total_zec_deposited = herd.total_zec_deposited.checked_sub(payout).unwrap();

    if let Some(addr) = zcash_address {
        memo::stamp(ctx.accounts.memo_ctx(), &herd.coin_mint, burn_amount, payout, &addr)?;
    }
    Ok(())
}
pub struct Herd {
    pub coin_mint: Pubkey,
    pub zec_vault: Pubkey,
    pub total_zec_deposited: u64,
    pub cap: u64,
    pub payee_mode: PayeeMode,
    pub paused: bool,
    pub bump: u8,
}
require!(herd_bps >= HERD_BPS_MIN, ErrorCode::HerdFloorViolated);
require!(treasury_bps <= TREASURY_BPS_MAX, ErrorCode::TreasuryCeilingViolated);

THE MECHANISM

Burn to earn.

Every payout traces back to a formula, not a dashboard. What you see above is the actual shape of the instruction that would run on mainnet.

PLANT

Launch a coin

EXPLORE

Browse the herd

DOCS

Read the whitepaper

COMMUNITY

Follow along

PLANT A COIN.GROW IT IN ZEC.

HIDDEN BY DEFAULT.YOURS TO REVEAL.

Burn to earn.

PLANT A COIN.
GROW IT IN ZEC.

HIDDEN BY DEFAULT.
YOURS TO REVEAL.