refactor: method response typehints

client/api/api_nodes.py

@@ -1,7 +1,11 @@
+from typing import Optional
+
 from client.resource import Resource
+from client.types import PaginatedResponse
+from client.types.api_nodes import ApiNodeResponse, ApiNodesQuery
 
 
 class ApiNodes(Resource):
 
-    def all(self, query={}):
+    def all(self, query: Optional[ApiNodesQuery] = None) -> PaginatedResponse[ApiNodeResponse]:
         return self.with_endpoint('api').request_get('api-nodes', query)

client/api/blockchain.py

@@ -1,7 +1,9 @@
 from client.resource import Resource
+from client.types import Response
+from client.types.blockchain import BlockchainResponse
 
 
 class Blockchain(Resource):
 
-    def blockchain(self):
+    def blockchain(self) -> Response[BlockchainResponse]:
         return self.with_endpoint('api').request_get('blockchain')

client/api/blocks.py

@@ -1,21 +1,30 @@
+from typing import Optional
+
 from client.resource import Resource
+from client.types import PaginatedResponse, Response
+from client.types.blocks import BlockResponse, BlockTransactionsQuery, BlocksQuery
+from client.types.transactions import TransactionResponse
 
 
 class Blocks(Resource):
 
-    def all(self, query={}):
+    def all(self, query: Optional[BlocksQuery] = None) -> PaginatedResponse[BlockResponse]:
         return self.with_endpoint('api').request_get('blocks', query)
 
-    def get(self, block_id):
-        return self.with_endpoint('api').request_get(f'blocks/{block_id}')
+    def get(self, block_hash: str) -> Response[BlockResponse]:
+        return self.with_endpoint('api').request_get(f'blocks/{block_hash}')
 
-    def first(self):
+    def first(self) -> Response[BlockResponse]:
         return self.with_endpoint('api').request_get('blocks/first')
 
-    def last(self):
+    def last(self) -> Response[BlockResponse]:
         return self.with_endpoint('api').request_get('blocks/last')
 
-    def transactions(self, block_id, query={}):
+    def transactions(
+        self,
+        block_hash: str,
+        query: Optional[BlockTransactionsQuery] = None,
+    ) -> PaginatedResponse[TransactionResponse]:
         return self.with_endpoint('api').request_get(
-            f'blocks/{block_id}/transactions', query
+            f'blocks/{block_hash}/transactions', query
         )

client/api/commits.py

@@ -1,7 +1,9 @@
 from client.resource import Resource
+from client.types import Response
+from client.types.commits import CommitResponse
 
 
 class Commits(Resource):
 
-    def show(self, block_number):
-        return self.with_endpoint('api').request_get(f'commits/{block_number}')
+    def get(self, height: int) -> Response[CommitResponse]:
+        return self.with_endpoint('api').request_get(f'commits/{height}')

client/api/contracts.py

@@ -1,10 +1,12 @@
 from client.resource import Resource
+from client.types import Response
+from client.types.contracts import ContractAbiResponse, ContractResponse
 
 
 class Contracts(Resource):
 
-    def all(self):
+    def all(self) -> Response[ContractResponse]:
         return self.with_endpoint('api').request_get('contracts')
 
-    def abi(self, name: str, implementation: str):
+    def abi(self, name: str, implementation: str) -> Response[ContractAbiResponse]:
         return self.with_endpoint('api').request_get(f'contracts/{name}/{implementation}/abi')

client/api/evm.py

@@ -1,10 +1,10 @@
-from typing import Any
 from client.resource import Resource
+from client.types.evm import EvmBodyPartialParams
 
 
 class EVM(Resource):
-    def call(self, params: dict[str, Any]):
+    def call(self, payload: EvmBodyPartialParams):
         return self.with_endpoint('evm').request_post('', {
             'jsonrpc': "2.0",
-            **params,
+            **payload,
         })

client/api/node.py

@@ -1,23 +1,30 @@
+from typing import Optional
+
 from client.resource import Resource
+from client.types import Response
+from client.types.node import (
+    NodeConfigurationResponse,
+    NodeCryptoResponse,
+    NodeFeesQuery,
+    NodeFeesResponse,
+    NodeStatusResponse,
+    NodeSyncingResponse,
+)
 
 
 class Node(Resource):
 
-    def status(self):
+    def status(self) -> Response[NodeStatusResponse]:
         return self.with_endpoint('api').request_get('node/status')
 
-    def syncing(self):
+    def syncing(self) -> Response[NodeSyncingResponse]:
         return self.with_endpoint('api').request_get('node/syncing')
 
-    def configuration(self):
-        return self.with_endpoint('api').request_get(
-            'node/configuration'
-        )
+    def configuration(self) -> Response[NodeConfigurationResponse]:
+        return self.with_endpoint('api').request_get('node/configuration')
 
