Solana SDK

https://docs.rs/solana-sdk/latest/solana_sdk/
Admin
Solana SDK is the base library for off-chain programs that interact with Solana or operate on Solana...
Tokens:579,169
Snippets:3,519
Trust Score:9.7
Update:21 hours ago
Show doc for...
Tokens:
Raw
### split_first method example for slice

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Shows how to use split_first to get the first element and the rest of the slice.

```rust
let x = &[0, 1, 2];

if let Some((first, elements)) = x.split_first() {
    assert_eq!(first, &0);
    assert_eq!(elements, &[1, 2]);
}
```

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

### get example

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Demonstrates using get to retrieve an element or subslice by index or range, returning None if out of bounds.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&40), v.get(1));
assert_eq!(Some(&[10, 40][..]), v.get(0..2));
assert_eq!(None, v.get(3));
assert_eq!(None, v.get(0..4));
```

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

### starts_with method example

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Checks if a slice starts with a given prefix. Returns true if the prefix matches the beginning of the slice.

```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));
```

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

### first method example for slice

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Shows how to use the first method to get the first element of a slice, returning None for an empty slice.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&10), v.first());

let w: &[i32] = &[];
assert_eq!(None, w.first());
```

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

### len method example for slice

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Shows how to use the len method on a slice to get the number of elements.

```rust
let a = [1, 2, 3];
assert_eq!(a.len(), 3);
```

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

### impl AbiExample for EpochSchedule

Source: https://docs.rs/solana-sdk/latest/solana_sdk/sysvar/epoch_schedule/struct.EpochSchedule.html

Provides an example instance of EpochSchedule for ABI example purposes.

```APIDOC
## impl AbiExample for EpochSchedule

### Description
Provides an example instance of EpochSchedule for ABI example purposes.

### Method
`fn example() -> EpochSchedule`

### Parameters
None

### Returns
- **EpochSchedule** - An example EpochSchedule instance.
```

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

### Create a fully-signed transaction with new_signed_with_payer

Source: https://docs.rs/solana-sdk/latest/solana_sdk/transaction/struct.Transaction.html

This example shows how to use `Transaction::new_signed_with_payer` to create and send a transaction. It defines a custom program instruction using Borsh serialization, constructs an `Instruction`, gets the latest blockhash, and sends the transaction via `RpcClient`. The method panics if signing fails.

```rust
use anyhow::Result;
use borsh::{BorshSerialize, BorshDeserialize};
use solana_instruction::Instruction;
use solana_keypair::Keypair;
use solana_message::Message;
use solana_pubkey::Pubkey;
use solana_rpc_client::rpc_client::RpcClient;
use solana_signer::Signer;
use solana_transaction::Transaction;

// A custom program instruction. This would typically be defined in
// another crate so it can be shared between the on-chain program and
// the client.
#[derive(BorshSerialize, BorshDeserialize)]
enum BankInstruction {
    Initialize,
    Deposit { lamports: u64 },
    Withdraw { lamports: u64 },
}

fn send_initialize_tx(
    client: &RpcClient,
    program_id: Pubkey,
    payer: &Keypair
) -> Result<()> {

    let bank_instruction = BankInstruction::Initialize;

    let instruction = Instruction::new_with_borsh(
        program_id,
        &bank_instruction,
        vec![],
    );

    let blockhash = client.get_latest_blockhash()?;
    let mut tx = Transaction::new_signed_with_payer(
        &[instruction],
        Some(&payer.pubkey()),
        &[payer],
        blockhash,
    );
    client.send_and_confirm_transaction(&tx)?;

    Ok(())
}
```

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

### partition_point basic example

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Returns the index of the first element of the second partition according to the predicate. The example finds the partition point for values less than 5 and asserts the result.

```rust
let v = [1, 2, 3, 3, 5, 6, 7];
let i = v.partition_point(|&x| x < 5);

assert_eq!(i, 4);
assert!(v[..i].iter().all(|&x| x < 5));
assert!(v[i..].iter().all(|&x| !(x < 5)));
```

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

