Solana

https://solana.com/docs
Admin
Solana is a high-performance blockchain platform designed for building scalable decentralized...
Tokens:1,343,994
Snippets:8,069
Trust Score:10
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Example output of successful installation

Source: https://solana.com/docs/intro/installation

Example output from a successful installation. Version numbers change as tools are released.

```txt
Installed Versions:
Rust: rustc x.y.z (...)
Solana CLI: solana-cli x.y.z (..., client:Agave)
Anchor CLI: anchor-cli x.y.z
Surfpool CLI: surfpool x.y.z
Node.js: vx.y.z
Yarn: x.y.z
```

--------------------------------

### Start JavaScript client

Source: https://solana.com/docs/tokens/extensions/dynamic-metadata-nft

Starts the JavaScript client, installing dependencies and starting the development server.

```shell
cd app
yarn install
yarn dev
```

--------------------------------

### Create mint account - full example with rent

Source: https://solana.com/docs/intro/quick-start/writing-to-network

Complete example for creating a mint account, including imports, client setup, and rent calculation. The focus marker highlights the rent calculation lines.

```ts
import { createClient, generateKeyPairSigner, lamports } from "@solana/kit";
import { solanaRpc, rpcAirdrop } from "@solana/kit-plugin-rpc";
import { generatedPayer, airdropPayer } from "@solana/kit-plugin-signer";
import { getCreateAccountInstruction } from "@solana-program/system";
import {
  fetchMint,
  getInitializeMintInstruction,
  getMintSize,
  TOKEN_2022_PROGRAM_ADDRESS
} from "@solana-program/token-2022";

const client = await createClient()
  .use(generatedPayer())
  .use(
    solanaRpc({
      rpcUrl: "http://localhost:8899",
      rpcSubscriptionsUrl: "ws://localhost:8900"
    })
  )
  .use(rpcAirdrop())
  .use(airdropPayer(lamports(1_000_000_000n)));

const mint = await generateKeyPairSigner();

// !focus(1:3)
const space = BigInt(getMintSize());

const rent = await client.rpc.getMinimumBalanceForRentExemption(space).send();
```

--------------------------------

### Install and Start Kora CLI

Source: https://solana.com/docs/payments/send-payments/payment-processing/fee-abstraction

Installs the Kora CLI and starts the Kora JSON-RPC server with a configuration file and a signers configuration file. Run these commands in a terminal to deploy Kora.

```bash
cargo install kora-cli
kora --config path/to/kora.toml rpc start --signers-config path/to/signers.toml
```

--------------------------------

### Example output of npx codama init

Source: https://solana.com/docs/programs/codama/clients

Example output from running `npx codama init` with a JavaScript and Rust client preset. Shows the interactive prompts, the dependency installation command, and the final path of the created codama.json file.

```shell
Welcome to Codama!
✔ Where is your IDL located? (Supports Codama and Anchor IDLs). … idl.json
✔ Which script preset would you like to use? › Generate JavaScript client, Generate Rust client
✔ [js] Where should the JavaScript code be generated? … clients/js/src/generated
✔ [rust] Where is the Rust client crate located? … clients/rust
✔ [rust] Where should the Rust code be generated? … clients/rust/src/generated
▲ Your configuration requires additional dependencies.
▲ Install command: pnpm install @codama/nodes-from-anchor @codama/renderers-js @codama/renderers-rust
✔ Install dependencies? … yes
→ Installing
  ├─ @codama/nodes-from-anchor
  ├─ @codama/renderers-js
  └─ @codama/renderers-rust
✔ Dependencies installed successfully.

✔ Configuration file created.
  └─ Path: /example/codama.json
```

--------------------------------

### Batch account setup example

Source: https://solana.com/docs/tools/litesvm/typescript/api-reference/account-management

Sets up multiple test accounts efficiently using setAccount. The callout notes that setAccount is faster than airdrop for bulk setup since it doesn't execute transactions.

```typescript
// Set up multiple test accounts
const accounts = await Promise.all(
  Array.from({ length: 10 }, () => generateKeyPairSigner())
);

for (const [index, account] of accounts.entries()) {
  client.svm.setAccount({
    address: account.address,
    data: new Uint8Array([index]),
    executable: false,
    lamports: lamports(1_000_000n),
    programAddress: address("11111111111111111111111111111111"),
    space: 1n
  });
}
```

--------------------------------

### Example keypair file (target/deploy/hello_world-keypair.json)

Source: https://solana.com/docs/programs/rust

Example contents of the keypair file `target/deploy/hello_world-keypair.json`, which contains the keypair used for the program ID.

