refactor: query params typehinting

client/api/api_nodes.py

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

client/api/blocks.py

@@ -1,21 +1,28 @@
+from typing import Optional
+
 from client.resource import Resource
+from client.types.blocks import BlockTransactionsQuery, BlocksQuery
 
 
 class Blocks(Resource):
 
-    def all(self, query={}):
+    def all(self, query: Optional[BlocksQuery] = None):
         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):
+        return self.with_endpoint('api').request_get(f'blocks/{block_hash}')
 
     def first(self):
         return self.with_endpoint('api').request_get('blocks/first')
 
     def last(self):
         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,
+    ):
         return self.with_endpoint('api').request_get(
-            f'blocks/{block_id}/transactions', query
+            f'blocks/{block_hash}/transactions', query
         )

client/api/commits.py

@@ -3,5 +3,5 @@
 
 class Commits(Resource):
 
-    def show(self, block_number):
-        return self.with_endpoint('api').request_get(f'commits/{block_number}')
+    def get(self, height: int):
+        return self.with_endpoint('api').request_get(f'commits/{height}')

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,4 +1,7 @@
+from typing import Optional
+
 from client.resource import Resource
+from client.types.node import NodeFeesQuery
 
 
 class Node(Resource):
@@ -19,5 +22,5 @@ def crypto(self):
             'node/configuration/crypto'
         )
 
-    def fees(self, query={}):
+    def fees(self, query: Optional[NodeFeesQuery] = None):
         return self.with_endpoint('api').request_get('node/fees', query)

client/api/peers.py

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

client/api/receipts.py

@@ -1,11 +1,23 @@
+from typing import Optional
+
 from client.resource import Resource
+from client.types.receipts import ReceiptContractsQuery, ReceiptQuery, ReceiptsQuery
 
 
 class Receipts(Resource):
-    def all(self, query={}):
+    def all(self, query: Optional[ReceiptsQuery] = None):
         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,
+    ):
+        return self.with_endpoint('api').request_get(
+            f'receipts/{transaction_hash}', query
+        )
+
+    def contracts(self, query: Optional[ReceiptContractsQuery] = None):
         return self.with_endpoint('api').request_get(
-            f'receipts/{transaction_hash}'
+            'receipts/contracts', query
         )

client/api/rounds.py

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

client/api/tokens.py

@@ -1,27 +1,54 @@
+from typing import Optional
+
 from client.resource import Resource
+from client.types import PaginatedQuery
+from client.types.tokens import TokenApprovalsQuery, TokenLookupQuery, TokenTransfersQuery, TokensQuery
 
 
 class Tokens(Resource):
 
-    def all(self, query={}):
+    def all(self, query: Optional[TokensQuery] = None):
         return self.with_endpoint('api').request_get('tokens', query)
 
-    def get(self, address):
+    def transfers(self, query: Optional[TokenTransfersQuery] = None):
         return self.with_endpoint('api').request_get(
-            f'tokens/{address}'
+            'tokens/transfers', query
+        )
+
+    def approvals(self, query: Optional[TokenApprovalsQuery] = None):
+        return self.with_endpoint('api').request_get(
+            'tokens/approvals', query
+        )
+
+    def whitelist(self, query: Optional[PaginatedQuery] = None):
+        return self.with_endpoint('api').request_get(
+            'tokens/whitelist', query
         )
 
-    def holders(self, address, query={}):
+    def get(self, address: str):
         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,
+    ):
         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,
+    ):
         return self.with_endpoint('api').request_get(
-            'tokens/transfers', query
+            f'tokens/{address}/approvals', query
+        )
+
+    def holders_for(self, address: str):
+        return self.with_endpoint('api').request_get(
+            f'tokens/{address}/holders'
         )

client/api/transactions.py

@@ -1,30 +1,40 @@
+from typing import Optional, Sequence
+
 from client.resource import Resource
+from client.types.transactions import TransactionGetQuery, TransactionsQuery, UnconfirmedTransactionsQuery
 
 
 class Transactions(Resource):
 
-    def all(self, query={}):
+    def all(self, query: Optional[TransactionsQuery] = None):
         return self.with_endpoint('api').request_get(
             'transactions', query
         )
 
