Merge pull request #338 from michaelhly/remove-blockhash

Remove Blockhash, TransactionSignature, SIG_LENGTH and SigPubkeyPair

Author: kevinheavey

CHANGELOG.md

@@ -5,11 +5,11 @@
 ## Added
 
 - Add VersionedTransaction support to `send_transaction` and `simulate_transaction` methods [(#334)](https://github.com/michaelhly/solana-py/pull/334)
-- Support VersionedMessage in `get_fee_for_message` methods [(#336)](https://github.com/michaelhly/solana-py/pull/336)
+- Support VersionedMessage in `get_fee_for_message` methods [(#337)](https://github.com/michaelhly/solana-py/pull/337)
 
 ## Changed
 
-- Remove redundant classes and modules ([#329](https://github.com/michaelhly/solana-py/pull/329) and [#335](https://github.com/michaelhly/solana-py/pull/335)):
+- Remove redundant classes and modules ([#329](https://github.com/michaelhly/solana-py/pull/329), [#335](https://github.com/michaelhly/solana-py/pull/335) and [#338](https://github.com/michaelhly/solana-py/pull/338)):
     - Remove `PublicKey`, in favour of `solders.pubkey.Pubkey`.
     - Remove `AccountMeta` in favour of `solders.instruction.AccountMeta`.
     - Remove `TransactionInstruction` in favour of `solders.instruction.Instruction`.
@@ -22,6 +22,10 @@
     - Remove `Message` in favour of `solders.message.Message`.
     - Remove `system_program` in favour of `solders.system_program`. Note: where previously a params object like `AssignParams` called a field `program_id`, it now calls it `owner`.
     - Remove `sysvar` in favour of `solders.sysvar`. The constants in `solders.sysvar` have short names, so instead of `solana.sysvar.SYSVAR_RENT_PUBKEY` you'll use `solders.sysvar.RENT`.
+    - Remove `solana.blockhash.Blockhash` in favour of `solders.hash.Hash`. Note: `Blockhash(my_str)` -> `Hash.from_str(my_str)`.
+    - Remove `solana.transaction.TransactionSignature` newtype. This was unused - solana-py is already using `solders.signature.Signature`.
+    - Remove constant `solana.transaction.SIG_LENGTH` in favour of `solders.signature.Signature.LENGTH`.
+    - Remove unused `solana.transaction.SigPubkeyPair`.
 - Use latest solders [(#334)](https://github.com/michaelhly/solana-py/pull/334)
 - Use new `solders.rpc.requests.SendRawTransasction` in `send_raw_transaction` methods
 

src/solana/blockhash.py

@@ -1,16 +1,7 @@
-"""Blockhash.
-
-Example:
-    >>> # An arbitrary base58 encoded blockhash:
-    >>> Blockhash("EETubP5AKHgjPAhzPAFcb8BAY1hMH639CWCFTqi3hq1k")
-    'EETubP5AKHgjPAhzPAFcb8BAY1hMH639CWCFTqi3hq1k'
-"""
-from typing import NewType
+"""Blockhash utils."""
 
 from cachetools import TTLCache
-
-Blockhash = NewType("Blockhash", str)
-"""Type for blockhash."""
+from solders.hash import Hash
 
 
 class BlockhashCache:
@@ -26,11 +17,11 @@ def __init__(self, ttl: int = 60) -> None:
         self.unused_blockhashes: TTLCache = TTLCache(maxsize=maxsize, ttl=ttl)
         self.used_blockhashes: TTLCache = TTLCache(maxsize=maxsize, ttl=ttl)
 
-    def set(self, blockhash: Blockhash, slot: int, used_immediately: bool = False) -> None:
+    def set(self, blockhash: Hash, slot: int, used_immediately: bool = False) -> None:
         """Update the cache.
 
         Args:
-            blockhash: new Blockhash value.
+            blockhash: new blockhash value.
             slot: the slot which the blockhash came from.
             used_immediately: whether the client used the blockhash immediately after fetching it.
 
@@ -43,11 +34,11 @@ def set(self, blockhash: Blockhash, slot: int, used_immediately: bool = False) -
             return
         self.unused_blockhashes[slot] = blockhash
 
-    def get(self) -> Blockhash:
-        """Get the cached Blockhash. Raises KeyError if cache has expired.
+    def get(self) -> Hash:
+        """Get the cached blockhash. Raises KeyError if cache has expired.
 
         Returns:
-            cached Blockhash.
+            cached blockhash.
 
         """
         try:

src/solana/rpc/api.py

@@ -4,6 +4,7 @@
 from time import sleep, time
 from typing import Dict, List, Optional, Sequence, Union
 
+from solders.hash import Hash as Blockhash
 from solders.keypair import Keypair
 from solders.message import VersionedMessage
 from solders.pubkey import Pubkey
@@ -61,7 +62,7 @@
 from solders.signature import Signature
 from solders.transaction import VersionedTransaction
 
-from solana.blockhash import Blockhash, BlockhashCache
+from solana.blockhash import BlockhashCache
 from solana.rpc import types
 from solana.transaction import Transaction
 

src/solana/rpc/async_api.py

@@ -3,6 +3,7 @@
 from time import time
 from typing import Dict, List, Optional, Sequence, Union
 
+from solders.hash import Hash as Blockhash
 from solders.keypair import Keypair
 from solders.message import VersionedMessage
 from solders.pubkey import Pubkey
@@ -59,7 +60,7 @@
 from solders.signature import Signature
 from solders.transaction import VersionedTransaction
 
-from solana.blockhash import Blockhash, BlockhashCache
+from solana.blockhash import BlockhashCache
 from solana.rpc import types
 from solana.transaction import Transaction
 

src/solana/rpc/core.py

@@ -9,6 +9,7 @@
 
 from solders.account_decoder import UiAccountEncoding, UiDataSliceConfig
 from solders.commitment_config import CommitmentLevel
+from solders.hash import Hash as Blockhash
 from solders.message import MessageV0, VersionedMessage
 from solders.pubkey import Pubkey
 from solders.rpc.config import (
@@ -83,7 +84,7 @@
 from solders.transaction import VersionedTransaction
 from solders.transaction_status import UiTransactionEncoding
 
-from solana.blockhash import Blockhash, BlockhashCache
+from solana.blockhash import BlockhashCache
 from solana.rpc import types
 from solana.transaction import Transaction
 
@@ -518,7 +519,7 @@ def _post_send(resp: SendTransactionResp) -> SendTransactionResp:
     @staticmethod
     def parse_recent_blockhash(blockhash_resp: GetLatestBlockhashResp) -> Blockhash:
         """Extract blockhash from JSON RPC result."""
-        return Blockhash(str(blockhash_resp.value.blockhash))
+        return blockhash_resp.value.blockhash
 
     def _process_blockhash_resp(self, blockhash_resp: GetLatestBlockhashResp, used_immediately: bool) -> Blockhash:
         recent_blockhash = self.parse_recent_blockhash(blockhash_resp)

src/solana/transaction.py

@@ -1,10 +1,9 @@
 """Library to package an atomic sequence of instructions to a transaction."""
 from __future__ import annotations
 
-from dataclasses import dataclass
-from typing import Any, List, NamedTuple, NewType, Optional, Sequence, Tuple, Union
+from typing import Any, List, NamedTuple, Optional, Sequence, Tuple, Union
 
-from solders.hash import Hash
+from solders.hash import Hash as Blockhash
 from solders.instruction import AccountMeta, Instruction
 from solders.keypair import Keypair
 from solders.message import Message
@@ -15,14 +14,8 @@
 from solders.transaction import Transaction as SoldersTx
 from solders.transaction import TransactionError
 
-from solana.blockhash import Blockhash
-
-TransactionSignature = NewType("TransactionSignature", str)
-"""Type for TransactionSignature."""
 PACKET_DATA_SIZE = 1280 - 40 - 8
 """Constant for maximum over-the-wire size of a Transaction."""
-SIG_LENGTH = 64
-"""Constant for standard length of a signature."""
 
 
 class NonceInformation(NamedTuple):
@@ -34,14 +27,6 @@ class NonceInformation(NamedTuple):
     """AdvanceNonceAccount Instruction."""
 
 
-@dataclass
-class SigPubkeyPair:
-    """Pair of signature and corresponding public key."""
-
-    pubkey: Pubkey
-    signature: Optional[bytes] = None
-
-
 def _build_solders_tx(
     recent_blockhash: Optional[Blockhash] = None,
     nonce_info: Optional[NonceInformation] = None,
@@ -52,17 +37,15 @@ def _build_solders_tx(
     underlying_instructions = (
         core_instructions if nonce_info is None else [nonce_info.nonce_instruction, *core_instructions]
     )
-    underlying_blockhash_str: Optional[str]
+    underlying_blockhash: Optional[Blockhash]
     if nonce_info is not None:
-        underlying_blockhash_str = nonce_info.nonce
+        underlying_blockhash = nonce_info.nonce
     elif recent_blockhash is not None:
-        underlying_blockhash_str = recent_blockhash
+        underlying_blockhash = recent_blockhash
     else:
-        underlying_blockhash_str = None
+        underlying_blockhash = None
     underlying_fee_payer = None if fee_payer is None else fee_payer
-    underlying_blockhash = (
-        Hash.default() if underlying_blockhash_str is None else Hash.from_string(underlying_blockhash_str)
-    )
+    underlying_blockhash = Blockhash.default() if underlying_blockhash is None else underlying_blockhash
     msg = SoldersMessage.new_with_blockhash(underlying_instructions, underlying_fee_payer, underlying_blockhash)
     return SoldersTx.new_unsigned(msg)
 
@@ -144,7 +127,7 @@ def __eq__(self, other: Any) -> bool:
     @property
     def recent_blockhash(self) -> Optional[Blockhash]:
         """Optional[Blockhash]: The blockhash assigned to this transaction."""
-        return Blockhash(str(self._solders.message.recent_blockhash))
+        return self._solders.message.recent_blockhash
 
     @recent_blockhash.setter
     def recent_blockhash(self, blockhash: Optional[Blockhash]) -> None:  # noqa: D102
@@ -288,15 +271,14 @@ def serialize(self, verify_signatures: bool = True) -> bytes:
 
         Example:
             >>> from solders.keypair import Keypair
-            >>> from solana.blockhash import Blockhash
             >>> from solders.pubkey import Pubkey
             >>> from solders.hash import Hash
             >>> from solders.system_program import transfer, TransferParams
             >>> leading_zeros = [0] * 31
             >>> seed = bytes(leading_zeros + [1])
             >>> sender, receiver = Keypair.from_seed(seed), Pubkey(leading_zeros + [2])
             >>> transfer_tx = Transaction().add(transfer(TransferParams(from_pubkey=sender.pubkey(), to_pubkey=receiver, lamports=1000)))
-            >>> transfer_tx.recent_blockhash = Blockhash(str(Hash(leading_zeros + [3])))
+            >>> transfer_tx.recent_blockhash = Hash(leading_zeros + [3])
             >>> transfer_tx.sign(sender)
             >>> transfer_tx.serialize().hex()
             '019d53be8af3a7c30f86c1092d2c3ea61d270c0cfa275a23ba504674c8fbbb724827b23b42dc8e08019e23120f1b6f40f9799355ce54185b4415be37ca2cee6e0e010001034cb5abf6ad79fbf5abbccafcc269d85cd2651ed4b885b5869f241aedf0a5ba2900000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000301020200010c02000000e803000000000000'
@@ -355,7 +337,7 @@ def populate(cls, message: Message, signatures: List[Signature]) -> Transaction:
             >>> from solders.message import Message
             >>> from solders.signature import Signature
             >>> msg = Message.from_bytes(raw_message)
-            >>> signatures = [Signature(bytes([1] * SIG_LENGTH)), Signature(bytes([2] * SIG_LENGTH))]
+            >>> signatures = [Signature(bytes([1] * Signature.LENGTH)), Signature(bytes([2] * Signature.LENGTH))]
             >>> type(Transaction.populate(msg, signatures))
             <class 'solana.transaction.Transaction'>
 

src/spl/token/async_client.py

@@ -4,10 +4,10 @@
 
 from typing import List, Optional, Union, cast
 
-from solana.blockhash import Blockhash
 from solana.rpc.async_api import AsyncClient
 from solana.rpc.commitment import Commitment
 from solana.rpc.types import TxOpts
+from solders.hash import Hash as Blockhash
 from solders.keypair import Keypair
 from solders.pubkey import Pubkey
 from solders.rpc.responses import (

src/spl/token/client.py

@@ -4,10 +4,10 @@
 
 from typing import List, Optional, Union, cast
 
-from solana.blockhash import Blockhash
 from solana.rpc.api import Client
 from solana.rpc.commitment import Commitment
 from solana.rpc.types import TxOpts
+from solders.hash import Hash as Blockhash
 from solders.keypair import Keypair
 from solders.pubkey import Pubkey
 from solders.rpc.responses import (

tests/conftest.py

@@ -4,10 +4,10 @@
 from typing import NamedTuple
 
 import pytest
-from solana.blockhash import Blockhash
 from solana.rpc.api import Client
 from solana.rpc.async_api import AsyncClient
 from solana.rpc.commitment import Processed
+from solders.hash import Hash as Blockhash
 from solders.keypair import Keypair
 from solders.pubkey import Pubkey
 
@@ -36,7 +36,7 @@ def event_loop():
 @pytest.fixture(scope="session")
 def stubbed_blockhash() -> Blockhash:
     """Arbitrary block hash."""
-    return Blockhash("EETubP5AKHgjPAhzPAFcb8BAY1hMH639CWCFTqi3hq1k")
+    return Blockhash.from_string("EETubP5AKHgjPAhzPAFcb8BAY1hMH639CWCFTqi3hq1k")
 
 
 @pytest.fixture(scope="session")

tests/integration/test_async_http_client.py

@@ -3,7 +3,6 @@
 
 import pytest
 import solders.system_program as sp
-from solana.blockhash import Blockhash
 from solana.rpc.async_api import AsyncClient
 from solana.rpc.commitment import Confirmed, Finalized, Processed
 from solana.rpc.core import RPCException, TransactionExpiredBlockheightExceededError
@@ -270,7 +269,7 @@ async def test_send_raw_transaction_and_get_balance(
     recent_blockhash = resp.value.blockhash
     assert recent_blockhash is not None
     # Create transfer tx transfer lamports from stubbed sender to async_stubbed_receiver
-    transfer_tx = Transaction(recent_blockhash=Blockhash(str(recent_blockhash))).add(
+    transfer_tx = Transaction(recent_blockhash=recent_blockhash).add(
         sp.transfer(
             sp.TransferParams(
                 from_pubkey=async_stubbed_sender.pubkey(), to_pubkey=async_stubbed_receiver, lamports=1000
@@ -305,7 +304,7 @@ async def test_send_raw_transaction_and_get_balance_using_latest_blockheight(
     assert recent_blockhash is not None
     last_valid_block_height = resp.value.last_valid_block_height
     # Create transfer tx transfer lamports from stubbed sender to async_stubbed_receiver
-    transfer_tx = Transaction(recent_blockhash=Blockhash(str(recent_blockhash))).add(
+    transfer_tx = Transaction(recent_blockhash=recent_blockhash).add(
         sp.transfer(
             sp.TransferParams(
                 from_pubkey=async_stubbed_sender.pubkey(), to_pubkey=async_stubbed_receiver, lamports=1000
@@ -340,7 +339,7 @@ async def test_confirm_expired_transaction(stubbed_sender, stubbed_receiver, tes
     assert recent_blockhash is not None
     last_valid_block_height = resp.value.last_valid_block_height - 330
     # Create transfer tx transfer lamports from stubbed sender to stubbed_receiver
-    transfer_tx = Transaction(recent_blockhash=Blockhash(str(recent_blockhash))).add(
+    transfer_tx = Transaction(recent_blockhash=recent_blockhash).add(
         sp.transfer(sp.TransferParams(from_pubkey=stubbed_sender.pubkey(), to_pubkey=stubbed_receiver, lamports=1000))
     )
     # Sign transaction
@@ -367,7 +366,7 @@ async def test_get_fee_for_transaction_message(stubbed_sender, stubbed_receiver,
     recent_blockhash = resp.value.blockhash
     assert recent_blockhash is not None
     # Create transfer tx transfer lamports from stubbed sender to stubbed_receiver
-    transfer_tx = Transaction(recent_blockhash=Blockhash(str(recent_blockhash))).add(
+    transfer_tx = Transaction(recent_blockhash=recent_blockhash).add(
         sp.transfer(sp.TransferParams(from_pubkey=stubbed_sender.pubkey(), to_pubkey=stubbed_receiver, lamports=1000))
     )
     # Get fee for transaction message