refactor: method response typehints

client/api/api_nodes.py

@@ -1,10 +1,11 @@
 from typing import Optional
 
 from client.resource import Resource
-from client.types.api_nodes import ApiNodesQuery
+from client.types import PaginatedResponse
+from client.types.api_nodes import ApiNodeResponse, ApiNodesQuery
 
 
 class ApiNodes(Resource):
 
-    def all(self, query: Optional[ApiNodesQuery] = None):
+    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,28 +1,30 @@
 from typing import Optional
 
 from client.resource import Resource
-from client.types.blocks import BlockTransactionsQuery, BlocksQuery
+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: Optional[BlocksQuery] = None):
+    def all(self, query: Optional[BlocksQuery] = None) -> PaginatedResponse[BlockResponse]:
         return self.with_endpoint('api').request_get('blocks', query)
 
-    def get(self, block_hash: str):
+    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_hash: str,
         query: Optional[BlockTransactionsQuery] = None,
-    ):
+    ) -> PaginatedResponse[TransactionResponse]:
         return self.with_endpoint('api').request_get(
             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 get(self, height: int):
+    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/node.py

@@ -1,26 +1,30 @@
 from typing import Optional
 
 from client.resource import Resource
-from client.types.node import NodeFeesQuery
+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: Optional[NodeFeesQuery] = None):
+    def fees(self, query: Optional[NodeFeesQuery] = None) -> Response[NodeFeesResponse]:
         return self.with_endpoint('api').request_get('node/fees', query)

client/api/peers.py

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

client/api/receipts.py

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

client/api/rounds.py

@@ -1,18 +1,19 @@
 from typing import Optional
 
 from client.resource import Resource
-from client.types import PaginatedQuery
+from client.types import PaginatedQuery, PaginatedResponse, Response
+from client.types.rounds import RoundResponse
 
 
 class Rounds(Resource):
 
-    def all(self, query: Optional[PaginatedQuery] = None):
+    def all(self, query: Optional[PaginatedQuery] = None) -> PaginatedResponse[RoundResponse]:
         return self.with_endpoint('api').request_get('rounds', query)
 
-    def show(self, round_id: str):
+    def show(self, round_id: str) -> Response[RoundResponse]:
         return self.with_endpoint('api').request_get(f'rounds/{round_id}')
 
-    def validators(self, round_id: str):
+    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,31 +1,42 @@
 from typing import Optional
 
 from client.resource import Resource
-from client.types import PaginatedQuery
-from client.types.tokens import TokenApprovalsQuery, TokenLookupQuery, TokenTransfersQuery, TokensQuery
+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: Optional[TokensQuery] = None):
+    def all(self, query: Optional[TokensQuery] = None) -> PaginatedResponse[TokenResponse]:
         return self.with_endpoint('api').request_get('tokens', query)
 
-    def transfers(self, query: Optional[TokenTransfersQuery] = None):
+    def transfers(self, query: Optional[TokenTransfersQuery] = None) -> TokenPaginatedResponseResults[TokenActionsResponse]:
         return self.with_endpoint('api').request_get(
             'tokens/transfers', query
         )
 
-    def approvals(self, query: Optional[TokenApprovalsQuery] = None):
+    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):
+    def whitelist(self, query: Optional[PaginatedQuery] = None) -> PaginatedResponse[TokenWhitelistResponse]:
         return self.with_endpoint('api').request_get(
             'tokens/whitelist', query
         )
 
-    def get(self, address: str):
+    def get(self, address: str) -> Response[TokenAddressesResponse]:
         return self.with_endpoint('api').request_get(
             f'tokens/{address}'
         )
@@ -34,7 +45,7 @@ def transfers_for(
         self,
         address: str,
         query: Optional[TokenLookupQuery] = None,
-    ):
+    ) -> TokenPaginatedResponseResults[TokenActionsResponse]:
         return self.with_endpoint('api').request_get(
             f'tokens/{address}/transfers', query
         )
@@ -43,12 +54,12 @@ def approvals_for(
         self,
         address: str,
         query: Optional[TokenLookupQuery] = None,
-    ):
+    ) -> TokenPaginatedResponseResults[TokenActionsResponse]:
         return self.with_endpoint('api').request_get(
             f'tokens/{address}/approvals', query
         )
 
-    def holders_for(self, address: str):
+    def holders_for(self, address: str) -> PaginatedResponse[TokenAddressHoldersResponse]:
         return self.with_endpoint('api').request_get(
             f'tokens/{address}/holders'
         )

client/api/transactions.py

@@ -1,17 +1,25 @@
 from typing import Optional, Sequence
 
 from client.resource import Resource
-from client.types.transactions import TransactionGetQuery, TransactionsQuery, UnconfirmedTransactionsQuery
+from client.types import PaginatedResponse, Response
+from client.types.transactions import (
+    TransactionConfigurationResponse,
+    TransactionCreateResponse,
+    TransactionGetQuery,
+    TransactionResponse,
+    TransactionsQuery,
+    UnconfirmedTransactionsQuery,
+)
 
 
 class Transactions(Resource):
 
-    def all(self, query: Optional[TransactionsQuery] = None):
+    def all(self, query: Optional[TransactionsQuery] = None) -> PaginatedResponse[TransactionResponse]:
         return self.with_endpoint('api').request_get(
             'transactions', query
         )
 
-    def create(self, transactions: Sequence[str]):
+    def create(self, transactions: Sequence[str]) -> Response[TransactionCreateResponse]:
         return self.with_endpoint('transactions').request_post(
             'transactions', data={'transactions': transactions}
         )
@@ -20,25 +28,25 @@ def get(
         self,
         transaction_id: str,
         query: Optional[TransactionGetQuery] = None,
-    ):
+    ) -> Response[TransactionResponse]:
         return self.with_endpoint('api').request_get(
             f'transactions/{transaction_id}', query
         )
 
     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: str):
+    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,17 +1,19 @@
 from typing import Optional
 
-from client.api.blocks import BlocksQuery
-from client.api.wallets import WalletsQuery
 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: Optional[ValidatorsQuery] = None):
+    def all(self, query: Optional[ValidatorsQuery] = None) -> PaginatedResponse[WalletResponse]:
         return self.with_endpoint('api').request_get('validators', query)
 
-    def get(self, validator_id: str):
+    def get(self, validator_id: str) -> Response[WalletResponse]:
         return self.with_endpoint('api').request_get(
             f'validators/{validator_id}'
         )
@@ -20,7 +22,7 @@ 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
         )
@@ -29,7 +31,7 @@ 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
         )

client/api/votes.py

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