-    def create(self, transactions):
+    def create(self, transactions: Sequence[str]):
         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,
+    ):
         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,
+    ):
+        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):
+        return self.with_endpoint('transactions').request_get(
             f'transactions/unconfirmed/{transaction_id}'
         )
 

client/api/validators.py

@@ -1,22 +1,35 @@
+from typing import Optional
+
+from client.api.blocks import BlocksQuery
+from client.api.wallets import WalletsQuery
 from client.resource import Resource
+from client.types.validators import ValidatorsQuery
 
 
 class Validators(Resource):
 
-    def all(self, query={}):
+    def all(self, query: Optional[ValidatorsQuery] = None):
         return self.with_endpoint('api').request_get('validators', query)
 
-    def get(self, validator_id):
+    def get(self, validator_id: str):
         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,
+    ):
         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,
+    ):
         return self.with_endpoint('api').request_get(
             f'validators/{validator_id}/voters', query
         )

client/api/votes.py

@@ -1,10 +1,13 @@
+from typing import Optional
+
 from client.resource import Resource
+from client.types.votes import VoteQuery, VotesQuery
 
 
 class Votes(Resource):
 
-    def all(self, query={}):
+    def all(self, query: Optional[VotesQuery] = None):
         return self.with_endpoint('api').request_get('votes', query)
 
-    def get(self, vote_id):
-        return self.with_endpoint('api').request_get(f'votes/{vote_id}')
+    def get(self, vote_id: str, query: Optional[VoteQuery] = None):
+        return self.with_endpoint('api').request_get(f'votes/{vote_id}', query)

client/api/wallets.py

@@ -1,45 +1,69 @@
+from typing import Optional
+
 from client.resource import Resource
+from client.types.transactions import TransactionsQuery
+from client.types.wallets import WalletTokensForQuery, WalletTokensQuery, WalletsQuery
 
 
 class Wallets(Resource):
 
-    def all(self, query={}):
+    def all(self, query: Optional[WalletsQuery] = None):
         return self.with_endpoint('api').request_get('wallets', query)
 
-    def top(self, query={}):
+    def top(self, query: Optional[WalletsQuery] = None):
         return self.with_endpoint('api').request_get('wallets/top', query)
 
-    def get(self, wallet_id):
+    def get(self, wallet_id: str):
         return self.with_endpoint('api').request_get(
             f'wallets/{wallet_id}'
         )
 
-    def transactions(self, wallet_id, query={}):
+    def transactions(
+        self,
+        wallet_id: str,
+        query: Optional[TransactionsQuery] = None,
+    ):
         return self.with_endpoint('api').request_get(
             f'wallets/{wallet_id}/transactions', query
         )
 
-    def sent_transactions(self, wallet_id, query={}):
+    def sent_transactions(
+        self,
+        wallet_id: str,
+        query: Optional[TransactionsQuery] = None,
+    ):
         return self.with_endpoint('api').request_get(
             f'wallets/{wallet_id}/transactions/sent', query
         )
 
-    def received_transactions(self, wallet_id, query={}):
+    def received_transactions(
+        self,
+        wallet_id: str,
+        query: Optional[TransactionsQuery] = None,
+    ):
         return self.with_endpoint('api').request_get(
             f'wallets/{wallet_id}/transactions/received', query
         )
 
-    def votes(self, wallet_id, query={}):
+    def votes(
+        self,
+        wallet_id: str,
+        query: Optional[TransactionsQuery] = None,
+    ):
         return self.with_endpoint('api').request_get(
             f'wallets/{wallet_id}/votes', query
         )
 
-    def tokens(self, wallet_id, query={}):
+    def tokens_for(
+        self,
+        address: str,
+        query: Optional[WalletTokensForQuery] = None,
+    ):
         return self.with_endpoint('api').request_get(
-            f'wallets/{wallet_id}/tokens', query
+            f'wallets/{address}/tokens', query
         )
 
-    def tokens_for(self, query={}):
+    def tokens(self, query: Optional[WalletTokensQuery] = None):
         return self.with_endpoint('api').request_get(
             'wallets/tokens', query
         )