Accumulator Updater Program (#712)

* feat(accumulator_updater): initial skeleton for accumulator_udpater program

Initial layout for accumulator updater program. Includes mock-cpi-caller which is meant to represent
pyth oracle(or any future allowed program) that will call the accumulator updater program. All
implementation details are open for discussion/subject to change

* test(accumulator_updater): add additional checks in tests and minor clean up

* chore(accumulator_updater): misc clean-up

* refactor(accumulator_updater): added comments & to-dos and minor refactoring to address PR comments

.pre-commit-config.yaml

@@ -58,9 +58,23 @@ repos:
         entry: cargo +nightly clippy --manifest-path ./target_chains/cosmwasm/Cargo.toml --tests --fix --allow-dirty --allow-staged -- -D warnings
         pass_filenames: false
         files: target_chains/cosmwasm
+      # Hooks for price-service/server-rust
       - id: cargo-fmt-price-service
         name: Cargo format for Rust Price Service
         language: "rust"
         entry: cargo +nightly fmt --manifest-path ./price_service/server-rust/Cargo.toml --all -- --config-path rustfmt.toml
         pass_filenames: false
         files: price_service/server-rust
+      # Hooks for accumulator updater contract
+      - id: cargo-fmt-accumulator-updater
+        name: Cargo format for accumulator updater contract
+        language: "rust"
+        entry: cargo +nightly fmt --manifest-path ./accumulator_updater/Cargo.toml --all -- --config-path rustfmt.toml
+        pass_filenames: false
+        files: accumulator_updater
+      - id: cargo-clippy-accumulator-updater
+        name: Cargo clippy for accumulator-updater contract
+        language: "rust"
+        entry: cargo +nightly clippy --manifest-path ./accumulator_updater/Cargo.toml --tests --fix --allow-dirty --allow-staged -- -D warnings
+        pass_filenames: false
+        files: accumulator_updater

accumulator_updater/.gitignore

@@ -0,0 +1,7 @@
+
+.anchor
+.DS_Store
+target
+**/*.rs.bk
+node_modules
+test-ledger

accumulator_updater/.prettierignore

@@ -0,0 +1,8 @@
+
+.anchor
+.DS_Store
+target
+node_modules
+dist
+build
+test-ledger

accumulator_updater/Anchor.toml

@@ -0,0 +1,16 @@
+[features]
+seeds = true
+skip-lint = false
+[programs.localnet]
+accumulator_updater = "Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS"
+mock_cpi_caller = "Dg5PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS"
+
+[registry]
+url = "https://api.apr.dev"
+
+[provider]
+cluster = "Localnet"
+wallet = "~/.config/solana/id.json"
+
+[scripts]
+test = "yarn run ts-mocha -p ./tsconfig.json -t 1000000 tests/**/*.ts"

accumulator_updater/Cargo.toml

@@ -0,0 +1,13 @@
+[workspace]
+members = [
+    "programs/*"
+]
+
+[profile.release]
+overflow-checks = true
+lto = "fat"
+codegen-units = 1
+[profile.release.build-override]
+opt-level = 3
+incremental = false
+codegen-units = 1

accumulator_updater/NOTES.md

@@ -0,0 +1,142 @@
+## Questions
+
+1.  Do we need to support multiple Whitelists?
+2.  Support multiple accumulators
+    1.  should each accumulator store a different type of data?
+        => implications for length of merkle proof
+    2.
+3.  authority?
+4.  how to know what went into the `AccumulatorAccount` (for deserializing/proofs)
+    1.  Header?
+
+## To Do
+
+1. map out flow for add/remove price & product (handled by xc_admin).
+2. map out flow for update price (pyth-agent)
+3. map out proposed flow for accumulator updater
+4. map out current e2e flow including client/target chain
+5. Need a way to map a combination of (PythAccountTypes, PythSchema) to the actual fields being used
+   1. e.g. (Price, Compact) => [price, expo, timestamp]
+6. Also need to be careful to preserve backwards compatibility
+   by only ever appending fields if the fields for a (PythAccountType, PythSchema) combination
+   ever change.
+   1. maybe safer to always lock the fields once they've been published and just add new schemas (e.g. a CompactV2)
+
+## Implementation Notes/Questions:
+
+1. use anchor? solitaire? vanilla solana?
+   1. for anchor, if add/delete/updateAccount should support multiple accounts at once, use Option or old `&ctx.accounts.remaining_accounts` call?
+2. should AccumulatorMapping have its own consts
+
+## Accumulator Update Flow:
+
+### Add Price Account
+
+1.  pyth-agent
+2.  `pyth-contract` - add_price() ix with price account & accumulator-updater program
+3.  cpi call to accumulator_updater `add_account` ix
+
+### Update Price Account
+
+1. pyth-agent - update_price
+2. pyth-contract - update*price ix - always tries to aggregate `if clock.slot > latest_agg_price.pub_slot*`
+3. if pyth-contract::aggregate_price
+
+### Add Price "Compact" Account
+
+## Accumulator Schema (possibly pyth-schema instead)
+
+We could have multiple derivations of the PriceAccount that need to be included in the accumulator
+ex: `PriceAccount` (full) `PriceOnly` `PriceAndEma`
+
+### Problems
+
+1. all calls to add/delete/update\_<pyth_account> need to include these (from the pyth-agent)
+   There are 2 options for how to handle/implement this:
+
+   1. manually update pyth-agent/contract. we would need to run our own pyth-agent calling `update_<pyth_account>`
+      and always running the latest version (to account for the time gap until all publishers are running
+      the latest version of pyth-agent - how realistic is this expectation?)
+   2. generate a PDA that will act as a schema. then the pyth-agent could use this programmatically determine which
+      accumulator accounts need to be passed in to
+
+      ```rust
+      #[repr(u8)]
+      enum PythSchema {
+      	full = 0,
+      	compact = 1,
+      	minimal = 2,
+      }
+      /*
+      Map: {
+          [accountType, [(accountSchema, FromFn), ...]
+      }
+      Map: {
+          (accountType, accountSchema) => accountSchema::from(accountType) = F
+      }
+       */
+      struct SchemaRegistry {
+      	/// e.g.
+      	/// Map {
+      	///     [PriceAccount,  [0,1,2]],
+      	///     [MappingAccount, [0]],
+      	///     [Product, [0,1]]
+      	/// }
+      	schema: Map<PythAccountType, Vec<PythSchema>>
+      }
+      ```
+
+      pyth-agent
+
+      ```rust
+      async fn calculate_price_accounts(price_id: Pubkey) -> Result<Vec<Pubkey>> {
+      	// this will most likely be a PDA as well.
+      	let schema_pubkey = Pubkey::from_str("<mapping_account>").unwrap();
+      	let account = *load_schema_account(
+      		rpc_client
+      		.get_account_data(&schema_pubkey)
+      		.await?
+      	)?;
+      	let schemas = account.schema.get(PythAccountType::PriceAccount)?;
+      	schemas
+      		.iter()
+      		.map(|s| Pubkey::find_program_address(
+      				[b"accumulator".as_ref(), PythAccountType::PriceAccount, s.to_le_bytes()]
+      			), &acc_mapping_pid
+      		).collect::<Vec<Pubkey>>()
+      }
+
+      ```
+
+2. how to provide these transformations/schemas for clients who get the `AccumulatorInput`?
+   1. Manually update them in the SDKs and as long as backwards compatibility is handled it should be okay if clients
+      aren't on the latest version?
+
+## Additional feedback/notes
+
+Accumulator root VAA
+
+wormhole signatures
+header to distinguish this message type from the old message format -- must be in the exact same byte position as the existing batch price attestation header
+merkle tree root hash
+chain timestamp when it was sent -- this is "attestationTimestamp" now
+slot
+Merkle Tree -- just some hashes + an account key (accumulator updater PDA) for each leaf
+-- accumulator PDA is derived from the (program, program controlled account pubkey -- "price feed id", serialization format -- just differentiates between different ways to save the "same" data).
+
+Payload
+-- header has (account id, schema)
+-- binary data entirely controlled by the program writing the data into the accumulator
+
+how do we look up a price update for a specific feed?
+You pass the price feed id + serialization format to the price service. The price service derives the accumulator PDA for the feed (it knows the oracle program address so it can do this). The price service looks at the current wormhole-attested merkle tree root and gets the slot. It then looks at the circular buffer of merkle trees in the validator to get the proof for the PDA.
+
+how do we update the target chain contracts in a backward-compatible way?
+you look at the header for the wormhole VAA
+
+how does the target chain code know that it has the price data for a specific price feed?
+
+look at the account id in the header of the data payload
+how do we ensure that a price update is timely?
+
+this is the caller of the accumulator update program's responsibility to put a timestamp in the payload.

accumulator_updater/migrations/deploy.ts

@@ -0,0 +1,12 @@
+// Migrations are an early feature. Currently, they're nothing more than this
+// single deploy script that's invoked from the CLI, injecting a provider
+// configured from the workspace's Anchor.toml.
+
+const anchor = require("@coral-xyz/anchor");
+
+module.exports = async function (provider) {
+  // Configure client to use the provider.
+  anchor.setProvider(provider);
+
+  // Add your deploy script here.
+};

accumulator_updater/package.json

@@ -0,0 +1,20 @@
+{
+  "scripts": {
+    "lint:fix": "prettier */*.js \"*/**/*{.js,.ts}\" -w",
+    "lint": "prettier */*.js \"*/**/*{.js,.ts}\" --check"
+  },
+  "dependencies": {
+    "@coral-xyz/anchor": "^0.27.0",
+    "@lumina-dev/test": "^0.0.12"
+  },
+  "devDependencies": {
+    "@types/bn.js": "^5.1.0",
+    "@types/chai": "^4.3.0",
+    "@types/mocha": "^9.0.0",
+    "chai": "^4.3.4",
+    "mocha": "^9.0.3",
+    "prettier": "^2.6.2",
+    "ts-mocha": "^10.0.0",
+    "typescript": "^4.3.5"
+  }
+}

accumulator_updater/programs/accumulator_updater/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "accumulator_updater"
+version = "0.1.0"
+description = "Accumulator Updater Pythnet Program"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+name = "accumulator_updater"
+
+[features]
+no-entrypoint = []
+no-idl = []
+no-log-ix-name = []
+cpi = ["no-entrypoint"]
+default = []
+
+[dependencies]
+anchor-lang = "0.27.0"
+# needed for the new #[account(zero_copy)] in anchor 0.27.0
+bytemuck = { version = "1.4.0", features = ["derive", "min_const_generics"]}

accumulator_updater/programs/accumulator_updater/Xargo.toml

@@ -0,0 +1,2 @@
+[target.bpfel-unknown-unknown.dependencies.std]
+features = []

accumulator_updater/programs/accumulator_updater/src/lib.rs

@@ -0,0 +1,297 @@
+mod macros;
+
+use anchor_lang::{
+    prelude::*,
+    solana_program::sysvar::{
+        self,
+        instructions::get_instruction_relative,
+    },
+    system_program::{
+        self,
+        CreateAccount,
+    },
+};
+
+declare_id!("Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS");
+
+#[program]
+pub mod accumulator_updater {
+    use super::*;
+
+    pub fn initialize(ctx: Context<Initialize>) -> Result<()> {
+        let whitelist = &mut ctx.accounts.whitelist;
+        whitelist.bump = *ctx.bumps.get("whitelist").unwrap();
+        Ok(())
+    }
+
+    //TODO: add authorization mechanism for this
+    pub fn add_allowed_program(
+        ctx: Context<AddAllowedProgram>,
+        allowed_program: Pubkey,
+    ) -> Result<()> {
+        let whitelist = &mut ctx.accounts.whitelist;
+        require_keys_neq!(allowed_program, Pubkey::default());
+        require!(
+            !whitelist.allowed_programs.contains(&allowed_program),
+            AccumulatorUpdaterError::DuplicateAllowedProgram
+        );
+        whitelist.allowed_programs.push(allowed_program);
+        Ok(())
+    }
+
+    /// Add new account(s) to be included in the accumulator
+    ///
+    /// * `base_account` - Pubkey of the original account the AccumulatorInput(s) are derived from
+    /// * `data` - Vec of AccumulatorInput account data
+    /// * `account_type` - Marker to indicate base_account account_type
+    /// * `account_schemas` - Vec of markers to indicate schemas for AccumulatorInputs. In same respective
+    ///    order as data
+    pub fn create_inputs<'info>(
+        ctx: Context<'_, '_, '_, 'info, CreateInputs<'info>>,
+        base_account: Pubkey,
+        data: Vec<Vec<u8>>,
+        account_type: u32,
+        account_schemas: Vec<u8>,
+    ) -> Result<()> {
+        let cpi_caller = ctx.accounts.whitelist_verifier.is_allowed()?;
+        let accts = ctx.remaining_accounts;
+        require_eq!(accts.len(), data.len());
+        require_eq!(data.len(), account_schemas.len());
+        let mut zip = data.into_iter().zip(account_schemas.into_iter());
+
+        let rent = Rent::get()?;
+
+        for ai in accts {
+            let (account_data, account_schema) = zip.next().unwrap();
+            let seeds = accumulator_acc_seeds!(cpi_caller, base_account, account_schema);
+            let (pda, bump) = Pubkey::find_program_address(seeds, &crate::ID);
+            require_keys_eq!(ai.key(), pda);
+
+            //TODO: Update this with serialization logic
+            let accumulator_size = 8 + AccumulatorInput::get_initial_size(&account_data);
+            let accumulator_input = AccumulatorInput::new(
+                AccumulatorHeader::new(
+                    1, //from CPI caller?
+                    account_type,
+                    account_schema,
+                ),
+                account_data,
+            );
+            CreateInputs::create_and_initialize_accumulator_input_pda(
+                ai,
+                accumulator_input,
+                accumulator_size,
+                &ctx.accounts.payer,
+                &[accumulator_acc_seeds_with_bump!(
+                    cpi_caller,
+                    base_account,
+                    account_schema,
+                    bump
+                )],
+                &rent,
+                &ctx.accounts.system_program,
+            )?;
+        }
+
+        Ok(())
+    }
+}
+
+
+// Note: purposely not making this zero_copy
+// otherwise whitelist must always be marked mutable
+// and majority of operations are read
+#[account]
+#[derive(InitSpace)]
+pub struct Whitelist {
+    pub bump:             u8,
+    #[max_len(32)]
+    pub allowed_programs: Vec<Pubkey>,
+}
+
+
+#[derive(Accounts)]
+pub struct WhitelistVerifier<'info> {
+    #[account(
+        seeds = [b"accumulator".as_ref(), b"whitelist".as_ref()],
+        bump = whitelist.bump,
+    )]
+    pub whitelist:  Account<'info, Whitelist>,
+    /// CHECK: Instruction introspection sysvar
+    #[account(address = sysvar::instructions::ID)]
+    pub ixs_sysvar: UncheckedAccount<'info>,
+}
+
+impl<'info> WhitelistVerifier<'info> {
+    pub fn get_cpi_caller(&self) -> Result<Pubkey> {
+        let instruction = get_instruction_relative(0, &self.ixs_sysvar.to_account_info())?;
+        Ok(instruction.program_id)
+    }
+    pub fn is_allowed(&self) -> Result<Pubkey> {
+        let cpi_caller = self.get_cpi_caller()?;
+        let whitelist = &self.whitelist;
+        require!(
+            whitelist.allowed_programs.contains(&cpi_caller),
+            AccumulatorUpdaterError::CallerNotAllowed
+        );
+        Ok(cpi_caller)
+    }
+}
+
+#[derive(Accounts)]
+pub struct Initialize<'info> {
+    #[account(mut)]
+    pub payer:          Signer<'info>,
+    #[account(
+        init,
+        payer = payer,
+        seeds = [b"accumulator".as_ref(), b"whitelist".as_ref()],
+        bump,
+        space = 8 + Whitelist::INIT_SPACE
+    )]
+    pub whitelist:      Account<'info, Whitelist>,
+    pub system_program: Program<'info, System>,
+}
+
+#[derive(Accounts)]
+pub struct AddAllowedProgram<'info> {
+    #[account(mut)]
+    pub payer:          Signer<'info>,
+    #[account(
+    mut,
+    seeds = [b"accumulator".as_ref(), b"whitelist".as_ref()],
+    bump = whitelist.bump,
+    )]
+    pub whitelist:      Account<'info, Whitelist>,
+    pub system_program: Program<'info, System>,
+}
+
+
+#[derive(Accounts)]
+#[instruction(base_account: Pubkey, data: Vec<Vec<u8>>, account_type: u32)] // only needed if using optional accounts
+pub struct CreateInputs<'info> {
+    #[account(mut)]
+    pub payer:              Signer<'info>,
+    pub whitelist_verifier: WhitelistVerifier<'info>,
+    pub system_program:     Program<'info, System>,
+    //TODO: decide on using optional accounts vs ctx.remaining_accounts
+    //      - optional accounts can leverage anchor macros for PDA init/verification
+    //      - ctx.remaining_accounts can be used to pass in any number of accounts
+    //
+    // https://github.com/coral-xyz/anchor/pull/2101 - anchor optional accounts PR
+    // #[account(
+    //     init,
+    //     payer = payer,
+    //     seeds = [
+    //          whitelist_verifier.get_cpi_caller()?.as_ref(),
+    //          b"accumulator".as_ref(),
+    //          base_account.as_ref()
+    //          &account_type.to_le_bytes(),
+    //      ],
+    //     bump,
+    //     space = 8 + AccumulatorAccount::get_initial_size(&data[0])
+    // )]
+    // pub acc_input_0:          Option<Account<'info, AccumulatorInput>>,
+}
+
+impl<'info> CreateInputs<'info> {
+    fn create_and_initialize_accumulator_input_pda<'a>(
+        accumulator_input_ai: &AccountInfo<'a>,
+        accumulator_input: AccumulatorInput,
+        accumulator_input_size: usize,
+        payer: &AccountInfo<'a>,
+        seeds: &[&[&[u8]]],
+        rent: &Rent,
+        system_program: &AccountInfo<'a>,
+    ) -> Result<()> {
+        let lamports = rent.minimum_balance(accumulator_input_size);
+
+        system_program::create_account(
+            CpiContext::new_with_signer(
+                system_program.to_account_info(),
+                CreateAccount {
+                    from: payer.to_account_info(),
+                    to:   accumulator_input_ai.to_account_info(),
+                },
+                seeds,
+            ),
+            lamports,
+            accumulator_input_size.try_into().unwrap(),
+            &crate::ID,
+        )?;
+
+        AccountSerialize::try_serialize(
+            &accumulator_input,
+            &mut &mut accumulator_input_ai.data.borrow_mut()[..],
+        )
+        .map_err(|e| {
+            msg!("original error: {:?}", e);
+            AccumulatorUpdaterError::SerializeError
+        })?;
+        // msg!("accumulator_input_ai: {:#?}", accumulator_input_ai);
+
+        Ok(())
+    }
+}
+
+// TODO: should UpdateInput be allowed to resize an AccumulatorInput account?
+#[derive(Accounts)]
+pub struct UpdateInputs<'info> {
+    #[account(mut)]
+    pub payer:              Signer<'info>,
+    pub whitelist_verifier: WhitelistVerifier<'info>,
+}
+
+//TODO: implement custom serialization & set alignment
+#[account]
+pub struct AccumulatorInput {
+    pub header: AccumulatorHeader,
+    //TODO: Vec<u8> for resizing?
+    pub data:   Vec<u8>,
+}
+
+impl AccumulatorInput {
+    pub fn get_initial_size(data: &Vec<u8>) -> usize {
+        AccumulatorHeader::SIZE + 4 + data.len()
+    }
+
+    pub fn new(header: AccumulatorHeader, data: Vec<u8>) -> Self {
+        Self { header, data }
+    }
+}
+
+//TODO:
+// - implement custom serialization & set alignment
+// - what other fields are needed?
+#[derive(AnchorSerialize, AnchorDeserialize, Clone, Debug, Default)]
+pub struct AccumulatorHeader {
+    pub version:        u8,
+    // u32 for parity with pyth oracle contract
+    pub account_type:   u32,
+    pub account_schema: u8,
+}
+
+
+impl AccumulatorHeader {
+    pub const SIZE: usize = 1 + 4 + 1;
+
+    pub fn new(version: u8, account_type: u32, account_schema: u8) -> Self {
+        Self {
+            version,
+            account_type,
+            account_schema,
+        }
+    }
+}
+
+#[error_code]
+pub enum AccumulatorUpdaterError {
+    #[msg("CPI Caller not allowed")]
+    CallerNotAllowed,
+    #[msg("Whitelist already contains program")]
+    DuplicateAllowedProgram,
+    #[msg("Conversion Error")]
+    ConversionError,
+    #[msg("Serialization Error")]
+    SerializeError,
+}

