switchboard-on-demand 0.5.6

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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

#[cfg(feature = "anchor")]
use anchor_lang::solana_program;
// AccountInfo only needed for Rust fallback (which is cfg-gated)
use anyhow::Error as AnyhowError;
use crate::sysvar::ed25519_sysvar::{Ed25519Sysvar, ParsedEd25519SignatureDataRef};
use solana_sdk_ids::ed25519_program::ID as ED25519_PROGRAM_ID;
use solana_sdk_ids::sysvar::instructions::ID as INSTRUCTIONS_SYSVAR_ID;

const ED25519_PROGRAM_ID_U64_PTR: *const u64 = &ED25519_PROGRAM_ID.to_bytes()[0] as *const u8 as *const u64;
const INSTRUCTIONS_SYSVAR_ID_U64_PTR: *const u64 = &INSTRUCTIONS_SYSVAR_ID.to_bytes()[0] as *const u8 as *const u64;

extern "C" {
    #[cfg(target_os = "solana")]
    fn write_instruction_0_data_asm_extern(base_ptr: *const u8, dst_ptr: *mut u8, dst_len: usize) -> u16;
}

#[derive(Copy, Clone, Default, serde::Serialize, serde::Deserialize)]
pub struct Instructions;

#[cfg(feature = "anchor")]
impl anchor_lang::solana_program::sysvar::SysvarId for Instructions {
    fn id() -> solana_program::pubkey::Pubkey {
        solana_program::sysvar::instructions::id().to_bytes().into()
    }

    fn check_id(id: &solana_program::pubkey::Pubkey) -> bool {
        solana_program::sysvar::instructions::id() == id.to_bytes().into()
    }
}
#[cfg(feature = "anchor")]
impl anchor_lang::solana_program::sysvar::Sysvar for Instructions {
    // override
    fn size_of() -> usize {
        // hard-coded so that we don't have to construct an empty
        0 // golden, update if MAX_ENTRIES changes
    }
    fn from_account_info(
        _account_info: &anchor_lang::prelude::AccountInfo,
    ) -> Result<Self, solana_program::program_error::ProgramError> {
        Ok(Self {})
    }
}

impl Instructions {

    #[inline(always)]
    pub fn write_instruction_0_data(data: &[u8], dst: &mut [u8]) -> u16 {
        unsafe {
            let base = data.as_ptr();
            let p = base.add((base.add(2) as *const u16).read_unaligned() as usize);
            let _ = 1u8 / (*p | *p.add(1) == 0) as u8; // trap if non-zero
            let pid_ptr = p.add(2) as *const u64;
            assert_eq!(pid_ptr.read_unaligned(), ED25519_PROGRAM_ID_U64_PTR.read_unaligned());
            assert_eq!(pid_ptr.add(1).read_unaligned(), ED25519_PROGRAM_ID_U64_PTR.add(1).read_unaligned());
            assert_eq!(pid_ptr.add(2).read_unaligned(), ED25519_PROGRAM_ID_U64_PTR.add(2).read_unaligned());
            assert_eq!(pid_ptr.add(3).read_unaligned(), ED25519_PROGRAM_ID_U64_PTR.add(3).read_unaligned());

            let len = min_branchless((p.add(34) as *const u16).read_unaligned(), dst.len() as u16);
            solana_define_syscall::definitions::sol_memcpy_(dst.as_mut_ptr(), p.add(36), len as u64);
            len
        }
    }

    #[inline(always)]
    pub fn write_ix_0_from_account_info(
        account_info: &solana_program::account_info::AccountInfo,
        dst: &mut [u8],
    ) -> u16 {
        unsafe {
            let ix_id_ptr = account_info.key.as_ref().as_ptr() as *const u64;
            assert_eq!(ix_id_ptr.read_unaligned(), INSTRUCTIONS_SYSVAR_ID_U64_PTR.read_unaligned());
            assert_eq!(ix_id_ptr.add(1).read_unaligned(), INSTRUCTIONS_SYSVAR_ID_U64_PTR.add(1).read_unaligned());
            assert_eq!(ix_id_ptr.add(2).read_unaligned(), INSTRUCTIONS_SYSVAR_ID_U64_PTR.add(2).read_unaligned());
            assert_eq!(ix_id_ptr.add(3).read_unaligned(), INSTRUCTIONS_SYSVAR_ID_U64_PTR.add(3).read_unaligned());
            let ix_data = &account_info.data.borrow();
            Self::write_instruction_0_data(ix_data, dst)
        }
    }
}

#[inline(always)]
fn min_branchless(a: u16, b: u16) -> u16 {
    // mask = 0xFFFF if a < b, else 0x0000
    let mask = ((a < b) as u16).wrapping_neg();
    (a & mask) | (b & !mask)
}