Fix python and JS constants

Author: joncinque

stake-pool/js/src/constants.ts

@@ -12,4 +12,4 @@ export const TRANSIENT_STAKE_SEED_PREFIX = Buffer.from('transient');
 
 // Minimum amount of staked SOL required in a validator stake account to allow
 // for merges without a mismatch on credits observed
-export const MINIMUM_ACTIVE_STAKE = LAMPORTS_PER_SOL / 1_000;
+export const MINIMUM_ACTIVE_STAKE = LAMPORTS_PER_SOL;

stake-pool/program/tests/update_validator_list_balance.rs

@@ -7,13 +7,14 @@ use {
     solana_program::{borsh::try_from_slice_unchecked, program_pack::Pack, pubkey::Pubkey, stake},
     solana_program_test::*,
     solana_sdk::{
-        stake::state::{Authorized, Lockup, StakeState},
         signature::{Keypair, Signer},
+        stake::state::{Authorized, Lockup, StakeState},
         system_instruction,
         transaction::Transaction,
     },
     spl_stake_pool::{
-        find_withdraw_authority_program_address, find_transient_stake_program_address, id, instruction,
+        find_transient_stake_program_address, find_withdraw_authority_program_address, id,
+        instruction,
         state::{StakePool, StakeStatus, ValidatorList},
         MAX_VALIDATORS_TO_UPDATE, MINIMUM_ACTIVE_STAKE, MINIMUM_RESERVE_LAMPORTS,
     },
@@ -686,10 +687,20 @@ async fn success_ignoring_hijacked_transient_stake_with_authorized() {
 #[tokio::test]
 async fn success_ignoring_hijacked_transient_stake_with_lockup() {
     let hijacker = Pubkey::new_unique();
-    check_ignored_hijacked_transient_stake(None, Some(&Lockup { custodian: hijacker, ..Lockup::default() })).await;
+    check_ignored_hijacked_transient_stake(
+        None,
+        Some(&Lockup {
+            custodian: hijacker,
+            ..Lockup::default()
+        }),
+    )
+    .await;
 }
 
-async fn check_ignored_hijacked_transient_stake(hijack_authorized: Option<&Authorized>, hijack_lockup: Option<&Lockup>) {
+async fn check_ignored_hijacked_transient_stake(
+    hijack_authorized: Option<&Authorized>,
+    hijack_lockup: Option<&Lockup>,
+) {
     let num_validators = 1;
     let (mut context, stake_pool_accounts, stake_accounts, _, lamports, _, mut slot) =
         setup(num_validators).await;

stake-pool/py/bot/rebalance.py

@@ -7,15 +7,12 @@
 from solana.rpc.async_api import AsyncClient
 from solana.rpc.commitment import Confirmed
 
-from stake.constants import STAKE_LEN
+from stake.constants import STAKE_LEN, LAMPORTS_PER_SOL
 from stake_pool.actions import decrease_validator_stake, increase_validator_stake, update_stake_pool
+from stake_pool.constants import MINIMUM_ACTIVE_STAKE
 from stake_pool.state import StakePool, ValidatorList
 
 
-LAMPORTS_PER_SOL: int = 1_000_000_000
-MINIMUM_INCREASE_LAMPORTS: int = LAMPORTS_PER_SOL // 100
-
-
 async def get_client(endpoint: str) -> AsyncClient:
     print(f'Connecting to network at {endpoint}')
     async_client = AsyncClient(endpoint=endpoint, commitment=Confirmed)
@@ -87,10 +84,10 @@ async def rebalance(endpoint: str, stake_pool_address: PublicKey, staker: Keypai
                     ))
             elif validator.active_stake_lamports < lamports_per_validator:
                 lamports_to_increase = lamports_per_validator - validator.active_stake_lamports
-                if lamports_to_increase < MINIMUM_INCREASE_LAMPORTS:
+                if lamports_to_increase < MINIMUM_ACTIVE_STAKE:
                     print(f'Skipping increase on {validator.vote_account_address}, \
 currently at {validator.active_stake_lamports} lamports, \
-increase of {lamports_to_increase} less than the minimum of {MINIMUM_INCREASE_LAMPORTS}')
+increase of {lamports_to_increase} less than the minimum of {MINIMUM_ACTIVE_STAKE}')
                 else:
                     futures.append(increase_validator_stake(
                         async_client, staker, staker, stake_pool_address,

stake-pool/py/stake/constants.py

@@ -10,3 +10,9 @@
 
 STAKE_LEN: int = 200
 """Size of stake account."""
+
+LAMPORTS_PER_SOL: int = 1_000_000_000
+"""Number of lamports per SOL"""
+
+MINIMUM_DELEGATION: int = LAMPORTS_PER_SOL
+"""Minimum delegation allowed by the stake program"""

stake-pool/py/stake_pool/actions.py

@@ -16,6 +16,7 @@
 from stake.state import StakeAuthorize
 from stake_pool.constants import \
     MAX_VALIDATORS_TO_UPDATE, \
+    MINIMUM_RESERVE_LAMPORTS, \
     STAKE_POOL_PROGRAM_ID, \
     find_stake_program_address, \
     find_transient_stake_program_address, \
@@ -98,7 +99,7 @@ async def create_all(client: AsyncClient, manager: Keypair, fee: Fee, referral_f
         STAKE_POOL_PROGRAM_ID, stake_pool.public_key)
 
     reserve_stake = Keypair()
-    await create_stake(client, manager, reserve_stake, pool_withdraw_authority, 1)
+    await create_stake(client, manager, reserve_stake, pool_withdraw_authority, MINIMUM_RESERVE_LAMPORTS)
 
     pool_mint = Keypair()
     await create_mint(client, manager, pool_mint, pool_withdraw_authority)

stake-pool/py/stake_pool/constants.py

@@ -3,13 +3,20 @@
 from typing import Tuple
 
 from solana.publickey import PublicKey
+from stake.constants import MINIMUM_DELEGATION
 
 STAKE_POOL_PROGRAM_ID: PublicKey = PublicKey("SPoo1Ku8WFXoNDMHPsrGSTSG1Y47rzgn41SLUNakuHy")
 """Public key that identifies the SPL Stake Pool program."""
 
 MAX_VALIDATORS_TO_UPDATE: int = 5
 """Maximum number of validators to update during UpdateValidatorListBalance."""
 
+MINIMUM_RESERVE_LAMPORTS: int = MINIMUM_DELEGATION
+"""Minimum balance required in the stake pool reserve"""
+
+MINIMUM_ACTIVE_STAKE: int = MINIMUM_DELEGATION
+"""Minimum active delegated staked required in a stake account"""
+
 
 def find_deposit_authority_program_address(
     program_id: PublicKey,

stake-pool/py/tests/conftest.py

@@ -92,7 +92,7 @@ def async_client(event_loop, solana_test_validator) -> Iterator[AsyncClient]:
 @pytest.fixture
 def payer(event_loop, async_client) -> Keypair:
     payer = Keypair()
-    airdrop_lamports = 10_000_000_000
+    airdrop_lamports = 20_000_000_000
     event_loop.run_until_complete(airdrop(async_client, payer.public_key, airdrop_lamports))
     return payer
 

stake-pool/py/tests/test_a_time_sensitive.py

@@ -5,16 +5,17 @@
 from spl.token.instructions import get_associated_token_address
 
 from stake.constants import STAKE_LEN
-from stake_pool.state import StakePool, ValidatorList
 from stake_pool.actions import deposit_sol, decrease_validator_stake, increase_validator_stake, update_stake_pool
+from stake_pool.constants import MINIMUM_ACTIVE_STAKE
+from stake_pool.state import StakePool, ValidatorList
 
 
 @pytest.mark.asyncio
 async def test_increase_decrease_this_is_very_slow(async_client, validators, payer, stake_pool_addresses, waiter):
     (stake_pool_address, validator_list_address) = stake_pool_addresses
     resp = await async_client.get_minimum_balance_for_rent_exemption(STAKE_LEN)
     stake_rent_exemption = resp['result']
-    increase_amount = 100_000_000
+    increase_amount = MINIMUM_ACTIVE_STAKE * 2
     decrease_amount = increase_amount // 2
     deposit_amount = (increase_amount + stake_rent_exemption) * len(validators)
 

stake-pool/py/tests/test_bot_rebalance.py

@@ -3,9 +3,10 @@
 from solana.rpc.commitment import Confirmed
 from spl.token.instructions import get_associated_token_address
 
-from stake.constants import STAKE_LEN
-from stake_pool.state import StakePool, ValidatorList
+from stake.constants import STAKE_LEN, LAMPORTS_PER_SOL
 from stake_pool.actions import deposit_sol
+from stake_pool.constants import MINIMUM_ACTIVE_STAKE, MINIMUM_RESERVE_LAMPORTS
+from stake_pool.state import StakePool, ValidatorList
 
 from bot.rebalance import rebalance
 
@@ -18,7 +19,7 @@ async def test_rebalance_this_is_very_slow(async_client, validators, payer, stak
     (stake_pool_address, validator_list_address) = stake_pool_addresses
     resp = await async_client.get_minimum_balance_for_rent_exemption(STAKE_LEN)
     stake_rent_exemption = resp['result']
-    increase_amount = 100_000_000
+    increase_amount = MINIMUM_ACTIVE_STAKE
     deposit_amount = (increase_amount + stake_rent_exemption) * len(validators)
 
     resp = await async_client.get_account_info(stake_pool_address, commitment=Confirmed)
@@ -32,7 +33,7 @@ async def test_rebalance_this_is_very_slow(async_client, validators, payer, stak
 
     # should only have minimum left
     resp = await async_client.get_account_info(stake_pool.reserve_stake, commitment=Confirmed)
-    assert resp['result']['value']['lamports'] == stake_rent_exemption + 1
+    assert resp['result']['value']['lamports'] == stake_rent_exemption + MINIMUM_RESERVE_LAMPORTS
 
     # should all be the same
     resp = await async_client.get_account_info(validator_list_address, commitment=Confirmed)
@@ -45,12 +46,12 @@ async def test_rebalance_this_is_very_slow(async_client, validators, payer, stak
     # Test case 2: Decrease
     print('Waiting for next epoch')
     await waiter.wait_for_next_epoch(async_client)
-    await rebalance(ENDPOINT, stake_pool_address, payer, deposit_amount / 1_000_000_000)
+    await rebalance(ENDPOINT, stake_pool_address, payer, deposit_amount / LAMPORTS_PER_SOL)
 
     # should still only have minimum left + rent exemptions from increase
     resp = await async_client.get_account_info(stake_pool.reserve_stake, commitment=Confirmed)
     reserve_lamports = resp['result']['value']['lamports']
-    assert reserve_lamports == stake_rent_exemption * (1 + len(validator_list.validators)) + 1
+    assert reserve_lamports == stake_rent_exemption * (1 + len(validator_list.validators)) + MINIMUM_RESERVE_LAMPORTS
 
     # should all be decreasing now
     resp = await async_client.get_account_info(validator_list_address, commitment=Confirmed)
@@ -63,12 +64,12 @@ async def test_rebalance_this_is_very_slow(async_client, validators, payer, stak
     # Test case 3: Do nothing
     print('Waiting for next epoch')
     await waiter.wait_for_next_epoch(async_client)
-    await rebalance(ENDPOINT, stake_pool_address, payer, deposit_amount / 1_000_000_000)
+    await rebalance(ENDPOINT, stake_pool_address, payer, deposit_amount / LAMPORTS_PER_SOL)
 
     # should still only have minimum left + rent exemptions from increase
     resp = await async_client.get_account_info(stake_pool.reserve_stake, commitment=Confirmed)
     reserve_lamports = resp['result']['value']['lamports']
-    assert reserve_lamports == stake_rent_exemption + deposit_amount + 1
+    assert reserve_lamports == stake_rent_exemption + deposit_amount + MINIMUM_RESERVE_LAMPORTS
 
     # should all be decreasing now
     resp = await async_client.get_account_info(validator_list_address, commitment=Confirmed)

stake-pool/py/tests/test_create.py

@@ -3,7 +3,10 @@
 from solana.rpc.commitment import Confirmed
 from spl.token.constants import TOKEN_PROGRAM_ID
 
-from stake_pool.constants import find_withdraw_authority_program_address, STAKE_POOL_PROGRAM_ID
+from stake_pool.constants import \
+    find_withdraw_authority_program_address, \
+    MINIMUM_RESERVE_LAMPORTS, \
+    STAKE_POOL_PROGRAM_ID
 from stake_pool.state import StakePool, Fee
 
 from stake.actions import create_stake
@@ -19,7 +22,7 @@ async def test_create_stake_pool(async_client, payer):
         STAKE_POOL_PROGRAM_ID, stake_pool.public_key)
 
     reserve_stake = Keypair()
-    await create_stake(async_client, payer, reserve_stake, pool_withdraw_authority, 1)
+    await create_stake(async_client, payer, reserve_stake, pool_withdraw_authority, MINIMUM_RESERVE_LAMPORTS)
 
     pool_mint = Keypair()
     await create_mint(async_client, payer, pool_mint, pool_withdraw_authority)

stake-pool/py/tests/test_deposit_withdraw_stake.py

@@ -7,6 +7,7 @@
 from stake.constants import STAKE_LEN
 from stake.state import StakeState
 from stake_pool.actions import deposit_stake, withdraw_stake, update_stake_pool
+from stake_pool.constants import MINIMUM_ACTIVE_STAKE
 from stake_pool.state import StakePool
 
 
@@ -17,7 +18,7 @@ async def test_deposit_withdraw_stake(async_client, validators, payer, stake_poo
     data = resp['result']['value']['data']
     stake_pool = StakePool.decode(data[0], data[1])
     validator = next(iter(validators))
-    stake_amount = 1_000_000
+    stake_amount = MINIMUM_ACTIVE_STAKE
     stake = Keypair()
     await create_stake(async_client, payer, stake, payer.public_key, stake_amount)
     stake = stake.public_key

stake-pool/py/tests/test_stake.py

@@ -2,14 +2,15 @@
 import pytest
 from solana.keypair import Keypair
 
-from stake.state import StakeAuthorize
 from stake.actions import authorize, create_stake, delegate_stake
+from stake.constants import MINIMUM_DELEGATION
+from stake.state import StakeAuthorize
 
 
 @pytest.mark.asyncio
 async def test_create_stake(async_client, payer):
     stake = Keypair()
-    await create_stake(async_client, payer, stake, payer.public_key, 100_000)
+    await create_stake(async_client, payer, stake, payer.public_key, MINIMUM_DELEGATION)
 
 
 @pytest.mark.asyncio
@@ -24,7 +25,7 @@ async def test_delegate_stake(async_client, validators, payer):
 async def test_authorize_stake(async_client, payer):
     stake = Keypair()
     new_authority = Keypair()
-    await create_stake(async_client, payer, stake, payer.public_key, 1_000)
+    await create_stake(async_client, payer, stake, payer.public_key, MINIMUM_DELEGATION)
     await asyncio.gather(
         authorize(async_client, payer, payer, stake.public_key, new_authority.public_key, StakeAuthorize.STAKER),
         authorize(async_client, payer, payer, stake.public_key, new_authority.public_key, StakeAuthorize.WITHDRAWER)