Add vote init instruction for cleaner tests

stake-pool/py/actions/stake_pool.py → stake-pool/py/stake_pool/actions.py

@@ -15,8 +15,8 @@
 from stake_pool.state import STAKE_POOL_LAYOUT, ValidatorList, Fee, StakePool
 import stake_pool.instructions as sp
 
-import actions.stake
-import actions.token
+from stake.actions import create_stake
+from spl_token.actions import create_mint, create_associated_token_account
 
 
 async def create(client: AsyncClient, manager: Keypair,
@@ -87,12 +87,12 @@ async def create_all(client: AsyncClient, manager: Keypair, fee: Fee, referral_f
         STAKE_POOL_PROGRAM_ID, stake_pool.public_key)
 
     reserve_stake = Keypair()
-    await actions.stake.create_stake(client, manager, reserve_stake, pool_withdraw_authority)
+    await create_stake(client, manager, reserve_stake, pool_withdraw_authority)
 
     pool_mint = Keypair()
-    await actions.token.create_mint(client, manager, pool_mint, pool_withdraw_authority)
+    await create_mint(client, manager, pool_mint, pool_withdraw_authority)
 
-    manager_fee_account = await actions.token.create_associated_token_account(
+    manager_fee_account = await create_associated_token_account(
         client,
         manager,
         manager.public_key,

stake-pool/py/tests/conftest.py

@@ -4,13 +4,17 @@
 import shutil
 import tempfile
 import time
-from typing import Iterator
-from subprocess import run, Popen
+from typing import Iterator, List
+from subprocess import Popen
 
+from solana.keypair import Keypair
 from solana.publickey import PublicKey
 from solana.rpc.async_api import AsyncClient
 from solana.rpc.commitment import Confirmed
 
+from vote.actions import create_vote
+from system.actions import airdrop
+
 
 @pytest.fixture(scope="session")
 def solana_test_validator():
@@ -27,24 +31,16 @@ def solana_test_validator():
 
 
 @pytest.fixture
-def validators(async_client):
+def validators(event_loop, async_client, payer) -> List[PublicKey]:
     num_validators = 3
     validators = []
+    futures = []
     for i in range(num_validators):
-        tf = tempfile.NamedTemporaryFile()
-        identity = f"{tf.name}-identity-{i}.json"
-        run(["solana-keygen", "new", "-s", "-o", identity])
-        vote = f"{tf.name}-vote-{i}.json"
-        run(["solana-keygen", "new", "-s", "-o", vote])
-        withdrawer = f"{tf.name}-withdrawer-{i}.json"
-        run(["solana-keygen", "new", "-s", "-o", withdrawer])
-        run(["solana", "create-vote-account",
-             vote, identity, withdrawer,
-             "--commission", "1",
-             "--commitment", "confirmed",
-             "-ul"])
-        output = run(["solana-keygen", "pubkey", vote], capture_output=True)
-        validators.append(PublicKey(output.stdout.decode('utf-8').strip()))
+        vote = Keypair()
+        node = Keypair()
+        futures.append(create_vote(async_client, payer, vote, node, payer.public_key, payer.public_key, 10))
+        validators.append(vote.public_key)
+    event_loop.run_until_complete(asyncio.gather(*futures))
     return validators
 
 
@@ -68,3 +64,11 @@ def async_client(event_loop, solana_test_validator) -> Iterator[AsyncClient]:
         time.sleep(1)
     yield async_client
     event_loop.run_until_complete(async_client.close())
+
+
+@pytest.fixture
+def payer(event_loop, async_client) -> Keypair:
+    payer = Keypair()
+    airdrop_lamports = 10_000_000_000
+    event_loop.run_until_complete(airdrop(async_client, payer.public_key, airdrop_lamports))
+    return payer

stake-pool/py/tests/test_add_remove.py

@@ -1,27 +1,21 @@
 import pytest
-from solana.keypair import Keypair
 from solana.publickey import PublicKey
 from solana.rpc.commitment import Confirmed
 
-import actions.system
-import actions.stake_pool
 from vote.constants import VOTE_PROGRAM_ID
 from stake_pool.state import Fee, ValidatorList, StakeStatus
+from stake_pool.actions import create_all, add_validator_to_pool, remove_validator_from_pool
 
 
 @pytest.mark.asyncio
-async def test_add_validator(async_client, validators):
-    manager = Keypair()
-    airdrop_lamports = 1_000_000_000_000
-    await actions.system.airdrop(async_client, manager.public_key, airdrop_lamports)
-
+async def test_add_validator(async_client, validators, payer):
     fee = Fee(numerator=1, denominator=1000)
     referral_fee = 20
-    (stake_pool, validator_list_address) = await actions.stake_pool.create_all(async_client, manager, fee, referral_fee)
+    (stake_pool, validator_list_address) = await create_all(async_client, payer, fee, referral_fee)
     for validator in validators:
         resp = await async_client.get_account_info(validator, commitment=Confirmed)
         assert PublicKey(resp['result']['value']['owner']) == VOTE_PROGRAM_ID
-        await actions.stake_pool.add_validator_to_pool(async_client, manager, stake_pool, validator)
+        await add_validator_to_pool(async_client, payer, stake_pool, validator)
 
     resp = await async_client.get_account_info(validator_list_address, commitment=Confirmed)
     data = resp['result']['value']['data']
@@ -33,7 +27,7 @@ async def test_add_validator(async_client, validators):
         assert validator_info.transient_stake_lamports == 0
         assert validator_info.last_update_epoch == 0
         assert validator_info.status == StakeStatus.ACTIVE
-        await actions.stake_pool.remove_validator_from_pool(async_client, manager, stake_pool, validator)
+        await remove_validator_from_pool(async_client, payer, stake_pool, validator)
 
     resp = await async_client.get_account_info(validator_list_address, commitment=Confirmed)
     data = resp['result']['value']['data']

stake-pool/py/tests/test_create.py

@@ -6,80 +6,42 @@
 from stake_pool.constants import find_withdraw_authority_program_address, STAKE_POOL_PROGRAM_ID
 from stake_pool.state import StakePool, Fee
 
-import actions.system
-import actions.stake
-import actions.stake_pool
-import actions.token
+from stake.actions import create_stake
+from stake_pool.actions import create
+from spl_token.actions import create_mint, create_associated_token_account
 
 
 @pytest.mark.asyncio
-async def test_airdrop(async_client):
-    manager = Keypair()
-    airdrop_lamports = 1_000_000
-    await actions.system.airdrop(async_client, manager.public_key, airdrop_lamports)
-    resp = await async_client.get_balance(manager.public_key, commitment=Confirmed)
-    assert resp['result']['value'] == airdrop_lamports
-
-
-@pytest.mark.asyncio
-async def test_create_stake(async_client):
-    owner = Keypair()
-    reserve_stake = Keypair()
-    airdrop_lamports = 1_000_000_000
-    await actions.system.airdrop(async_client, owner.public_key, airdrop_lamports)
-    await actions.stake.create_stake(async_client, owner, reserve_stake, owner.public_key)
-
-
-@pytest.mark.asyncio
-async def test_create_mint(async_client):
-    owner = Keypair()
-    airdrop_lamports = 1_000_000_000
-    await actions.system.airdrop(async_client, owner.public_key, airdrop_lamports)
-    pool_mint = Keypair()
-    await actions.token.create_mint(async_client, owner, pool_mint, owner.public_key)
-    await actions.token.create_associated_token_account(
-        async_client,
-        owner,
-        owner.public_key,
-        pool_mint.public_key,
-    )
-
-
-@pytest.mark.asyncio
-async def test_create_stake_pool(async_client):
-    manager = Keypair()
-    airdrop_lamports = 1_000_000_000_000
-    await actions.system.airdrop(async_client, manager.public_key, airdrop_lamports)
-
+async def test_create_stake_pool(async_client, payer):
     stake_pool = Keypair()
     validator_list = Keypair()
     (pool_withdraw_authority, seed) = find_withdraw_authority_program_address(
         STAKE_POOL_PROGRAM_ID, stake_pool.public_key)
 
     reserve_stake = Keypair()
-    await actions.stake.create_stake(async_client, manager, reserve_stake, pool_withdraw_authority)
+    await create_stake(async_client, payer, reserve_stake, pool_withdraw_authority)
 
     pool_mint = Keypair()
-    await actions.token.create_mint(async_client, manager, pool_mint, pool_withdraw_authority)
+    await create_mint(async_client, payer, pool_mint, pool_withdraw_authority)
 
-    manager_fee_account = await actions.token.create_associated_token_account(
+    manager_fee_account = await create_associated_token_account(
         async_client,
-        manager,
-        manager.public_key,
+        payer,
+        payer.public_key,
         pool_mint.public_key,
     )
 
     fee = Fee(numerator=1, denominator=1000)
     referral_fee = 20
-    await actions.stake_pool.create(
-        async_client, manager, stake_pool, validator_list, pool_mint.public_key,
+    await create(
+        async_client, payer, stake_pool, validator_list, pool_mint.public_key,
         reserve_stake.public_key, manager_fee_account, fee, referral_fee)
     resp = await async_client.get_account_info(stake_pool.public_key, commitment=Confirmed)
     assert resp['result']['value']['owner'] == str(STAKE_POOL_PROGRAM_ID)
     data = resp['result']['value']['data']
     pool_data = StakePool.decode(data[0], data[1])
-    assert pool_data.manager == manager.public_key
-    assert pool_data.staker == manager.public_key
+    assert pool_data.manager == payer.public_key
+    assert pool_data.staker == payer.public_key
     assert pool_data.stake_withdraw_bump_seed == seed
     assert pool_data.validator_list == validator_list.public_key
     assert pool_data.reserve_stake == reserve_stake.public_key

stake-pool/py/tests/test_stake.py

@@ -0,0 +1,10 @@
+import pytest
+from solana.keypair import Keypair
+
+from stake.actions import create_stake
+
+
+@pytest.mark.asyncio
+async def test_create_stake(async_client, payer):
+    reserve_stake = Keypair()
+    await create_stake(async_client, payer, reserve_stake, payer.public_key)

stake-pool/py/tests/test_system.py

@@ -0,0 +1,14 @@
+import pytest
+from solana.keypair import Keypair
+from solana.rpc.commitment import Confirmed
+
+import system.actions
+
+
+@pytest.mark.asyncio
+async def test_airdrop(async_client):
+    manager = Keypair()
+    airdrop_lamports = 1_000_000
+    await system.actions.airdrop(async_client, manager.public_key, airdrop_lamports)
+    resp = await async_client.get_balance(manager.public_key, commitment=Confirmed)
+    assert resp['result']['value'] == airdrop_lamports

stake-pool/py/tests/test_token.py

@@ -0,0 +1,16 @@
+import pytest
+from solana.keypair import Keypair
+
+from spl_token.actions import create_mint, create_associated_token_account
+
+
+@pytest.mark.asyncio
+async def test_create_mint(async_client, payer):
+    pool_mint = Keypair()
+    await create_mint(async_client, payer, pool_mint, payer.public_key)
+    await create_associated_token_account(
+        async_client,
+        payer,
+        payer.public_key,
+        pool_mint.public_key,
+    )

stake-pool/py/tests/test_vote.py

@@ -0,0 +1,11 @@
+import pytest
+from solana.keypair import Keypair
+
+from vote.actions import create_vote
+
+
+@pytest.mark.asyncio
+async def test_create_vote(async_client, payer):
+    vote = Keypair()
+    node = Keypair()
+    await create_vote(async_client, payer, vote, node, payer.public_key, payer.public_key, 10)

stake-pool/py/vote/actions.py

@@ -0,0 +1,45 @@
+from solana.publickey import PublicKey
+from solana.keypair import Keypair
+from solana.rpc.async_api import AsyncClient
+from solana.rpc.commitment import Confirmed
+from solana.rpc.types import TxOpts
+from solana.sysvar import SYSVAR_CLOCK_PUBKEY, SYSVAR_RENT_PUBKEY
+from solana.transaction import Transaction
+import solana.system_program as sys
+
+from vote.constants import VOTE_PROGRAM_ID, VOTE_STATE_LEN
+from vote.instructions import initialize, InitializeParams
+
+
+async def create_vote(
+        client: AsyncClient, payer: Keypair, vote: Keypair, node: Keypair,
+        voter: PublicKey, withdrawer: PublicKey, commission: int):
+    print(f"Creating vote account {vote.public_key}")
+    resp = await client.get_minimum_balance_for_rent_exemption(VOTE_STATE_LEN)
+    txn = Transaction()
+    txn.add(
+        sys.create_account(
+            sys.CreateAccountParams(
+                from_pubkey=payer.public_key,
+                new_account_pubkey=vote.public_key,
+                lamports=resp['result'],
+                space=VOTE_STATE_LEN,
+                program_id=VOTE_PROGRAM_ID,
+            )
+        )
+    )
+    txn.add(
+        initialize(
+            InitializeParams(
+                vote=vote.public_key,
+                rent_sysvar=SYSVAR_RENT_PUBKEY,
+                clock_sysvar=SYSVAR_CLOCK_PUBKEY,
+                node=node.public_key,
+                authorized_voter=voter,
+                authorized_withdrawer=withdrawer,
+                commission=commission,
+            )
+        )
+    )
+    await client.send_transaction(
+        txn, payer, vote, node, opts=TxOpts(skip_confirmation=False, preflight_commitment=Confirmed))

stake-pool/py/vote/constants.py

@@ -3,3 +3,6 @@
 
 VOTE_PROGRAM_ID = PublicKey("Vote111111111111111111111111111111111111111")
 """Program id for the native vote program."""
+
+VOTE_STATE_LEN: int = 3731
+"""Size of vote account."""