refactor: split processor

Author: Reisen

program/rust/src/lib.rs

@@ -11,7 +11,6 @@ mod deserialize;
 mod error;
 mod instruction;
 mod processor;
-mod rust_oracle;
 mod time_machine_types;
 mod utils;
 

program/rust/src/processor.rs

@@ -5,23 +5,6 @@ use {
             load_command_header_checked,
             OracleCommand,
         },
-        rust_oracle::{
-            add_mapping,
-            add_price,
-            add_product,
-            add_publisher,
-            del_price,
-            del_product,
-            del_publisher,
-            init_mapping,
-            init_price,
-            resize_price_account,
-            set_min_pub,
-            upd_permissions,
-            upd_price,
-            upd_price_no_fail_on_error,
-            upd_product,
-        },
     },
     solana_program::{
         entrypoint::ProgramResult,
@@ -30,34 +13,68 @@ use {
     },
 };
 
+mod add_mapping;
+mod add_price;
+mod add_product;
+mod add_publisher;
+mod del_price;
+mod del_product;
+mod del_publisher;
+mod init_mapping;
+mod init_price;
+mod resize_price_account;
+mod set_min_pub;
+mod upd_permissions;
+mod upd_price;
+mod upd_product;
+
+pub use {
+    add_mapping::add_mapping,
+    add_price::add_price,
+    add_product::add_product,
+    add_publisher::add_publisher,
+    del_price::del_price,
+    del_product::del_product,
+    del_publisher::del_publisher,
+    init_mapping::init_mapping,
+    init_price::init_price,
+    resize_price_account::resize_price_account,
+    set_min_pub::set_min_pub,
+    upd_permissions::upd_permissions,
+    upd_price::{
+        c_upd_aggregate,
+        upd_price,
+        upd_price_no_fail_on_error,
+    },
+    upd_product::upd_product,
+};
+
 /// Dispatch to the right instruction in the oracle.
 pub fn process_instruction(
     program_id: &Pubkey,
     accounts: &[AccountInfo],
     instruction_data: &[u8],
 ) -> ProgramResult {
+    use OracleCommand::*;
+
     match load_command_header_checked(instruction_data)? {
-        OracleCommand::InitMapping => init_mapping(program_id, accounts, instruction_data),
-        OracleCommand::AddMapping => add_mapping(program_id, accounts, instruction_data),
-        OracleCommand::AddProduct => add_product(program_id, accounts, instruction_data),
-        OracleCommand::UpdProduct => upd_product(program_id, accounts, instruction_data),
-        OracleCommand::AddPrice => add_price(program_id, accounts, instruction_data),
-        OracleCommand::AddPublisher => add_publisher(program_id, accounts, instruction_data),
-        OracleCommand::DelPublisher => del_publisher(program_id, accounts, instruction_data),
-        OracleCommand::UpdPrice => upd_price(program_id, accounts, instruction_data),
-        OracleCommand::AggPrice => upd_price(program_id, accounts, instruction_data),
-        OracleCommand::InitPrice => init_price(program_id, accounts, instruction_data),
-        OracleCommand::InitTest => Err(OracleError::UnrecognizedInstruction.into()),
-        OracleCommand::UpdTest => Err(OracleError::UnrecognizedInstruction.into()),
-        OracleCommand::SetMinPub => set_min_pub(program_id, accounts, instruction_data),
-        OracleCommand::UpdPriceNoFailOnError => {
-            upd_price_no_fail_on_error(program_id, accounts, instruction_data)
-        }
-        OracleCommand::ResizePriceAccount => {
-            resize_price_account(program_id, accounts, instruction_data)
-        }
-        OracleCommand::DelPrice => del_price(program_id, accounts, instruction_data),
-        OracleCommand::DelProduct => del_product(program_id, accounts, instruction_data),
-        OracleCommand::UpdPermissions => upd_permissions(program_id, accounts, instruction_data),
+        InitMapping => init_mapping(program_id, accounts, instruction_data),
+        AddMapping => add_mapping(program_id, accounts, instruction_data),
+        AddProduct => add_product(program_id, accounts, instruction_data),
+        UpdProduct => upd_product(program_id, accounts, instruction_data),
+        AddPrice => add_price(program_id, accounts, instruction_data),
+        AddPublisher => add_publisher(program_id, accounts, instruction_data),
+        DelPublisher => del_publisher(program_id, accounts, instruction_data),
+        UpdPrice => upd_price(program_id, accounts, instruction_data),
+        AggPrice => upd_price(program_id, accounts, instruction_data),
+        InitPrice => init_price(program_id, accounts, instruction_data),
+        InitTest => Err(OracleError::UnrecognizedInstruction.into()),
+        UpdTest => Err(OracleError::UnrecognizedInstruction.into()),
+        SetMinPub => set_min_pub(program_id, accounts, instruction_data),
+        UpdPriceNoFailOnError => upd_price_no_fail_on_error(program_id, accounts, instruction_data),
+        ResizePriceAccount => resize_price_account(program_id, accounts, instruction_data),
+        DelPrice => del_price(program_id, accounts, instruction_data),
+        DelProduct => del_product(program_id, accounts, instruction_data),
+        UpdPermissions => upd_permissions(program_id, accounts, instruction_data),
     }
 }

