Implemented stake account checkpoints creation and fix tests (#204)

* WIP: implemented stake account checkpoints creation

* Update delegation logic to use owner address instead of checkpoints address

* Update CastVote with new checkpoints

* Remove mockClockTime and freeze from GlobalConfig

* Fix tests

* Apply yarn format

* Fix stake_account_checkpoints_last_index update in the delegate instruction. Update tests

* Fix TransferVesting. Update tests

* Fix tests

* Fix castVote. Add tests

* Return deleted emitted events DelegateVotesChanged

Author: zpoken

solana/app/StakeConnection.ts

@@ -81,6 +81,10 @@ export class CheckpointAccount {
 
     return `${this.checkpointData.toString()}\nCheckpoints:\n${checkpointsStr || "No valid checkpoints available."}`;
   }
+
+  getCheckpointCount(): number {
+    return this.checkpoints.length;
+  }
 }
 
 export async function readCheckpoints(

solana/app/checkpoints.ts

@@ -16,3 +16,6 @@ export const hubProposalMetadata = new Uint8Array([
 
 /// Wormhole Hub Chain ID
 export const hubChainId = 10002;
+
+export const CHECKPOINTS_ACCOUNT_LIMIT = 654998;
+export const TEST_CHECKPOINTS_ACCOUNT_LIMIT = 10;

solana/app/constants.ts

@@ -1,7 +1,7 @@
 import { Wallet, AnchorProvider, Program } from "@coral-xyz/anchor";
 import { Connection } from "@solana/web3.js";
 import { DEPLOYER_AUTHORITY_KEYPAIR, WORMHOLE_TOKEN, RPC_NODE } from "./devnet";
-import { STAKING_ADDRESS } from "../constants";
+import { CHECKPOINTS_ACCOUNT_LIMIT, STAKING_ADDRESS } from "../constants";
 import { Staking } from "../../target/types/staking";
 import fs from "fs";
 
@@ -18,10 +18,10 @@ async function main() {
 
   const globalConfig = {
     bump: 255,
-    freeze: false,
     governanceAuthority: DEPLOYER_AUTHORITY_KEYPAIR.publicKey,
     whTokenMint: WORMHOLE_TOKEN,
     vestingAdmin: DEPLOYER_AUTHORITY_KEYPAIR.publicKey,
+    maxCheckpointsAccountLimit: CHECKPOINTS_ACCOUNT_LIMIT,
   };
   await program.methods.initConfig(globalConfig).rpc();
 }

solana/app/deploy/1_init_staking.ts

@@ -38,7 +38,6 @@ async function main() {
       .withdrawTokens(new BN(1))
       .accounts({
         currentDelegateStakeAccountCheckpoints: stakeAccountCheckpointsAddress,
-        stakeAccountCheckpoints: stakeAccountCheckpointsAddress,
         destination: toAccount,
       })
       .rpc({ skipPreflight: DEBUG });

solana/app/deploy/5_withdraw.ts

@@ -220,7 +220,7 @@ async function main() {
     .then(confirm);
 
   let stakeAccountCheckpointsAddress =
-    await vesterStakeConnection.delegate_with_vest(
+    await vesterStakeConnection.delegateWithVest(
       vester.publicKey,
       WHTokenBalance.fromString("0"),
       true,

solana/app/deploy/test_vesting.ts

@@ -13,10 +13,9 @@ no-entrypoint = []
 no-idl = []
 no-log-ix-name = []
 cpi = ["no-entrypoint"]
-mock-clock = []
 wasm = ["no-entrypoint", "js-sys", "bincode"]
 idl-build = ["anchor-lang/idl-build", "anchor-spl/idl-build", "wormhole-anchor-sdk/idl-build"]
-default = ["mock-clock","testnet", "idl-build"]
+default = ["testnet", "idl-build"]
 localnet = ["wormhole-solana-consts/localnet"]
 testnet = ["wormhole-solana-consts/testnet", "wormhole-anchor-sdk/solana-devnet"]
 mainnet = ["wormhole-solana-consts/mainnet", "wormhole-anchor-sdk/mainnet"]

solana/programs/staking/Cargo.toml

@@ -53,6 +53,7 @@ pub struct InitConfig<'info> {
 }
 
 #[derive(Accounts)]
+#[instruction(delegatee: Pubkey, current_delegate_stake_account_owner: Pubkey)]
 pub struct Delegate<'info> {
     // Native payer:
     #[account(address = stake_account_metadata.owner)]
@@ -64,41 +65,38 @@ pub struct Delegate<'info> {
         AccountLoader<'info, checkpoints::CheckpointData>,
     #[account(
         mut,
-        seeds = [STAKE_ACCOUNT_METADATA_SEED.as_bytes(), current_delegate_stake_account_checkpoints.key().as_ref()],
+        seeds = [STAKE_ACCOUNT_METADATA_SEED.as_bytes(), current_delegate_stake_account_owner.as_ref()],
         bump = current_delegate_stake_account_metadata.metadata_bump
     )]
     pub current_delegate_stake_account_metadata:
         Box<Account<'info, stake_account::StakeAccountMetadata>>,
-
     // Delegatee stake accounts:
     #[account(mut)]
     pub delegatee_stake_account_checkpoints: AccountLoader<'info, checkpoints::CheckpointData>,
     #[account(
         mut,
-        seeds = [STAKE_ACCOUNT_METADATA_SEED.as_bytes(), delegatee_stake_account_checkpoints.key().as_ref()],
+        seeds = [STAKE_ACCOUNT_METADATA_SEED.as_bytes(), delegatee.as_ref()],
         bump = delegatee_stake_account_metadata.metadata_bump
     )]
     pub delegatee_stake_account_metadata: Box<Account<'info, stake_account::StakeAccountMetadata>>,
 
     // User stake account:
-    #[account(mut)]
-    pub stake_account_checkpoints: AccountLoader<'info, checkpoints::CheckpointData>,
     #[account(
         mut,
-        seeds = [STAKE_ACCOUNT_METADATA_SEED.as_bytes(), stake_account_checkpoints.key().as_ref()],
+        seeds = [STAKE_ACCOUNT_METADATA_SEED.as_bytes(), payer.key().as_ref()],
         bump = stake_account_metadata.metadata_bump,
-        constraint = stake_account_metadata.delegate == current_delegate_stake_account_checkpoints.key()
+        constraint = stake_account_metadata.delegate == current_delegate_stake_account_owner
             @ ErrorCode::InvalidCurrentDelegate
     )]
     pub stake_account_metadata: Box<Account<'info, stake_account::StakeAccountMetadata>>,
     /// CHECK : This AccountInfo is safe because it's a checked PDA