accumulator_updater/programs/accumulator_updater/src/macros.rs

@@ -0,0 +1,25 @@
+#[macro_export]
+macro_rules! accumulator_acc_seeds {
+    ($cpi_caller_pid:expr, $base_account:expr, $account_type:expr) => {
+        &[
+            $cpi_caller_pid.as_ref(),
+            b"accumulator".as_ref(),
+            $base_account.as_ref(),
+            &$account_type.to_le_bytes(),
+        ]
+    };
+}
+
+
+#[macro_export]
+macro_rules! accumulator_acc_seeds_with_bump {
+    ($cpi_caller_pid:expr, $base_account:expr, $account_type:expr, $bump:expr) => {
+        &[
+            $cpi_caller_pid.as_ref(),
+            b"accumulator".as_ref(),
+            $base_account.as_ref(),
+            &$account_type.to_le_bytes(),
+            &[$bump],
+        ]
+    };
+}

accumulator_updater/programs/mock-cpi-caller/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "mock-cpi-caller"
+version = "0.1.0"
+description = "Created with Anchor"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+name = "mock_cpi_caller"
+
+[features]
+no-entrypoint = []
+no-idl = []
+no-log-ix-name = []
+cpi = ["no-entrypoint"]
+default = []
+
+[dependencies]
+anchor-lang = "0.27.0"
+accumulator_updater = { path = "../accumulator_updater", features = ["cpi"] }

