star_frame 0.30.0

A high performance Solana framework for building fast, scalable, and secure smart contracts.
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

//! Core program definitions and utilities for Star Frame programs. Provides the foundational traits and macros needed to define and execute Solana programs with type safety.

pub mod system;

use crate::prelude::*;

pub use star_frame_proc::StarFrameProgram;

/// A Solana program's definition and the main entrypoint in to a Star Frame program. This should be derived using the [`StarFrameProgram`](derive@StarFrameProgram) macro,
/// since it does more than just implement this trait.
pub trait StarFrameProgram {
    /// The instruction set used by this program.
    type InstructionSet: InstructionSet;

    type AccountDiscriminant: Pod + Eq;

    const ID: Pubkey;

    /// Handles errors returned from the program and then returns a [`ProgramError`].
    ///
    /// By default, it logs the error with [`Error::log`].
    #[inline]
    #[must_use]
    fn handle_error(error: Error) -> ProgramError {
        error.log();
        error.into()
    }

    /// The entrypoint for the program which calls in to [`InstructionSet::dispatch`] on [`Self::InstructionSet`]. This has the same signature as the Solana program entrypoint, and
    /// is called by [`star_frame_entrypoint`](crate::star_frame_entrypoint) macro.
    #[allow(clippy::inline_always)]
    #[inline(always)]
    fn entrypoint(
        program_id: &'static pinocchio::pubkey::Pubkey,
        accounts: &[AccountInfo],
        instruction_data: &[u8],
    ) -> ProgramResult {
        let program_id = bytemuck::cast_ref(program_id);
        Self::InstructionSet::dispatch(program_id, accounts, instruction_data)
            .map_err(Self::handle_error)
    }
}

/// Defines useful top level items for a `star_frame` program.
///
/// This is called by the [`StarFrameProgram`](star_frame_proc::StarFrameProgram) derive macro.
#[macro_export]
macro_rules! program_setup {
    ($program:ty) => {
        #[allow(dead_code)]
        pub type StarFrameDeclaredProgram = $program;

        #[doc = r" The const program ID."]
        pub const ID: $crate::prelude::Pubkey = <$program as $crate::program::StarFrameProgram>::ID;

        #[doc = r" Returns `true` if given pubkey is the program ID."]
        pub fn check_id(id: &$crate::prelude::Pubkey) -> bool {
            id == &ID
        }

        #[doc = r" Returns the program ID."]
        pub const fn id() -> $crate::prelude::Pubkey {
            ID
        }

        #[test]
        fn test_id() {
            assert!(check_id(&id()));
        }
    };
}