-    #[account(seeds = [AUTHORITY_SEED.as_bytes(), stake_account_checkpoints.key().as_ref()], bump)]
+    #[account(seeds = [AUTHORITY_SEED.as_bytes(), payer.key().as_ref()], bump)]
     pub custody_authority: AccountInfo<'info>,
     #[account(
         mut,
         seeds = [
             CUSTODY_SEED.as_bytes(),
-            stake_account_checkpoints.key().as_ref()
+            payer.key().as_ref()
         ],
         bump,
         token::mint = mint,
@@ -120,7 +118,11 @@ pub struct Delegate<'info> {
 }
 
 #[derive(Accounts)]
-#[instruction(proposal_id: [u8; 32])]
+#[instruction(proposal_id: [u8; 32],
+        _against_votes: u64,
+        _for_votes: u64,
+        _abstain_votes: u64,
+        checkpoint_index: u8)]
 pub struct CastVote<'info> {
     #[account(mut)]
     pub owner: Signer<'info>,
@@ -132,19 +134,27 @@ pub struct CastVote<'info> {
     )]
     pub proposal: Account<'info, proposal::ProposalData>,
 
-    #[account(mut, has_one = owner)]
+    #[account(
+        mut,
+        has_one = owner,
+        seeds = [CHECKPOINT_DATA_SEED.as_bytes(), owner.key().as_ref(), checkpoint_index.to_le_bytes().as_ref()],
+        bump
+    )]
     pub voter_checkpoints: AccountLoader<'info, checkpoints::CheckpointData>,
 
     #[account(
         init_if_needed,
         payer = owner,
         space = proposal_voters_weight_cast::ProposalVotersWeightCast::LEN,
-        seeds = [b"proposal_voters_weight_cast", proposal.key().as_ref(), voter_checkpoints.key().as_ref()],
+        seeds = [b"proposal_voters_weight_cast", proposal.key().as_ref(), owner.key().as_ref()],
         bump
     )]
     pub proposal_voters_weight_cast:
         Account<'info, proposal_voters_weight_cast::ProposalVotersWeightCast>,
 
+    #[account(seeds = [CONFIG_SEED.as_bytes()], bump = config.bump)]
+    pub config: Box<Account<'info, global_config::GlobalConfig>>,
+
     pub system_program: Program<'info, System>,
 }
 