-    def crypto(self):
-        return self.with_endpoint('api').request_get(
-            'node/configuration/crypto'
-        )
+    def crypto(self) -> Response[NodeCryptoResponse]:
+        return self.with_endpoint('api').request_get('node/configuration/crypto')
 
-    def fees(self, query={}):
+    def fees(self, query: Optional[NodeFeesQuery] = None) -> Response[NodeFeesResponse]:
         return self.with_endpoint('api').request_get('node/fees', query)

client/api/peers.py

@@ -1,10 +1,14 @@
+from typing import Optional
+
 from client.resource import Resource
+from client.types import PaginatedResponse, Response
+from client.types.peers import PeerResponse, PeersQuery
 
 
 class Peers(Resource):
 
-    def all(self, query={}):
+    def all(self, query: Optional[PeersQuery] = None) -> PaginatedResponse[PeerResponse]:
         return self.with_endpoint('api').request_get('peers', query)
 
-    def get(self, ip):
+    def get(self, ip: str) -> Response[PeerResponse]:
         return self.with_endpoint('api').request_get(f'peers/{ip}')

client/api/receipts.py

@@ -1,11 +1,25 @@
+from typing import Optional
+
 from client.resource import Resource
+from client.types import PaginatedResponse, Response
+from client.types.receipts import ReceiptContractsQuery, ReceiptQuery, ReceiptResponse, ReceiptsQuery
 
 
 class Receipts(Resource):
-    def all(self, query={}):
+
+    def all(self, query: Optional[ReceiptsQuery] = None) -> PaginatedResponse[ReceiptResponse]:
         return self.with_endpoint('api').request_get('receipts', query)
 
-    def get(self, transaction_hash: str):
+    def get(
+        self,
+        transaction_hash: str,
+        query: Optional[ReceiptQuery] = None,
+    ) -> Response[ReceiptResponse]:
+        return self.with_endpoint('api').request_get(
+            f'receipts/{transaction_hash}', query
+        )
+
+    def contracts(self, query: Optional[ReceiptContractsQuery] = None) -> PaginatedResponse[ReceiptResponse]:
         return self.with_endpoint('api').request_get(
-            f'receipts/{transaction_hash}'
+            'receipts/contracts', query
         )

client/api/rounds.py

@@ -1,15 +1,19 @@
+from typing import Optional
+
 from client.resource import Resource
+from client.types import PaginatedQuery, PaginatedResponse, Response
+from client.types.rounds import RoundResponse
 
 
 class Rounds(Resource):
 
-    def all(self, query={}):
+    def all(self, query: Optional[PaginatedQuery] = None) -> PaginatedResponse[RoundResponse]:
         return self.with_endpoint('api').request_get('rounds', query)
 
-    def show(self, round_id):
+    def show(self, round_id: str) -> Response[RoundResponse]:
         return self.with_endpoint('api').request_get(f'rounds/{round_id}')
 
-    def validators(self, round_id):
+    def validators(self, round_id: str) -> Response[RoundResponse]:
         return self.with_endpoint('api').request_get(
             f'rounds/{round_id}/validators'
         )

client/api/tokens.py

@@ -1,27 +1,65 @@
+from typing import Optional
+
 from client.resource import Resource
+from client.types import PaginatedQuery, PaginatedResponse, Response
+from client.types.tokens import (
+    TokenActionsResponse,
+    TokenAddressHoldersResponse,
+    TokenAddressesResponse,
+    TokenApprovalsQuery,
+    TokenLookupQuery,
+    TokenPaginatedResponseResults,
+    TokenResponse,
+    TokenTransfersQuery,
+    TokenWhitelistResponse,
+    TokensQuery,
+)
 
 
 class Tokens(Resource):
 
-    def all(self, query={}):
+    def all(self, query: Optional[TokensQuery] = None) -> PaginatedResponse[TokenResponse]:
         return self.with_endpoint('api').request_get('tokens', query)
 
-    def get(self, address):
+    def transfers(self, query: Optional[TokenTransfersQuery] = None) -> TokenPaginatedResponseResults[TokenActionsResponse]:
         return self.with_endpoint('api').request_get(
-            f'tokens/{address}'
+            'tokens/transfers', query
+        )
+
+    def approvals(self, query: Optional[TokenApprovalsQuery] = None) -> TokenPaginatedResponseResults[TokenActionsResponse]:
+        return self.with_endpoint('api').request_get(
+            'tokens/approvals', query
+        )
+
+    def whitelist(self, query: Optional[PaginatedQuery] = None) -> PaginatedResponse[TokenWhitelistResponse]:
+        return self.with_endpoint('api').request_get(
+            'tokens/whitelist', query
         )
 
