2019-04-04 12:01:09 -07:00
|
|
|
use crate::account::{Account, KeyedAccount};
|
2019-03-23 20:12:27 -07:00
|
|
|
use crate::instruction::InstructionError;
|
2018-12-14 20:39:10 -08:00
|
|
|
use crate::pubkey::Pubkey;
|
2019-04-04 12:01:09 -07:00
|
|
|
use bincode::ErrorKind;
|
2019-04-25 10:29:44 -07:00
|
|
|
use num_traits::FromPrimitive;
|
2018-11-13 18:17:32 -08:00
|
|
|
|
|
|
|
// All native programs export a symbol named process()
|
|
|
|
pub const ENTRYPOINT: &str = "process";
|
|
|
|
|
|
|
|
// Native program ENTRYPOINT prototype
|
2018-11-17 17:02:14 -08:00
|
|
|
pub type Entrypoint = unsafe extern "C" fn(
|
|
|
|
program_id: &Pubkey,
|
|
|
|
keyed_accounts: &mut [KeyedAccount],
|
|
|
|
data: &[u8],
|
|
|
|
tick_height: u64,
|
2019-03-18 09:05:03 -07:00
|
|
|
) -> Result<(), InstructionError>;
|
2018-11-13 18:38:51 -08:00
|
|
|
|
|
|
|
// Convenience macro to define the native program entrypoint. Supply a fn to this macro that
|
|
|
|
// conforms to the `Entrypoint` type signature.
|
|
|
|
#[macro_export]
|
|
|
|
macro_rules! solana_entrypoint(
|
|
|
|
($entrypoint:ident) => (
|
|
|
|
#[no_mangle]
|
2018-11-17 17:02:14 -08:00
|
|
|
pub extern "C" fn process(
|
2019-03-21 13:36:25 -07:00
|
|
|
program_id: &solana_sdk::pubkey::Pubkey,
|
|
|
|
keyed_accounts: &mut [solana_sdk::account::KeyedAccount],
|
2018-11-17 17:02:14 -08:00
|
|
|
data: &[u8],
|
|
|
|
tick_height: u64
|
2019-03-23 20:12:27 -07:00
|
|
|
) -> Result<(), solana_sdk::instruction::InstructionError> {
|
2018-12-03 13:32:31 -08:00
|
|
|
$entrypoint(program_id, keyed_accounts, data, tick_height)
|
2018-11-13 18:38:51 -08:00
|
|
|
}
|
2019-04-30 15:11:08 -07:00
|
|
|
)
|
|
|
|
);
|
|
|
|
|
|
|
|
#[macro_export]
|
|
|
|
macro_rules! solana_program_id(
|
|
|
|
($program_id:ident) => (
|
|
|
|
|
|
|
|
pub fn check_id(program_id: &solana_sdk::pubkey::Pubkey) -> bool {
|
|
|
|
program_id.as_ref() == $program_id
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn id() -> solana_sdk::pubkey::Pubkey {
|
|
|
|
solana_sdk::pubkey::Pubkey::new(&$program_id)
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
#[test]
|
|
|
|
fn test_program_id() {
|
|
|
|
assert!(check_id(&id()));
|
|
|
|
}
|
2018-11-13 18:38:51 -08:00
|
|
|
)
|
|
|
|
);
|
2019-04-04 12:01:09 -07:00
|
|
|
|
|
|
|
/// Conveinence trait to covert bincode errors to instruction errors.
|
|
|
|
pub trait State<T> {
|
|
|
|
fn state(&self) -> Result<T, InstructionError>;
|
|
|
|
fn set_state(&mut self, state: &T) -> Result<(), InstructionError>;
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<T> State<T> for Account
|
|
|
|
where
|
|
|
|
T: serde::Serialize + serde::de::DeserializeOwned,
|
|
|
|
{
|
|
|
|
fn state(&self) -> Result<T, InstructionError> {
|
|
|
|
self.deserialize_data()
|
|
|
|
.map_err(|_| InstructionError::InvalidAccountData)
|
|
|
|
}
|
|
|
|
fn set_state(&mut self, state: &T) -> Result<(), InstructionError> {
|
|
|
|
self.serialize_data(state).map_err(|err| match *err {
|
|
|
|
ErrorKind::SizeLimit => InstructionError::AccountDataTooSmall,
|
|
|
|
_ => InstructionError::GenericError,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a, T> State<T> for KeyedAccount<'a>
|
|
|
|
where
|
|
|
|
T: serde::Serialize + serde::de::DeserializeOwned,
|
|
|
|
{
|
|
|
|
fn state(&self) -> Result<T, InstructionError> {
|
|
|
|
self.account.state()
|
|
|
|
}
|
|
|
|
fn set_state(&mut self, state: &T) -> Result<(), InstructionError> {
|
|
|
|
self.account.set_state(state)
|
|
|
|
}
|
|
|
|
}
|
2019-04-25 10:29:44 -07:00
|
|
|
|
|
|
|
pub trait DecodeError<E> {
|
|
|
|
fn decode_custom_error_to_enum(int: u32) -> Option<E>
|
|
|
|
where
|
|
|
|
E: FromPrimitive,
|
|
|
|
{
|
|
|
|
E::from_u32(int)
|
|
|
|
}
|
|
|
|
fn type_of(&self) -> &'static str;
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use super::*;
|
|
|
|
use num_derive::FromPrimitive;
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_decode_custom_error_to_enum() {
|
|
|
|
#[derive(Debug, FromPrimitive, PartialEq)]
|
|
|
|
enum TestEnum {
|
|
|
|
A,
|
|
|
|
B,
|
|
|
|
C,
|
|
|
|
}
|
|
|
|
impl<T> DecodeError<T> for TestEnum {
|
|
|
|
fn type_of(&self) -> &'static str {
|
|
|
|
"TestEnum"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
assert_eq!(TestEnum::decode_custom_error_to_enum(0), Some(TestEnum::A));
|
|
|
|
assert_eq!(TestEnum::decode_custom_error_to_enum(1), Some(TestEnum::B));
|
|
|
|
assert_eq!(TestEnum::decode_custom_error_to_enum(2), Some(TestEnum::C));
|
|
|
|
let option: Option<TestEnum> = TestEnum::decode_custom_error_to_enum(3);
|
|
|
|
assert_eq!(option, None);
|
|
|
|
}
|
|
|
|
}
|