@@ -385,16 +395,22 @@ pub struct CreateStakeAccount<'info> {
     // Stake program accounts:
     #[account(
         init,
-        seeds = [CHECKPOINT_DATA_SEED.as_bytes(), payer.key().as_ref()],
+        seeds = [CHECKPOINT_DATA_SEED.as_bytes(), payer.key().as_ref(), 0u8.to_le_bytes().as_ref()],
         bump,
         payer = payer,
         space = checkpoints::CheckpointData::LEN,
     )]
     pub stake_account_checkpoints: AccountLoader<'info, checkpoints::CheckpointData>,
-    #[account(init, payer = payer, space = stake_account::StakeAccountMetadata::LEN, seeds = [STAKE_ACCOUNT_METADATA_SEED.as_bytes(), stake_account_checkpoints.key().as_ref()], bump)]
+    #[account(
+        init,
+        payer = payer,
+        space = stake_account::StakeAccountMetadata::LEN,
+        seeds = [STAKE_ACCOUNT_METADATA_SEED.as_bytes(), payer.key().as_ref()],
+        bump
+    )]
     pub stake_account_metadata: Box<Account<'info, stake_account::StakeAccountMetadata>>,
     /// CHECK : This AccountInfo is safe because it's a checked PDA
-    #[account(seeds = [AUTHORITY_SEED.as_bytes(), stake_account_checkpoints.key().as_ref()], bump)]
+    #[account(seeds = [AUTHORITY_SEED.as_bytes(), payer.key().as_ref()], bump)]
     pub custody_authority: AccountInfo<'info>,
     #[account(seeds = [CONFIG_SEED.as_bytes()], bump = config.bump)]
     pub config: Box<Account<'info, global_config::GlobalConfig>>,
@@ -405,7 +421,7 @@ pub struct CreateStakeAccount<'info> {
         init,
         seeds = [
             CUSTODY_SEED.as_bytes(),
-            stake_account_checkpoints.key().as_ref()
+            payer.key().as_ref()
         ],
         bump,
         payer = payer,
@@ -418,11 +434,35 @@ pub struct CreateStakeAccount<'info> {
     pub token_program: Program<'info, Token>,
     pub system_program: Program<'info, System>,
 }
+#[derive(Accounts)]
+pub struct CreateCheckpoints<'info> {
+    // Native payer:
+    #[account(mut)]
+    pub payer: Signer<'info>,
+    #[account(mut)]
+    pub stake_account_metadata: Box<Account<'info, stake_account::StakeAccountMetadata>>,
+    // Stake program accounts:
+    #[account(mut)]
+    pub stake_account_checkpoints: AccountLoader<'info, checkpoints::CheckpointData>,
+    // Stake program accounts:
+    #[account(
+        init,
+        seeds = [CHECKPOINT_DATA_SEED.as_bytes(), payer.key().as_ref(), stake_account_metadata.stake_account_checkpoints_last_index.to_le_bytes().as_ref()],
+        bump,
+        payer = payer,
+        space = checkpoints::CheckpointData::LEN,
+    )]
+    pub new_stake_account_checkpoints: AccountLoader<'info, checkpoints::CheckpointData>,
+    // Primitive accounts :
+    pub system_program: Program<'info, System>,
+}
 
 #[derive(Accounts)]
+#[instruction(amount: u64, current_delegate_stake_account_metadata_owner: Pubkey, stake_account_metadata_owner: Pubkey
+)]
 pub struct WithdrawTokens<'info> {
     // Native payer:
-    #[account( address = stake_account_metadata.owner)]
+    #[account(mut, address = stake_account_metadata.owner)]
     pub payer: Signer<'info>,
 
     // Current delegate stake account:
@@ -431,7 +471,7 @@ pub struct WithdrawTokens<'info> {
         AccountLoader<'info, checkpoints::CheckpointData>,
     #[account(
         mut,
-        seeds = [STAKE_ACCOUNT_METADATA_SEED.as_bytes(), current_delegate_stake_account_checkpoints.key().as_ref()],
+        seeds = [STAKE_ACCOUNT_METADATA_SEED.as_bytes(), current_delegate_stake_account_metadata_owner.as_ref()],
         bump = current_delegate_stake_account_metadata.metadata_bump
     )]
     pub current_delegate_stake_account_metadata:
@@ -441,23 +481,23 @@ pub struct WithdrawTokens<'info> {
     #[account(mut)]
     pub destination: Account<'info, TokenAccount>,
     // Stake program accounts:
