switchboard-on-demand 0.9.1

A Rust library to interact with the Switchboard Solana program.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

#[cfg(feature = "anchor")]
use anchor_lang::solana_program;
#[cfg(not(feature = "anchor"))]
use crate::solana_program;
use solana_program::pubkey::Pubkey;

fn derive_lookup_table_address(authority_address: &Pubkey, recent_block_slot: u64) -> (Pubkey, u8) {
    use crate::on_demand::ADDRESS_LOOKUP_TABLE_PROGRAM_ID;
    Pubkey::find_program_address(
        &[authority_address.as_ref(), &recent_block_slot.to_le_bytes()],
        &ADDRESS_LOOKUP_TABLE_PROGRAM_ID.to_bytes().into(),
    )
}

use crate::{cfg_client, utils, ON_DEMAND_DEVNET_PID, ON_DEMAND_MAINNET_PID};

const LUT_SIGNER_SEED: &[u8] = b"LutSigner";

/// Finds the address lookup table signer PDA for a given key
pub fn find_lut_signer(k: &Pubkey) -> Pubkey {
    let pid = if utils::is_devnet() {
        ON_DEMAND_DEVNET_PID
    } else {
        ON_DEMAND_MAINNET_PID
    };
    Pubkey::find_program_address(&[LUT_SIGNER_SEED, k.as_ref()], &pid).0
}

/// Derives the address lookup table address for a given key and slot
pub fn find_lut_of(k: &Pubkey, lut_slot: u64) -> Pubkey {
    derive_lookup_table_address(k, lut_slot).0
    // Pubkey::find_program_address(
    // &[find_lut_signer(k).as_ref(), lut_slot.to_le_bytes().as_ref()],
    // &LUT_PROGRAM_ID,
    // )
    // .0
}

cfg_client! {
    use crate::OnDemandError;
    use anchor_client::solana_client::nonblocking::rpc_client::RpcClient;
    use spl_associated_token_account::solana_program::address_lookup_table::state::AddressLookupTable;
    use spl_associated_token_account::solana_program::address_lookup_table::AddressLookupTableAccount;

    pub async fn fetch(client: &RpcClient, address: &Pubkey) -> Result<AddressLookupTableAccount, OnDemandError> {
        let converted_address: anchor_client::solana_sdk::pubkey::Pubkey = address.to_bytes().into();
        let account = client.get_account_data(&converted_address)
            .await
            .map_err(|_| OnDemandError::AddressLookupTableFetchError)?;
        let lut = AddressLookupTable::deserialize(&account)
            .map_err(|_| OnDemandError::AddressLookupTableDeserializeError)?;
        let out = AddressLookupTableAccount {
            key: address.to_bytes().into(),
            addresses: lut.addresses.iter().cloned().collect(),
        };
        Ok(out)
    }
}