```json
[
  203, 253, 43, 62, 165, 111, 94, 222, 105, 225, 218, 85, 143, 9, 114, 96, 243,
  181, 114, 89, 72, 230, 124, 85, 59, 165, 198, 23, 240, 212, 23, 154, 229, 241,
  153, 61, 153, 105, 79, 204, 193, 163, 33, 65, 82, 183, 49, 240, 224, 137, 248,
  24, 128, 25, 192, 197, 118, 235, 239, 67, 85, 156, 219, 231
]

```

--------------------------------

### LiteSVM API Quick Reference

Source: https://solana.com/docs/tools/litesvm/api-reference/quick-reference

Quick reference table and getting started guide for LiteSVM API methods.

```APIDOC
## LiteSVM::new()

### Description
Creates a new LiteSVM basic test environment.

### Method
new

### Parameters
None

### Returns
LiteSVM instance

```

```APIDOC
## LiteSVM::default()

### Description
Returns the "default value" for a type.

### Method
default

### Parameters
None

### Returns
Default LiteSVM instance

```

```APIDOC
## airdrop(&Address, lamports)

### Description
Funds the account with the lamports specified.

### Method
airdrop

### Parameters
- **Address** (&Address) - Required - The address of the account to fund
- **lamports** (u64) - Required - The number of lamports to airdrop

```

```APIDOC
## get_account(&Address)

### Description
Returns all information associated with the account of the provided address.

### Method
get_account

### Parameters
- **Address** (&Address) - Required - The address of the account to retrieve

### Returns
Account information

```

```APIDOC
## set_account(Address, Account)

### Description
Sets all information associated with the account of the provided address.

### Method
set_account

### Parameters
- **Address** (Address) - Required - The address of the account to set
- **Account** (Account) - Required - The account data to set

```

```APIDOC
## get_balance(&Address)

### Description
Gets the lamport balance of the provided account address.

### Method
get_balance

### Parameters
- **Address** (&Address) - Required - The address of the account to query

### Returns
Lamport balance (u64)

```

```APIDOC
## minimum_balance_for_rent_exemption(data_len)

### Description
Returns minimum balance required to make an account with specified data length rent exempt.

### Method
minimum_balance_for_rent_exemption

### Parameters
- **data_len** (usize) - Required - The data length of the account

### Returns
Minimum balance (u64)

```

```APIDOC
## add_program(program_id, &bytes)

### Description
Adds an SBF program to the test environment.

### Method
add_program

### Parameters
- **program_id** (Pubkey) - Required - The program ID
- **bytes** (&[u8]) - Required - The SBF program bytes

```

```APIDOC
## add_program_from_file(program_id, path)

### Description
Adds an SBF program to the test environment from the file specified.

### Method
add_program_from_file

### Parameters
- **program_id** (Pubkey) - Required - The program ID
- **path** (Path) - Required - The file path to the SBF program

```

```APIDOC
## send_transaction(tx)

### Description
Submits a signed transaction.

### Method
send_transaction

### Parameters
- **tx** (Transaction) - Required - The signed transaction to submit

### Returns
Transaction result

```

```APIDOC
## simulate_transaction(tx)

### Description
Simulates a transaction without modifying state.

### Method
simulate_transaction

### Parameters
- **tx** (Transaction) - Required - The transaction to simulate

### Returns
Simulation result

```

```APIDOC
## get_transaction(&signature)

### Description
Gets a transaction from history.

### Method
get_transaction

### Parameters
- **signature** (&Signature) - Required - The transaction signature

### Returns
Transaction data

```

```APIDOC
## latest_blockhash()

### Description
Gets current blockhash.

### Method
latest_blockhash

### Parameters
None

### Returns
Blockhash

```

```APIDOC
## expire_blockhash()

### Description
Force blockhash expiration on the current blockhash.

### Method
expire_blockhash

### Parameters
None

```

```APIDOC
## warp_to_slot(slot)

### Description
Warps the clock to the specified slot.

### Method
warp_to_slot

### Parameters
- **slot** (Slot) - Required - The slot to warp to

```

```APIDOC
## get_sysvar<T>()

### Description
Gets a sysvar from the test environment.

### Method
get_sysvar

### Parameters
None

### Returns
Sysvar of type T

```

```APIDOC
## set_sysvar<T>(&value)

### Description
Sets the sysvar to the test environment.

### Method
set_sysvar

### Parameters
- **value** (&T) - Required - The sysvar value to set

```

```APIDOC
## with_feature_accounts()

### Description
Includes feature gate accounts in the test environment.

### Method
with_feature_accounts

### Parameters
None

### Returns
LiteSVM instance with feature accounts

```