-    pub stake_account_checkpoints: AccountLoader<'info, checkpoints::CheckpointData>,
     #[account(
         mut,
-        seeds = [STAKE_ACCOUNT_METADATA_SEED.as_bytes(), stake_account_checkpoints.key().as_ref()],
+        seeds = [STAKE_ACCOUNT_METADATA_SEED.as_bytes(), stake_account_metadata_owner.as_ref()],
         bump = stake_account_metadata.metadata_bump,
-        constraint = stake_account_metadata.delegate == current_delegate_stake_account_checkpoints.key()
+        constraint = stake_account_metadata.delegate == current_delegate_stake_account_metadata_owner
             @ ErrorCode::InvalidCurrentDelegate
     )]
     pub stake_account_metadata: Box<Account<'info, stake_account::StakeAccountMetadata>>,
     #[account(
         mut,
-        seeds = [CUSTODY_SEED.as_bytes(), stake_account_checkpoints.key().as_ref()],
+        seeds = [CUSTODY_SEED.as_bytes(), payer.key().as_ref()],
         bump = stake_account_metadata.custody_bump,
     )]
     pub stake_account_custody: Account<'info, TokenAccount>,
     /// CHECK : This AccountInfo is safe because it's a checked PDA
-    #[account(seeds = [AUTHORITY_SEED.as_bytes(), stake_account_checkpoints.key().as_ref()], bump = stake_account_metadata.authority_bump)]
+    #[account(seeds = [AUTHORITY_SEED.as_bytes(), payer.key().as_ref()], bump = stake_account_metadata.authority_bump
+    )]
     pub custody_authority: AccountInfo<'info>,
     #[account(seeds = [CONFIG_SEED.as_bytes()], bump = config.bump)]
     pub config: Account<'info, global_config::GlobalConfig>,

solana/programs/staking/src/context.rs

@@ -5,12 +5,13 @@ use anchor_spl::token_interface::{
     transfer_checked, Mint, TokenAccount, TokenInterface, TransferChecked,
 };
 use std::convert::TryInto;
-
-use crate::error::VestingError;
+use crate::{
+    error::{ErrorCode, VestingError},
+    state::{Vesting, VestingBalance, VestingConfig},
+};
 use crate::state::checkpoints::{push_checkpoint, CheckpointData, Operation};
 use crate::state::global_config::GlobalConfig;
 use crate::state::stake_account::StakeAccountMetadata;
-use crate::state::{Vesting, VestingBalance, VestingConfig};
 
 #[derive(Accounts)]
 pub struct ClaimVesting<'info> {
@@ -79,6 +80,21 @@ impl<'info> ClaimVesting<'info> {
                 &mut self.stake_account_metadata,
                 &mut self.stake_account_checkpoints,
             ) {
+                // Check if stake account checkpoints is out of bounds
+                let loaded_checkpoints = stake_account_checkpoints.load()?;
+                require!(
+                    loaded_checkpoints.next_index
+                        < self.global_config.max_checkpoints_account_limit.into(),
+                    ErrorCode::TooManyCheckpoints,
+                );
+
+                // Verify that the actual address matches the expected one
+                require!(
+                    stake_account_metadata.delegate.key() == loaded_checkpoints.owner,
+                    VestingError::InvalidStakeAccountCheckpoints
+                );
+                drop(loaded_checkpoints);
+
                 require!(
                     self.config.mint == self.global_config.wh_token_mint,
                     // This error can never happen here, because for the condition above
@@ -89,12 +105,6 @@ impl<'info> ClaimVesting<'info> {
                     VestingError::InvalidVestingMint
                 );
 
-                // Verify that the actual address matches the expected one
-                require!(
-                    stake_account_metadata.delegate.key() == stake_account_checkpoints.key(),
-                    VestingError::InvalidStakeAccountCheckpoints
-                );
-
                 // Additional checks to ensure the owner matches
                 require!(
                     stake_account_metadata.owner == self.vesting_balance.vester,
@@ -122,6 +132,13 @@ impl<'info> ClaimVesting<'info> {
                     &self.vester.to_account_info(),
                     &self.system_program.to_account_info(),
                 )?;
+
+                let loaded_checkpoints = stake_account_checkpoints.load()?;
+                if loaded_checkpoints.next_index
+                    >= self.global_config.max_checkpoints_account_limit.into()
+                {
+                    stake_account_metadata.stake_account_checkpoints_last_index += 1;
+                }
             } else {
                 return err!(VestingError::ErrorOfStakeAccountParsing);
             }