accumulator_updater/programs/mock-cpi-caller/Xargo.toml

@@ -0,0 +1,2 @@
+[target.bpfel-unknown-unknown.dependencies.std]
+features = []

accumulator_updater/programs/mock-cpi-caller/src/lib.rs

@@ -0,0 +1,299 @@
+use {
+    accumulator_updater::{
+        cpi::accounts as AccumulatorUpdaterCpiAccts,
+        program::AccumulatorUpdater as AccumulatorUpdaterProgram,
+    },
+    anchor_lang::{
+        prelude::*,
+        solana_program::{
+            hash::hashv,
+            sysvar,
+        },
+    },
+};
+
+declare_id!("Dg5PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS");
+
+#[program]
+pub mod mock_cpi_caller {
+    use super::*;
+
+    pub fn add_price<'info>(
+        ctx: Context<'_, '_, '_, 'info, AddPrice<'info>>,
+        params: AddPriceParams,
+    ) -> Result<()> {
+        let pyth_price_acct = &mut ctx.accounts.pyth_price_account;
+        pyth_price_acct.init(params)?;
+
+        let mut price_account_data_vec = vec![];
+        AccountSerialize::try_serialize(
+            &pyth_price_acct.clone().into_inner(),
+            &mut price_account_data_vec,
+        )?;
+
+
+        let price_only_data = PriceOnly::from(&pyth_price_acct.clone().into_inner())
+            .try_to_vec()
+            .unwrap();
+
+
+        let account_data: Vec<Vec<u8>> = vec![price_account_data_vec, price_only_data];
+        let account_schemas = [PythSchemas::Full, PythSchemas::Compact]
+            .into_iter()
+            .map(|s| s.to_u8())
+            .collect::<Vec<u8>>();
+
+        // 44444 compute units
+        // AddPrice::invoke_cpi_anchor(ctx, account_data, PythAccountType::Price, account_schemas)
+        // 44045 compute units
+        AddPrice::invoke_cpi_solana(ctx, account_data, PythAccountType::Price, account_schemas)
+    }
+}
+
+
+impl<'info> AddPrice<'info> {
+    fn create_inputs_ctx(
+        &self,
+        remaining_accounts: &[AccountInfo<'info>],
+    ) -> CpiContext<'_, '_, '_, 'info, AccumulatorUpdaterCpiAccts::CreateInputs<'info>> {
+        let mut cpi_ctx = CpiContext::new(
+            self.accumulator_program.to_account_info(),
+            AccumulatorUpdaterCpiAccts::CreateInputs {
+                payer:              self.payer.to_account_info(),
+                whitelist_verifier: AccumulatorUpdaterCpiAccts::WhitelistVerifier {
+                    whitelist:  self.accumulator_whitelist.to_account_info(),
+                    ixs_sysvar: self.ixs_sysvar.to_account_info(),
+                },
+                system_program:     self.system_program.to_account_info(),
+            },
+        );
+
+
+        cpi_ctx = cpi_ctx.with_remaining_accounts(remaining_accounts.to_vec());
+        cpi_ctx
+    }
+
+    /// invoke cpi call using anchor
+    fn invoke_cpi_anchor(
+        ctx: Context<'_, '_, '_, 'info, AddPrice<'info>>,
+        account_data: Vec<Vec<u8>>,
+        account_type: PythAccountType,
+        account_schemas: Vec<u8>,
+    ) -> Result<()> {
+        accumulator_updater::cpi::create_inputs(
+            // cpi_ctx,
+            ctx.accounts.create_inputs_ctx(ctx.remaining_accounts),
+            ctx.accounts.pyth_price_account.key(),
+            account_data,
+            account_type.to_u32(),
+            account_schemas,
+        )?;
+        Ok(())
+    }
+
+
+    /// invoke cpi call using solana
+    fn invoke_cpi_solana(
+        ctx: Context<'_, '_, '_, 'info, AddPrice<'info>>,
+        account_data: Vec<Vec<u8>>,
+        account_type: PythAccountType,
+        account_schemas: Vec<u8>,
+    ) -> Result<()> {
+        let mut accounts = vec![
+            AccountMeta::new(ctx.accounts.payer.key(), true),
+            AccountMeta::new_readonly(ctx.accounts.accumulator_whitelist.key(), false),
+            AccountMeta::new_readonly(ctx.accounts.ixs_sysvar.key(), false),
+            AccountMeta::new_readonly(ctx.accounts.system_program.key(), false),
+        ];
+        accounts.extend_from_slice(
+            &ctx.remaining_accounts
+                .iter()
+                .map(|a| AccountMeta::new(a.key(), false))
+                .collect::<Vec<_>>(),
+        );
+        let add_accumulator_input_ix = anchor_lang::solana_program::instruction::Instruction {
+            program_id: ctx.accounts.accumulator_program.key(),
+            accounts,
+            data: (
+                //anchor ix discriminator/identifier
+                sighash("global", "create_inputs"),
+                ctx.accounts.pyth_price_account.key(),
+                account_data,
+                account_type.to_u32(),
+                account_schemas,
+            )
+                .try_to_vec()
+                .unwrap(),
+        };
+        let account_infos = &mut ctx.accounts.to_account_infos();
+        account_infos.extend_from_slice(ctx.remaining_accounts);
+        anchor_lang::solana_program::program::invoke(&add_accumulator_input_ix, account_infos)?;
+        Ok(())
+    }
+}
+
+
+/// Generate discriminator to be able to call anchor program's ix
+/// * `namespace` - "global" for instructions
+/// * `name` - name of ix to call CASE-SENSITIVE
+pub fn sighash(namespace: &str, name: &str) -> [u8; 8] {
+    let preimage = format!("{namespace}:{name}");
+
+    let mut sighash = [0u8; 8];
+    sighash.copy_from_slice(&hashv(&[preimage.as_bytes()]).to_bytes()[..8]);
+    sighash
+}
+
+#[derive(AnchorSerialize, AnchorDeserialize, Clone, Debug, PartialEq, Eq)]
+pub struct AddPriceParams {
+    pub id:         u64,
+    pub price:      u64,
+    pub price_expo: u64,
+    pub ema:        u64,
+    pub ema_expo:   u64,
+}
+
+#[derive(Copy, Clone)]
+#[repr(u32)]
+pub enum PythAccountType {
+    Mapping     = 1,
+    Product     = 2,
+    Price       = 3,
+    Test        = 4,
+    Permissions = 5,
+}
+impl PythAccountType {
+    fn to_u32(&self) -> u32 {
+        *self as u32
+    }
+}
+
+#[derive(Copy, Clone)]
+#[repr(u8)]
+pub enum PythSchemas {
+    Full    = 0,
+    Compact = 1,
+    Minimal = 2,
+}
+
+impl PythSchemas {
+    fn to_u8(&self) -> u8 {
+        *self as u8
+    }
+}
+
+#[derive(Accounts)]
+#[instruction(params: AddPriceParams)]
+pub struct AddPrice<'info> {
+    #[account(
+        init,
+        payer = payer,
+        seeds = [b"pyth".as_ref(), b"price".as_ref(), &params.id.to_le_bytes()],
+        bump,
+        space = 8 + PriceAccount::INIT_SPACE
+    )]
+    pub pyth_price_account:    Account<'info, PriceAccount>,
+    #[account(mut)]
+    pub payer:                 Signer<'info>,
+    /// also needed for accumulator_updater
+    pub system_program:        Program<'info, System>,
+    /// CHECK: whitelist
+    pub accumulator_whitelist: UncheckedAccount<'info>,
+    /// CHECK: instructions introspection sysvar
+    #[account(address = sysvar::instructions::ID)]
+    pub ixs_sysvar:            UncheckedAccount<'info>,
+    pub accumulator_program:   Program<'info, AccumulatorUpdaterProgram>,
+    // Remaining Accounts
+    // should all be new uninitialized accounts
+}
+
+
+//Note: this will use anchor's default borsh serialization schema with the header
+#[account]
+#[derive(InitSpace)]
+pub struct PriceAccount {
+    pub id:         u64,
+    pub price:      u64,
+    pub price_expo: u64,
+    pub ema:        u64,
+    pub ema_expo:   u64,
+}
+
+impl PriceAccount {
+    fn init(&mut self, params: AddPriceParams) -> Result<()> {
+        self.id = params.id;
+        self.price = params.price;
+        self.price_expo = params.price_expo;
+        self.ema = params.ema;
+        self.ema_expo = params.ema_expo;
+        Ok(())
+    }
+}
+
+// #[derive(Default, Debug, borsh::BorshSerialize)]
+#[derive(AnchorSerialize, AnchorDeserialize, Default, Debug, Clone)]
+pub struct PriceOnly {
+    pub price_expo: u64,
+    pub price:      u64,
+    pub id:         u64,
+}
+
+impl PriceOnly {
+    fn serialize(&self) -> Vec<u8> {
+        self.try_to_vec().unwrap()
+    }
+
+    fn serialize_from_price_account(other: PriceAccount) -> Vec<u8> {
+        PriceOnly::from(&other).try_to_vec().unwrap()
+    }
+}
+
+
+impl From<&PriceAccount> for PriceOnly {
+    fn from(other: &PriceAccount) -> Self {
+        Self {
+            id:         other.id,
+            price:      other.price,
+            price_expo: other.price_expo,
+        }
+    }
+}
+
+
+impl From<PriceAccount> for PriceOnly {
+    fn from(other: PriceAccount) -> Self {
+        Self {
+            id:         other.id,
+            price:      other.price,
+            price_expo: other.price_expo,
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use {
+        super::*,
+        anchor_lang::InstructionData,
+    };
+
+    #[test]
+    fn ix_discriminator() {
+        let a = &(accumulator_updater::instruction::CreateInputs {
+            base_account:    anchor_lang::prelude::Pubkey::default(),
+            data:            vec![],
+            account_type:    0,
+            account_schemas: vec![],
+        }
+        .data()[..8]);
+
+        let sighash = sighash("global", "create_inputs");
+        println!(
+            r"
+            a: {a:?}
+            sighash: {sighash:?}
+            ",
+        );
+        assert_eq!(a, &sighash);
+    }
+}

accumulator_updater/tests/accumulator_updater.ts

@@ -0,0 +1,195 @@
+import * as anchor from "@coral-xyz/anchor";
+import { IdlTypes, Program, IdlAccounts } from "@coral-xyz/anchor";
+import { AccumulatorUpdater } from "../target/types/accumulator_updater";
+import { MockCpiCaller } from "../target/types/mock_cpi_caller";
+import lumina from "@lumina-dev/test";
+import { assert } from "chai";
+import { ComputeBudgetProgram } from "@solana/web3.js";
+
+// Enables tool that runs in localbrowser for easier debugging of txns
+// in this test -  https://lumina.fyi/debug
+lumina();
+
+const accumulatorUpdaterProgram = anchor.workspace
+  .AccumulatorUpdater as Program<AccumulatorUpdater>;
+const mockCpiProg = anchor.workspace.MockCpiCaller as Program<MockCpiCaller>;
+
+describe("accumulator_updater", () => {
+  // Configure the client to use the local cluster.
+  let provider = anchor.AnchorProvider.env();
+  anchor.setProvider(provider);
+
+  const [whitelistPda, whitelistBump] =
+    anchor.web3.PublicKey.findProgramAddressSync(
+      [Buffer.from("accumulator"), Buffer.from("whitelist")],
+      accumulatorUpdaterProgram.programId
+    );
+
+  it("Is initialized!", async () => {
+    // Add your test here.
+    const tx = await accumulatorUpdaterProgram.methods
+      .initialize()
+      .accounts({})
+      .rpc();
+    console.log("Your transaction signature", tx);
+
+    const whitelist = await accumulatorUpdaterProgram.account.whitelist.fetch(
+      whitelistPda
+    );
+    assert.strictEqual(whitelist.bump, whitelistBump);
+    console.info(`whitelist: ${JSON.stringify(whitelist)}`);
+  });
+
+  it("Adds a program to the whitelist", async () => {
+    const addToWhitelistTx = await accumulatorUpdaterProgram.methods
+      .addAllowedProgram(mockCpiProg.programId)
+      .accounts({})
+      .rpc();
+    const whitelist = await accumulatorUpdaterProgram.account.whitelist.fetch(
+      whitelistPda
+    );
+    console.info(`whitelist after add: ${JSON.stringify(whitelist)}`);
+
+    assert.isTrue(
+      whitelist.allowedPrograms
+        .map((pk) => pk.toString())
+        .includes(mockCpiProg.programId.toString())
+    );
+  });
+
+  it("Mock CPI program - AddPrice", async () => {
+    const addPriceParams = {
+      id: new anchor.BN(1),
+      price: new anchor.BN(2),
+      priceExpo: new anchor.BN(3),
+      ema: new anchor.BN(4),
+      emaExpo: new anchor.BN(5),
+    };
+
+    const mockCpiCallerAddPriceTxPubkeys = await mockCpiProg.methods
+      .addPrice(addPriceParams)
+      .accounts({
+        systemProgram: anchor.web3.SystemProgram.programId,
+        ixsSysvar: anchor.web3.SYSVAR_INSTRUCTIONS_PUBKEY,
+        accumulatorWhitelist: whitelistPda,
+        accumulatorProgram: accumulatorUpdaterProgram.programId,
+      })
+      .pubkeys();
+
+    const accumulatorPdas = [0, 1].map((pythSchema) => {
+      const [pda] = anchor.web3.PublicKey.findProgramAddressSync(
+        [
+          mockCpiProg.programId.toBuffer(),
+          Buffer.from("accumulator"),
+          mockCpiCallerAddPriceTxPubkeys.pythPriceAccount.toBuffer(),
+          new anchor.BN(pythSchema).toArrayLike(Buffer, "le", 1),
+        ],
+        accumulatorUpdaterProgram.programId
+      );
+      console.log(`pda for pyth schema ${pythSchema}: ${pda.toString()}`);
+      return {
+        pubkey: pda,
+        isSigner: false,
+        isWritable: true,
+      };
+      // return pda;
+    });
+
+    const mockCpiCallerAddPriceTxPrep = await mockCpiProg.methods
+      .addPrice(addPriceParams)
+      .accounts({
+        ...mockCpiCallerAddPriceTxPubkeys,
+      })
+      .remainingAccounts(accumulatorPdas)
+      .prepare();
+
+    console.log(
+      `ix: ${JSON.stringify(
+        mockCpiCallerAddPriceTxPrep.instruction,
+        (k, v) => {
+          if (k === "data") {
+            return v.toString();
+          } else {
+            return v;
+          }
+        },
+        2
+      )}`
+    );
+    for (const prop in mockCpiCallerAddPriceTxPrep.pubkeys) {
+      console.log(
+        `${prop}: ${mockCpiCallerAddPriceTxPrep.pubkeys[prop].toString()}`
+      );
+    }
+
+    const addPriceTx = await mockCpiProg.methods
+      .addPrice(addPriceParams)
+      .accounts({
+        ...mockCpiCallerAddPriceTxPubkeys,
+      })
+      .remainingAccounts(accumulatorPdas)
+      .preInstructions([
+        ComputeBudgetProgram.setComputeUnitLimit({ units: 1_000_000 }),
+      ])
+      .rpc({
+        skipPreflight: true,
+      });
+
+    console.log(`addPriceTx: ${addPriceTx}`);
+    const accumulatorInputkeys = accumulatorPdas.map((a) => a.pubkey);
+
+    const accumulatorInputs =
+      await accumulatorUpdaterProgram.account.accumulatorInput.fetchMultiple(
+        accumulatorInputkeys
+      );
+
+    const accumulatorPriceAccounts = accumulatorInputs.map((ai) => {
+      const { header, data } = ai;
+
+      return parseAccumulatorInput(ai);
+    });
+    console.log(
+      `accumulatorPriceAccounts: ${JSON.stringify(
+        accumulatorPriceAccounts,
+        null,
+        2
+      )}`
+    );
+    accumulatorPriceAccounts.forEach((pa) => {
+      assert.isTrue(pa.id.eq(addPriceParams.id));
+      assert.isTrue(pa.price.eq(addPriceParams.price));
+      assert.isTrue(pa.priceExpo.eq(addPriceParams.priceExpo));
+    });
+  });
+});
+
+type AccumulatorInputHeader = IdlTypes<AccumulatorUpdater>["AccumulatorHeader"];
+type AccumulatorInputPriceAccountTypes =
+  | IdlAccounts<MockCpiCaller>["priceAccount"] // case-sensitive
+  | IdlTypes<MockCpiCaller>["PriceOnly"];
+
+// Parses AccumulatorInput.data into a PriceAccount or PriceOnly object based on the
+// accountType and accountSchema.
+//
+// AccumulatorInput.data for AccumulatorInput<PriceAccount> will
+// have mockCpiCaller::PriceAccount.discriminator()
+// AccumulatorInput<PriceOnly> will not since its not an account
+function parseAccumulatorInput({
+  header,
+  data,
+}: {
+  header: AccumulatorInputHeader;
+  data: Buffer;
+}): AccumulatorInputPriceAccountTypes {
+  console.log(`header: ${JSON.stringify(header)}`);
+  assert.strictEqual(header.accountType, 3);
+  if (header.accountSchema === 0) {
+    console.log(`[full]data: ${data.toString("hex")}`);
+    // case-sensitive. Note that "P" is capitalized here and not in
+    // the AccumulatorInputPriceAccountTypes type alias.
+    return mockCpiProg.coder.accounts.decode("PriceAccount", data);
+  } else {
+    console.log(`[compact]data: ${data.toString("hex")}`);
+    return mockCpiProg.coder.types.decode("PriceOnly", data);
+  }
+}

accumulator_updater/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "types": ["mocha", "chai"],
+    "typeRoots": ["./node_modules/@types"],
+    "lib": ["es2015"],
+    "module": "commonjs",
+    "target": "es6",
+    "esModuleInterop": true
+  }
+}