### Rust example for binary_search_by

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Demonstrates binary_search_by on a slice of integers. The example looks up four elements, showing found and not-found cases, and a case with multiple matches.

```rust
let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];

let seek = 13;
assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Ok(9));
let seek = 4;
assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(7));
let seek = 100;
assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(13));
let seek = 1;
let r = s.binary_search_by(|probe| probe.cmp(&seek));
assert!(match r { Ok(1..=4) => true, _ => false, });
```

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

### fill method example

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Demonstrates the fill method on a mutable slice, which fills the slice with a cloned value. The example creates a vector of zeros and fills it with ones.

```rust
let mut buf = vec![0; 10];
buf.fill(1);
assert_eq!(buf, vec![1; 10]);
```

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

### array_windows example

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Returns an iterator over overlapping windows of N elements. The example iterates over windows of size 2 and asserts each window.

```rust
let slice = [0, 1, 2, 3];
let mut iter = slice.array_windows();
assert_eq!(iter.next().unwrap(), &[0, 1]);
assert_eq!(iter.next().unwrap(), &[1, 2]);
assert_eq!(iter.next().unwrap(), &[2, 3]);
assert!(iter.next().is_none());
```

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

### impl AbiExample for Address

Source: https://docs.rs/solana-sdk/latest/solana_sdk/pubkey/struct.Pubkey.html

Provides an example instance of the Address type for ABI example generation.

```APIDOC
## impl AbiExample for Address

### Description
Provides an example instance of the Address type for ABI example generation.

### Method
`fn example() -> Address`

### Returns
- **Address** - An example Address instance.

```

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

### impl AbiExample for VersionedTransaction

Source: https://docs.rs/solana-sdk/latest/solana_sdk/transaction/struct.VersionedTransaction.html

Provides an example instance of VersionedTransaction for ABI example generation.

```APIDOC
## impl AbiExample for VersionedTransaction

### Description
Provides an example instance of VersionedTransaction for ABI example generation.

### Method
`fn example() -> VersionedTransaction`

### Parameters
None

### Returns
- **VersionedTransaction** - An example instance of VersionedTransaction.

```

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

### Example usage of declare_id!

Source: https://docs.rs/solana-sdk/latest/solana_sdk/macro.declare_id.html

Example demonstrating how to use declare_id! with a base58 string literal, then verify the generated id() function returns the expected Pubkey.

```rust
use std::str::FromStr;
use solana_sdk::{declare_id, pubkey::Pubkey};

declare_id!("My11111111111111111111111111111111111111111");

let my_id = Pubkey::from_str("My11111111111111111111111111111111111111111").unwrap();
assert_eq!(id(), my_id);
```

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

### Example: Define static Pubkey with pubkey!

Source: https://docs.rs/solana-sdk/latest/solana_sdk/macro.pubkey.html

Shows how to use `pubkey!` to define a static `Pubkey` from a base58 literal and compare it with a parsed value.

```rust
use std::str::FromStr;
use solana_program::{pubkey, pubkey::Pubkey};

static ID: Pubkey = pubkey!("My11111111111111111111111111111111111111111");

let my_id = Pubkey::from_str("My11111111111111111111111111111111111111111").unwrap();
assert_eq!(ID, my_id);
```

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

### iter method example

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Returns an iterator over the slice, yielding all items from start to end. Example shows iterating and asserting each element.

```rust
let x = &[1, 2, 4];
let mut iterator = x.iter();

assert_eq!(iterator.next(), Some(&1));
assert_eq!(iterator.next(), Some(&2));
assert_eq!(iterator.next(), Some(&4));
assert_eq!(iterator.next(), None);
```

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

### Create and send a fully-signed transaction with Transaction::new

Source: https://docs.rs/solana-sdk/latest/solana_sdk/transaction/struct.Transaction.html

