Test Your Program

Quick Access

If you prefer to dive straight into the code:

GitHub

Typescript Tests

Guide

Local Development

Step-By-Step Guide

Build valid transactions that calls your program instructions for delegation and undelegation. The complete test for this project can be found in the Typescript Test Script.

Import SDK and initialize Connection

Set up connection and accounts

Delegate PDA on Base Layer

Test CPI hook to delegate state account on Base Layer

Commit PDA on ER

Test CPI hook to commit state account on ER

Undelegate PDA on ER

Test CPI hook to undelegate state account on ER

Counter Example

The following software packages may be required, other versions may also be compatible:

Software	Version	Installation Guide
Solana	2.3.13	Install Solana
Rust	1.85.0	Install Rust
Node	24.10.0	Install Node

Code Snippets

1. Connection
2. Delegate
3. Commit
4. Undelegate

Import SDK and create Connection

Import relevant libraries @magicblock-labs/ephemeral-rollups-sdk or @magicblock-labs/ephemeral-rollups-kit. Initialize connection before testing and sending transactions.

yarn add @magicblock-labs/ephemeral-rollups-kit@latest

yarn add @magicblock-labs/ephemeral-rollups-sdk@latest

These public RPC endpoints are currently free and supported for development:
Magic Router Devnet: https://devnet-router.magicblock.app
Solana Devnet: https://api.devnet.solana.com
ER Devnet: https://devnet.magicblock.app
TEE Devnet: https://tee.magicblock.app/
Find out more details here .

import {
  Instruction,
  getAddressEncoder,
  getProgramDerivedAddress,
  AccountRole,
  createKeyPairFromBytes,
  getAddressFromPublicKey,
  address,
  createTransactionMessage,
  appendTransactionMessageInstructions,
  pipe,
  setTransactionMessageFeePayer,
} from "@solana/kit";

import {
  Connection,
  DELEGATION_PROGRAM_ID,
  delegationRecordPdaFromDelegatedAccount,
  delegationMetadataPdaFromDelegatedAccount,
  delegateBufferPdaFromDelegatedAccountAndOwnerProgram,
  MAGIC_CONTEXT_ID,
  MAGIC_PROGRAM_ID,
} from "@magicblock-labs/ephemeral-rollups-kit";

// Set up a base and ephemeral connection (alternatively use router, see Magic Router)
const connection = await Connection.create(
  process.env.PROVIDER_ENDPOINT || "https://api.devnet.solana.com",
  process.env.WS_ENDPOINT || "wss://api.devnet.solana.com"
);
const ephemeralConnection = await Connection.create(
  process.env.EPHEMERAL_PROVIDER_ENDPOINT || "https://devnet-as.magicblock.app",
  process.env.EPHEMERAL_WS_ENDPOINT || "wss://devnet-as.magicblock.app"
);

// Prepare user
const userKeypair = await initializeSolSignerKeypair();
const userPubkey = await getAddressFromPublicKey(userKeypair.publicKey);

// Get PDA
const addressEncoder = getAddressEncoder();
const [counterPda, bump] = await getProgramDerivedAddress({
  programAddress: PROGRAM_ID,
  seeds: [Buffer.from("counter_account"), addressEncoder.encode(userPubkey)],
});

import {
  Keypair,
  PublicKey,
  SystemProgram,
  Transaction,
  TransactionInstruction,
  Connection,
  sendAndConfirmTransaction,
} from "@solana/web3.js";

import {
  DELEGATION_PROGRAM_ID,
  delegationRecordPdaFromDelegatedAccount,
  delegationMetadataPdaFromDelegatedAccount,
  delegateBufferPdaFromDelegatedAccountAndOwnerProgram,
  MAGIC_CONTEXT_ID,
  MAGIC_PROGRAM_ID,
  GetCommitmentSignature,
} from "@magicblock-labs/ephemeral-rollups-sdk";

// Set up a base and ephemeral connection (alternatively use router, see Magic Router)
const connectionBaseLayer = new Connection(
  process.env.PROVIDER_ENDPOINT || "https://api.devnet.solana.com",
  { wsEndpoint: process.env.WS_ENDPOINT || "wss://api.devnet.solana.com" }
);
const connectionEphemeralRollup = new Connection(
  process.env.EPHEMERAL_PROVIDER_ENDPOINT ||
    "https://devnet-as.magicblock.app/",
  {
    wsEndpoint:
      process.env.EPHEMERAL_WS_ENDPOINT || "wss://devnet-as.magicblock.app/",
  }
);

