Intro to Development

Welcome! This guide has everything you need to know to start developing with ZK Compression on Solana.

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

What You'll Need to Get Started

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

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

A Quick Intro to Client-side Development

The following TypeScript and Rust SDKs are used to interact with ZK Compression:

LanguageSDKDescription

TypeScript

@lightprotocol/stateless.js

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

TypeScript

@lightprotocol/compressed-token

SDK to interact with the compressed token program

Rust

light-sdk

Rust client

RPC Connection

An RPC connection is needed 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.

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.

Quickstart

The code samples work! You can copy & paste them into your IDE or terminal and run!

Installation (Node.js, web)

Package Manager Command

NPM

npm install --save \
    @lightprotocol/stateless.js \
    @lightprotocol/compressed-token \
    @solana/web3.js \
    @coral-xyz/anchor \
    @lightprotocol/zk-compression-cli

Yarn

yarn add \
    @lightprotocol/stateless.js \
    @lightprotocol/compressed-token \
    @solana/web3.js \
    @coral-xyz/anchor \
    @lightprotocol/zk-compression-cli

Creating an RPC Connection

import {
  Rpc,
  createRpc,
} from "@lightprotocol/stateless.js";

// Helius exposes Solana and Photon RPC endpoints through a single URL
const RPC_ENDPOINT = "https://devnet.helius-rpc.com?api-key=<api_key>";
const PHOTON_ENDPOINT = RPC_ENDPOINT;
const connection: Rpc = createRpc(RPC_ENDPOINT, PHOTON_ENDPOINT)

console.log("connection", connection);

Using Localnet

# Start a local test validator
light test-validator
const stateless = require("@lightprotocol/stateless.js");

const connection = stateless.createRpc();

async function main() {
  let slot = await connection.getSlot();
  console.log(slot);

  let health = await connection.getIndexerHealth(slot);
  console.log(health);
  // "Ok"
}

main();

Minting and Transferring Compressed Tokens

This example uses the compressed token program, which is built using ZK Compression and offers an SPL-compatible token layout.

import {
  LightSystemProgram,
  Rpc,
  confirmTx,
  createRpc,
} from "@lightprotocol/stateless.js";
import { createMint, mintTo, transfer } from "@lightprotocol/compressed-token";
import { Keypair } from "@solana/web3.js";

const payer = Keypair.generate();
const tokenRecipient = Keypair.generate();

/// Helius exposes Solana and compression RPC endpoints through a single URL
const RPC_ENDPOINT = "https://devnet.helius-rpc.com?api-key=<api_key>";
const COMPRESSION_RPC_ENDPOINT = RPC_ENDPOINT;
const connection: Rpc = createRpc(RPC_ENDPOINT, COMPRESSION_RPC_ENDPOINT)

const main = async () => {
  /// Airdrop lamports to pay fees
  await confirmTx(
    connection,
    await connection.requestAirdrop(payer.publicKey, 10e9)
  );

  await confirmTx(
    connection,
    await connection.requestAirdrop(tokenRecipient.publicKey, 1e6)
  );

  /// Create compressed token mint
  const { mint, transactionSignature } = await createMint(
    connection,
    payer,
    payer.publicKey,
    9 // Number of decimals
  );

  console.log(`create-mint  success! txId: ${transactionSignature}`);

  /// Mint compressed tokens to the payer's account
  const mintToTxId = await mintTo(
    connection,
    payer,
    mint,
    payer.publicKey, // Destination
    payer,
    1e9 // Amount
  );

  console.log(`Minted 1e9 tokens to ${payer.publicKey} was a success!`);
  console.log(`txId: ${mintToTxId}`);

  /// Transfer compressed tokens from payer to tokenRecipient's pubkey
  const transferTxId = await transfer(
    connection,
    payer,
    mint,
    7e8, // Amount
    payer, // Owner
    tokenRecipient.publicKey // To address
  );

  console.log(`Transfer of 7e8 ${mint} to ${tokenRecipient.publicKey} was a success!`);
  console.log(`txId: ${transferTxId}`);
};

main();

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, ensure your development environment has installed Rust, the Solana CLI, and Anchor. 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. The light test-validator command, available with the ZK Compression CLI, 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.

ProgramDescription

light-system-program

The system program. It enforces the compressed account layout with ownership and sum checks and verifies the validity of your input state

It is also invoked to create/write to compressed accounts and PDAs

light-compressed-token

A compressed token implementation built on top of ZK Compression. It enforces a SPL-compatible token layout and allows for arbitrary compression/decompression between this and the SPL standard

account-compression

Implements state and address trees. It is used by the Light System program

Build by Example

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

Developer Environments

ZK Compression is available on Localnet using light test-validator, Devnet, and Mainnet-Beta.

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!

PreviousOverviewNextEvent: Solana Zero Hackathon

Last updated