Example from the docs for `Transaction::new` showing how to build a `Message` from a custom `BankInstruction`, sign it with a payer keypair, and send it via `RpcClient`. Requires the `solana_rpc_client` and `anyhow` crates. Panics if signing fails.

```rust
use anyhow::Result;
use borsh::{BorshSerialize, BorshDeserialize};
use solana_instruction::Instruction;
use solana_keypair::Keypair;
use solana_message::Message;
use solana_pubkey::Pubkey;
use solana_rpc_client::rpc_client::RpcClient;
use solana_signer::Signer;
use solana_transaction::Transaction;

// A custom program instruction. This would typically be defined in
// another crate so it can be shared between the on-chain program and
// the client.
#[derive(BorshSerialize, BorshDeserialize)]
enum BankInstruction {
    Initialize,
    Deposit { lamports: u64 },
    Withdraw { lamports: u64 },
}

fn send_initialize_tx(
    client: &RpcClient,
    program_id: Pubkey,
    payer: &Keypair
) -> Result<()> {

    let bank_instruction = BankInstruction::Initialize;

    let instruction = Instruction::new_with_borsh(
        program_id,
        &bank_instruction,
        vec![],
    );

    let message = Message::new(
        &[instruction],
        Some(&payer.pubkey()),
    );

    let blockhash = client.get_latest_blockhash()?;
    let mut tx = Transaction::new(&[payer], message, blockhash);
    client.send_and_confirm_transaction(&tx)?;

    Ok(())
}
```

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

### AccountMeta::new example

Source: https://docs.rs/solana-sdk/latest/solana_sdk/instruction/struct.AccountMeta.html

Constructs metadata for a writable account using AccountMeta::new. The example shows creating an instruction with two account metas: one signer and one non-signer.

```rust
let instr = Instruction::new_with_borsh(
    program_id,
    &instruction,
    vec![
        AccountMeta::new(from, true),
        AccountMeta::new(to, false),
    ],
);
```

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

### split_last example

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Demonstrates using split_last to get references to the last element and the rest of the slice.

```rust
let x = &[0, 1, 2];

if let Some((last, elements)) = x.split_last() {
    assert_eq!(last, &2);
    assert_eq!(elements, &[0, 1]);
}
```

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

### Example: Define static Address with address!

Source: https://docs.rs/solana-sdk/latest/solana_sdk/macro.pubkey.html

Shows how to use `address!` to define a static `Address` from a base58 literal and compare it with a parsed value.

```rust
use std::str::FromStr;
use solana_address::{address, Address};

static ID: Address = address!("My11111111111111111111111111111111111111111");

let my_id = Address::from_str("My11111111111111111111111111111111111111111").unwrap();
assert_eq!(ID, my_id);
```

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

### len method example for Vec

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Shows how to use the len method on a Vec to get the number of elements.

```rust
let a = vec![1, 2, 3];
assert_eq!(a.len(), 3);
```

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

### last example

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Demonstrates using last to get a reference to the last element, returning None for empty slices.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&30), v.last());

let w: &[i32] = &[];
assert_eq!(None, w.last());
```

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

### Create Instruction with new_with_bincode

Source: https://docs.rs/solana-sdk/latest/solana_sdk/instruction/struct.Instruction.html

Example for Instruction::new_with_bincode, which serializes a custom struct using bincode. Requires the 'bincode' crate feature. The example defines MyInstruction with a lamports field and creates an Instruction with two AccountMeta entries.

```rust
#[derive(Serialize, Deserialize)]
pub struct MyInstruction {
    pub lamports: u64,
}

pub fn create_instruction(
    program_id: &Pubkey,
    from: &Pubkey,
    to: &Pubkey,
    lamports: u64,
) -> Instruction {
    let instr = MyInstruction { lamports };

    Instruction::new_with_bincode(
        *program_id,
        &instr,
        vec![
            AccountMeta::new(*from, true),
            AccountMeta::new(*to, false),
        ],
   )
}
```

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

### split_last_mut example

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Demonstrates using split_last_mut to get mutable references to the last element and the rest of the slice, modifying them.

```rust
let x = &mut [0, 1, 2];

