Replace Deprecated Account type with Keypair

Pipfile

@@ -28,7 +28,7 @@ pytest-asyncio = "*"
 types-requests = "*"
 
 [packages]
-solana = {version = ">=0.11.3"}
+solana = {version = ">=0.15.0"}
 construct = "*"
 flake8 = "*"
 construct-typing = "*"

pyserum/market/async_market.py

@@ -3,7 +3,7 @@
 
 from typing import List
 
-from solana.account import Account
+from solana.keypair import Keypair
 from solana.publickey import PublicKey
 from solana.rpc.async_api import AsyncClient
 from solana.rpc.types import RPCResponse, TxOpts
@@ -91,7 +91,7 @@ async def load_fills(self, limit=100) -> List[t.FilledOrder]:
     async def place_order(  # pylint: disable=too-many-arguments,too-many-locals
         self,
         payer: PublicKey,
-        owner: Account,
+        owner: Keypair,
         order_type: OrderType,
         side: Side,
         limit_price: float,
@@ -100,8 +100,8 @@ async def place_order(  # pylint: disable=too-many-arguments,too-many-locals
         opts: TxOpts = TxOpts(),
     ) -> RPCResponse:  # TODO: Add open_orders_address_key param and fee_discount_pubkey
         transaction = Transaction()
-        signers: List[Account] = [owner]
-        open_order_accounts = await self.find_open_orders_accounts_for_owner(owner.public_key())
+        signers: List[Keypair] = [owner]
+        open_order_accounts = await self.find_open_orders_accounts_for_owner(owner.public_key)
         if open_order_accounts:
             place_order_open_order_account = open_order_accounts[0].address
         else:
@@ -128,24 +128,24 @@ async def place_order(  # pylint: disable=too-many-arguments,too-many-locals
         return await self._conn.send_transaction(transaction, *signers, opts=opts)
 
     async def cancel_order_by_client_id(
-        self, owner: Account, open_orders_account: PublicKey, client_id: int, opts: TxOpts = TxOpts()
+        self, owner: Keypair, open_orders_account: PublicKey, client_id: int, opts: TxOpts = TxOpts()
     ) -> RPCResponse:
         txs = self._build_cancel_order_by_client_id_tx(
             owner=owner, open_orders_account=open_orders_account, client_id=client_id
         )
         return await self._conn.send_transaction(txs, owner, opts=opts)
 
-    async def cancel_order(self, owner: Account, order: t.Order, opts: TxOpts = TxOpts()) -> RPCResponse:
+    async def cancel_order(self, owner: Keypair, order: t.Order, opts: TxOpts = TxOpts()) -> RPCResponse:
         txn = self._build_cancel_order_tx(owner=owner, order=order)
         return await self._conn.send_transaction(txn, owner, opts=opts)
 
-    async def match_orders(self, fee_payer: Account, limit: int, opts: TxOpts = TxOpts()) -> RPCResponse:
+    async def match_orders(self, fee_payer: Keypair, limit: int, opts: TxOpts = TxOpts()) -> RPCResponse:
         txn = self._build_match_orders_tx(limit)
         return await self._conn.send_transaction(txn, fee_payer, opts=opts)
 
     async def settle_funds(  # pylint: disable=too-many-arguments
         self,
-        owner: Account,
+        owner: Keypair,
         open_orders: AsyncOpenOrdersAccount,
         base_wallet: PublicKey,
         quote_wallet: PublicKey,  # TODO: add referrer_quote_wallet.

pyserum/market/core.py

@@ -5,7 +5,7 @@
 import logging
 from typing import List, Union
 
-from solana.account import Account
+from solana.keypair import Keypair
 from solana.publickey import PublicKey
 from solana.rpc.types import RPCResponse
 from solana.system_program import CreateAccountParams, create_account
@@ -115,14 +115,15 @@ def parse_fill_event(self, event: t.Event) -> t.FilledOrder:
         )
 
     def _prepare_new_oo_account(
-        self, owner: Account, balance_needed: int, signers: List[Account], transaction: Transaction
+        self, owner: Keypair, balance_needed: int, signers: List[Keypair], transaction: Transaction
     ) -> PublicKey:
-        new_open_orders_account = Account()
-        place_order_open_order_account = new_open_orders_account.public_key()
+        # new_open_orders_account = Account()
+        new_open_orders_account = Keypair()
+        place_order_open_order_account = new_open_orders_account.public_key
         transaction.add(
             make_create_account_instruction(
-                owner_address=owner.public_key(),
-                new_account_address=new_open_orders_account.public_key(),
+                owner_address=owner.public_key,
+                new_account_address=new_open_orders_account.public_key,
                 lamports=balance_needed,
                 program_id=self.state.program_id(),
             )
@@ -134,18 +135,18 @@ def _prepare_order_transaction(  # pylint: disable=too-many-arguments,too-many-l
         self,
         transaction: Transaction,
         payer: PublicKey,
-        owner: Account,
+        owner: Keypair,
         order_type: OrderType,
         side: Side,
-        signers: List[Account],
+        signers: List[Keypair],
         limit_price: float,
         max_quantity: float,
         client_id: int,
         open_order_accounts: Union[List[OpenOrdersAccount], List[AsyncOpenOrdersAccount]],
         place_order_open_order_account: PublicKey,
     ) -> None:
         # unwrapped SOL cannot be used for payment
-        if payer == owner.public_key():
+        if payer == owner.public_key:
             raise ValueError("Invalid payer account. Cannot use unwrapped SOL.")
 
         # TODO: add integration test for SOL wrapping.
@@ -154,14 +155,15 @@ def _prepare_order_transaction(  # pylint: disable=too-many-arguments,too-many-l
         )
 
         if should_wrap_sol:
-            wrapped_sol_account = Account()
-            payer = wrapped_sol_account.public_key()
+            # wrapped_sol_account = Account()
+            wrapped_sol_account = Keypair()
+            payer = wrapped_sol_account.public_key
             signers.append(wrapped_sol_account)
             transaction.add(
                 create_account(
                     CreateAccountParams(
-                        from_pubkey=owner.public_key(),
-                        new_account_pubkey=wrapped_sol_account.public_key(),
+                        from_pubkey=owner.public_key,
+                        new_account_pubkey=wrapped_sol_account.public_key,
                         lamports=self._get_lamport_need_for_sol_wrapping(
                             limit_price, max_quantity, side, open_order_accounts
                         ),
@@ -173,9 +175,9 @@ def _prepare_order_transaction(  # pylint: disable=too-many-arguments,too-many-l
             transaction.add(
                 initialize_account(
                     InitializeAccountParams(
-                        account=wrapped_sol_account.public_key(),
+                        account=wrapped_sol_account.public_key,
                         mint=WRAPPED_SOL_MINT,
-                        owner=owner.public_key(),
+                        owner=owner.public_key,
                         program_id=TOKEN_PROGRAM_ID,
                     )
                 )
@@ -198,16 +200,16 @@ def _prepare_order_transaction(  # pylint: disable=too-many-arguments,too-many-l
             transaction.add(
                 close_account(
                     CloseAccountParams(
-                        account=wrapped_sol_account.public_key(),
-                        owner=owner.public_key(),
-                        dest=owner.public_key(),
+                        account=wrapped_sol_account.public_key,
+                        owner=owner.public_key,
+                        dest=owner.public_key,
                         program_id=TOKEN_PROGRAM_ID,
                     )
                 )
             )
 
     def _after_oo_mbfre_resp(
-        self, mbfre_resp: RPCResponse, owner: Account, signers: List[Account], transaction: Transaction
+        self, mbfre_resp: RPCResponse, owner: Keypair, signers: List[Keypair], transaction: Transaction
     ) -> PublicKey:
         balance_needed = mbfre_resp["result"]
         place_order_open_order_account = self._prepare_new_oo_account(owner, balance_needed, signers, transaction)
@@ -235,7 +237,7 @@ def _get_lamport_need_for_sol_wrapping(
     def make_place_order_instruction(  # pylint: disable=too-many-arguments
         self,
         payer: PublicKey,
-        owner: Account,
+        owner: Keypair,
         order_type: OrderType,
         side: Side,
         limit_price: float,
@@ -254,7 +256,7 @@ def make_place_order_instruction(  # pylint: disable=too-many-arguments
                     market=self.state.public_key(),
                     open_orders=open_order_account,
                     payer=payer,
-                    owner=owner.public_key(),
+                    owner=owner.public_key,
                     request_queue=self.state.request_queue(),
                     base_vault=self.state.base_vault(),
                     quote_vault=self.state.quote_vault(),
@@ -271,7 +273,7 @@ def make_place_order_instruction(  # pylint: disable=too-many-arguments
                 market=self.state.public_key(),
                 open_orders=open_order_account,
                 payer=payer,
-                owner=owner.public_key(),
+                owner=owner.public_key,
                 request_queue=self.state.request_queue(),
                 event_queue=self.state.event_queue(),
                 bids=self.state.bids(),
@@ -294,18 +296,18 @@ def make_place_order_instruction(  # pylint: disable=too-many-arguments
         )
 
     def _build_cancel_order_by_client_id_tx(
-        self, owner: Account, open_orders_account: PublicKey, client_id: int
+        self, owner: Keypair, open_orders_account: PublicKey, client_id: int
     ) -> Transaction:
         return Transaction().add(self.make_cancel_order_by_client_id_instruction(owner, open_orders_account, client_id))
 
     def make_cancel_order_by_client_id_instruction(
-        self, owner: Account, open_orders_account: PublicKey, client_id: int
+        self, owner: Keypair, open_orders_account: PublicKey, client_id: int
     ) -> TransactionInstruction:
         if self._use_request_queue():
             return instructions.cancel_order_by_client_id(
                 instructions.CancelOrderByClientIDParams(
                     market=self.state.public_key(),
-                    owner=owner.public_key(),
+                    owner=owner.public_key,
                     open_orders=open_orders_account,
                     request_queue=self.state.request_queue(),
                     client_id=client_id,
@@ -315,7 +317,7 @@ def make_cancel_order_by_client_id_instruction(
         return instructions.cancel_order_by_client_id_v2(
             instructions.CancelOrderByClientIDV2Params(
                 market=self.state.public_key(),
-                owner=owner.public_key(),
+                owner=owner.public_key,
                 open_orders=open_orders_account,
                 bids=self.state.bids(),
                 asks=self.state.asks(),
@@ -325,8 +327,8 @@ def make_cancel_order_by_client_id_instruction(
             )
         )
 
-    def _build_cancel_order_tx(self, owner: Account, order: t.Order) -> Transaction:
-        return Transaction().add(self.make_cancel_order_instruction(owner.public_key(), order))
+    def _build_cancel_order_tx(self, owner: Keypair, order: t.Order) -> Transaction:
+        return Transaction().add(self.make_cancel_order_instruction(owner.public_key, order))
 
     def make_cancel_order_instruction(self, owner: PublicKey, order: t.Order) -> TransactionInstruction:
         if self._use_request_queue():
@@ -376,16 +378,16 @@ def make_match_orders_instruction(self, limit: int) -> TransactionInstruction:
 
     def _build_settle_funds_tx(  # pylint: disable=too-many-arguments
         self,
-        owner: Account,
-        signers: List[Account],
+        owner: Keypair,
+        signers: List[Keypair],
         open_orders: Union[OpenOrdersAccount, AsyncOpenOrdersAccount],
         base_wallet: PublicKey,
         quote_wallet: PublicKey,  # TODO: add referrer_quote_wallet.
         min_bal_for_rent_exemption: int,
         should_wrap_sol: bool,
     ) -> Transaction:
         # TODO: Handle wrapped sol accounts
-        if open_orders.owner != owner.public_key():
+        if open_orders.owner != owner.public_key:
             raise Exception("Invalid open orders account")
         vault_signer = PublicKey.create_program_address(
             [bytes(self.state.public_key()), self.state.vault_signer_nonce().to_bytes(8, byteorder="little")],
@@ -394,15 +396,15 @@ def _build_settle_funds_tx(  # pylint: disable=too-many-arguments
         transaction = Transaction()
 
         if should_wrap_sol:
-            wrapped_sol_account = Account()
+            wrapped_sol_account = Keypair()
             signers.append(wrapped_sol_account)
             # make a wrapped SOL account with enough balance to
             # fund the trade, run the program, then send itself back home
             transaction.add(
                 create_account(
                     CreateAccountParams(
-                        from_pubkey=owner.public_key(),
-                        new_account_pubkey=wrapped_sol_account.public_key(),
+                        from_pubkey=owner.public_key,
+                        new_account_pubkey=wrapped_sol_account.public_key,
                         lamports=min_bal_for_rent_exemption,
                         space=ACCOUNT_LEN,
                         program_id=TOKEN_PROGRAM_ID,
@@ -413,9 +415,9 @@ def _build_settle_funds_tx(  # pylint: disable=too-many-arguments
             transaction.add(
                 initialize_account(
                     InitializeAccountParams(
-                        account=wrapped_sol_account.public_key(),
+                        account=wrapped_sol_account.public_key,
                         mint=WRAPPED_SOL_MINT,
-                        owner=owner.public_key(),
+                        owner=owner.public_key,
                         program_id=TOKEN_PROGRAM_ID,
                     )
                 )
@@ -424,8 +426,8 @@ def _build_settle_funds_tx(  # pylint: disable=too-many-arguments
         transaction.add(
             self.make_settle_funds_instruction(
                 open_orders,
-                base_wallet if self.state.base_mint() != WRAPPED_SOL_MINT else wrapped_sol_account.public_key(),
-                quote_wallet if self.state.quote_mint() != WRAPPED_SOL_MINT else wrapped_sol_account.public_key(),
+                base_wallet if self.state.base_mint() != WRAPPED_SOL_MINT else wrapped_sol_account.public_key,
+                quote_wallet if self.state.quote_mint() != WRAPPED_SOL_MINT else wrapped_sol_account.public_key,
                 vault_signer,
             )
         )
@@ -435,9 +437,9 @@ def _build_settle_funds_tx(  # pylint: disable=too-many-arguments
             transaction.add(
                 close_account(
                     CloseAccountParams(
-                        account=wrapped_sol_account.public_key(),
-                        owner=owner.public_key(),
-                        dest=owner.public_key(),
+                        account=wrapped_sol_account.public_key,
+                        owner=owner.public_key,
+                        dest=owner.public_key,
                         program_id=TOKEN_PROGRAM_ID,
                     )
                 )

pyserum/market/market.py

@@ -3,7 +3,7 @@
 
 from typing import List
 
-from solana.account import Account
+from solana.keypair import Keypair
 from solana.publickey import PublicKey
 from solana.rpc.api import Client
 from solana.rpc.types import RPCResponse, TxOpts
@@ -91,7 +91,7 @@ def load_fills(self, limit=100) -> List[t.FilledOrder]:
     def place_order(  # pylint: disable=too-many-arguments,too-many-locals
         self,
         payer: PublicKey,
-        owner: Account,
+        owner: Keypair,
         order_type: OrderType,
         side: Side,
         limit_price: float,
@@ -100,8 +100,8 @@ def place_order(  # pylint: disable=too-many-arguments,too-many-locals
         opts: TxOpts = TxOpts(),
     ) -> RPCResponse:  # TODO: Add open_orders_address_key param and fee_discount_pubkey
         transaction = Transaction()
-        signers: List[Account] = [owner]
-        open_order_accounts = self.find_open_orders_accounts_for_owner(owner.public_key())
+        signers: List[Keypair] = [owner]
+        open_order_accounts = self.find_open_orders_accounts_for_owner(owner.public_key)
         if open_order_accounts:
             place_order_open_order_account = open_order_accounts[0].address
         else:
@@ -128,24 +128,24 @@ def place_order(  # pylint: disable=too-many-arguments,too-many-locals
         return self._conn.send_transaction(transaction, *signers, opts=opts)
 
     def cancel_order_by_client_id(
-        self, owner: Account, open_orders_account: PublicKey, client_id: int, opts: TxOpts = TxOpts()
+        self, owner: Keypair, open_orders_account: PublicKey, client_id: int, opts: TxOpts = TxOpts()
     ) -> RPCResponse:
         txs = self._build_cancel_order_by_client_id_tx(
             owner=owner, open_orders_account=open_orders_account, client_id=client_id
         )
         return self._conn.send_transaction(txs, owner, opts=opts)
 
-    def cancel_order(self, owner: Account, order: t.Order, opts: TxOpts = TxOpts()) -> RPCResponse:
+    def cancel_order(self, owner: Keypair, order: t.Order, opts: TxOpts = TxOpts()) -> RPCResponse:
         txn = self._build_cancel_order_tx(owner=owner, order=order)
         return self._conn.send_transaction(txn, owner, opts=opts)
 
-    def match_orders(self, fee_payer: Account, limit: int, opts: TxOpts = TxOpts()) -> RPCResponse:
+    def match_orders(self, fee_payer: Keypair, limit: int, opts: TxOpts = TxOpts()) -> RPCResponse:
         txn = self._build_match_orders_tx(limit)
         return self._conn.send_transaction(txn, fee_payer, opts=opts)
 
     def settle_funds(  # pylint: disable=too-many-arguments
         self,
-        owner: Account,
+        owner: Keypair,
         open_orders: OpenOrdersAccount,
         base_wallet: PublicKey,
         quote_wallet: PublicKey,  # TODO: add referrer_quote_wallet.
@@ -166,4 +166,4 @@ def settle_funds(  # pylint: disable=too-many-arguments
             min_bal_for_rent_exemption=min_bal_for_rent_exemption,
             should_wrap_sol=should_wrap_sol,
         )
-        return self._conn.send_transaction(transaction, *signers, opts=opts)
+        return self._conn.send_transaction(transaction, owner, opts=opts)