// Create user keypair and airdrop SOL if needed
const userKeypair = initializeSolSignerKeypair();

// Get pda
let [counterPda, bump] = PublicKey.findProgramAddressSync(
  [Buffer.from("counter_account"), userKeypair.publicKey.toBuffer()],
  PROGRAM_ID
);

⬆️ Back to Top

Test `delegation` transaction

Create a instruction with the right order and attributes of accounts, and the instruction discriminator for delegation of your program. Send the transaction with the instruction to Base Layer (Solana) network.

Transaction (Base Layer): Delegate

Inspect transactions details on Solana Explorer

// "Delegate" transaction

// Add local validator identity to the remaining accounts if running on localnet
const remainingAccounts =
  connection.clusterUrlHttp.includes("localhost") ||
  connection.clusterUrlHttp.includes("127.0.0.1")
    ? [
        {
          address: address("mAGicPQYBMvcYveUZA5F5UNNwyHvfYh5xkLS2Fr1mev"),
          role: AccountRole.READONLY,
        },
      ]
    : [];
const accounts = [
  { address: userPubkey, role: AccountRole.WRITABLE_SIGNER },
  { address: SYSTEM_PROGRAM_ADDRESS, role: AccountRole.READONLY },
  { address: counterPda, role: AccountRole.WRITABLE },
  { address: PROGRAM_ID, role: AccountRole.READONLY },
  {
    address: await delegateBufferPdaFromDelegatedAccountAndOwnerProgram(
      counterPda,
      PROGRAM_ID
    ),
    role: AccountRole.WRITABLE,
  },
  {
    address: await delegationRecordPdaFromDelegatedAccount(counterPda),
    role: AccountRole.WRITABLE,
  },
  {
    address: await delegationMetadataPdaFromDelegatedAccount(counterPda),
    role: AccountRole.WRITABLE,
  },
  { address: DELEGATION_PROGRAM_ID, role: AccountRole.READONLY },
  ...remainingAccounts,
];
const serializedInstructionData = Buffer.from(
  CounterInstruction.Delegate,
  "hex"
);
const delegateIx: Instruction = {
  accounts,
  programAddress: PROGRAM_ID,
  data: serializedInstructionData,
};
const transactionMessage = pipe(
  createTransactionMessage({ version: 0 }),
  (tx) => setTransactionMessageFeePayer(userPubkey, tx),
  (tx) => appendTransactionMessageInstructions([delegateIx], tx)
);

// Send and confirm transaction on base layer
const txHash = await connection.sendAndConfirmTransaction(
  transactionMessage,
  [userKeypair],
  { commitment: "confirmed", skipPreflight: true }
);

// "Delegate" transaction

// Add local validator identity to the remaining accounts if running on localnet
const remainingAccounts =
  connectionEphemeralRollup.rpcEndpoint.includes("localhost") ||
  connectionEphemeralRollup.rpcEndpoint.includes("127.0.0.1")
    ? [
        {
          pubkey: new PublicKey("mAGicPQYBMvcYveUZA5F5UNNwyHvfYh5xkLS2Fr1mev"),
          isSigner: false,
          isWritable: false,
        },
      ]
    : [];

const tx = new web3.Transaction();
const keys = [
  // Initializer
  {
    pubkey: userKeypair.publicKey,
    isSigner: true,
    isWritable: true,
  },
  // System Program
  {
    pubkey: web3.SystemProgram.programId,
    isSigner: false,
    isWritable: false,
  },
  // Counter Account
  {
    pubkey: counterPda,
    isSigner: false,
    isWritable: true,
  },
  // Owner Program
  {
    pubkey: PROGRAM_ID,
    isSigner: false,
    isWritable: false,
  },
  // Delegation Buffer
  {
    pubkey: getDelegationBufferPda(counterPda, PROGRAM_ID),
    isSigner: false,
    isWritable: true,
  },
  // Delegation Record
  {
    pubkey: getDelegationRecordPda(counterPda),
    isSigner: false,
    isWritable: true,
  },
  // Delegation Metadata
  {
    pubkey: getDelegationMetadataPda(counterPda),
    isSigner: false,
    isWritable: true,
  },
  // Delegation Program
  {
    pubkey: DELEGATION_PROGRAM_ID,
    isSigner: false,
    isWritable: false,
  },
  // ER Validator
  ...remainingAccounts,
];
const serializedInstructionData = Buffer.from(
  CounterInstruction.Delegate,
  "hex"
);
const delegateIx = new web3.TransactionInstruction({
  keys: keys,
  programId: PROGRAM_ID,
  data: serializedInstructionData,
});
tx.add(delegateIx);