if let Some((last, elements)) = x.split_last_mut() {
    *last = 3;
    elements[0] = 4;
    elements[1] = 5;
}
assert_eq!(x, &[4, 5, 3]);
```

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

### split_first_mut example

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Demonstrates using split_first_mut to get mutable references to the first element and the rest of the slice, modifying them.

```rust
let x = &mut [0, 1, 2];

if let Some((first, elements)) = x.split_first_mut() {
    *first = 3;
    elements[0] = 4;
    elements[1] = 5;
}
assert_eq!(x, &[3, 4, 5]);
```

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

### Sign a transaction with Transaction::sign

Source: https://docs.rs/solana-sdk/latest/solana_sdk/transaction/struct.Transaction.html

This example shows how to create and sign a transaction using `Transaction::sign`. It requires the `solana_rpc_client` and `anyhow` crates. The method panics on signing failure; use `try_sign` to handle errors. The example defines a custom `BankInstruction` enum and sends an initialize instruction.

```rust
use anyhow::Result;
use borsh::{BorshSerialize, BorshDeserialize};
use solana_instruction::Instruction;
use solana_keypair::Keypair;
use solana_message::Message;
use solana_pubkey::Pubkey;
use solana_rpc_client::rpc_client::RpcClient;
use solana_signer::Signer;
use solana_transaction::Transaction;

// A custom program instruction. This would typically be defined in
// another crate so it can be shared between the on-chain program and
// the client.
#[derive(BorshSerialize, BorshDeserialize)]
enum BankInstruction {
    Initialize,
    Deposit { lamports: u64 },
    Withdraw { lamports: u64 },
}

fn send_initialize_tx(
    client: &RpcClient,
    program_id: Pubkey,
    payer: &Keypair
) -> Result<()> {

    let bank_instruction = BankInstruction::Initialize;

    let instruction = Instruction::new_with_borsh(
        program_id,
        &bank_instruction,
        vec![],
    );

    let mut tx = Transaction::new_with_payer(&[instruction], Some(&payer.pubkey()));
    let blockhash = client.get_latest_blockhash()?;
    tx.sign(&[payer], blockhash);
    client.send_and_confirm_transaction(&tx)?;

    Ok(())
}
```

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

### first_mut method example for slice

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Demonstrates the first_mut method to get a mutable reference to the first element and modify it.

```rust
let x = &mut [0, 1, 2];

if let Some(first) = x.first_mut() {
    *first = 5;
}
assert_eq!(x, &[5, 1, 2]);

let y: &mut [i32] = &mut [];
assert_eq!(None, y.first_mut());
```

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

### rsplitn example: print groups of slice split from end by predicate

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Splits a slice into at most n subslices separated by elements matching the predicate, starting from the end. The matched element is not included in the subslices. The example prints the groups.

```rust
let v = [10, 40, 30, 20, 60, 50];

for group in v.rsplitn(2, |num| *num % 3 == 0) {
    println!("{group:?}");
}
```

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

### binary_search_by_key example

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Example showing how to use binary_search_by_key on a slice of pairs sorted by their second elements. It demonstrates finding an element, handling not-found cases, and handling multiple matches.

```rust
let s = [(0, 0), (2, 1), (4, 1), (5, 1), (3, 1),
         (1, 2), (2, 3), (4, 5), (5, 8), (3, 13),
         (1, 21), (2, 34), (4, 55)];

