Solana / SVM

Switchboard Randomness for Solana and SVM applications

Prerequisites

  • Basic understanding of Solana development and Anchor Framework.

  • A working Solana development environment (Solana tool suite, Anchor).

  • Solana CLI connected to the devnet.

  • Enough SOL tokens for devnet transactions.

Tooling:

Install Switchboard On-Demand in your program.

cargo add switchboard-on-demand

Install Switchboard On-Demand in your Javascript Client file:

npm i @switchboard-xyz/on-demand

Step 1: Coin Flip Program (Solana)

  1. Define the Player State

    Make sure to store the user's randomness_account in your program.

    #[account]
pub struct PlayerState {
    allowed_user: Pubkey,
    latest_flip_result: bool,
    randomness_account: Pubkey,
    current_guess: bool,
    wager: u64,
    bump: u8,
}

  • Commit to a Future Slot

    Commit to the game by locking the randomness_account.

    pub fn coin_flip(ctx: Context<CoinFlip>, randomness_account: Pubkey, guess: bool) -> Result<()> {
    // Load clock to check data from the future        
    let clock = Clock::get()?;
    // Update player_state's randomness_account
    let randomness_data = RandomnessAccountData::parse(ctx.accounts.randomness_account_data.data.borrow()).unwrap();    
    if randomness_data.seed_slot != clock.slot - 1 {
        msg!("seed_slot: {}", randomness_data.seed_slot);
        msg!("slot: {}", clock.slot);
        return Err(ErrorCode::RandomnessAlreadyRevealed.into());
    }

    // **IMPORTANT**:
    // Remember in Switchboard Randomness, game collateral MUST be taken upon randomness request, not on reveal.
    // ***
    transfer(
        ctx.accounts.system_program.to_account_info(),
        ctx.accounts.user.to_account_info(),
        ctx.accounts.escrow_account.to_account_info(),
        player_state.wager,
        None,
    )?;

    // Store flip commitment to the future slot byt referencing the randomness account
    player_state.randomness_account = randomness_account;
}

  • Settle the Flip

    Resolve randomness through the settle_flip function.

    pub fn settle_flip(ctx: Context<SettleFlip>) -> Result<()> {
    // Load clock to check data from the future
    let clock = Clock::get()?;

    // Parsing the oracle's scroll Call the switchboard on-demand parse function to get the randomness data
    let randomness_data = RandomnessAccountData::parse(ctx.accounts.randomness_account_data.data.borrow()).unwrap();
    
    // Call the switchboard on-demand get_value function to get the revealed random value
    let revealed_random_value = randomness_data.get_value(&clock)
        .map_err(|_| ErrorCode::RandomnessNotResolved)?;
}

Step 2: TypeScript Client

  1. Setup and Environment Configuration:

import * as anchor from "@coral-xyz/anchor";
import {
  Connection,
  PublicKey,
  Keypair,
  Transaction,
  SystemProgram,
  VersionedTransaction,
} from "@solana/web3.js";
import {
  AnchorUtils,
  InstructionUtils,
  Queue,
  Randomness,
  SB_ON_DEMAND_PID,
  sleep,
} from "@switchboard-xyz/on-demand";
import dotenv from "dotenv";
import * as fs from "fs";
import reader from "readline-sync";

(async function () {
  dotenv.config();
  console.clear();
  
  const { keypair, connection, provider, wallet } = await AnchorUtils.loadEnv();
  const payer = wallet.payer;
  // Switchboard sbQueue fixed
  const sbQueue = new PublicKey("FfD96yeXs4cxZshoPPSKhSPgVQxLAJUT3gefgh84m1Di");
  const sbProgramId = SB_ON_DEMAND_PID;
  const sbProgram = await anchor.Program.at(sbProgramId, sbProgramId, provider);
  const queueAccount = new Queue(sbProgram, sbQueue);

  // setup
  const path = "sb-randomness/target/deploy/sb_randomness-keypair.json";
  
  const [_, myProgramKeypair] = await AnchorUtils.initWalletFromFile(path);
  const coinFlipProgramId = myProgramKeypair.publicKey;
  const coinFlipProgram = await myAnchorProgram(provider, coinFlipProgramId);

  1. Creating a Randomness Account: Before flipping that coin, start with a clean randomness account.

const rngKp = Keypair.generate();
const [randomness, ix] = await Randomness.create(sbProgram, rngKp, sbQueue);

  1. Committing to Randomness: Use randomness account to commit to the oracle.

const commitIx = await randomness.commitIx(sbQueue);
// Add this instruction to your coinFlip transaction and send it

  1. Revealing the Vision: Once the slot is generated, invoke to generate randomness for the committed slot.

const revealIx = await randomness.revealIx();
// Execute the reveal instruction, followed by your program's settle_flip function

Note: here is an optional way to save the revealIx()transaction .

randomness.serializeIxToFile(
  [revealIx, SettleFlipIx],
  "serializedIx.bin"
);

  1. Settling the Flip: Finally, record the coin flip in the randomness account.

const settleFlipIx = await coinFlipProgram.instruction.settleFlip(
    escrowBump,
    {
      accounts: {
        playerState: playerStateAccount,
        randomnessAccountData: randomness.pubkey,
        escrowAccount: escrowAccount,
        user: provider.wallet.publicKey,
        systemProgram: SystemProgram.programId,
      },
    }
  );
// Add the revealIx and this instruction together and execute

You've just integrated randomness into your Solana application.

For more details, refer to the example repository

PreviousTutorialsNextEVM

Last updated