program/rust/src/processor/add_mapping.rs

@@ -0,0 +1,68 @@
+use {
+    crate::{
+        accounts::{
+            MappingAccount,
+            PythAccount,
+        },
+        c_oracle_header::PC_MAP_TABLE_SIZE,
+        deserialize::{
+            load,
+            load_checked,
+        },
+        instruction::CommandHeader,
+        utils::{
+            check_valid_funding_account,
+            check_valid_signable_account_or_permissioned_funding_account,
+            pyth_assert,
+        },
+        OracleError,
+    },
+    solana_program::{
+        account_info::AccountInfo,
+        entrypoint::ProgramResult,
+        program_error::ProgramError,
+        pubkey::Pubkey,
+    },
+};
+
+pub fn add_mapping(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> ProgramResult {
+    let (funding_account, cur_mapping, next_mapping, permissions_account_option) = match accounts {
+        [x, y, z] => Ok((x, y, z, None)),
+        [x, y, z, p] => Ok((x, y, z, Some(p))),
+        _ => Err(OracleError::InvalidNumberOfAccounts),
+    }?;
+
+    let hdr = load::<CommandHeader>(instruction_data)?;
+
+    check_valid_funding_account(funding_account)?;
+    check_valid_signable_account_or_permissioned_funding_account(
+        program_id,
+        cur_mapping,
+        funding_account,
+        permissions_account_option,
+        hdr,
+    )?;
+    check_valid_signable_account_or_permissioned_funding_account(
+        program_id,
+        next_mapping,
+        funding_account,
+        permissions_account_option,
+        hdr,
+    )?;
+
+    let mut cur_mapping = load_checked::<MappingAccount>(cur_mapping, hdr.version)?;
+    pyth_assert(
+        cur_mapping.number_of_products == PC_MAP_TABLE_SIZE
+            && cur_mapping.next_mapping_account == Pubkey::default(),
+        ProgramError::InvalidArgument,
+    )?;
+
+    MappingAccount::initialize(next_mapping, hdr.version)?;
+    cur_mapping.next_mapping_account = *next_mapping.key;
+
+    Ok(())
+}

program/rust/src/processor/add_price.rs

@@ -0,0 +1,82 @@
+use {
+    crate::{
+        accounts::{
+            PriceAccount,
+            ProductAccount,
+            PythAccount,
+        },
+        c_oracle_header::PC_PTYPE_UNKNOWN,
+        deserialize::{
+            load,
+            load_checked,
+        },
+        instruction::AddPriceArgs,
+        utils::{
+            check_exponent_range,
+            check_valid_funding_account,
+            check_valid_signable_account_or_permissioned_funding_account,
+            pyth_assert,
+        },
+        OracleError,
+    },
+    solana_program::{
+        account_info::AccountInfo,
+        entrypoint::ProgramResult,
+        program_error::ProgramError,
+        pubkey::Pubkey,
+    },
+};
+
+/// Add a price account to a product account
+/// accounts[0] funding account                                   [signer writable]
+/// accounts[1] product account to add the price account to       [signer writable]
+/// accounts[2] newly created price account                       [signer writable]
+pub fn add_price(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> ProgramResult {
+    let cmd_args = load::<AddPriceArgs>(instruction_data)?;
+
+    check_exponent_range(cmd_args.exponent)?;
+    pyth_assert(
+        cmd_args.price_type != PC_PTYPE_UNKNOWN,
+        ProgramError::InvalidArgument,
+    )?;
+
+
+    let (funding_account, product_account, price_account, permissions_account_option) =
+        match accounts {
+            [x, y, z] => Ok((x, y, z, None)),
+            [x, y, z, p] => Ok((x, y, z, Some(p))),
+            _ => Err(OracleError::InvalidNumberOfAccounts),
+        }?;
+
+    check_valid_funding_account(funding_account)?;
+    check_valid_signable_account_or_permissioned_funding_account(
+        program_id,
+        product_account,
+        funding_account,
+        permissions_account_option,
+        &cmd_args.header,
+    )?;
+    check_valid_signable_account_or_permissioned_funding_account(
+        program_id,
+        price_account,
+        funding_account,
+        permissions_account_option,
+        &cmd_args.header,
+    )?;
+
+    let mut product_data =
+        load_checked::<ProductAccount>(product_account, cmd_args.header.version)?;
+
+    let mut price_data = PriceAccount::initialize(price_account, cmd_args.header.version)?;
+    price_data.exponent = cmd_args.exponent;
+    price_data.price_type = cmd_args.price_type;
+    price_data.product_account = *product_account.key;
+    price_data.next_price_account = product_data.first_price_account;
+    product_data.first_price_account = *price_account.key;
+
+    Ok(())
+}

program/rust/src/processor/add_product.rs

@@ -0,0 +1,83 @@
+use {
+    crate::{
+        accounts::{
+            MappingAccount,
+            ProductAccount,
+            PythAccount,
+        },
+        c_oracle_header::PC_MAP_TABLE_SIZE,
+        deserialize::{
+            load,
+            load_checked,
+        },
+        instruction::CommandHeader,
+        utils::{
+            check_valid_funding_account,
+            check_valid_signable_account_or_permissioned_funding_account,
+            pyth_assert,
+            try_convert,
+        },
+        OracleError,
+    },
+    solana_program::{
+        account_info::AccountInfo,
+        entrypoint::ProgramResult,
+        program_error::ProgramError,
+        pubkey::Pubkey,
+    },
+    std::mem::{
+        size_of,
+        size_of_val,
+    },
+};
+
+pub fn add_product(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> ProgramResult {
+    let (funding_account, tail_mapping_account, new_product_account, permissions_account_option) =
+        match accounts {
+            [x, y, z] => Ok((x, y, z, None)),
+            [x, y, z, p] => Ok((x, y, z, Some(p))),
+            _ => Err(OracleError::InvalidNumberOfAccounts),
+        }?;
+
+    let hdr = load::<CommandHeader>(instruction_data)?;
+
+    check_valid_funding_account(funding_account)?;
+    check_valid_signable_account_or_permissioned_funding_account(
+        program_id,
+        tail_mapping_account,
+        funding_account,
+        permissions_account_option,
+        hdr,
+    )?;
+    check_valid_signable_account_or_permissioned_funding_account(
+        program_id,
+        new_product_account,
+        funding_account,
+        permissions_account_option,
+        hdr,
+    )?;
+
+
+    let mut mapping_data = load_checked::<MappingAccount>(tail_mapping_account, hdr.version)?;
+    // The mapping account must have free space to add the product account
+    pyth_assert(
+        mapping_data.number_of_products < PC_MAP_TABLE_SIZE,
+        ProgramError::InvalidArgument,
+    )?;
+
+    ProductAccount::initialize(new_product_account, hdr.version)?;
+
+    let current_index: usize = try_convert(mapping_data.number_of_products)?;
+    mapping_data.products_list[current_index] = *new_product_account.key;
+    mapping_data.number_of_products += 1;
+    mapping_data.header.size = try_convert::<_, u32>(
+        size_of::<MappingAccount>() - size_of_val(&mapping_data.products_list),
+    )? + mapping_data.number_of_products
+        * try_convert::<_, u32>(size_of::<Pubkey>())?;
+
+    Ok(())
+}