-    def holders(self, address, query={}):
+    def get(self, address: str) -> Response[TokenAddressesResponse]:
         return self.with_endpoint('api').request_get(
-            f'tokens/{address}/holders', query
+            f'tokens/{address}'
         )
 
-    def transfers_by_token(self, address, query={}):
+    def transfers_for(
+        self,
+        address: str,
+        query: Optional[TokenLookupQuery] = None,
+    ) -> TokenPaginatedResponseResults[TokenActionsResponse]:
         return self.with_endpoint('api').request_get(
             f'tokens/{address}/transfers', query
         )
 
-    def transfers(self, query={}):
+    def approvals_for(
+        self,
+        address: str,
+        query: Optional[TokenLookupQuery] = None,
+    ) -> TokenPaginatedResponseResults[TokenActionsResponse]:
         return self.with_endpoint('api').request_get(
-            'tokens/transfers', query
+            f'tokens/{address}/approvals', query
+        )
+
+    def holders_for(self, address: str) -> PaginatedResponse[TokenAddressHoldersResponse]:
+        return self.with_endpoint('api').request_get(
+            f'tokens/{address}/holders'
         )

client/api/transactions.py

@@ -1,34 +1,52 @@
+from typing import Optional, Sequence
+
 from client.resource import Resource
+from client.types import PaginatedResponse, Response
+from client.types.transactions import (
+    TransactionConfigurationResponse,
+    TransactionCreateResponse,
+    TransactionGetQuery,
+    TransactionResponse,
+    TransactionsQuery,
+    UnconfirmedTransactionsQuery,
+)
 
 
 class Transactions(Resource):
 
-    def all(self, query={}):
+    def all(self, query: Optional[TransactionsQuery] = None) -> PaginatedResponse[TransactionResponse]:
         return self.with_endpoint('api').request_get(
             'transactions', query
         )
 
-    def create(self, transactions):
+    def create(self, transactions: Sequence[str]) -> Response[TransactionCreateResponse]:
         return self.with_endpoint('transactions').request_post(
             'transactions', data={'transactions': transactions}
         )
 
-    def get(self, transaction_id):
+    def get(
+        self,
+        transaction_id: str,
+        query: Optional[TransactionGetQuery] = None,
+    ) -> Response[TransactionResponse]:
         return self.with_endpoint('api').request_get(
-            f'transactions/{transaction_id}'
+            f'transactions/{transaction_id}', query
         )
 
-    def all_unconfirmed(self, query={}):
-        return self.with_endpoint('api').request_get(
+    def all_unconfirmed(
+        self,
+        query: Optional[UnconfirmedTransactionsQuery] = None,
+    ) -> PaginatedResponse[TransactionResponse]:
+        return self.with_endpoint('transactions').request_get(
             'transactions/unconfirmed', query
         )
 
-    def get_unconfirmed(self, transaction_id):
-        return self.with_endpoint('api').request_get(
+    def get_unconfirmed(self, transaction_id: str) -> Response[TransactionResponse]:
+        return self.with_endpoint('transactions').request_get(
             f'transactions/unconfirmed/{transaction_id}'
         )
 
-    def configuration(self):
+    def configuration(self) -> Response[TransactionConfigurationResponse]:
         return self.with_endpoint('transactions').request_get(
             'configuration'
         )

client/api/validators.py

@@ -1,22 +1,37 @@
+from typing import Optional
+
 from client.resource import Resource
+from client.types import PaginatedResponse, Response
+from client.types.blocks import BlocksQuery
+from client.types.transactions import TransactionResponse
+from client.types.validators import ValidatorsQuery
+from client.types.wallets import WalletResponse, WalletsQuery
 
 
 class Validators(Resource):
 
-    def all(self, query={}):
+    def all(self, query: Optional[ValidatorsQuery] = None) -> PaginatedResponse[WalletResponse]:
         return self.with_endpoint('api').request_get('validators', query)
 
-    def get(self, validator_id):
+    def get(self, validator_id: str) -> Response[WalletResponse]:
         return self.with_endpoint('api').request_get(
             f'validators/{validator_id}'
         )
 
-    def blocks(self, validator_id, query={}):
+    def blocks(
+        self,
+        validator_id: str,
+        query: Optional[BlocksQuery] = None,
+    ) -> PaginatedResponse[TransactionResponse]:
         return self.with_endpoint('api').request_get(
             f'validators/{validator_id}/blocks', query
         )
 
-    def voters(self, validator_id, query={}):
+    def voters(
+        self,
+        validator_id: str,
+        query: Optional[WalletsQuery] = None,
+    ) -> PaginatedResponse[WalletResponse]:
         return self.with_endpoint('api').request_get(
             f'validators/{validator_id}/voters', query
         )