// Send and confirm transaction to Base Layer
const txHash = await sendAndConfirmTransaction(
  connectionBaseLayer,
  tx,
  [userKeypair],
  {
    skipPreflight: true,
    commitment: "confirmed",
  }
);

⬆️ Back to Top

Test `commit` transaction

Create a instruction with the right order and attributes of accounts, and the instruction discriminator for commit of your program. Send the transaction with the instruction to ER network.

Transaction (ER): Commit

Inspect transaction details on Solana Explorer

Transaction (Base layer): Commit

Inspect transaction details on Solana Explorer

// "Commit" transaction

const accounts = [
  { address: userPubkey, role: AccountRole.WRITABLE_SIGNER },
  { address: counterPda, role: AccountRole.WRITABLE },
  { address: address(MAGIC_PROGRAM_ID.toString()), role: AccountRole.READONLY },
  { address: address(MAGIC_CONTEXT_ID.toString()), role: AccountRole.WRITABLE },
];
const serializedInstructionData = Buffer.from(CounterInstruction.Commit, "hex");
const commitIx: Instruction = {
  accounts,
  programAddress: PROGRAM_ID,
  data: serializedInstructionData,
};
const transactionMessage = pipe(
  createTransactionMessage({ version: 0 }),
  (tx) => setTransactionMessageFeePayer(userPubkey, tx),
  (tx) => appendTransactionMessageInstructions([commitIx], tx)
);

// Send and confirm transaction on ER
const txHash = await ephemeralConnection.sendAndConfirmTransaction(
  transactionMessage,
  [userKeypair],
  { commitment: "confirmed", skipPreflight: true }
);

// "Commit" transaction

const tx = new web3.Transaction();
const keys = [
  // Initializer
  {
    pubkey: userKeypair.publicKey,
    isSigner: true,
    isWritable: true,
  },
  // Counter Account
  {
    pubkey: counterPda,
    isSigner: false,
    isWritable: true,
  },
  // Magic Program
  {
    pubkey: MAGIC_PROGRAM_ID,
    isSigner: false,
    isWritable: false,
  },
  // Magic Context
  {
    pubkey: MAGIC_CONTEXT_ID,
    isSigner: false,
    isWritable: true,
  },
];
const serializedInstructionData = Buffer.from(CounterInstruction.Commit, "hex");
const commitIx = new web3.TransactionInstruction({
  keys: keys,
  programId: PROGRAM_ID,
  data: serializedInstructionData,
});
tx.add(commitIx);

// Send and confirm transaction to ER
const txHash = await sendAndConfirmTransaction(
  connectionEphemeralRollup,
  tx,
  [userKeypair],
  {
    skipPreflight: true,
    commitment: "confirmed",
  }
);

⬆️ Back to Top

Test `undelegation` transaction

Create a instruction with the right order and attributes of accounts, and the instruction discriminator for undelegation of your program. Send the transaction with the instruction to ER network.

Transaction (ER): Undelegate

Inspect transaction details on Solana Explorer

Transaction (Base layer): Undelegate

Inspect transaction details on Solana Explorer

// "Undelegate" transaction

