refactor(lazer): keep good names for new types and methods

Author: Riateche

lazer/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "pyth-lazer-solana-contract"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 description = "Pyth Lazer Solana contract and SDK."
 license = "Apache-2.0"

lazer/contracts/solana/programs/pyth-lazer-solana-contract/Cargo.toml

@@ -3,8 +3,7 @@ mod signature;
 use {
     crate::signature::VerifiedMessage,
     anchor_lang::{prelude::*, solana_program::pubkey::PUBKEY_BYTES, system_program},
-    std::io::Cursor,
-    std::mem::size_of,
+    std::{io::Cursor, mem::size_of},
 };
 
 pub use {
@@ -24,6 +23,7 @@ fn test_ids() {
     );
 }
 
+pub const ANCHOR_DISCRIMINATOR_BYTES: usize = 8;
 pub const MAX_NUM_TRUSTED_SIGNERS: usize = 2;
 pub const SPACE_FOR_TRUSTED_SIGNERS: usize = 5;
 pub const EXTRA_SPACE: usize = 100;
@@ -39,15 +39,15 @@ impl TrustedSignerInfo {
 }
 
 /// TODO: remove this legacy storage type
-#[account]
-pub struct Storage {
+#[derive(AnchorDeserialize)]
+pub struct StorageV010 {
     pub top_authority: Pubkey,
     pub num_trusted_signers: u8,
     pub trusted_signers: [TrustedSignerInfo; MAX_NUM_TRUSTED_SIGNERS],
 }
 
-impl Storage {
-    const SERIALIZED_LEN: usize = PUBKEY_BYTES
+impl StorageV010 {
+    pub const SERIALIZED_LEN: usize = PUBKEY_BYTES
         + size_of::<u8>()
         + TrustedSignerInfo::SERIALIZED_LEN * MAX_NUM_TRUSTED_SIGNERS;
 
@@ -57,7 +57,7 @@ impl Storage {
 }
 
 #[account]
-pub struct StorageV2 {
+pub struct Storage {
     pub top_authority: Pubkey,
     pub treasury: Pubkey,
     pub single_update_fee_in_lamports: u64,
@@ -66,7 +66,7 @@ pub struct StorageV2 {
     pub _extra_space: [u8; EXTRA_SPACE],
 }
 
-impl StorageV2 {
+impl Storage {
     const SERIALIZED_LEN: usize = PUBKEY_BYTES
         + PUBKEY_BYTES
         + size_of::<u64>()
@@ -83,16 +83,12 @@ pub const STORAGE_SEED: &[u8] = b"storage";
 
 #[program]
 pub mod pyth_lazer_solana_contract {
-    use super::*;
+    use anchor_lang::Discriminator;
 
-    /// TODO: remove this legacy instruction
-    pub fn initialize(ctx: Context<Initialize>, top_authority: Pubkey) -> Result<()> {
-        ctx.accounts.storage.top_authority = top_authority;
-        Ok(())
-    }
+    use super::*;
 
-    pub fn initialize_v2(
-        ctx: Context<InitializeV2>,
+    pub fn initialize(
+        ctx: Context<Initialize>,
         top_authority: Pubkey,
         treasury: Pubkey,
     ) -> Result<()> {
@@ -102,20 +98,25 @@ pub mod pyth_lazer_solana_contract {
         Ok(())
     }
 
-    pub fn migrate_to_storage_v2(ctx: Context<MigrateToStorageV2>, treasury: Pubkey) -> Result<()> {
-        let old_storage = Storage::try_deserialize(&mut &**ctx.accounts.storage.data.borrow())?;
+    pub fn migrate_from_0_1_0(ctx: Context<MigrateFrom010>, treasury: Pubkey) -> Result<()> {
+        let old_data = ctx.accounts.storage.data.borrow();
+        if old_data[0..ANCHOR_DISCRIMINATOR_BYTES] != Storage::DISCRIMINATOR {
+            return Err(ProgramError::InvalidAccountData.into());
+        }
+        let old_storage = StorageV010::deserialize(&mut &old_data[ANCHOR_DISCRIMINATOR_BYTES..])?;
         if old_storage.top_authority != ctx.accounts.top_authority.key() {
             return Err(ProgramError::MissingRequiredSignature.into());
         }
+        drop(old_data);
 
-        let space = 8 + StorageV2::SERIALIZED_LEN;
+        let space = ANCHOR_DISCRIMINATOR_BYTES + Storage::SERIALIZED_LEN;
         ctx.accounts.storage.realloc(space, false)?;
         let min_lamports = Rent::get()?.minimum_balance(space);
         if ctx.accounts.storage.lamports() < min_lamports {
             return Err(ProgramError::AccountNotRentExempt.into());
         }
 
-        let mut new_storage = StorageV2 {
+        let mut new_storage = Storage {
             top_authority: old_storage.top_authority,
             treasury,
             single_update_fee_in_lamports: 1,
@@ -228,7 +229,7 @@ pub struct Initialize<'info> {
     #[account(
         init,
         payer = payer,
-        space = 8 + Storage::SERIALIZED_LEN,
+        space = ANCHOR_DISCRIMINATOR_BYTES + Storage::SERIALIZED_LEN,
         seeds = [STORAGE_SEED],
         bump,
     )]
@@ -237,7 +238,7 @@ pub struct Initialize<'info> {
 }
 
 #[derive(Accounts)]
-pub struct MigrateToStorageV2<'info> {
+pub struct MigrateFrom010<'info> {
     pub top_authority: Signer<'info>,
     #[account(
         mut,
@@ -249,21 +250,6 @@ pub struct MigrateToStorageV2<'info> {
     pub system_program: Program<'info, System>,
 }
 
-#[derive(Accounts)]
-pub struct InitializeV2<'info> {
-    #[account(mut)]
-    pub payer: Signer<'info>,
-    #[account(
-        init,
-        payer = payer,
-        space = 8 + StorageV2::SERIALIZED_LEN,
-        seeds = [STORAGE_SEED],
-        bump,
-    )]
-    pub storage: Account<'info, StorageV2>,
-    pub system_program: Program<'info, System>,
-}
-
 #[derive(Accounts)]
 pub struct Update<'info> {
     pub top_authority: Signer<'info>,
@@ -273,7 +259,7 @@ pub struct Update<'info> {
         bump,
         has_one = top_authority,
     )]
-    pub storage: Account<'info, StorageV2>,
+    pub storage: Account<'info, Storage>,
 }
 
 #[derive(Accounts)]
@@ -285,7 +271,7 @@ pub struct VerifyMessage<'info> {
         bump,
         has_one = treasury
     )]
-    pub storage: Account<'info, StorageV2>,
+    pub storage: Account<'info, Storage>,
     /// CHECK: this account doesn't need additional constraints.
     pub treasury: AccountInfo<'info>,
     pub system_program: Program<'info, System>,

lazer/contracts/solana/programs/pyth-lazer-solana-contract/src/lib.rs

@@ -1,5 +1,5 @@
 use {
-    crate::StorageV2,
+    crate::Storage,
     anchor_lang::{
         prelude::{borsh, AccountInfo, Clock, ProgramError, Pubkey, SolanaSysvar},
         solana_program::{ed25519_program, pubkey::PUBKEY_BYTES, sysvar},
@@ -158,7 +158,7 @@ impl From<SignatureVerificationError> for anchor_lang::error::Error {
 /// - `message_offset` is the offset of the signed message within the
 ///   input data for the current instruction.
 pub fn verify_message(
-    storage: &StorageV2,
+    storage: &Storage,
     instructions_sysvar: &AccountInfo,
     message_data: &[u8],
     ed25519_instruction_index: u16,

lazer/contracts/solana/programs/pyth-lazer-solana-contract/src/signature.rs

@@ -1,38 +1,47 @@
 use {
     anchor_lang::{prelude::AccountMeta, InstructionData},
-    pyth_lazer_solana_contract::ed25519_program_args,
+    pyth_lazer_solana_contract::{ed25519_program_args, ANCHOR_DISCRIMINATOR_BYTES},
     solana_program_test::{BanksClient, ProgramTest},
     solana_sdk::{
-        ed25519_program, hash::Hash, instruction::Instruction, pubkey::Pubkey, signature::Keypair,
-        signer::Signer, system_instruction, system_program, system_transaction, sysvar,
+        account::Account,
+        ed25519_program,
+        hash::Hash,
+        instruction::Instruction,
+        pubkey::{Pubkey, PUBKEY_BYTES},
+        signature::Keypair,
+        signer::Signer,
+        system_instruction, system_program, system_transaction, sysvar,
         transaction::Transaction,
     },
     std::env,
 };
 
+fn program_test() -> ProgramTest {
+    if env::var("SBF_OUT_DIR").is_err() {
+        env::set_var(
+            "SBF_OUT_DIR",
+            format!(
+                "{}/../../../../target/sbf-solana-solana/release",
+                env::var("CARGO_MANIFEST_DIR").unwrap()
+            ),
+        );
+    }
+    println!("if add_program fails, run `cargo build-sbf` first.");
+    ProgramTest::new(
+        "pyth_lazer_solana_contract",
+        pyth_lazer_solana_contract::ID,
+        None,
+    )
+}
+
 struct Setup {
     banks_client: BanksClient,
     payer: Keypair,
     recent_blockhash: Hash,
 }
 
 impl Setup {
-    async fn new() -> Self {
-        if env::var("SBF_OUT_DIR").is_err() {
-            env::set_var(
-                "SBF_OUT_DIR",
-                format!(
-                    "{}/../../../../target/sbf-solana-solana/release",
-                    env::var("CARGO_MANIFEST_DIR").unwrap()
-                ),
-            );
-        }
-        println!("if add_program fails, run `cargo build-sbf` first.");
-        let program_test = ProgramTest::new(
-            "pyth_lazer_solana_contract",
-            pyth_lazer_solana_contract::ID,
-            None,
-        );
+    async fn with_program_test(program_test: ProgramTest) -> Self {
         let (banks_client, payer, recent_blockhash) = program_test.start().await;
         Self {
             banks_client,
@@ -41,6 +50,10 @@ impl Setup {
         }
     }
 
+    async fn new() -> Self {
+        Self::with_program_test(program_test()).await
+    }
+
     async fn create_treasury(&mut self) -> Pubkey {
         let treasury =
             Pubkey::create_with_seed(&self.payer.pubkey(), "treasury", &system_program::ID)
@@ -154,14 +167,14 @@ impl Setup {
 }
 
 #[tokio::test]
-async fn test_with_init_v2() {
+async fn test_basic() {
     let mut setup = Setup::new().await;
     let treasury = setup.create_treasury().await;
 
     let mut transaction_init_contract = Transaction::new_with_payer(
         &[Instruction::new_with_bytes(
             pyth_lazer_solana_contract::ID,
-            &pyth_lazer_solana_contract::instruction::InitializeV2 {
+            &pyth_lazer_solana_contract::instruction::Initialize {
                 top_authority: setup.payer.pubkey(),
                 treasury,
             }
@@ -195,32 +208,33 @@ async fn test_with_init_v2() {
 }
 
 #[tokio::test]
-async fn test_with_init_v1_and_migrate() {
-    let mut setup = Setup::new().await;
-    let treasury = setup.create_treasury().await;
-
-    let mut transaction_init_contract = Transaction::new_with_payer(
-        &[Instruction::new_with_bytes(
-            pyth_lazer_solana_contract::ID,
-            &pyth_lazer_solana_contract::instruction::Initialize {
-                top_authority: setup.payer.pubkey(),
-            }
-            .data(),
-            vec![
-                AccountMeta::new(setup.payer.pubkey(), true),
-                AccountMeta::new(pyth_lazer_solana_contract::STORAGE_ID, false),
-                AccountMeta::new_readonly(system_program::ID, false),
-            ],
-        )],
-        Some(&setup.payer.pubkey()),
+async fn test_migrate_from_0_1_0() {
+    let mut program_test = program_test();
+    // Create a storage PDA account with the data that was produced by the program v0.1.0.
+    let mut old_storage_data = hex::decode(
+        "d175ffb9c4af4409aa4dcb5d31150b162b664abd843cb231cee5c0ebf759ce371d9cb36ffc653796\
+        0174313a6525edf99936aa1477e94c72bc5cc617b21745f5f03296f3154461f214ffffffffffffff7\
+        f00000000000000000000000000000000000000000000000000000000000000000000000000000000",
+    )
+    .unwrap();
+    let top_authority = Keypair::new();
+    // Replace top authority pubkey in storage PDA data to allow successful migration.
+    old_storage_data[ANCHOR_DISCRIMINATOR_BYTES..ANCHOR_DISCRIMINATOR_BYTES + PUBKEY_BYTES]
+        .copy_from_slice(&top_authority.pubkey().to_bytes());
+    program_test.add_account(
+        pyth_lazer_solana_contract::STORAGE_ID,
+        Account {
+            lamports: 1733040,
+            data: old_storage_data,
+            owner: pyth_lazer_solana_contract::ID,
+            executable: false,
+            rent_epoch: 18446744073709551615,
+        },
     );
-    transaction_init_contract.sign(&[&setup.payer], setup.recent_blockhash);
-    setup
-        .banks_client
-        .process_transaction(transaction_init_contract)
-        .await
-        .unwrap();
+    let mut setup = Setup::with_program_test(program_test).await;
+    let treasury = setup.create_treasury().await;
 
+    // Make sure storage PDA will be rent-exempt after resize.
     let tx_transfer = system_transaction::transfer(
         &setup.payer,
         &pyth_lazer_solana_contract::STORAGE_ID,
@@ -236,31 +250,30 @@ async fn test_with_init_v1_and_migrate() {
     let mut transaction_migrate_contract = Transaction::new_with_payer(
         &[Instruction::new_with_bytes(
             pyth_lazer_solana_contract::ID,
-            &pyth_lazer_solana_contract::instruction::MigrateToStorageV2 { treasury }.data(),
+            &pyth_lazer_solana_contract::instruction::MigrateFrom010 { treasury }.data(),
             vec![
-                AccountMeta::new(setup.payer.pubkey(), true),
+                AccountMeta::new(top_authority.pubkey(), true),
                 AccountMeta::new(pyth_lazer_solana_contract::STORAGE_ID, false),
                 AccountMeta::new_readonly(system_program::ID, false),
             ],
         )],
         Some(&setup.payer.pubkey()),
     );
-    transaction_migrate_contract.sign(&[&setup.payer], setup.recent_blockhash);
+    transaction_migrate_contract.sign(&[&setup.payer, &top_authority], setup.recent_blockhash);
     setup
         .banks_client
         .process_transaction(transaction_migrate_contract)
         .await
         .unwrap();
 
-    let verifying_key =
-        hex::decode("74313a6525edf99936aa1477e94c72bc5cc617b21745f5f03296f3154461f214").unwrap();
     let message = hex::decode(
         "b9011a82e5cddee2c1bd364c8c57e1c98a6a28d194afcad410ff412226c8b2ae931ff59a57147cb47c7307\
         afc2a0a1abec4dd7e835a5b7113cf5aeac13a745c6bed6c60074313a6525edf99936aa1477e94c72bc5cc61\
         7b21745f5f03296f3154461f2141c0075d3c7931c9773f30a240600010102000000010000e1f50500000000",
     )
     .unwrap();
 
-    setup.set_trusted(verifying_key.try_into().unwrap()).await;
+    // The contract will recognize the trusted signer without calling `set_trusted`
+    // because it was present in the original storage PDA data.
     setup.verify_message(&message, treasury).await;
 }