```APIDOC
## set_invocation_inspect_callback(callback)

### Description
Registers a pre/post invocation callback (requires `invocation-inspect-callback` feature).

### Method
set_invocation_inspect_callback

### Parameters
- **callback** (Callback) - Required - The callback function

```

--------------------------------

### Rust: Start a local Surfnet with surfpool-sdk

Source: https://solana.com/docs/tools/surfpool/sdk/overview

Use this Rust example to start a local Surfnet inside a tokio test, get the RPC client, and assert that the pre-funded payer has a positive balance. It prints the RPC and WebSocket URLs. Requires the surfpool-sdk crate and a tokio runtime.

```rust
use surfpool_sdk::{Signer, Surfnet};

#[tokio::test]
async fn starts_a_local_surfnet() {
    let surfnet = Surfnet::start().await.unwrap();

    let rpc = surfnet.rpc_client();
    let balance = rpc.get_balance(&surfnet.payer().pubkey()).unwrap();

    assert!(balance > 0);
    println!("rpc: {}", surfnet.rpc_url());
    println!("ws: {}", surfnet.ws_url());
}
```

--------------------------------

### Cancel Subscription Immediately (TypeScript)

Source: https://solana.com/docs/payments/subscriptions/subscription-plan

TypeScript example for canceling a subscription immediately. It fetches the subscription delegation account to get the current period start timestamp, then sends the cancelSubscriptionNow instruction with the expected timestamp. The transaction will be rejected with StaleSubscriptionApproval if the subscription has changed since the period start was observed.

```TypeScript
import { fetchSubscriptionDelegation } from '@solana/subscriptions';

const subscription = await fetchSubscriptionDelegation(
  subscriberClient.rpc,
  subscriptionPda,
);

await subscriberClient.subscriptions.instructions
  .cancelSubscriptionNow({
    subscriber: subscriberSigner,
    merchant: merchantSigner,
    planPda,
    expectedCurrentPeriodStartTs: subscription.data.currentPeriodStartTs,
  })
  .sendTransaction();
```

--------------------------------

### Set up demo prerequisites

Source: https://solana.com/docs/tools/kora/guides/full-demo

Commands to set up the demo environment: start a local Solana test validator, start the Kora RPC server with the signers configuration, and initialize the client environment.

```bash
solana-test-validator -r
```

```bash
kora rpc start --signers-config signers.toml
```

```bash
pnpm init-env
```

--------------------------------

### Combine and send setup instructions with @solana/kit

Source: https://solana.com/docs/payments/send-payments/payment-processing/batch-payments

Combines all setup instructions (create account, initialize mint, create ATAs, mint to) into a single array and sends them in one transaction using client.sendTransaction. Returns the client and mint for further use.

```javascript
  // Combine all setup instructions
  const setupInstructions = [
    createAccountInstruction, // Create mint account
    initializeMintInstruction, // Initialize mint
    createSenderAtaInstruction, // Create sender's ATA
    createRecipient1AtaInstruction, // Create recipient 1's ATA
    createRecipient2AtaInstruction, // Create recipient 2's ATA
    mintToInstruction // Mint tokens to sender
  ];

  // Send all setup instructions in a single transaction using @solana/kit
  await client.sendTransaction(setupInstructions);

  return {
    client,
    mint
  };
}
```

--------------------------------

### Install Solana CLI and start local validator

Source: https://solana.com/docs/tools/solana-pay/quickstart/installation

Installs the Solana CLI and starts a local validator for testing and key generation.

```bash
# Solana CLI (for testing and key generation)
sh -c "$(curl -sSfL https://release.anza.xyz/stable/install)"

# Local validator for testing
solana-test-validator
```

--------------------------------

### Plugin Setup

Source: https://solana.com/docs/tools/litesvm/typescript/api-reference

Shows how to set up a LiteSVM client using the @solana/kit and its plugins.

```APIDOC
## Plugin Setup

### Description
Initializes a LiteSVM client with the `@solana/kit` and its plugins.

### Code
```typescript
import { createClient, generateKeyPairSigner } from "@solana/kit";
import { litesvm } from "@solana/kit-plugin-litesvm";
import { signer } from "@solana/kit-plugin-signer";

const mySigner = await generateKeyPairSigner();
const client = createClient().use(signer(mySigner)).use(litesvm());
// client.svm: LiteSVM instance
// client.rpc: RPC compatibility layer
```
```

--------------------------------

### GET Response example

Source: https://solana.com/docs/tools/solana-pay/specification/version1-1

