Rust/del publisher (#237)

* Simplistic trait

* Remove irrelevant file

* Rename

* Delete

* Add functions to initialize tests

* Restore rust oracle

* Add comment

* Upd product uses the new syntax

* Formatted

* Implemented

* Add test

* Prune oracle

* Lint

* Delete

* Update memset

Author: guibescos

program/c/src/oracle/oracle.c

@@ -107,54 +107,6 @@ static uint64_t init_price( SolParameters *prm, SolAccountInfo *ka )
   return SUCCESS;
 }
 
-// remove publisher from price node
-static uint64_t del_publisher( SolParameters *prm, SolAccountInfo *ka )
-{
-  // Validate command parameters
-  cmd_del_publisher_t *cptr = (cmd_del_publisher_t*)prm->data;
-  if ( prm->data_len != sizeof( cmd_del_publisher_t ) ||
-       pc_pub_key_is_zero( &cptr->pub_ ) ) {
-    return ERROR_INVALID_ARGUMENT;
-  }
-
-  // Account (1) is the price account
-  // Verify that this is signed, writable with correct ownership
-  // and size
-  if ( prm->ka_num != 2 ||
-       !valid_funding_account( &ka[0] ) ||
-       !valid_signable_account( prm, &ka[1], sizeof( pc_price_t ) ) ) {
-    return ERROR_INVALID_ARGUMENT;
-  }
-
-  // Verify that symbol account is initialized and corresponds to the
-  // same symbol and price-type in the instruction parameters
-  pc_price_t *sptr = (pc_price_t*)ka[1].data;
-  if ( sptr->magic_ != PC_MAGIC ||
-       sptr->ver_ != cptr->ver_ ||
-       sptr->type_ != PC_ACCTYPE_PRICE ) {
-    return ERROR_INVALID_ARGUMENT;
-  }
-
-  // try to remove publisher
-  for(uint32_t i=0; i != sptr->num_; ++i ) {
-    pc_price_comp_t *iptr = &sptr->comp_[i];
-    if ( pc_pub_key_equal( &iptr->pub_, &cptr->pub_ ) ) {
-      for( unsigned j=i+1; j != sptr->num_; ++j ) {
-        pc_price_comp_t *jptr = &sptr->comp_[j];
-        iptr[0] = jptr[0];
-        iptr = jptr;
-      }
-      --sptr->num_;
-      sol_memset( iptr, 0, sizeof( pc_price_comp_t ) );
-      // update size of account
-      sptr->size_ = sizeof( pc_price_t ) - sizeof( sptr->comp_ ) +
-        sptr->num_ * sizeof( pc_price_comp_t );
-      return SUCCESS;
-    }
-  }
-  return ERROR_INVALID_ARGUMENT;
-}
-
 static uint64_t upd_price( SolParameters *prm, SolAccountInfo *ka )
 {
   // Validate command parameters
@@ -259,7 +211,7 @@ static uint64_t dispatch( SolParameters *prm, SolAccountInfo *ka )
     case e_cmd_upd_product:                return ERROR_INVALID_ARGUMENT;
     case e_cmd_add_price:                  return ERROR_INVALID_ARGUMENT;
     case e_cmd_add_publisher:              return ERROR_INVALID_ARGUMENT;
-    case e_cmd_del_publisher:              return del_publisher( prm, ka );
+    case e_cmd_del_publisher:              return ERROR_INVALID_ARGUMENT;
     case e_cmd_init_price:                 return init_price( prm, ka );
     case e_cmd_init_test:                  return ERROR_INVALID_ARGUMENT;
     case e_cmd_upd_test:                   return ERROR_INVALID_ARGUMENT;

program/c/src/oracle/test_oracle.c

@@ -371,84 +371,3 @@ Test( oracle, upd_aggregate ) {
   cr_assert( px->prev_conf_ == prev_conf_ );
   cr_assert( px->prev_timestamp_ == prev_timestamp_ );
 }
-
-Test( oracle, del_publisher ) {
-  pc_price_info_t p1 = { .price_=100, .conf_=10,
-    .status_ = PC_STATUS_TRADING, .pub_slot_ = 42 };
-  pc_price_info_t p2 = { .price_=200, .conf_=20,
-    .status_ = PC_STATUS_TRADING, .pub_slot_ = 42 };
-
-  // start with perfect inputs
-  pc_pub_key_t p_id = { .k8_ = { 1, 2, 3, 4 } };
-  pc_pub_key_t p_id2= { .k8_ = { 2, 3, 4, 5 } };
-  pc_pub_key_t p_id3= { .k8_ = { 3, 4, 5, 6 } };
-  cmd_add_publisher_t idata = {
-    .ver_   = PC_VERSION,
-    .cmd_   = e_cmd_del_publisher,
-    .pub_   = p_id2
-  };
-  SolPubkey pkey = {.x = { 1, }};
-  SolPubkey skey = {.x = { 3, }};
-  uint64_t pqty = 100;
-  pc_price_t sptr[1];
-  sol_memset( sptr, 0, sizeof( pc_price_t ) );
-  sptr->magic_ = PC_MAGIC;
-  sptr->ver_ = PC_VERSION;
-  sptr->ptype_ = PC_PTYPE_PRICE;
-  sptr->type_ = PC_ACCTYPE_PRICE;
-  sptr->num_ = 1;
-  sptr->comp_[0].latest_ = p1;
-  pc_pub_key_assign( &sptr->comp_[0].pub_, (pc_pub_key_t*)&p_id2 );
-
-  SolAccountInfo acc[] = {{
-      .key         = &pkey,
-      .lamports    = &pqty,
-      .data_len    = 0,
-      .data        = NULL,
-      .owner       = NULL,
-      .rent_epoch  = 0,
-      .is_signer   = true,
-      .is_writable = true,
-      .executable  = false
-  },{
-      .key         = &skey,
-      .lamports    = &PRICE_ACCOUNT_LAMPORTS,
-      .data_len    = sizeof( pc_price_t ),
-      .data        = (uint8_t*)sptr,
-      .owner       = (SolPubkey*)&p_id,
-      .rent_epoch  = 0,
-      .is_signer   = true,
-      .is_writable = true,
-      .executable  = false
-  } };
-  SolParameters prm = {
-    .ka         = acc,
-    .ka_num     = 2,
-    .data       = (const uint8_t*)&idata,
-    .data_len   = sizeof( idata ),
-    .program_id = (SolPubkey*)&p_id
-  };
-  cr_assert( SUCCESS == dispatch( &prm, acc ) );
-  cr_assert( sptr->num_ == 0 );
-  cr_assert( sptr->comp_[0].latest_.status_ == 0 );
-
-  sptr->num_ = 2;
-  sptr->comp_[0].latest_ = p1;
-  sptr->comp_[1].latest_ = p2;
-  pc_pub_key_assign( &sptr->comp_[0].pub_, (pc_pub_key_t*)&p_id2 );
-  pc_pub_key_assign( &sptr->comp_[1].pub_, (pc_pub_key_t*)&p_id3 );
-  cr_assert( SUCCESS == dispatch( &prm, acc ) );
-  cr_assert( sptr->num_ == 1 );
-  cr_assert( sptr->comp_[0].latest_.price_ == p2.price_ );
-  cr_assert( sptr->comp_[1].latest_.status_ == 0 );
-
-  sptr->num_ = 2;
-  sptr->comp_[0].latest_ = p1;
-  sptr->comp_[1].latest_ = p2;
-  pc_pub_key_assign( &sptr->comp_[0].pub_, (pc_pub_key_t*)&p_id3 );
-  pc_pub_key_assign( &sptr->comp_[1].pub_, (pc_pub_key_t*)&p_id2 );
-  cr_assert( SUCCESS == dispatch( &prm, acc ) );
-  cr_assert( sptr->num_ == 1 );
-  cr_assert( sptr->comp_[0].latest_.price_ == p1.price_ );
-  cr_assert( sptr->comp_[1].latest_.status_ == 0 );
-}

program/rust/src/c_oracle_header.rs

@@ -52,16 +52,6 @@ impl PythAccount for pc_price_t {
     const INITIAL_SIZE: u32 = PC_PRICE_T_COMP_OFFSET as u32;
 }
 
-impl pc_pub_key_t {
-    pub fn new_unique() -> pc_pub_key_t {
-        let solana_unique = Pubkey::new_unique();
-        pc_pub_key_t {
-            k1_: solana_unique.to_bytes(),
-        }
-    }
-}
-
-
 #[cfg(target_endian = "little")]
 unsafe impl Zeroable for pc_acc {
 }
@@ -143,6 +133,13 @@ unsafe impl Pod for cmd_add_publisher_t {
 }
 
 #[cfg(target_endian = "little")]
+unsafe impl Zeroable for cmd_del_publisher_t {
+}
+
+#[cfg(target_endian = "little")]
+unsafe impl Pod for cmd_del_publisher_t {
+}
+
 unsafe impl Zeroable for cmd_set_min_pub_t {
 }
 
@@ -166,3 +163,12 @@ unsafe impl Zeroable for pc_price_comp_t {
 #[cfg(target_endian = "little")]
 unsafe impl Pod for pc_price_comp_t {
 }
+
+impl pc_pub_key_t {
+    pub fn new_unique() -> pc_pub_key_t {
+        let solana_unique = Pubkey::new_unique();
+        pc_pub_key_t {
+            k1_: solana_unique.to_bytes(),
+        }
+    }
+}

program/rust/src/processor.rs

@@ -10,6 +10,7 @@ use crate::c_oracle_header::{
     command_t_e_cmd_add_product,
     command_t_e_cmd_add_publisher,
     command_t_e_cmd_agg_price,
+    command_t_e_cmd_del_publisher,
     command_t_e_cmd_init_mapping,
     command_t_e_cmd_set_min_pub,
     command_t_e_cmd_upd_account_version,
@@ -28,6 +29,7 @@ use crate::rust_oracle::{
     add_price,
     add_product,
     add_publisher,
+    del_publisher,
     init_mapping,
     set_min_pub,
     upd_product,
@@ -66,6 +68,7 @@ pub fn process_instruction(
         command_t_e_cmd_init_mapping => init_mapping(program_id, accounts, instruction_data),
         command_t_e_cmd_add_mapping => add_mapping(program_id, accounts, instruction_data),
         command_t_e_cmd_add_publisher => add_publisher(program_id, accounts, instruction_data),
+        command_t_e_cmd_del_publisher => del_publisher(program_id, accounts, instruction_data),
         command_t_e_cmd_add_product => add_product(program_id, accounts, instruction_data),
         command_t_e_cmd_upd_product => upd_product(program_id, accounts, instruction_data),
         command_t_e_cmd_set_min_pub => set_min_pub(program_id, accounts, instruction_data),

program/rust/src/rust_oracle.rs

@@ -22,6 +22,7 @@ use solana_program::rent::Rent;
 use crate::c_oracle_header::{
     cmd_add_price_t,
     cmd_add_publisher_t,
+    cmd_del_publisher_t,
     cmd_hdr_t,
     cmd_set_min_pub_t,
     cmd_upd_product_t,
@@ -221,6 +222,54 @@ pub fn add_publisher(
             + price_data.num_ * try_convert::<_, u32>(size_of::<pc_price_comp>())?;
     Ok(SUCCESS)
 }
+
+/// add a publisher to a price account
+/// accounts[0] funding account                                   [signer writable]
+/// accounts[1] price account to delete the publisher from        [signer writable]
+pub fn del_publisher(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> OracleResult {
+    let cmd_args = load::<cmd_del_publisher_t>(instruction_data)?;
+
+    pyth_assert(
+        instruction_data.len() == size_of::<cmd_del_publisher_t>()
+            && !pubkey_is_zero(&cmd_args.pub_),
+        ProgramError::InvalidArgument,
+    )?;
+
+    let [funding_account, price_account] = match accounts {
+        [x, y] => Ok([x, y]),
+        _ => Err(ProgramError::InvalidArgument),
+    }?;
+
+    check_valid_funding_account(funding_account)?;
+    check_valid_signable_account(program_id, price_account, size_of::<pc_price_t>())?;
+
+    let mut price_data = load_checked::<pc_price_t>(price_account, cmd_args.ver_)?;
+
+    for i in 0..(price_data.num_ as usize) {
+        if pubkey_equal(&cmd_args.pub_, bytes_of(&price_data.comp_[i].pub_)) {
+            for j in i + 1..(price_data.num_ as usize) {
+                price_data.comp_[j - 1] = price_data.comp_[j];
+            }
+            price_data.num_ -= 1;
+            let current_index: usize = try_convert(price_data.num_)?;
+            sol_memset(
+                bytes_of_mut(&mut price_data.comp_[current_index]),
+                0,
+                size_of::<pc_price_comp>(),
+            );
+            price_data.size_ =
+                try_convert::<_, u32>(size_of::<pc_price_t>() - size_of_val(&price_data.comp_))?
+                    + price_data.num_ * try_convert::<_, u32>(size_of::<pc_price_comp>())?;
+            return Ok(SUCCESS);
+        }
+    }
+    Err(ProgramError::InvalidArgument)
+}
+
 pub fn add_product(
     program_id: &Pubkey,
     accounts: &[AccountInfo],

program/rust/src/tests/mod.rs

@@ -2,6 +2,7 @@ mod test_add_mapping;
 mod test_add_price;
 mod test_add_product;
 mod test_add_publisher;
+mod test_del_publisher;
 mod test_init_mapping;
 mod test_set_min_pub;
 mod test_upd_product;