Learn to build on
Zcash. Ship real apps.

# Run the official Zebra node (Zcash Foundation)
# Docs: https://zebra.zfnd.org
docker run -d \
  --name zebra \
  -p 8232:8232 \
  -p 8233:8233 \
  -v zebrad-cache:/home/zebra/.cache/zebra \
  zfnd/zebra:latest

# Follow sync progress
docker logs -f zebra

# ⚠ Initial sync downloads ~250 GB — use testnet for development
# For testnet: add -e ZEBRA_NETWORK=testnet and use port 18232/18233

# Once synced — install lightwalletd (Zaino gRPC compatible)
git clone https://github.com/zcash/lightwalletd.git
cd lightwalletd && go build && make install

# Connect lightwalletd to Zebra
lightwalletd \
  --zcash-conf-path ~/.config/zcash.conf \
  --data-dir ~/.cache/lightwalletd \
  --no-tls-very-insecure

# Your gRPC endpoint is now live at localhost:9067
# Get TAZ: https://zechub.wiki/using-zcash/testnet

// Cargo.toml
[dependencies]
zingolib = "*"  // ZODL · github.com/zodl-inc/zingolib
tokio    = { version = "1", features = ["full"] }

// src/main.rs — connect, sync, get balance
use zingolib::config::load_clientconfig;
use zingolib::lightclient::LightClient;
use zingolib::wallet::WalletBase;

async fn main() -> anyhow::Result<()> {
    // Connect to your lightwalletd/Zaino endpoint
    let cfg = load_clientconfig(
        "http://localhost:9067".to_string(),
        None,
        zingolib::config::Network::TestNet,
        true,
    )?;

    // Create a new wallet (or restore from seed)
    let client = LightClient::create_from_wallet_base(
        WalletBase::MnemonicPhrase("your twelve word seed phrase here".to_string()),
        &cfg, 0, false,
    ).await?;

    // Sync the wallet (scans compact blocks)
    client.do_sync(true).await?;

    // Print balance
    println!("{}", client.do_balance().await);

    // Get your Unified Address
    println!("{}", client.do_addresses().await);

    Ok(())
}

// Install grpc-js for lightwalletd / Zaino
npm install @grpc/grpc-js @grpc/proto-loader

// get-block.ts — query chain tip via lightwalletd gRPC
import * as grpc from '@grpc/grpc-js';
import * as protoLoader from '@grpc/proto-loader';

const pkgDef = protoLoader.loadSync('lightwalletd/walletrpc/compact_formats.proto');
const proto  = grpc.loadPackageDefinition(pkgDef) as any;

const client = new proto.cash.z.wallet.sdk.rpc.CompactTxStreamer(
  'localhost:9067',
  grpc.credentials.createInsecure()  // use SSL in production
);

// Get the latest block height
client.GetLatestBlock({}, (err: Error, resp: any) => {
  if (err) return console.error(err);
  console.log('Chain tip:', resp.height, resp.hash?.toString('hex'));
});

// Stream compact blocks for wallet scanning
const stream = client.GetCompactBlocks({
  start: { height: 2500000 },  // wallet birthday
  end:   { height: 0 },          // 0 = chain tip
});
stream.on('data', (block: any) => console.log('block:', block.height));
stream.on('end',  () => console.log('Scan complete'));

# Install grpcio for lightwalletd / Zaino
pip install grpcio grpcio-tools

# Generate Python stubs from the lightwalletd proto files
git clone https://github.com/zcash/lightwalletd.git
python -m grpc_tools.protoc \
    -I lightwalletd/walletrpc \
    --python_out=. \
    --grpc_python_out=. \
    lightwalletd/walletrpc/service.proto

# query_chain.py — get chain tip
import grpc
import service_pb2, service_pb2_grpc

# Connect to your lightwalletd / Zaino endpoint
channel = grpc.insecure_channel("localhost:9067")
stub    = service_pb2_grpc.CompactTxStreamerStub(channel)

# Get latest block height
tip = stub.GetLatestBlock(service_pb2.ChainSpec())
print(f"Chain tip: {tip.height}")

# Broadcast a raw signed transaction
# tx_bytes = ... (construct with Zingolib or wallet SDK)
# result = stub.SendTransaction(service_pb2.RawTransaction(data=tx_bytes))
# print(f"txid: {result.errorCode} {result.errorMessage}")