assert_eq!(s.binary_search_by_key(&13, |&(a, b)| b),  Ok(9));
assert_eq!(s.binary_search_by_key(&4, |&(a, b)| b),   Err(7));
assert_eq!(s.binary_search_by_key(&100, |&(a, b)| b), Err(13));
let r = s.binary_search_by_key(&1, |&(a, b)| b);
assert!(match r { Ok(1..=4) => true, _ => false, });
```

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

### EpochRewards::example (AbiExample)

Source: https://docs.rs/solana-sdk/latest/solana_sdk/sysvar/epoch_rewards/struct.EpochRewards.html

Provides an example instance of EpochRewards for ABI testing.

```APIDOC
## EpochRewards::example (AbiExample)

### Description
Provides an example instance of EpochRewards for ABI testing.

### Method
fn example() -> EpochRewards

### Returns
- **EpochRewards** - An example instance of EpochRewards.
```

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

### first_chunk example

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Demonstrates using first_chunk to get an array reference to the first N items, returning None if the slice is too short.

```rust
let u = [10, 40, 30];
assert_eq!(Some(&[10, 40]), u.first_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.first_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.first_chunk::<0>());
```

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

### AccountInfo::new

Source: https://docs.rs/solana-sdk/latest/solana_sdk/entrypoint/struct.__AccountInfo.html

Creates a new AccountInfo instance with the given key, signer/writable flags, lamports, data, owner, and executable flag.

```APIDOC
## AccountInfo::new

### Description
Creates a new AccountInfo instance with the provided account metadata.

### Method
new

### Signature
pub fn new(
    key: &'a Address,
    is_signer: bool,
    is_writable: bool,
    lamports: &'a mut u64,
    data: &'a mut [u8],
    owner: &'a Address,
    executable: bool,
) -> AccountInfo<'a>