Example HTTP response to the GET request, returning a JSON object with `label` and `icon` fields. The response is gzip-compressed.

```http
HTTP/1.1 200 OK
Connection: close
Content-Type: application/json
Content-Length: 62
Content-Encoding: gzip

{"label":"Michael Vines","icon":"https://example.com/icon.svg"}
```

--------------------------------

### Create examples directory and client.rs

Source: https://solana.com/docs/programs/rust

Creates an examples directory and an empty client.rs file for the Rust client example.

```terminal
$ mkdir -p examples && touch examples/client.rs
```

--------------------------------

### Navigate to Demo Client Directory

Source: https://solana.com/docs/tools/kora/guides/full-demo

Navigate to the demo client directory to set up the project environment.

```shell
cd kora/examples/getting-started/demo/client
```

--------------------------------

### latestBlockhash usage example

Source: https://solana.com/docs/tools/litesvm/typescript/api-reference/transactions

Example of getting the current blockhash.

```typescript
const blockhash = client.svm.latestBlockhash();
console.log("Blockhash:", blockhash);
```

--------------------------------

### Initialize Codama with npx codama init

Source: https://solana.com/docs/programs/codama/clients

Run this command in the root of your project to start the interactive Codama configuration setup. It will prompt you for the IDL location, client languages, and output paths, then create a codama.json file and install the necessary dependencies.

```terminal
$ npx codama init
```

--------------------------------

### Demo Setup for Token Payment with Memo

Source: https://solana.com/docs/payments/send-payments/payment-with-memo

Full demo setup for a token payment with memo. It generates keypairs, creates a client and mint, derives associated token accounts, and imports the necessary instructions including getAddMemoInstruction.

```ts
// !collapse(1:16) collapsed
// Click ">" icon on left to expand demo imports
import { createClient, generateKeyPairSigner, lamports } from "@solana/kit";
import type { KeyPairSigner } from "@solana/kit";
import { signer } from "@solana/kit-plugin-signer";
import { solanaLocalRpc } from "@solana/kit-plugin-rpc";
import { getCreateAccountInstruction } from "@solana-program/system";
import {
  getCreateAssociatedTokenInstructionAsync,
  getInitializeMintInstruction,
  getMintSize,
  TOKEN_2022_PROGRAM_ADDRESS,
  findAssociatedTokenPda,
  getMintToInstruction,
  getTransferInstruction
} from "@solana-program/token-2022";
// !mark
import { getAddMemoInstruction } from "@solana-program/memo";

// Generate keypairs for sender and recipient
const sender = await generateKeyPairSigner();
const recipient = await generateKeyPairSigner();

console.log("Sender Address:", sender.address);
console.log("Recipient Address:", recipient.address);

// Demo Setup: Create client, mint account, token accounts, and fund with initial tokens
const { client, mint } = await demoSetup(sender, recipient);

console.log("\nMint Address:", mint.address);

// Derive the Associated Token Accounts addresses (ATAs) for sender and recipient
const [senderAta] = await findAssociatedTokenPda({
  mint: mint.address,
  owner: sender.address,
  tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
});

const [recipientAta] = await findAssociatedTokenPda({
  mint: mint.address,
  owner: recipient.address,
  tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
});

console.log("Sender Token Account:", senderAta.toString());
console.log("Recipient Token Account:", recipientAta.toString());

// =============================================================================
// Token Payment with Memo Demo
// =============================================================================
```

--------------------------------

### GET Request example

Source: https://solana.com/docs/tools/solana-pay/specification/version1-1

Example HTTP GET request to fetch transaction details. Includes headers such as `Accept: application/json` and `Accept-Encoding: br, gzip, deflate`.

```http
GET /solana-pay?order=12345 HTTP/1.1
Host: example.com
Connection: close
Accept: application/json
Accept-Encoding: br, gzip, deflate
```

--------------------------------

### Demo Setup Helper Function (demoSetup)

Source: https://solana.com/docs/payments/advanced-payments/deferred-execution

This snippet provides the `demoSetup` helper function that sets up the environment for the token transfer demo. It creates an RPC connection, airdrops SOL to the sender, generates a mint keypair, creates associated token accounts, and mints initial tokens. It returns the RPC connection and mint address.

