Add missing RPC methods (#1094)

* Add missing methods

* Add tests

* Fix lint

* Adjust tests

* Adjust tests

* Update migration guide

* Add test_get_syncing_status

* Fix lint

* Fix format

Author: drknzz

docs/migration_guide.rst

@@ -11,6 +11,13 @@ Migration guide
 
 .. currentmodule:: starknet_py.contract
 
+Also, four methods were added to its interface:
+
+- :meth:`FullNodeClient.get_block_number`
+- :meth:`FullNodeClient.get_block_hash_and_number`
+- :meth:`FullNodeClient.get_chain_id`
+- :meth:`FullNodeClient.get_syncing_status`
+
 
 :class:`Contract` now *initially* supports contracts written in **Cairo1**.
 

starknet_py/net/client_models.py

@@ -283,6 +283,22 @@ class StarknetBlockWithTxHashes(StarknetBlockCommon):
     transactions: List[int]
 
 
+@dataclass
+class BlockHashAndNumber:
+    block_hash: int
+    block_number: int
+
+
+@dataclass
+class SyncStatus:
+    starting_block_hash: int
+    starting_block_num: int
+    current_block_hash: int
+    current_block_num: int
+    highest_block_hash: int
+    highest_block_num: int
+
+
 @dataclass
 class BlockSingleTransactionTrace:
     """

starknet_py/net/full_node_client.py

@@ -8,6 +8,7 @@
 from starknet_py.net.client import Client
 from starknet_py.net.client_errors import ClientError
 from starknet_py.net.client_models import (
+    BlockHashAndNumber,
     BlockStateUpdate,
     BlockTransactionTraces,
     Call,
@@ -22,6 +23,7 @@
     SierraContractClass,
     StarknetBlock,
     StarknetBlockWithTxHashes,
+    SyncStatus,
     Tag,
     Transaction,
     TransactionReceipt,
@@ -39,6 +41,7 @@
 )
 from starknet_py.net.networks import Network
 from starknet_py.net.schemas.rpc import (
+    BlockHashAndNumberSchema,
     BlockStateUpdateSchema,
     ContractClassSchema,
     DeclareTransactionResponseSchema,
@@ -51,6 +54,7 @@
     SierraContractClassSchema,
     StarknetBlockSchema,
     StarknetBlockWithTxHashesSchema,
+    SyncStatusSchema,
     TransactionReceiptSchema,
     TypesOfTransactionsSchema,
 )
@@ -342,6 +346,26 @@ async def estimate_fee(
             ),
         )
 
+    async def get_block_number(self) -> int:
+        """Get the most recent accepted block number"""
+        return await self._client.call(method_name="blockNumber", params={})
+
+    async def get_block_hash_and_number(self) -> BlockHashAndNumber:
+        """Get the most recent accepted block hash and number"""
+        res = await self._client.call(method_name="blockHashAndNumber", params={})
+        return cast(BlockHashAndNumber, BlockHashAndNumberSchema().load(res))
+
+    async def get_chain_id(self) -> int:
+        """Return the currently configured Starknet chain id"""
+        return await self._client.call(method_name="chainId", params={})
+
+    async def get_syncing_status(self) -> Union[bool, SyncStatus]:
+        """Returns an object about the sync status, or false if the node is not syncing"""
+        sync_status = await self._client.call(method_name="syncing", params={})
+        if isinstance(sync_status, bool):
+            return sync_status
+        return cast(SyncStatus, SyncStatusSchema().load(sync_status))
+
     async def call_contract(
         self,
         call: Call,

starknet_py/net/http_client.py

@@ -85,7 +85,7 @@ async def handle_request_error(self, request: ClientResponse):
 
 
 class RpcHttpClient(HttpClient):
-    async def call(self, method_name: str, params: dict) -> dict:
+    async def call(self, method_name: str, params: dict):
         payload = {
             "jsonrpc": "2.0",
             "method": f"starknet_{method_name}",

starknet_py/net/schemas/rpc.py

@@ -3,6 +3,7 @@
 
 from starknet_py.abi.schemas import ContractAbiEntrySchema
 from starknet_py.net.client_models import (
+    BlockHashAndNumber,
     BlockStateUpdate,
     ContractClass,
     ContractsNonce,
@@ -32,6 +33,7 @@
     StarknetBlockWithTxHashes,
     StateDiff,
     StorageDiffItem,
+    SyncStatus,
     TransactionReceipt,
 )
 from starknet_py.net.schemas.common import (
@@ -231,6 +233,28 @@ def make_dataclass(self, data, **kwargs) -> StarknetBlock:
         return StarknetBlock(**data)
 
 
+class BlockHashAndNumberSchema(Schema):
+    block_hash = Felt(data_key="block_hash", required=True)
+    block_number = fields.Integer(data_key="block_number", required=True)
+
+    @post_load
+    def make_dataclass(self, data, **kwargs) -> BlockHashAndNumber:
+        return BlockHashAndNumber(**data)
+
+
+class SyncStatusSchema(Schema):
+    starting_block_hash = Felt(data_key="starting_block_hash", required=True)
+    starting_block_num = Felt(data_key="starting_block_num", required=True)
+    current_block_hash = Felt(data_key="current_block_hash", required=True)
+    current_block_num = Felt(data_key="current_block_num", required=True)
+    highest_block_hash = Felt(data_key="highest_block_hash", required=True)
+    highest_block_num = Felt(data_key="highest_block_num", required=True)
+
+    @post_load
+    def make_dataclass(self, data, **kwargs) -> SyncStatus:
+        return SyncStatus(**data)
+
+
 class StarknetBlockWithTxHashesSchema(Schema):
     block_hash = Felt(data_key="block_hash", required=True)
     parent_block_hash = Felt(data_key="parent_hash", required=True)

starknet_py/tests/e2e/client/full_node_test.py

@@ -1,5 +1,4 @@
-import asyncio
-from unittest.mock import MagicMock, patch
+from unittest.mock import AsyncMock, patch
 
 import pytest
 
@@ -9,13 +8,16 @@
 from starknet_py.net.account.account import Account
 from starknet_py.net.client_errors import ClientError
 from starknet_py.net.client_models import (
+    BlockHashAndNumber,
     ContractClass,
     DeclareTransaction,
     SierraContractClass,
+    SyncStatus,
     TransactionType,
 )
 from starknet_py.net.full_node_client import _to_rpc_felt
 from starknet_py.net.models import StarknetChainId
+from starknet_py.tests.e2e.utils import create_empty_block
 
 
 def _parse_event_name(event: str) -> str:
@@ -100,30 +102,26 @@ async def test_method_raises_on_both_block_hash_and_number(full_node_client):
 @pytest.mark.asyncio
 async def test_pending_transactions(full_node_client):
     with patch(
-        "starknet_py.net.http_client.RpcHttpClient.call", MagicMock()
+        "starknet_py.net.http_client.RpcHttpClient.call", AsyncMock()
     ) as mocked_http_call:
-        result = asyncio.Future()
-        result.set_result(
-            [
-                {
-                    "transaction_hash": "0x01",
-                    "class_hash": "0x05",
-                    "version": "0x0",
-                    "type": "DEPLOY",
-                    "contract_address": "0x02",
-                    "contract_address_salt": "0x0",
-                    "constructor_calldata": [],
-                }
-            ]
-        )
-        mocked_http_call.return_value = result
+        mocked_http_call.return_value = [
+            {
+                "transaction_hash": "0x01",
+                "class_hash": "0x05",
+                "version": "0x0",
+                "type": "DEPLOY",
+                "contract_address": "0x02",
+                "contract_address_salt": "0x0",
+                "constructor_calldata": [],
+            }
+        ]
 
         pending_transactions = await full_node_client.get_pending_transactions()
 
-        assert len(pending_transactions) == 1
-        assert pending_transactions[0].hash == 0x1
-        assert pending_transactions[0].signature == []
-        assert pending_transactions[0].max_fee == 0
+    assert len(pending_transactions) == 1
+    assert pending_transactions[0].hash == 0x1
+    assert pending_transactions[0].signature == []
+    assert pending_transactions[0].max_fee == 0
 
 
 @pytest.mark.asyncio
@@ -350,3 +348,64 @@ async def test_get_events_nonexistent_starting_block(
             follow_continuation_token=False,
             chunk_size=1,
         )
+
+
+@pytest.mark.asyncio
+async def test_get_block_number(full_node_client):
+    block_number = await full_node_client.get_block_number()
+
+    # pylint: disable=protected-access
+    await create_empty_block(full_node_client._client)
+
+    new_block_number = await full_node_client.get_block_number()
+    assert new_block_number == block_number + 1
+
+
+@pytest.mark.asyncio
+async def test_get_block_hash_and_number(full_node_client):
+    block_hash_and_number = await full_node_client.get_block_hash_and_number()
+
+    assert isinstance(block_hash_and_number, BlockHashAndNumber)
+
+    # pylint: disable=protected-access
+    await create_empty_block(full_node_client._client)
+
+    new_block_hash_and_number = await full_node_client.get_block_hash_and_number()
+
+    assert (
+        new_block_hash_and_number.block_number == block_hash_and_number.block_number + 1
+    )
+    assert new_block_hash_and_number.block_hash > 0
+
+
+@pytest.mark.asyncio
+async def test_get_chain_id(full_node_client):
+    chain_id = await full_node_client.get_chain_id()
+
+    assert chain_id == hex(StarknetChainId.TESTNET.value)
+
+
+@pytest.mark.asyncio
+async def test_get_syncing_status_false(full_node_client):
+    sync_status = await full_node_client.get_syncing_status()
+
+    assert sync_status is False
+
+
+@pytest.mark.asyncio
+async def test_get_syncing_status(full_node_client):
+    with patch(
+        "starknet_py.net.http_client.RpcHttpClient.call", AsyncMock()
+    ) as mocked_status:
+        mocked_status.return_value = {
+            "starting_block_num": "0xc8023",
+            "current_block_num": "0xc9773",
+            "highest_block_num": "0xc9773",
+            "starting_block_hash": "0x60be3a55621597c15a53a1f83e977ca5e52e775ab2ebf572d2ebd6a8168fc88",
+            "current_block_hash": "0x79abcb48e71524ad2e123624b0ee3d5f69f99759a23441f6f363794d0687a66",
+            "highest_block_hash": "0x79abcb48e71524ad2e123624b0ee3d5f69f99759a23441f6f363794d0687a66",
+        }
+
+        sync_status = await full_node_client.get_syncing_status()
+
+    assert isinstance(sync_status, SyncStatus)

starknet_py/tests/e2e/utils.py

@@ -7,6 +7,7 @@
 from starknet_py.net.account.account import Account
 from starknet_py.net.client import Client
 from starknet_py.net.gateway_client import GatewayClient
+from starknet_py.net.http_client import HttpClient, HttpMethod
 from starknet_py.net.models import StarknetChainId
 from starknet_py.net.models.transaction import DeployAccount
 from starknet_py.net.networks import Network
@@ -85,3 +86,11 @@ def _get_random_private_key_unsafe() -> int:
     This is not a safe way of generating private keys and should be used only in tests.
     """
     return random.randint(1, EC_ORDER - 1)
+
+
+async def create_empty_block(http_client: HttpClient) -> None:
+    url = http_client.url[:-4] if http_client.url.endswith("/rpc") else http_client.url
+    await http_client.request(
+        address=f"{url}/create_block",
+        http_method=HttpMethod.POST,
+    )