const accounts = [
  { address: userPubkey, role: AccountRole.WRITABLE_SIGNER },
  { address: counterPda, role: AccountRole.WRITABLE },
  { address: address(MAGIC_PROGRAM_ID.toString()), role: AccountRole.READONLY },
  { address: address(MAGIC_CONTEXT_ID.toString()), role: AccountRole.WRITABLE },
];
const serializedInstructionData = Buffer.from(
  CounterInstruction.CommitAndUndelegate,
  "hex"
);
const undelegateIx: Instruction = {
  accounts,
  programAddress: PROGRAM_ID,
  data: serializedInstructionData,
};
const transactionMessage = pipe(
  createTransactionMessage({ version: 0 }),
  (tx) => setTransactionMessageFeePayer(userPubkey, tx),
  (tx) => appendTransactionMessageInstructions([undelegateIx], tx)
);

// Send and confirm transaction on ER
const txHash = await ephemeralConnection.sendAndConfirmTransaction(
  transactionMessage,
  [userKeypair],
  { commitment: "confirmed", skipPreflight: true }
);

// "Undelegate" transaction

const tx = new web3.Transaction();
const keys = [
  // Initializer
  {
    pubkey: userKeypair.publicKey,
    isSigner: true,
    isWritable: true,
  },
  // Counter Account
  {
    pubkey: counterPda,
    isSigner: false,
    isWritable: true,
  },
  // Magic Program
  {
    pubkey: MAGIC_PROGRAM_ID,
    isSigner: false,
    isWritable: false,
  },
  // Magic Context
  {
    pubkey: MAGIC_CONTEXT_ID,
    isSigner: false,
    isWritable: true,
  },
];
const serializedInstructionData = Buffer.from(
  CounterInstruction.CommitAndUndelegate,
  "hex"
);
const undelegateIx = new web3.TransactionInstruction({
  keys: keys,
  programId: PROGRAM_ID,
  data: serializedInstructionData,
});
tx.add(undelegateIx);

// Send and confirm transaction to ER. Afterwards CPI callback will be triggered to "Undelegate" instruction of your program on the Base Layer.
const txHash = await sendAndConfirmTransaction(
  connectionEphemeralRollup,
  tx,
  [userKeypair],
  {
    skipPreflight: true,
    commitment: "confirmed",
  }
);

⬆️ Back to Top

Solana Explorer

Get insights about your transactions and accounts on Solana:

Solana Explorer

Official Solana Explorer

Solscan

Explore Solana Blockchain

Solana RPC Providers

Send transactions and requests through existing RPC providers:

Solana

Free Public Nodes

Helius

Free Shared Nodes

Triton

Dedicated High-Performance Nodes

Solana Validator Dashboard

Find real-time updates on Solana’s validator infrastructure:

Solana Beach

Get Validator Insights

Validators App

Discover Validator Metrics

Server Status

Subscribe to Solana’s and MagicBlock’s server status:

Solana Status

Subscribe to Solana Server Updates

MagicBlock Status

Subscribe to MagicBlock Server Status

How-to-Guide

Reference Material

API

Quick Access

GitHub

Guide

Step-By-Step Guide

Counter Example

Code Snippets

Import SDK and create Connection

Test `delegation` transaction

Transaction (Base Layer): Delegate

Test `commit` transaction

Transaction (ER): Commit

Transaction (Base layer): Commit

Test `undelegation` transaction

Transaction (ER): Undelegate

Transaction (Base layer): Undelegate

Solana Explorer

Solana Explorer

Solscan

Solana RPC Providers

Solana

Helius

Triton

Solana Validator Dashboard

Solana Beach

Validators App

Server Status

Solana Status

MagicBlock Status

​Quick Access

GitHub

Guide

​Step-By-Step Guide

​Counter Example

​Code Snippets

​Import SDK and create Connection

​Test delegation transaction

Transaction (Base Layer): Delegate

​Test commit transaction

Transaction (ER): Commit

Transaction (Base layer): Commit

​Test undelegation transaction

Transaction (ER): Undelegate

Transaction (Base layer): Undelegate

​Solana Explorer

Solana Explorer

Solscan

​Solana RPC Providers

Solana

Helius

Triton

​Solana Validator Dashboard

Solana Beach

Validators App

​Server Status

Solana Status

MagicBlock Status

Quick Access

Step-By-Step Guide

Counter Example

Code Snippets

Import SDK and create Connection

Test `delegation` transaction

Test `commit` transaction

Test `undelegation` transaction

Solana Explorer

Solana RPC Providers

Solana Validator Dashboard

Server Status