### Parameters
- **key** (&'a Address) - Required - The account's public key.
- **is_signer** (bool) - Required - Whether the account is a signer.
- **is_writable** (bool) - Required - Whether the account is writable.
- **lamports** (&'a mut u64) - Required - Mutable reference to the account's lamports.
- **data** (&'a mut [u8]) - Required - Mutable reference to the account's data.
- **owner** (&'a Address) - Required - The account's owner program address.
- **executable** (bool) - Required - Whether the account is executable.

### Returns
- **AccountInfo<'a>** - The newly created AccountInfo instance.

```

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

### last_mut example

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Demonstrates using last_mut to get a mutable reference to the last element, modifying it, and returning None for empty slices.

```rust
let x = &mut [0, 1, 2];

if let Some(last) = x.last_mut() {
    *last = 10;
}
assert_eq!(x, &[0, 1, 10]);

let y: &mut [i32] = &mut [];
assert_eq!(None, y.last_mut());
```

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

### last_chunk example

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Demonstrates using last_chunk to get an array reference to the last N items. Returns None if the slice is shorter than N.

```rust
let u = [10, 40, 30];
assert_eq!(Some(&[40, 30]), u.last_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.last_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.last_chunk::<0>());
```

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

### Create Instruction with new_with_borsh

Source: https://docs.rs/solana-sdk/latest/solana_sdk/instruction/struct.Instruction.html

Example of creating an Instruction using the new_with_borsh method, which serializes a custom data structure with Borsh. Requires the 'borsh' crate feature. The example defines a MyInstruction struct with a lamports field and constructs an Instruction with program_id, data, and account metadata.

```rust
#[derive(BorshSerialize, BorshDeserialize)]
pub struct MyInstruction {
    pub lamports: u64,
}

pub fn create_instruction(
    program_id: &Pubkey,
    from: &Pubkey,
    to: &Pubkey,
    lamports: u64,
) -> Instruction {
    let instr = MyInstruction { lamports };

    Instruction::new_with_borsh(
        *program_id,
        &instr,
        vec![
            AccountMeta::new(*from, true),
            AccountMeta::new(*to, false),
        ],
   )
}
```

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

### last_chunk_mut example

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Demonstrates using last_chunk_mut to get a mutable array reference to the last N items. Returns None if the slice is shorter than N.

```rust
let x = &mut [0, 1, 2];

if let Some(last) = x.last_chunk_mut::<2>() {
    last[0] = 10;
    last[1] = 20;
}
assert_eq!(x, &[0, 10, 20]);

assert_eq!(None, x.last_chunk_mut::<4>());
```

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

### Example: partial_sort_unstable_by usage

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Shows how to use `partial_sort_unstable_by` with various ranges. Requires the nightly feature `slice_partial_sort_unstable`. Demonstrates empty ranges, single-element ranges, subrange sorting, and full-range sorting.

```rust
#![feature(slice_partial_sort_unstable)]

let mut v = [4, -5, 1, -3, 2];

// empty range at the beginning, nothing changed
v.partial_sort_unstable_by(0..0, |a, b| b.cmp(a));
assert_eq!(v, [4, -5, 1, -3, 2]);

// empty range in the middle, partitioning the slice
v.partial_sort_unstable_by(2..2, |a, b| b.cmp(a));
for i in 0..2 {
   assert!(v[i] >= v[2]);
}
for i in 3..v.len() {
  assert!(v[2] >= v[i]);
}

// single element range, same as select_nth_unstable
v.partial_sort_unstable_by(2..3, |a, b| b.cmp(a));
for i in 0..2 {
   assert!(v[i] >= v[2]);
}
for i in 3..v.len() {
  assert!(v[2] >= v[i]);
}

// partial sort a subrange
v.partial_sort_unstable_by(1..4, |a, b| b.cmp(a));
assert_eq!(&v[1..4], [2, 1, -3]);

// partial sort the whole range, same as sort_unstable
v.partial_sort_unstable_by(.., |a, b| b.cmp(a));
assert_eq!(v, [4, 2, 1, -3, -5]);
```

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

### first_chunk_mut example

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Shows how to use first_chunk_mut to get a mutable reference to the first N items of a slice. Returns None if the slice is shorter than N.

```rust
let x = &mut [0, 1, 2];

if let Some(first) = x.first_chunk_mut::<2>() {
    first[0] = 5;
    first[1] = 4;
}
assert_eq!(x, &[5, 4, 2]);

assert_eq!(None, x.first_chunk_mut::<4>());
```

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

### split_last_chunk_mut example

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Demonstrates using split_last_chunk_mut to get a mutable reference to the last N elements and the remaining slice. If the slice is shorter than N, returns None.

```rust
let x = &mut [0, 1, 2];

if let Some((elements, last)) = x.split_last_chunk_mut::<2>() {
    last[0] = 3;
    last[1] = 4;
    elements[0] = 5;
}
assert_eq!(x, &[5, 3, 4]);

assert_eq!(None, x.split_last_chunk_mut::<4>());
```

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

### Find range of matching items with partition_point

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Demonstrates using partition_point to find the whole range of matching items instead of an arbitrary match. Shows how to get the low and high bounds and verify the range.

```rust
let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];

let low = s.partition_point(|x| x < &1);
assert_eq!(low, 1);
let high = s.partition_point(|x| x <= &1);
assert_eq!(high, 5);
let r = s.binary_search(&1);
assert!((low..high).contains(&r.unwrap()));

assert!(s[..low].iter().all(|&x| x < 1));
assert!(s[low..high].iter().all(|&x| x == 1));
assert!(s[high..].iter().all(|&x| x > 1));

// For something not found, the "range" of equal items is empty
assert_eq!(s.partition_point(|x| x < &11), 9);
assert_eq!(s.partition_point(|x| x <= &11), 9);
assert_eq!(s.binary_search(&11), Err(9));
```

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

### split_last_chunk example

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Shows how to use split_last_chunk to get an array reference to the last N items and the remaining slice. Returns None if the slice is shorter than N.

```rust
let x = &[0, 1, 2];

if let Some((elements, last)) = x.split_last_chunk::<2>() {
    assert_eq!(elements, &[0]);
    assert_eq!(last, &[1, 2]);
}

assert_eq!(None, x.split_last_chunk::<4>());
```

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

### Rust example: send_initialize_tx using Transaction::try_sign

Source: https://docs.rs/solana-sdk/latest/solana_sdk/transaction/struct.Transaction.html

Example from the try_sign documentation. Uses solana_rpc_client and anyhow crates. Defines a custom BankInstruction enum and a function that creates a transaction, signs it with try_sign, and sends it via RpcClient. Requires the wincode crate feature for try_sign.

```rust
use anyhow::Result;
use borsh::{BorshSerialize, BorshDeserialize};
use solana_instruction::Instruction;
use solana_keypair::Keypair;
use solana_message::Message;
use solana_pubkey::Pubkey;
use solana_rpc_client::rpc_client::RpcClient;
use solana_signer::Signer;
use solana_transaction::Transaction;

// A custom program instruction. This would typically be defined in
// another crate so it can be shared between the on-chain program and
// the client.
#[derive(BorshSerialize, BorshDeserialize)]
enum BankInstruction {
    Initialize,
    Deposit { lamports: u64 },
    Withdraw { lamports: u64 },
}

fn send_initialize_tx(
    client: &RpcClient,
    program_id: Pubkey,
    payer: &Keypair
) -> Result<()> {

    let bank_instruction = BankInstruction::Initialize;

    let instruction = Instruction::new_with_borsh(
        program_id,
        &bank_instruction,
        vec![],
    );

    let mut tx = Transaction::new_with_payer(&[instruction], Some(&payer.pubkey()));
    let blockhash = client.get_latest_blockhash()?;
    tx.try_sign(&[payer], blockhash)?;
    client.send_and_confirm_transaction(&tx)?;

    Ok(())
}
```

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

### split_first_chunk_mut example

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Shows how to use split_first_chunk_mut to get mutable references to the first N items and the remaining slice. Returns None if the slice is shorter than N.

```rust
let x = &mut [0, 1, 2];

if let Some((first, elements)) = x.split_first_chunk_mut::<2>() {
    first[0] = 3;
    first[1] = 4;
    elements[0] = 5;
}
assert_eq!(x, &[3, 4, 5]);

assert_eq!(None, x.split_first_chunk_mut::<4>());
```

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

### capacity example: vector with capacity

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Shows how to create a vector with a specified capacity and assert that the capacity is at least that value.

```rust
let mut vec: Vec<i32> = Vec::with_capacity(10);
vec.push(42);
assert!(vec.capacity() >= 10);
```

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

### split_first_chunk example

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Shows how to use split_first_chunk to get an array reference to the first N items and the remaining slice. Returns None if the slice is shorter than N.

```rust
let x = &[0, 1, 2];

if let Some((first, elements)) = x.split_first_chunk::<2>() {
    assert_eq!(first, &[0, 1]);
    assert_eq!(elements, &[2]);
}

assert_eq!(None, x.split_first_chunk::<4>());
```

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

### strip_prefix example

Source: https://docs.rs/solana-sdk/latest/solana_sdk/slot_hashes/struct.SlotHashes.html

Demonstrates the strip_prefix method on slices. Returns Some with the subslice after the prefix if the slice starts with the prefix, otherwise None. Handles empty prefix and full match cases.

```rust
let v = &[10, 40, 30];
assert_eq!(v.strip_prefix(&[10]), Some(&[40, 30][..]));
assert_eq!(v.strip_prefix(&[10, 40]), Some(&[30][..]));
assert_eq!(v.strip_prefix(&[10, 40, 30]), Some(&[][..]));
assert_eq!(v.strip_prefix(&[50]), None);
assert_eq!(v.strip_prefix(&[10, 50]), None);

let prefix : &str = "he";
assert_eq!(b"hello".strip_prefix(prefix.as_bytes()),
           Some(b"llo".as_ref()));
```
Tokens:
Raw