Intro to Development

Welcome! Light's core primitive is ZK Compression. This guide has everything you need to know to start developing with it.

For the sake of brevity, the guide assumes you are familiar with the basics of Solana. If you aren't, we recommend reading the Solana documentation first.

What you'll need to get started

Development with ZK Compression on Solana consists of two main parts:

The glue between clients and on-chain programs is the ZK Compression RPC API. It extends Solana's default JSON RPC API with additional endpoints for interacting with ZK compressed state. To view the full list of supported endpoints, visit the JSON RPC Methods section.

Client-side development

You can use SDKs in Rust and Typescript to interact with ZK Compression:



SDK to interact with compression programs via the ZK Compression RPC API


SDK to interact with the compressed token program


Rust client

You'll also need a connection with an RPC to interact with the network. You can either work with an RPC infrastructure provider that supports ZK Compression or run your own RPC Node.

Helius Labs supports ZK Compression and maintains its canonical RPC and Photon indexer implementation here.

Our local dev tooling supports Photon out of the box via the light test-validator command. To learn how to run a standalone Photon RPC node, visit the Run a Node section.


Installation (node.js, web)


npm install --save \
    @lightprotocol/stateless.js \
    @solana/web3.js \

Creating an Rpc connection


const stateless = require("@lightprotocol/stateless.js");

// Rpc is a thin wrapper around a web3.js Connection
let connection : = stateless.createRpc("");
let health = await connection.getIndexerHealth(slot);
// "Ok"

Creating and sending transactions


/// Compressing SOL
const {
} = require("@lightprotocol/stateless.js");

const { ComputeBudgetProgram, Keypair, PublicKey } = require("@solana/web3.js");

const fromKeypair = Keypair.generate();
const connection = createRpc();

(async () => {

    /// Fetch latest blockhash
    const { blockhash } = await connection.getLatestBlockhash();

    /// Compress lamports to self
    const ix = await LightSystemProgram.compress({
        payer: fromKeypair.publicKey,
        toAddress: fromKeypair.publicKey,
        lamports: 1_000_000_000,
        outputStateTree: defaultTestStateTreeAccounts().merkleTree, 

    /// Create a VersionedTransaction and sign it
    const tx = buildAndSignTx(
        [ComputeBudgetProgram.setComputeUnitLimit({ units: 1_200_000 }), ix],
    /// Confirm 
    const txId = await sendAndConfirmTx(connection, tx);

To get started quickly with an end-to-end client for your application, check out the ZK compression web and node examples on GitHub.

On-chain program development

The ZK compression primitive is the core of the Light protocol. To leverage ZK compression, your custom program invokes the Light system program via Cross-Program Invocation (CPI). For the sake of simplicity, we refer to this set of protocol smart contracts as compression programs.

You can write custom programs using ZK compression in Anchor or native Rust.

First, you'll need to ensure your machine has Rust, the Solana CLI, and Anchor installed. If you haven't installed them, refer to this setup guide.

We provide tooling for testing your on-chain program on a local Solana cluster.

ZK Compression CLI: light test-validator automatically initializes a local Solana cluster with the compression programs, all necessary system accounts, and syscalls activated. By default, it also starts a local Photon RPC instance and Prover node.

Photon Explorer: Helius Labs' Explorer parses compression transactions into a human-readable format, which is great for debugging your program.


The system program. Validity proof verification ownership and sum checks. Invoke to create/write to compressed accounts and PDAs.

A compressed token implementation

Implements state and address trees

Build by Example

While you get started building with ZK compression, use these GitHub resources available to help accelerate your journey:

Developer Environments

Today, you can build with ZK compression on Localnet. This is a local Solana cluster that you run on your machine using light test-validator. A public Devnet will become available soon.

Getting support

For the best support, head to the:

Remember to include as much detail as possible in your question, and please use text (not screenshots) to show error messages so other people with the same problem can find your question!

Next steps

You're now ready to start building with ZK compression! Head to the Client Quickstart section, or build a program and provide feedback!

Last updated