```TypeScript
/**
 * Sets up for a token transfer demo:
 * - Creates RPC connection
 * - Airdrops SOL to sender for transaction fees
 * - Generates mint keypair and creates/initializes mint account
 * - Creates associated token accounts for sender and recipient
 * - Mints initial tokens to sender
 *
 * @param sender - The sender's keypair (will be funded and used as mint authority)
 * @param recipient - The recipient's keypair
 * @returns RPC connection and mint address
 */
async function demoSetup(sender: KeyPairSigner, recipient: KeyPairSigner) {
  const rpc = createSolanaRpc("http://localhost:8899");
  const rpcSubscriptions = createSolanaRpcSubscriptions("ws://localhost:8900");

  // Fund sender with SOL for transaction fees
  await airdropFactory({ rpc, rpcSubscriptions })({
    recipientAddress: sender.address,
    lamports: lamports(1_000_000_000n),
    commitment: "confirmed"
  });

  // Create Mint and Token Accounts
  const mint = await generateKeyPairSigner();

  const mintSpace = BigInt(getMintSize());
  const mintRent = await rpc
    .getMinimumBalanceForRentExemption(mintSpace)
    .send();

  const createMintAccountIx = getCreateAccountInstruction({
    payer: sender,
    newAccount: mint,
    lamports: mintRent,
    space: mintSpace,
    programAddress: TOKEN_2022_PROGRAM_ADDRESS
  });

  const initializeMintIx = getInitializeMintInstruction({
    mint: mint.address,
    decimals: 6,
    mintAuthority: sender.address
  });

  const [senderAta] = await findAssociatedTokenPda({
    mint: mint.address,
    owner: sender.address,
    tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
  });

  const createSenderAtaIx = await getCreateAssociatedTokenInstructionAsync({
    payer: sender,
    mint: mint.address,
    owner: sender.address
  });

  const createRecipientAtaIx = await getCreateAssociatedTokenInstructionAsync({
    payer: sender,
    mint: mint.address,
    owner: recipient.address
  });

  const mintToIx = getMintToInstruction({
    mint: mint.address,
    token: senderAta,
    mintAuthority: sender.address,
    amount: 1_000_000n // Mint 1.00 tokens (1,000,000 base units with 6 decimals)
  });

  const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();

  const instructions = [
    createMintAccountIx,
    initializeMintIx,
    createSenderAtaIx,
    createRecipientAtaIx,
    mintToIx
  ];

  const transactionMessage = pipe(
    createTransactionMessage({ version: 0 }),
    (tx) => setTransactionMessageFeePayerSigner(sender, tx),
    (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
    (tx) => appendTransactionMessageInstructions(instructions, tx)
  );

  const signedTransaction =
    await signTransactionMessageWithSigners(transactionMessage);

  assertIsTransactionWithBlockhashLifetime(signedTransaction);

  await sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions })(
    signedTransaction,
    { commitment: "confirmed" }
  );

  return { rpc, rpcSubscriptions, mint };
}
```

--------------------------------

### Install dependencies and run examples with tsx

Source: https://solana.com/docs/tools/litesvm/typescript/examples

Install required packages with pnpm and run an example using npx tsx. Some addresses/variables require replacing placeholders with actual values.

```bash
# Install dependencies
pnpm add @solana/kit @solana/kit-plugin-litesvm @solana/kit-plugin-signer @solana-program/system

# Run an example
npx tsx example.ts
```

--------------------------------

### demoSetup function for delegate demo

Source: https://solana.com/docs/payments/advanced-payments/spend-permissions

Sets up a delegate demo by creating a @solana/kit client, airdropping SOL to the sender, generating a mint keypair, creating and initializing a mint account, creating an associated token account, and minting initial tokens. Returns the client, mint, and ATA address.

