diff --git a/program/rust/Cargo.toml b/program/rust/Cargo.toml
index 8681d5b54..3994f6d23 100644
--- a/program/rust/Cargo.toml
+++ b/program/rust/Cargo.toml
@@ -19,6 +19,7 @@ num-traits = "0.2"
 solana-program-test = "=1.10.29"
 solana-sdk = "=1.10.29"
 tokio = "1.14.1"
+hex = "0.3.1"
 
 [features]
 debug = []
diff --git a/program/rust/src/c_oracle_header.rs b/program/rust/src/c_oracle_header.rs
index 1d34c9456..aecc1924c 100644
--- a/program/rust/src/c_oracle_header.rs
+++ b/program/rust/src/c_oracle_header.rs
@@ -82,9 +82,9 @@ pub struct PriceAccount {
     pub unused_2_:          i16,
     pub unused_3_:          i32,
     /// Corresponding product account
-    pub product_account:    CPubkey,
+    pub product_account:    Pubkey,
     /// Next price account in the list
-    pub next_price_account: CPubkey,
+    pub next_price_account: Pubkey,
     /// Second to last slot where aggregation was succesful (i.e. status : TRADING)
     pub prev_slot_:         u64,
     /// Aggregate price at prev_slot_
@@ -102,7 +102,7 @@ pub struct PriceAccount {
 #[repr(C)]
 #[derive(Copy, Clone, Pod, Zeroable)]
 pub struct PriceComponent {
-    pub pub_:    CPubkey,
+    pub pub_:    Pubkey,
     pub agg_:    PriceInfo,
     pub latest_: PriceInfo,
 }
@@ -138,7 +138,7 @@ pub struct AccountHeader {
 #[derive(Copy, Clone, Pod, Zeroable)]
 pub struct ProductAccount {
     pub header:              AccountHeader,
-    pub first_price_account: CPubkey,
+    pub first_price_account: Pubkey,
 }
 
 #[repr(C)]
@@ -147,35 +147,12 @@ pub struct MappingAccount {
     pub header:               AccountHeader,
     pub number_of_products:   u32,
     pub unused_:              u32,
-    pub next_mapping_account: CPubkey,
-    pub products_list:        [CPubkey; PC_MAP_TABLE_SIZE as usize],
+    pub next_mapping_account: Pubkey,
+    pub products_list:        [Pubkey; PC_MAP_TABLE_SIZE as usize],
 }
 
-// Unsafe impl because CPubkey is a union
-unsafe impl Pod for CPubkey {
-}
-unsafe impl Zeroable for CPubkey {
-}
-
-
 // Unsafe impl because product_list is of size 640 and there's no derived trait for this size
 unsafe impl Pod for MappingAccount {
 }
 unsafe impl Zeroable for MappingAccount {
 }
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub union CPubkey {
-    pub k1_: [u8; 32usize],
-    pub k8_: [u64; 4usize],
-}
-
-impl CPubkey {
-    pub fn new_unique() -> CPubkey {
-        let solana_unique = Pubkey::new_unique();
-        CPubkey {
-            k1_: solana_unique.to_bytes(),
-        }
-    }
-}
diff --git a/program/rust/src/instruction.rs b/program/rust/src/instruction.rs
index ceba0d60a..6a03afded 100644
--- a/program/rust/src/instruction.rs
+++ b/program/rust/src/instruction.rs
@@ -1,7 +1,4 @@
-use crate::c_oracle_header::{
-    CPubkey,
-    PC_VERSION,
-};
+use crate::c_oracle_header::PC_VERSION;
 use crate::deserialize::load;
 use crate::error::OracleError;
 use bytemuck::{
@@ -13,6 +10,7 @@ use num_derive::{
     ToPrimitive,
 };
 use num_traits::FromPrimitive;
+use solana_program::pubkey::Pubkey;
 
 /// WARNING : NEW COMMANDS SHOULD BE ADDED AT THE END OF THE LIST
 #[repr(i32)]
@@ -122,7 +120,7 @@ pub type InitPriceArgs = AddPriceArgs;
 #[derive(Zeroable, Pod, Copy, Clone)]
 pub struct AddPublisherArgs {
     pub header:    CommandHeader,
-    pub publisher: CPubkey,
+    pub publisher: Pubkey,
 }
 
 pub type DelPublisherArgs = AddPublisherArgs;
diff --git a/program/rust/src/rust_oracle.rs b/program/rust/src/rust_oracle.rs
index 82f1a6254..f20e9f541 100644
--- a/program/rust/src/rust_oracle.rs
+++ b/program/rust/src/rust_oracle.rs
@@ -4,7 +4,6 @@ use std::mem::{
 };
 
 use crate::c_oracle_header::{
-    CPubkey,
     MappingAccount,
     PriceAccount,
     PriceComponent,
@@ -42,19 +41,12 @@ use crate::utils::{
     check_valid_signable_account,
     check_valid_writable_account,
     is_component_update,
-    pubkey_assign,
-    pubkey_clear,
-    pubkey_equal,
-    pubkey_is_zero,
     pyth_assert,
     read_pc_str_t,
     try_convert,
 };
 use crate::OracleError;
-use bytemuck::{
-    bytes_of,
-    bytes_of_mut,
-};
+use bytemuck::bytes_of_mut;
 use solana_program::account_info::AccountInfo;
 use solana_program::clock::Clock;
 use solana_program::entrypoint::ProgramResult;
@@ -209,15 +201,12 @@ pub fn add_mapping(
     let mut cur_mapping = load_checked::<MappingAccount>(cur_mapping, hdr.version)?;
     pyth_assert(
         cur_mapping.number_of_products == PC_MAP_TABLE_SIZE
-            && pubkey_is_zero(&cur_mapping.next_mapping_account),
+            && cur_mapping.next_mapping_account == Pubkey::default(),
         ProgramError::InvalidArgument,
     )?;
 
     initialize_pyth_account_checked::<MappingAccount>(next_mapping, hdr.version)?;
-    pubkey_assign(
-        &mut cur_mapping.next_mapping_account,
-        &next_mapping.key.to_bytes(),
-    );
+    cur_mapping.next_mapping_account = *next_mapping.key;
 
     Ok(())
 }
@@ -252,10 +241,7 @@ pub fn upd_price(
 
         // Verify that publisher is authorized
         while publisher_index < price_data.num_ as usize {
-            if pubkey_equal(
-                &price_data.comp_[publisher_index].pub_,
-                &funding_account.key.to_bytes(),
-            ) {
+            if price_data.comp_[publisher_index].pub_ == *funding_account.key {
                 break;
             }
             publisher_index += 1;
@@ -369,18 +355,9 @@ pub fn add_price(
         initialize_pyth_account_checked::<PriceAccount>(price_account, cmd_args.header.version)?;
     price_data.exponent = cmd_args.exponent;
     price_data.price_type = cmd_args.price_type;
-    pubkey_assign(
-        &mut price_data.product_account,
-        &product_account.key.to_bytes(),
-    );
-    pubkey_assign(
-        &mut price_data.next_price_account,
-        bytes_of(&product_data.first_price_account),
-    );
-    pubkey_assign(
-        &mut product_data.first_price_account,
-        &price_account.key.to_bytes(),
-    );
+    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(())
 }
@@ -411,22 +388,16 @@ pub fn del_price(
         let mut product_data = load_checked::<ProductAccount>(product_account, cmd_args.version)?;
         let price_data = load_checked::<PriceAccount>(price_account, cmd_args.version)?;
         pyth_assert(
-            pubkey_equal(
-                &product_data.first_price_account,
-                &price_account.key.to_bytes(),
-            ),
+            product_data.first_price_account == *price_account.key,
             ProgramError::InvalidArgument,
         )?;
 
         pyth_assert(
-            pubkey_equal(&price_data.product_account, &product_account.key.to_bytes()),
+            price_data.product_account == *product_account.key,
             ProgramError::InvalidArgument,
         )?;
 
-        pubkey_assign(
-            &mut product_data.first_price_account,
-            bytes_of(&price_data.next_price_account),
-        );
+        product_data.first_price_account = price_data.next_price_account;
     }
 
     // Zero out the balance of the price account to delete it.
@@ -514,7 +485,7 @@ pub fn add_publisher(
 
     pyth_assert(
         instruction_data.len() == size_of::<AddPublisherArgs>()
-            && !pubkey_is_zero(&cmd_args.publisher),
+            && cmd_args.publisher != Pubkey::default(),
         ProgramError::InvalidArgument,
     )?;
 
@@ -533,7 +504,7 @@ pub fn add_publisher(
     }
 
     for i in 0..(price_data.num_ as usize) {
-        if pubkey_equal(&cmd_args.publisher, bytes_of(&price_data.comp_[i].pub_)) {
+        if cmd_args.publisher == price_data.comp_[i].pub_ {
             return Err(ProgramError::InvalidArgument);
         }
     }
@@ -544,10 +515,7 @@ pub fn add_publisher(
         0,
         size_of::<PriceComponent>(),
     );
-    pubkey_assign(
-        &mut price_data.comp_[current_index].pub_,
-        bytes_of(&cmd_args.publisher),
-    );
+    price_data.comp_[current_index].pub_ = cmd_args.publisher;
     price_data.num_ += 1;
     price_data.header.size =
         try_convert::<_, u32>(size_of::<PriceAccount>() - size_of_val(&price_data.comp_))?
@@ -567,7 +535,7 @@ pub fn del_publisher(
 
     pyth_assert(
         instruction_data.len() == size_of::<DelPublisherArgs>()
-            && !pubkey_is_zero(&cmd_args.publisher),
+            && cmd_args.publisher != Pubkey::default(),
         ProgramError::InvalidArgument,
     )?;
 
@@ -582,7 +550,7 @@ pub fn del_publisher(
     let mut price_data = load_checked::<PriceAccount>(price_account, cmd_args.header.version)?;
 
     for i in 0..(price_data.num_ as usize) {
-        if pubkey_equal(&cmd_args.publisher, bytes_of(&price_data.comp_[i].pub_)) {
+        if cmd_args.publisher == price_data.comp_[i].pub_ {
             for j in i + 1..(price_data.num_ as usize) {
                 price_data.comp_[j - 1] = price_data.comp_[j];
             }
@@ -632,15 +600,12 @@ pub fn add_product(
     initialize_pyth_account_checked::<ProductAccount>(new_product_account, hdr.version)?;
 
     let current_index: usize = try_convert(mapping_data.number_of_products)?;
-    pubkey_assign(
-        &mut mapping_data.products_list[current_index],
-        bytes_of(&new_product_account.key.to_bytes()),
-    );
+    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::<CPubkey>())?;
+        * try_convert::<_, u32>(size_of::<Pubkey>())?;
 
     Ok(())
 }
@@ -763,15 +728,15 @@ pub fn del_product(
             ProgramError::InvalidArgument,
         )?;
         pyth_assert(
-            pubkey_is_zero(&product_data.first_price_account),
+            product_data.first_price_account == Pubkey::default(),
             ProgramError::InvalidArgument,
         )?;
 
-        let product_key = product_account.key.to_bytes();
+        let product_key = product_account.key;
         let product_index = mapping_data
             .products_list
             .iter()
-            .position(|x| pubkey_equal(x, &product_key))
+            .position(|x| *x == *product_key)
             .ok_or(ProgramError::InvalidArgument)?;
 
         let num_after_removal: usize = try_convert(
@@ -782,16 +747,13 @@ pub fn del_product(
         )?;
 
         let last_key_bytes = mapping_data.products_list[num_after_removal];
-        pubkey_assign(
-            &mut mapping_data.products_list[product_index],
-            bytes_of(&last_key_bytes),
-        );
-        pubkey_clear(&mut mapping_data.products_list[num_after_removal]);
+        mapping_data.products_list[product_index] = last_key_bytes;
+        mapping_data.products_list[num_after_removal] = Pubkey::default();
         mapping_data.number_of_products = try_convert::<_, u32>(num_after_removal)?;
         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::<CPubkey>())?;
+            * try_convert::<_, u32>(size_of::<Pubkey>())?;
     }
 
     // Zero out the balance of the price account to delete it.
diff --git a/program/rust/src/tests/test_add_mapping.rs b/program/rust/src/tests/test_add_mapping.rs
index c88e171d6..ac56f969b 100644
--- a/program/rust/src/tests/test_add_mapping.rs
+++ b/program/rust/src/tests/test_add_mapping.rs
@@ -15,12 +15,7 @@ use crate::instruction::{
 };
 use crate::processor::process_instruction;
 use crate::tests::test_utils::AccountSetup;
-use crate::utils::{
-    clear_account,
-    pubkey_assign,
-    pubkey_equal,
-    pubkey_is_zero,
-};
+use crate::utils::clear_account;
 use bytemuck::bytes_of;
 use solana_program::program_error::ProgramError;
 use solana_program::pubkey::Pubkey;
@@ -64,15 +59,9 @@ fn test_add_mapping() {
         let mut cur_mapping_data =
             load_checked::<MappingAccount>(&cur_mapping, PC_VERSION).unwrap();
 
-        assert!(pubkey_equal(
-            &cur_mapping_data.next_mapping_account,
-            &next_mapping.key.to_bytes()
-        ));
-        assert!(pubkey_is_zero(&next_mapping_data.next_mapping_account));
-        pubkey_assign(
-            &mut cur_mapping_data.next_mapping_account,
-            &Pubkey::default().to_bytes(),
-        );
+        assert!(cur_mapping_data.next_mapping_account == *next_mapping.key);
+        assert!(next_mapping_data.next_mapping_account == Pubkey::default());
+        cur_mapping_data.next_mapping_account = Pubkey::default();
         cur_mapping_data.number_of_products = 0;
     }
 
@@ -94,7 +83,7 @@ fn test_add_mapping() {
     {
         let mut cur_mapping_data =
             load_checked::<MappingAccount>(&cur_mapping, PC_VERSION).unwrap();
-        assert!(pubkey_is_zero(&cur_mapping_data.next_mapping_account));
+        assert!(cur_mapping_data.next_mapping_account == Pubkey::default());
         cur_mapping_data.number_of_products = PC_MAP_TABLE_SIZE;
         cur_mapping_data.header.magic_number = 0;
     }
diff --git a/program/rust/src/tests/test_add_price.rs b/program/rust/src/tests/test_add_price.rs
index 29994f9bb..882ae74bc 100644
--- a/program/rust/src/tests/test_add_price.rs
+++ b/program/rust/src/tests/test_add_price.rs
@@ -16,11 +16,7 @@ use crate::instruction::{
 };
 use crate::processor::process_instruction;
 use crate::tests::test_utils::AccountSetup;
-use crate::utils::{
-    clear_account,
-    pubkey_equal,
-    pubkey_is_zero,
-};
+use crate::utils::clear_account;
 use bytemuck::bytes_of;
 use solana_program::program_error::ProgramError;
 use solana_program::pubkey::Pubkey;
@@ -82,15 +78,9 @@ fn test_add_price() {
         let product_data = load_checked::<ProductAccount>(&product_account, PC_VERSION).unwrap();
         assert_eq!(price_data.exponent, 1);
         assert_eq!(price_data.price_type, 1);
-        assert!(pubkey_equal(
-            &price_data.product_account,
-            &product_account.key.to_bytes()
-        ));
-        assert!(pubkey_is_zero(&price_data.next_price_account));
-        assert!(pubkey_equal(
-            &product_data.first_price_account,
-            &price_account.key.to_bytes()
-        ));
+        assert!(price_data.product_account == *product_account.key);
+        assert!(price_data.next_price_account == Pubkey::default());
+        assert!(product_data.first_price_account == *price_account.key);
     }
 
     assert!(process_instruction(
@@ -109,18 +99,9 @@ fn test_add_price() {
         let product_data = load_checked::<ProductAccount>(&product_account, PC_VERSION).unwrap();
         assert_eq!(price_data_2.exponent, 1);
         assert_eq!(price_data_2.price_type, 1);
-        assert!(pubkey_equal(
-            &price_data_2.product_account,
-            &product_account.key.to_bytes()
-        ));
-        assert!(pubkey_equal(
-            &price_data_2.next_price_account,
-            &price_account.key.to_bytes()
-        ));
-        assert!(pubkey_equal(
-            &product_data.first_price_account,
-            &price_account_2.key.to_bytes()
-        ));
+        assert!(price_data_2.product_account == *product_account.key);
+        assert!(price_data_2.next_price_account == *price_account.key);
+        assert!(product_data.first_price_account == *price_account_2.key);
     }
 
     // Wrong number of accounts
diff --git a/program/rust/src/tests/test_add_product.rs b/program/rust/src/tests/test_add_product.rs
index e894bf0b4..4698a284c 100644
--- a/program/rust/src/tests/test_add_product.rs
+++ b/program/rust/src/tests/test_add_product.rs
@@ -22,10 +22,7 @@ use crate::instruction::{
 };
 use crate::processor::process_instruction;
 use crate::tests::test_utils::AccountSetup;
-use crate::utils::{
-    clear_account,
-    pubkey_equal,
-};
+use crate::utils::clear_account;
 use bytemuck::bytes_of;
 use solana_program::account_info::AccountInfo;
 use solana_program::clock::Epoch;
@@ -78,10 +75,7 @@ fn test_add_product() {
             mapping_data.header.size,
             (MappingAccount::INITIAL_SIZE + 32)
         );
-        assert!(pubkey_equal(
-            &mapping_data.products_list[0],
-            &product_account.key.to_bytes()
-        ));
+        assert!(mapping_data.products_list[0] == *product_account.key);
     }
 
     assert!(process_instruction(
@@ -101,10 +95,7 @@ fn test_add_product() {
             mapping_data.header.size,
             (MappingAccount::INITIAL_SIZE + 2 * 32)
         );
-        assert!(pubkey_equal(
-            &mapping_data.products_list[1],
-            &product_account_2.key.to_bytes()
-        ));
+        assert!(mapping_data.products_list[1] == *product_account_2.key);
     }
 
     // invalid account size
diff --git a/program/rust/src/tests/test_add_publisher.rs b/program/rust/src/tests/test_add_publisher.rs
index 91c4ccfd6..7b8a2da74 100644
--- a/program/rust/src/tests/test_add_publisher.rs
+++ b/program/rust/src/tests/test_add_publisher.rs
@@ -1,5 +1,4 @@
 use crate::c_oracle_header::{
-    CPubkey,
     PriceAccount,
     PriceComponent,
     PythAccount,
@@ -16,10 +15,7 @@ use crate::instruction::{
 };
 use crate::processor::process_instruction;
 use crate::tests::test_utils::AccountSetup;
-use crate::utils::{
-    clear_account,
-    pubkey_equal,
-};
+use crate::utils::clear_account;
 use crate::OracleError;
 use bytemuck::bytes_of;
 use solana_program::program_error::ProgramError;
@@ -30,7 +26,7 @@ use std::mem::size_of;
 #[test]
 fn test_add_publisher() {
     let program_id = Pubkey::new_unique();
-    let publisher = CPubkey::new_unique();
+    let publisher = Pubkey::new_unique();
 
     let mut cmd = AddPublisherArgs {
         header: OracleCommand::AddPublisher.into(),
@@ -77,10 +73,7 @@ fn test_add_publisher() {
             price_data.header.size,
             PriceAccount::INITIAL_SIZE + (size_of::<PriceComponent>() as u32)
         );
-        assert!(pubkey_equal(
-            &price_data.comp_[0].pub_,
-            bytes_of(&publisher)
-        ));
+        assert!(price_data.comp_[0].pub_ == publisher);
     }
 
     // Can't add twice
@@ -109,7 +102,7 @@ fn test_add_publisher() {
 
     //Fill up price node
     for i in 0..PC_COMP_SIZE {
-        cmd.publisher = CPubkey::new_unique();
+        cmd.publisher = Pubkey::new_unique();
         instruction_data = bytes_of::<AddPublisherArgs>(&cmd);
         assert!(process_instruction(
             &program_id,
@@ -122,10 +115,7 @@ fn test_add_publisher() {
         {
             let price_data = load_checked::<PriceAccount>(&price_account, PC_VERSION).unwrap();
             assert_eq!(price_data.num_, i + 1);
-            assert!(pubkey_equal(
-                &price_data.comp_[i as usize].pub_,
-                bytes_of(&cmd.publisher)
-            ));
+            assert!(price_data.comp_[i as usize].pub_ == cmd.publisher);
             assert_eq!(
                 price_data.header.size,
                 PriceAccount::INITIAL_SIZE + (size_of::<PriceComponent>() as u32) * (i + 1)
@@ -133,7 +123,7 @@ fn test_add_publisher() {
         }
     }
 
-    cmd.publisher = CPubkey::new_unique();
+    cmd.publisher = Pubkey::new_unique();
     instruction_data = bytes_of::<AddPublisherArgs>(&cmd);
     assert_eq!(
         process_instruction(
diff --git a/program/rust/src/tests/test_del_price.rs b/program/rust/src/tests/test_del_price.rs
index baf4a61da..7fa91887f 100644
--- a/program/rust/src/tests/test_del_price.rs
+++ b/program/rust/src/tests/test_del_price.rs
@@ -1,8 +1,8 @@
+use solana_program::pubkey::Pubkey;
 use solana_sdk::signer::Signer;
 
 use crate::c_oracle_header::ProductAccount;
 use crate::tests::pyth_simulator::PythSimulator;
-use crate::utils::pubkey_is_zero;
 
 #[tokio::test]
 async fn test_del_price() {
@@ -31,7 +31,7 @@ async fn test_del_price() {
         .get_account_data_as::<ProductAccount>(product1.pubkey())
         .await
         .unwrap();
-    assert!(pubkey_is_zero(&product1_data.first_price_account));
+    assert!(product1_data.first_price_account == Pubkey::default());
 
 
     // price2_1 is the 2nd item in the linked list since price2_2 got added after t.
@@ -48,5 +48,5 @@ async fn test_del_price() {
         .await
         .unwrap();
 
-    assert!(pubkey_is_zero(&product2_data.first_price_account));
+    assert!(product2_data.first_price_account == Pubkey::default());
 }
diff --git a/program/rust/src/tests/test_del_product.rs b/program/rust/src/tests/test_del_product.rs
index 5cbe6fa0a..586cb94f6 100644
--- a/program/rust/src/tests/test_del_product.rs
+++ b/program/rust/src/tests/test_del_product.rs
@@ -6,12 +6,9 @@ use std::mem::{
 use solana_program::pubkey::Pubkey;
 use solana_sdk::signer::Signer;
 
-use crate::c_oracle_header::{
-    CPubkey,
-    MappingAccount,
-};
+use crate::c_oracle_header::MappingAccount;
 use crate::tests::pyth_simulator::PythSimulator;
-use crate::utils::pubkey_equal;
+
 
 #[tokio::test]
 async fn test_del_product() {
@@ -78,13 +75,13 @@ fn mapping_product_list_equals(mapping_data: &MappingAccount, expected: Vec<Pubk
     }
 
     let expected_size = (size_of::<MappingAccount>() - size_of_val(&mapping_data.products_list)
-        + expected.len() * size_of::<CPubkey>()) as u32;
+        + expected.len() * size_of::<Pubkey>()) as u32;
     if mapping_data.header.size != expected_size {
         return false;
     }
 
     for i in 0..expected.len() {
-        if !pubkey_equal(&mapping_data.products_list[i], &expected[i].to_bytes()) {
+        if mapping_data.products_list[i] != expected[i] {
             return false;
         }
     }
diff --git a/program/rust/src/tests/test_del_publisher.rs b/program/rust/src/tests/test_del_publisher.rs
index 1b8402d58..80749a406 100644
--- a/program/rust/src/tests/test_del_publisher.rs
+++ b/program/rust/src/tests/test_del_publisher.rs
@@ -1,5 +1,4 @@
 use crate::c_oracle_header::{
-    CPubkey,
     PriceAccount,
     PriceComponent,
     PriceInfo,
@@ -18,12 +17,6 @@ use crate::instruction::{
 };
 use crate::processor::process_instruction;
 use crate::tests::test_utils::AccountSetup;
-use crate::utils::{
-    pubkey_assign,
-    pubkey_equal,
-    pubkey_is_zero,
-};
-use bytemuck::bytes_of;
 use solana_program::pubkey::Pubkey;
 use std::mem::size_of;
 
@@ -46,8 +39,8 @@ fn test_del_publisher() {
     };
 
     let program_id = Pubkey::new_unique();
-    let publisher = CPubkey::new_unique();
-    let publisher2 = CPubkey::new_unique();
+    let publisher = Pubkey::new_unique();
+    let publisher2 = Pubkey::new_unique();
 
     let mut instruction_data = [0u8; size_of::<DelPublisherArgs>()];
     let mut hdr = load_mut::<DelPublisherArgs>(&mut instruction_data).unwrap();
@@ -64,7 +57,7 @@ fn test_del_publisher() {
         let mut price_data = load_checked::<PriceAccount>(&price_account, PC_VERSION).unwrap();
         price_data.num_ = 1;
         price_data.comp_[0].latest_ = p1;
-        pubkey_assign(&mut price_data.comp_[0].pub_, bytes_of(&publisher));
+        price_data.comp_[0].pub_ = publisher
     }
 
     assert!(process_instruction(
@@ -83,13 +76,13 @@ fn test_del_publisher() {
         assert_eq!(price_data.comp_[0].latest_.pub_slot_, 0);
         assert_eq!(price_data.comp_[0].latest_.corp_act_status_, 0);
         assert_eq!(price_data.header.size, PriceAccount::INITIAL_SIZE);
-        assert!(pubkey_is_zero(&price_data.comp_[0].pub_));
+        assert!(price_data.comp_[0].pub_ == Pubkey::default());
 
         price_data.num_ = 2;
         price_data.comp_[0].latest_ = p1;
         price_data.comp_[1].latest_ = p2;
-        pubkey_assign(&mut price_data.comp_[0].pub_, bytes_of(&publisher));
-        pubkey_assign(&mut price_data.comp_[1].pub_, bytes_of(&publisher2));
+        price_data.comp_[0].pub_ = publisher;
+        price_data.comp_[1].pub_ = publisher2;
     }
 
     // Delete publisher at position 0
@@ -120,17 +113,14 @@ fn test_del_publisher() {
             price_data.header.size,
             PriceAccount::INITIAL_SIZE + (size_of::<PriceComponent>() as u32)
         );
-        assert!(pubkey_equal(
-            &price_data.comp_[0].pub_,
-            bytes_of(&publisher2)
-        ));
-        assert!(pubkey_is_zero(&price_data.comp_[1].pub_));
+        assert!(price_data.comp_[0].pub_ == publisher2);
+        assert!(price_data.comp_[1].pub_ == Pubkey::default());
 
         price_data.num_ = 2;
         price_data.comp_[0].latest_ = p2;
         price_data.comp_[1].latest_ = p1;
-        pubkey_assign(&mut price_data.comp_[0].pub_, bytes_of(&publisher2));
-        pubkey_assign(&mut price_data.comp_[1].pub_, bytes_of(&publisher));
+        price_data.comp_[0].pub_ = publisher2;
+        price_data.comp_[1].pub_ = publisher;
     }
 
     // Delete publisher at position 1
@@ -161,10 +151,7 @@ fn test_del_publisher() {
             price_data.header.size,
             PriceAccount::INITIAL_SIZE + (size_of::<PriceComponent>() as u32)
         );
-        assert!(pubkey_equal(
-            &price_data.comp_[0].pub_,
-            bytes_of(&publisher2)
-        ));
-        assert!(pubkey_is_zero(&price_data.comp_[1].pub_));
+        assert!(price_data.comp_[0].pub_ == publisher2);
+        assert!(price_data.comp_[1].pub_ == Pubkey::default());
     }
 }
diff --git a/program/rust/src/tests/test_init_price.rs b/program/rust/src/tests/test_init_price.rs
index 6583213ac..d1f86257b 100644
--- a/program/rust/src/tests/test_init_price.rs
+++ b/program/rust/src/tests/test_init_price.rs
@@ -3,7 +3,6 @@ use solana_program::program_error::ProgramError;
 use solana_program::pubkey::Pubkey;
 
 use crate::c_oracle_header::{
-    CPubkey,
     PriceAccount,
     PC_MAX_NUM_DECIMALS,
     PC_VERSION,
@@ -18,10 +17,6 @@ use crate::instruction::{
 };
 use crate::processor::process_instruction;
 use crate::tests::test_utils::AccountSetup;
-use crate::utils::{
-    pubkey_assign,
-    pubkey_equal,
-};
 use crate::OracleError;
 
 #[test]
@@ -37,10 +32,10 @@ fn test_init_price() {
     let instruction_data = bytes_of::<InitPriceArgs>(&cmd);
 
     let program_id = Pubkey::new_unique();
-    let publisher = CPubkey::new_unique();
-    let publisher2 = CPubkey::new_unique();
-    let product = CPubkey::new_unique();
-    let next_price = CPubkey::new_unique();
+    let publisher = Pubkey::new_unique();
+    let publisher2 = Pubkey::new_unique();
+    let product = Pubkey::new_unique();
+    let next_price = Pubkey::new_unique();
 
     let mut funding_setup = AccountSetup::new_funding();
     let funding_account = funding_setup.to_account_info();
@@ -65,10 +60,10 @@ fn test_init_price() {
         price_data.exponent = 0;
         price_data.min_pub_ = 7;
         price_data.num_ = 4;
-        pubkey_assign(&mut price_data.comp_[0].pub_, bytes_of(&publisher));
-        pubkey_assign(&mut price_data.comp_[3].pub_, bytes_of(&publisher2));
-        pubkey_assign(&mut price_data.product_account, bytes_of(&product));
-        pubkey_assign(&mut price_data.next_price_account, bytes_of(&next_price));
+        price_data.comp_[0].pub_ = publisher;
+        price_data.comp_[3].pub_ = publisher2;
+        price_data.product_account = product;
+        price_data.next_price_account = next_price;
 
         price_data.last_slot_ = 100;
         price_data.valid_slot_ = 100;
@@ -107,22 +102,10 @@ fn test_init_price() {
         assert_eq!(price_data.price_type, ptype);
         assert_eq!(price_data.min_pub_, 7);
         assert_eq!(price_data.num_, 4);
-        assert!(pubkey_equal(
-            &price_data.comp_[0].pub_,
-            bytes_of(&publisher)
-        ));
-        assert!(pubkey_equal(
-            &price_data.comp_[3].pub_,
-            bytes_of(&publisher2)
-        ));
-        assert!(pubkey_equal(
-            &price_data.product_account,
-            bytes_of(&product)
-        ));
-        assert!(pubkey_equal(
-            &price_data.next_price_account,
-            bytes_of(&next_price)
-        ));
+        assert!(price_data.comp_[0].pub_ == publisher);
+        assert!(price_data.comp_[3].pub_ == publisher2);
+        assert!(price_data.product_account == product);
+        assert!(price_data.next_price_account == next_price);
 
         assert_eq!(price_data.last_slot_, 0);
         assert_eq!(price_data.valid_slot_, 0);
diff --git a/program/rust/src/tests/test_sizes.rs b/program/rust/src/tests/test_sizes.rs
index 6ed398394..d4de35bf8 100644
--- a/program/rust/src/tests/test_sizes.rs
+++ b/program/rust/src/tests/test_sizes.rs
@@ -1,6 +1,5 @@
 use crate::c_oracle_header::{
     AccountHeader,
-    CPubkey,
     MappingAccount,
     PriceAccount,
     PriceComponent,
@@ -15,6 +14,7 @@ use crate::c_oracle_header::{
 };
 use crate::deserialize::{
     initialize_pyth_account_checked,
+    load,
     load_checked,
 };
 use crate::instruction::{
@@ -37,20 +37,20 @@ use std::mem::{
 
 #[test]
 fn test_sizes() {
-    assert_eq!(size_of::<CPubkey>(), 32);
+    assert_eq!(size_of::<Pubkey>(), 32);
     assert_eq!(
         size_of::<MappingAccount>(),
-        24 + (PC_MAP_TABLE_SIZE as usize + 1) * size_of::<CPubkey>()
+        24 + (PC_MAP_TABLE_SIZE as usize + 1) * size_of::<Pubkey>()
     );
     assert_eq!(size_of::<PriceInfo>(), 32);
     assert_eq!(
         size_of::<PriceComponent>(),
-        size_of::<CPubkey>() + 2 * size_of::<PriceInfo>()
+        size_of::<Pubkey>() + 2 * size_of::<PriceInfo>()
     );
     assert_eq!(
         size_of::<PriceAccount>(),
         48 + 8 * size_of::<u64>()
-            + 3 * size_of::<CPubkey>()
+            + 3 * size_of::<Pubkey>()
             + size_of::<PriceInfo>()
             + (PC_COMP_SIZE as usize) * size_of::<PriceComponent>()
     );
@@ -61,7 +61,7 @@ fn test_sizes() {
     assert_eq!(size_of::<AddPublisherArgs>(), 40);
     assert_eq!(size_of::<DelPublisherArgs>(), 40);
     assert_eq!(size_of::<UpdPriceArgs>(), 40);
-    assert_eq!(size_of::<CPubkey>(), 32);
+    assert_eq!(size_of::<Pubkey>(), 32);
     assert_eq!(size_of::<AccountHeader>(), 16);
     assert_eq!(size_of::<MappingAccount>(), 20536);
     assert_eq!(size_of::<ProductAccount>(), 48);
@@ -100,3 +100,24 @@ fn test_offsets() {
         try_convert::<_, usize>(MappingAccount::INITIAL_SIZE).unwrap()
     );
 }
+
+#[test]
+fn test_pubkey() {
+    let default_pubkey = Pubkey::default();
+    let zero_pubkey = Pubkey::new(&[0u8; 32]);
+    let unique_pubkey = Pubkey::new_unique();
+
+    assert_eq!(default_pubkey, zero_pubkey);
+    assert!(unique_pubkey != default_pubkey);
+
+    // Check that current onchain bytes are interpretable as a Solana Pubkey. I manually grabbed the
+    // bytes for BTC/USD price account's product field with `solana account` and check that they
+    // get properly interpreted as the actual base58 product account
+    let onchain_bytes =
+        hex::decode("3515b3861e8fe93e5f540ba4077c216404782b86d5e78077b3cbfd27313ab3bc").unwrap();
+    let onchain_bytes_as_solana_pubkey = load::<Pubkey>(onchain_bytes.as_slice()).unwrap();
+    assert_eq!(
+        onchain_bytes_as_solana_pubkey.to_string(),
+        "4aDoSXJ5o3AuvL7QFeR6h44jALQfTmUUCTVGDD6aoJTM"
+    );
+}
diff --git a/program/rust/src/tests/test_upd_price.rs b/program/rust/src/tests/test_upd_price.rs
index fc810c81d..e314da14f 100644
--- a/program/rust/src/tests/test_upd_price.rs
+++ b/program/rust/src/tests/test_upd_price.rs
@@ -23,7 +23,6 @@ use crate::tests::test_utils::{
     update_clock_slot,
     AccountSetup,
 };
-use crate::utils::pubkey_assign;
 #[test]
 fn test_upd_price() {
     let mut instruction_data = [0u8; size_of::<UpdPriceArgs>()];
@@ -42,10 +41,7 @@ fn test_upd_price() {
     {
         let mut price_data = load_checked::<PriceAccount>(&price_account, PC_VERSION).unwrap();
         price_data.num_ = 1;
-        pubkey_assign(
-            &mut price_data.comp_[0].pub_,
-            &funding_account.key.to_bytes(),
-        );
+        price_data.comp_[0].pub_ = *funding_account.key;
     }
 
     let mut clock_setup = AccountSetup::new_clock();
diff --git a/program/rust/src/tests/test_upd_price_no_fail_on_error.rs b/program/rust/src/tests/test_upd_price_no_fail_on_error.rs
index 361c66c2e..533b9d813 100644
--- a/program/rust/src/tests/test_upd_price_no_fail_on_error.rs
+++ b/program/rust/src/tests/test_upd_price_no_fail_on_error.rs
@@ -23,7 +23,6 @@ use crate::tests::test_utils::{
     update_clock_slot,
     AccountSetup,
 };
-use crate::utils::pubkey_assign;
 #[test]
 fn test_upd_price_no_fail_on_error_no_fail_on_error() {
     let mut instruction_data = [0u8; size_of::<UpdPriceArgs>()];
@@ -92,10 +91,7 @@ fn test_upd_price_no_fail_on_error_no_fail_on_error() {
 
         // Now permission the publish account for the price account.
         price_data.num_ = 1;
-        pubkey_assign(
-            &mut price_data.comp_[0].pub_,
-            &funding_account.key.to_bytes(),
-        );
+        price_data.comp_[0].pub_ = *funding_account.key;
     }
 
     // The update should now succeed, and have an effect.
diff --git a/program/rust/src/utils.rs b/program/rust/src/utils.rs
index a033a6cb2..38167ac7b 100644
--- a/program/rust/src/utils.rs
+++ b/program/rust/src/utils.rs
@@ -1,6 +1,5 @@
 use crate::c_oracle_header::{
     AccountHeader,
-    CPubkey,
     PC_MAX_NUM_DECIMALS,
 };
 use crate::deserialize::load_account_as;
@@ -95,28 +94,6 @@ pub fn check_exponent_range(expo: i32) -> Result<(), ProgramError> {
     )
 }
 
-// Assign pubkey bytes from source to target, fails if source is not 32 bytes
-pub fn pubkey_assign(target: &mut CPubkey, source: &[u8]) {
-    unsafe { target.k1_.copy_from_slice(source) }
-}
-
-pub fn pubkey_is_zero(key: &CPubkey) -> bool {
-    return unsafe { key.k8_.iter().all(|x| *x == 0) };
-}
-
-pub fn pubkey_equal(target: &CPubkey, source: &[u8]) -> bool {
-    unsafe { target.k1_ == *source }
-}
-
-/// Zero out the bytes of `key`.
-pub fn pubkey_clear(key: &mut CPubkey) {
-    unsafe {
-        for i in 0..key.k8_.len() {
-            key.k8_[i] = 0;
-        }
-    }
-}
-
 /// Convert `x: T` into a `U`, returning the appropriate `OracleError` if the conversion fails.
 pub fn try_convert<T, U: TryFrom<T>>(x: T) -> Result<U, OracleError> {
     // Note: the error here assumes we're only applying this function to integers right now.