```typescript
/**
 * Sets up for a delegate demo:
 * - Creates a @solana/kit client
 * - Airdrops SOL to sender for transaction fees
 * - Generates mint keypair and creates/initializes mint account
 * - Creates associated token account for sender
 * - Mints initial tokens to sender
 *
 * @param sender - The sender's keypair (will be funded and used as mint authority)
 * @returns Returns client instance, mint, and ATA address
 */
async function demoSetup(sender: KeyPairSigner) {
  // Create a @solana/kit client connected to the local validator
  const client = await createClient().use(signer(sender)).use(solanaLocalRpc());

  // Fund sender with SOL for transaction fees
  await client.airdrop(sender.address, lamports(1_000_000_000n));

  // Generate keypair to use as address of mint
  const mint = await generateKeyPairSigner();

  // Get default mint account size (in bytes), no extensions enabled
  const space = BigInt(getMintSize());

  // Get minimum balance for rent exemption
  const rent = await client.rpc.getMinimumBalanceForRentExemption(space).send();

  // Instruction to create new account for mint (token program)
  // Invokes the system program
  const createAccountInstruction = getCreateAccountInstruction({
    payer: sender,
    newAccount: mint,
    lamports: rent,
    space,
    programAddress: TOKEN_2022_PROGRAM_ADDRESS
  });

  // Instruction to initialize mint account data
  // Invokes the token 2022 program
  const initializeMintInstruction = getInitializeMintInstruction({
    mint: mint.address,
    decimals: 6,
    mintAuthority: sender.address
  });

  // Derive sender's associated token account address (ATA)
  const [senderAta] = await findAssociatedTokenPda({
    mint: mint.address,
    owner: sender.address,
    tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
  });

  // Create instruction for sender's ATA
  const createSenderAtaInstruction =
    await getCreateAssociatedTokenInstructionAsync({
      payer: sender,
      mint: mint.address,
      owner: sender.address,
      tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
    });

  // Create instruction to mint initial tokens to sender
  const mintToInstruction = getMintToInstruction({
    mint: mint.address,
    token: senderAta,
    mintAuthority: sender,
    amount: 2_000_000n // Mint 2.00 tokens (2,000,000 base units with 6 decimals)
  });

  // Combine all instructions and send with the kit client
  const setupInstructions = [
    createAccountInstruction, // Create mint account
    initializeMintInstruction, // Initialize mint
    createSenderAtaInstruction, // Create sender's ATA
    mintToInstruction // Mint tokens to sender
  ];

  // Send the setup transaction with the kit client
  await client.sendTransaction(setupInstructions);

  return {
    client,
    mint,
    senderAta
  };
}
```

--------------------------------

### Verify Rust Installation

Source: https://solana.com/docs/intro/installation/dependencies

Verifies the Rust installation by printing the installed Rust version, for example: rustc x.y.z (...).

```terminal
$ rustc --version
```

--------------------------------

### Create mint account - full setup

Source: https://solana.com/docs/intro/quick-start/writing-to-network

Full setup for creating a mint account, including imports and client configuration. The focus marker highlights the client and mint setup lines.

```ts
import { createClient, generateKeyPairSigner, lamports } from "@solana/kit";
import { solanaRpc, rpcAirdrop } from "@solana/kit-plugin-rpc";
import { generatedPayer, airdropPayer } from "@solana/kit-plugin-signer";
import { getCreateAccountInstruction } from "@solana-program/system";
import {
  fetchMint,
  getInitializeMintInstruction,
  getMintSize,
  TOKEN_2022_PROGRAM_ADDRESS
} from "@solana-program/token-2022";

// !focus(1:12)
const client = await createClient()
  .use(generatedPayer())
  .use(
    solanaRpc({
      rpcUrl: "http://localhost:8899",
      rpcSubscriptionsUrl: "ws://localhost:8900"
    })
  )
  .use(rpcAirdrop())
  .use(airdropPayer(lamports(1_000_000_000n)));

const mint = await generateKeyPairSigner();
```

--------------------------------

### Web3.js Setup for Transfer Fee Example

Source: https://solana.com/docs/tokens/extensions/transfer-fees

Sets up the Web3.js environment for the transfer fee example: imports the necessary Solana web3 and SPL Token libraries, creates a connection to a local node, generates keypairs for the fee payer, recipients, and fee receiver, requests an airdrop, and derives the associated token accounts for the mint and participants using the Token-2022 program.

```ts
import {
  Connection,
  Keypair,
  LAMPORTS_PER_SOL,
  sendAndConfirmTransaction,
  SystemProgram,
  Transaction
} from "@solana/web3.js";
import {
  ASSOCIATED_TOKEN_PROGRAM_ID,
  ExtensionType,
  createAssociatedTokenAccountInstruction,
  createHarvestWithheldTokensToMintInstruction,
  createInitializeMintInstruction,
  createInitializeTransferFeeConfigInstruction,
  createMintToCheckedInstruction,
  createSetTransferFeeInstruction,
  createTransferCheckedWithFeeInstruction,
  createWithdrawWithheldTokensFromAccountsInstruction,
  createWithdrawWithheldTokensFromMintInstruction,
  getAccount,
  getAssociatedTokenAddressSync,
  getMint,
  getMintLen,
  getTransferFeeAmount,
  getTransferFeeConfig,
  TOKEN_2022_PROGRAM_ID
} from "@solana/spl-token";

const connection = new Connection("http://localhost:8899", "confirmed");
const latestBlockhash = await connection.getLatestBlockhash();

const feePayer = Keypair.generate();
const recipientA = Keypair.generate();
const recipientB = Keypair.generate();
const feeReceiver = Keypair.generate();
const airdropSignature = await connection.requestAirdrop(
  feePayer.publicKey,
  5 * LAMPORTS_PER_SOL
);
await connection.confirmTransaction({
  blockhash: latestBlockhash.blockhash,
  lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
  signature: airdropSignature
});

const mint = Keypair.generate();
const transferFeeConfigExtensions = [ExtensionType.TransferFeeConfig];
const mintLen = getMintLen(transferFeeConfigExtensions);
const mintRent = await connection.getMinimumBalanceForRentExemption(mintLen);

const sourceToken = getAssociatedTokenAddressSync(
  mint.publicKey,
  feePayer.publicKey,
  false,
  TOKEN_2022_PROGRAM_ID,
  ASSOCIATED_TOKEN_PROGRAM_ID
);

const destinationAToken = getAssociatedTokenAddressSync(
  mint.publicKey,
  recipientA.publicKey,
  false,
  TOKEN_2022_PROGRAM_ID,
  ASSOCIATED_TOKEN_PROGRAM_ID
);

const destinationBToken = getAssociatedTokenAddressSync(
  mint.publicKey,
  recipientB.publicKey,
  false,
  TOKEN_2022_PROGRAM_ID,
  ASSOCIATED_TOKEN_PROGRAM_ID
);

const feeReceiverToken = getAssociatedTokenAddressSync(
  mint.publicKey,
  feeReceiver.publicKey,
  false,
  TOKEN_2022_PROGRAM_ID,
  ASSOCIATED_TOKEN_PROGRAM_ID
);
```

--------------------------------

### before Example

Source: https://solana.com/docs/rpc/http/getsignaturesforaddress

Example value for the before parameter, which starts searching backwards from the given transaction signature.

```json
{
  "before": "5h6xBEauJ3PK6SWCz5Qq8DbD4t7VDdaRhfvsRrHBhXX2x4dLZxN1YhJpN96CBvs1BgqsSVqSogn8CA9nVddrzNRs"
}
```

--------------------------------

### Verify Solana CLI Installation

Source: https://solana.com/docs/intro/installation/dependencies

Verifies the Solana CLI installation by printing the installed version, for example: solana-cli x.y.z (..., client:Agave).

```terminal
$ solana --version
```

--------------------------------

### Run client example

Source: https://solana.com/docs/programs/rust/program-structure

Runs the client example to interact with the deployed program.

```terminal
$ cargo run --example client
```

--------------------------------

### Kit: Instructions

Source: https://solana.com/docs/tokens/extensions/interest-bearing-tokens

Imports and client setup for creating an interest-bearing mint using the Kit. Includes necessary imports from @solana/kit and @solana-program/token-2022, and initializes the client with airdrop and payer setup.

```typescript
import {
  lamports,
  createClient,
  appendTransactionMessageInstructions,
  createTransactionMessage,
  generateKeyPairSigner,
  getBase64EncodedWireTransaction,
  pipe,
  setTransactionMessageFeePayerSigner,
  setTransactionMessageLifetimeUsingBlockhash,
  signTransactionMessageWithSigners,
  unwrapOption
} from "@solana/kit";
import { solanaRpc, rpcAirdrop } from "@solana/kit-plugin-rpc";
import { generatedPayer, airdropPayer } from "@solana/kit-plugin-signer";
import { getCreateAccountInstruction } from "@solana-program/system";
import {
  amountToUiAmountForMintWithoutSimulation,
  extension,
  fetchMint,
  findAssociatedTokenPda,
  getAmountToUiAmountInstruction,
  getCreateAssociatedTokenInstructionAsync,
  getInitializeInterestBearingMintInstruction,
  getInitializeMintInstruction,
  getMintSize,
  getMintToCheckedInstruction,
  getUpdateRateInterestBearingMintInstruction,
  isExtension,
  TOKEN_2022_PROGRAM_ADDRESS
} from "@solana-program/token-2022";

const client = await createClient()
  .use(generatedPayer())
  .use(
    solanaRpc({
      rpcUrl: "http://localhost:8899",
      rpcSubscriptionsUrl: "ws://localhost:8900"
    })
  )
  .use(rpcAirdrop())
  .use(airdropPayer(lamports(1_000_000_000n)));

const mint = await generateKeyPairSigner();
const recipient = await generateKeyPairSigner();
const tokenAmount = 1_000_000_000_000n;
```

--------------------------------

### Get current blockhash for transaction

Source: https://solana.com/docs/tools/litesvm/api-reference/transactions

Example of getting the current blockhash and using it to create a signed transaction.

```rust
let blockhash = svm.latest_blockhash();

let tx = Transaction::new_signed_with_payer(
    &[instruction],
    Some(&payer.pubkey()),
    &[&payer],
    blockhash,
);
```

--------------------------------

### Example output of solana config get

Source: https://solana.com/docs/intro/installation/solana-cli-basics

Example output from running 'solana config get' showing the default configuration values. The RPC URL points to mainnet, the keypair path is the default id.json, and the commitment is confirmed.

```txt
Config File: /Users/test/.config/solana/cli/config.yml
RPC URL: https://api.mainnet.solana.com
WebSocket URL: wss://api.mainnet.solana.com/ (computed)
Keypair Path: /Users/test/.config/solana/id.json
Commitment: confirmed
```

--------------------------------

### Run Client Demo

Source: https://solana.com/docs/tools/kora/beta/jito-guide

Runs the client demo after installing dependencies with pnpm. Expects a successful bundle execution at the end.

```bash
cd examples/jito-bundles/client

# Install dependencies
pnpm install

# Run the demo
pnpm start
```

--------------------------------

### Demo Setup Helper Function for Token Transfer with Memo

Source: https://solana.com/docs/payments/send-payments/payment-with-memo

Sets up the environment for the token transfer with memo demo: creates a @solana/kit client, airdrops SOL to the sender, generates a mint keypair, creates and initializes a mint account, creates associated token accounts for sender and recipient, and mints initial tokens to the sender. Returns the client and mint address.

```typescript
// =============================================================================
// Demo Setup Helper Function
// =============================================================================
// !collapse(1:1000) collapsed

/**
 * Sets up for a token transfer with memo demo:
 * - Creates @solana/kit client
 * - Airdrops SOL to sender for transaction fees
 * - Generates mint keypair and creates/initializes mint account
 * - Creates associated token accounts for sender and recipient
 * - Mints initial tokens to sender
 *
 * @param sender - The sender's keypair (will be funded and used as mint authority)
 * @param recipient - The recipient's keypair
 * @returns Returns client instance and mint address
 */
async function demoSetup(sender: KeyPairSigner, recipient: KeyPairSigner) {
  // Create @solana/kit client pointing to local validator
  const client = createClient().use(signer(sender)).use(solanaLocalRpc());

  // Fund sender with SOL for transaction fees
  await client.airdrop(sender.address, lamports(1_000_000_000n));

  // Generate keypair to use as address of mint
  const mint = await generateKeyPairSigner();

  // Get default mint account size (in bytes), no extensions enabled
  const space = BigInt(getMintSize());

  // Get minimum balance for rent exemption
  const rent = await client.rpc.getMinimumBalanceForRentExemption(space).send();

  // Instruction to create new account for mint (token program)
  // Invokes the system program
  const createAccountInstruction = getCreateAccountInstruction({
    payer: sender,
    newAccount: mint,
    lamports: rent,
    space,
    programAddress: TOKEN_2022_PROGRAM_ADDRESS
  });

  // Instruction to initialize mint account data
  // Invokes the token 2022 program
  const initializeMintInstruction = getInitializeMintInstruction({
    mint: mint.address,
    decimals: 6,
    mintAuthority: sender.address
  });

  // Derive sender's associated token account address (ATA)
  const [senderAta] = await findAssociatedTokenPda({
    mint: mint.address,
    owner: sender.address,
    tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
  });

  // Create instruction for sender's ATA
  const createSenderAtaInstruction =
    await getCreateAssociatedTokenInstructionAsync({
      payer: sender,
      mint: mint.address,
      owner: sender.address,
      tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
    });

  // Create instruction for recipient's ATA
  const createRecipientAtaInstruction =
    await getCreateAssociatedTokenInstructionAsync({
      payer: sender,
      mint: mint.address,
      owner: recipient.address,
      tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
    });

  // Create instruction to mint initial tokens to sender
  const mintToInstruction = getMintToInstruction({
    mint: mint.address,
    token: senderAta,
    mintAuthority: sender.address,
    amount: 1_000_000n // Mint 1.00 tokens (1,000,000 base units with 6 decimals)
  });

  // Combine all instructions and send
  const setupInstructions = [
    createAccountInstruction, // Create mint account
    initializeMintInstruction, // Initialize mint
    createSenderAtaInstruction, // Create sender's ATA
    createRecipientAtaInstruction, // Create recipient's ATA
    mintToInstruction // Mint tokens to sender
  ];

  // Send transaction
  await client.sendTransaction(setupInstructions);

  return {
    client,
    mint
  };
}
```

--------------------------------

### Install @solana/actions SDK

Source: https://solana.com/docs/tools/actions

Install the Solana Actions SDK in your application to start building custom Solana Actions.

```shell
npm install @solana/actions
```
Tokens:
Raw