diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 78d7205afb6..77995cb5a74 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -172,8 +172,8 @@ repos:
       - id: mypy
         name: "mypy: syft"
         always_run: true
-        files: "^packages/syft/src/syft/serde|^packages/syft/src/syft/util|^packages/syft/src/syft/service"
-        # files: "^packages/syft/src/syft/"
+        files: "^packages/syft/src/syft/"
+        exclude: "packages/syft/src/syft/types/dicttuple.py|^packages/syft/src/syft/service/action/action_graph.py|^packages/syft/src/syft/external/oblv/"
         args: [
             "--follow-imports=skip",
             "--ignore-missing-imports",
diff --git a/packages/syft/src/syft/__init__.py b/packages/syft/src/syft/__init__.py
index d438f9ef9bd..2a0fcfa5b6d 100644
--- a/packages/syft/src/syft/__init__.py
+++ b/packages/syft/src/syft/__init__.py
@@ -93,6 +93,9 @@
 logger.start()
 
 try:
+    # third party
+    from IPython import get_ipython
+
     get_ipython()  # noqa: F821
     # TODO: add back later or auto detect
     # display(
diff --git a/packages/syft/src/syft/abstract_node.py b/packages/syft/src/syft/abstract_node.py
index 2341d6e4926..046c7e493ff 100644
--- a/packages/syft/src/syft/abstract_node.py
+++ b/packages/syft/src/syft/abstract_node.py
@@ -2,12 +2,17 @@
 from enum import Enum
 from typing import Callable
 from typing import Optional
+from typing import TYPE_CHECKING
 from typing import Union
 
 # relative
 from .serde.serializable import serializable
 from .types.uid import UID
 
+if TYPE_CHECKING:
+    # relative
+    from .service.service import AbstractService
+
 
 @serializable()
 class NodeType(str, Enum):
@@ -37,5 +42,5 @@ class AbstractNode:
     node_side_type: Optional[NodeSideType]
     in_memory_workers: bool
 
-    def get_service(self, path_or_func: Union[str, Callable]) -> Callable:
+    def get_service(self, path_or_func: Union[str, Callable]) -> "AbstractService":
         raise NotImplementedError
diff --git a/packages/syft/src/syft/client/api.py b/packages/syft/src/syft/client/api.py
index df948df96ca..5821550b2b9 100644
--- a/packages/syft/src/syft/client/api.py
+++ b/packages/syft/src/syft/client/api.py
@@ -16,6 +16,7 @@
 from typing import Tuple
 from typing import Union
 from typing import _GenericAlias
+from typing import cast
 from typing import get_args
 from typing import get_origin
 
@@ -241,8 +242,8 @@ def __ipython_inspector_signature_override__(self) -> Optional[Signature]:
         return self.signature
 
     def prepare_args_and_kwargs(
-        self, args: List[Any], kwargs: Dict[str, Any]
-    ) -> Union[SyftError, Tuple[List[Any], Dict[str, Any]]]:
+        self, args: Union[list, tuple], kwargs: dict[str, Any]
+    ) -> Union[SyftError, tuple[tuple, dict[str, Any]]]:
         # Validate and migrate args and kwargs
         res = validate_callable_args_and_kwargs(args, kwargs, self.signature)
         if isinstance(res, SyftError):
@@ -279,7 +280,7 @@ def __call__(self, *args: Any, **kwargs: Any) -> Any:
         api_call = SyftAPICall(
             node_uid=self.node_uid,
             path=self.path,
-            args=_valid_args,
+            args=list(_valid_args),
             kwargs=_valid_kwargs,
             blocking=blocking,
         )
@@ -304,8 +305,8 @@ class RemoteUserCodeFunction(RemoteFunction):
     api: SyftAPI
 
     def prepare_args_and_kwargs(
-        self, args: List[Any], kwargs: Dict[str, Any]
-    ) -> Union[SyftError, Tuple[List[Any], Dict[str, Any]]]:
+        self, args: Union[list, tuple], kwargs: Dict[str, Any]
+    ) -> Union[SyftError, tuple[tuple, dict[str, Any]]]:
         # relative
         from ..service.action.action_object import convert_to_pointers
 
@@ -506,9 +507,12 @@ def _repr_html_(self) -> Any:
         results = self.get_all()
         return results._repr_html_()
 
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        return NotImplementedError
+
 
 def debox_signed_syftapicall_response(
-    signed_result: SignedSyftAPICall,
+    signed_result: Union[SignedSyftAPICall, Any],
 ) -> Union[Any, SyftError]:
     if not isinstance(signed_result, SignedSyftAPICall):
         return SyftError(message="The result is not signed")
@@ -825,16 +829,16 @@ def build_endpoint_tree(
         )
 
     @property
-    def services(self) -> Optional[APIModule]:
+    def services(self) -> APIModule:
         if self.api_module is None:
             self.generate_endpoints()
-        return self.api_module
+        return cast(APIModule, self.api_module)
 
     @property
-    def lib(self) -> Optional[APIModule]:
+    def lib(self) -> APIModule:
         if self.libs is None:
             self.generate_endpoints()
-        return self.libs
+        return cast(APIModule, self.libs)
 
     def has_service(self, service_name: str) -> bool:
         return hasattr(self.services, service_name)
@@ -940,19 +944,21 @@ class NodeIdentity(Identity):
     node_name: str
 
     @staticmethod
-    def from_api(api: SyftAPI) -> Optional[NodeIdentity]:
+    def from_api(api: SyftAPI) -> NodeIdentity:
         # stores the name root verify key of the domain node
-        if api.connection is not None:
-            node_metadata = api.connection.get_node_metadata(api.signing_key)
-            return NodeIdentity(
-                node_name=node_metadata.name,
-                node_id=api.node_uid,
-                verify_key=SyftVerifyKey.from_string(node_metadata.verify_key),
-            )
-        return None
+        if api.connection is None:
+            raise ValueError("{api}'s connection is None. Can't get the node identity")
+        node_metadata = api.connection.get_node_metadata(api.signing_key)
+        return NodeIdentity(
+            node_name=node_metadata.name,
+            node_id=api.node_uid,
+            verify_key=SyftVerifyKey.from_string(node_metadata.verify_key),
+        )
 
     @classmethod
     def from_change_context(cls, context: ChangeContext) -> NodeIdentity:
+        if context.node is None:
+            raise ValueError(f"{context}'s node is None")
         return cls(
             node_name=context.node.name,
             node_id=context.node.id,
diff --git a/packages/syft/src/syft/client/client.py b/packages/syft/src/syft/client/client.py
index 5d4228c1ce4..505b780f318 100644
--- a/packages/syft/src/syft/client/client.py
+++ b/packages/syft/src/syft/client/client.py
@@ -13,7 +13,6 @@
 from typing import List
 from typing import Optional
 from typing import TYPE_CHECKING
-from typing import Tuple
 from typing import Type
 from typing import Union
 from typing import cast
@@ -25,7 +24,7 @@
 from requests import Response
 from requests import Session
 from requests.adapters import HTTPAdapter
-from requests.packages.urllib3.util.retry import Retry
+from requests.packages.urllib3.util.retry import Retry  # type: ignore[import-untyped]
 from typing_extensions import Self
 
 # relative
@@ -94,9 +93,9 @@ def forward_message_to_proxy(
     proxy_target_uid: UID,
     path: str,
     credentials: Optional[SyftSigningKey] = None,
-    args: Optional[Tuple] = None,
+    args: Optional[list] = None,
     kwargs: Optional[Dict] = None,
-):
+) -> Union[Any, SyftError]:
     kwargs = {} if kwargs is None else kwargs
     args = [] if args is None else args
     call = SyftAPICall(
@@ -155,7 +154,7 @@ def get_cache_key(self) -> str:
     def api_url(self) -> GridURL:
         return self.url.with_path(self.routes.ROUTE_API_CALL.value)
 
-    def to_blob_route(self, path: str, **kwargs) -> GridURL:
+    def to_blob_route(self, path: str, **kwargs: Any) -> GridURL:
         _path = self.routes.ROUTE_BLOB_STORE.value + path
         return self.url.with_path(_path)
 
@@ -347,7 +346,7 @@ def get_node_metadata(self, credentials: SyftSigningKey) -> NodeMetadataJSON:
         else:
             return self.node.metadata.to(NodeMetadataJSON)
 
-    def to_blob_route(self, path: str, host=None) -> GridURL:
+    def to_blob_route(self, path: str, host: Optional[str] = None) -> GridURL:
         # TODO: FIX!
         if host is not None:
             return GridURL(host_or_ip=host, port=8333).with_path(path)
@@ -474,8 +473,8 @@ def __init__(
         self.metadata = metadata
         self.credentials: Optional[SyftSigningKey] = credentials
         self._api = api
-        self.communication_protocol = None
-        self.current_protocol = None
+        self.communication_protocol: Optional[Union[int, str]] = None
+        self.current_protocol: Optional[Union[int, str]] = None
 
         self.post_init()
 
@@ -485,7 +484,7 @@ def get_env(self) -> str:
     def post_init(self) -> None:
         if self.metadata is None:
             self._fetch_node_metadata(self.credentials)
-
+        self.metadata = cast(NodeMetadataJSON, self.metadata)
         self.communication_protocol = self._get_communication_protocol(
             self.metadata.supported_protocols
         )
@@ -528,7 +527,8 @@ def create_project(
         project = project_create.start()
         return project
 
-    def sync_code_from_request(self, request):
+    # TODO: type of request should be REQUEST, but it will give circular import error
+    def sync_code_from_request(self, request: Any) -> Union[SyftSuccess, SyftError]:
         # relative
         from ..service.code.user_code import UserCode
         from ..service.code.user_code import UserCodeStatusCollection
@@ -542,8 +542,11 @@ def sync_code_from_request(self, request):
         code.node_uid = self.id
         code.user_verify_key = self.verify_key
 
-        def get_nested_codes(code: UserCode):
-            result = []
+        def get_nested_codes(code: UserCode) -> list[UserCode]:
+            result: list[UserCode] = []
+            if code.nested_codes is None:
+                return result
+
             for _, (linked_code_obj, _) in code.nested_codes.items():
                 nested_code = linked_code_obj.resolve
                 nested_code = deepcopy(nested_code)
@@ -552,11 +555,6 @@ def get_nested_codes(code: UserCode):
                 result.append(nested_code)
                 result += get_nested_codes(nested_code)
 
-            updated_code_links = {
-                nested_code.service_func_name: (LinkedObject.from_obj(nested_code), {})
-                for nested_code in result
-            }
-            code.nested_codes = updated_code_links
             return result
 
         def get_code_statusses(codes: List[UserCode]) -> List[UserCodeStatusCollection]:
@@ -607,7 +605,7 @@ def verify_key(self) -> SyftVerifyKey:
 
     @classmethod
     def from_url(cls, url: Union[str, GridURL]) -> Self:
-        return cls(connection=HTTPConnection(GridURL.from_url(url)))
+        return cls(connection=HTTPConnection(url=GridURL.from_url(url)))
 
     @classmethod
     def from_node(cls, node: AbstractNode) -> Self:
@@ -641,8 +639,7 @@ def api(self) -> SyftAPI:
         # invalidate API
         if self._api is None or (self._api.signing_key != self.credentials):
             self._fetch_api(self.credentials)
-
-        return self._api
+        return cast(SyftAPI, self._api)  # we are sure self._api is not None after fetch
 
     def guest(self) -> Self:
         return self.__class__(
@@ -657,7 +654,8 @@ def exchange_route(self, client: Self) -> Union[SyftSuccess, SyftError]:
 
         self_node_route = connection_to_route(self.connection)
         remote_node_route = connection_to_route(client.connection)
-
+        if client.metadata is None:
+            return SyftError(f"client {client}'s metadata is None!")
         result = self.api.services.network.exchange_credentials_with(
             self_node_route=self_node_route,
             remote_node_route=remote_node_route,
@@ -715,10 +713,11 @@ def me(self) -> Optional[Union[UserView, SyftError]]:
     def login_as_guest(self) -> Self:
         _guest_client = self.guest()
 
-        print(
-            f"Logged into <{self.name}: {self.metadata.node_side_type.capitalize()}-side "
-            f"{self.metadata.node_type.capitalize()}> as GUEST"
-        )
+        if self.metadata is not None:
+            print(
+                f"Logged into <{self.name}: {self.metadata.node_side_type.capitalize()}-side "
+                f"{self.metadata.node_type.capitalize()}> as GUEST"
+            )
 
         return _guest_client
 
@@ -762,11 +761,11 @@ def login(
 
         client.__logged_in_user = email
 
-        if user_private_key is not None:
+        if user_private_key is not None and client.users is not None:
             client.__user_role = user_private_key.role
             client.__logged_in_username = client.users.get_current_user().name
 
-        if signing_key is not None:
+        if signing_key is not None and client.metadata is not None:
             print(
                 f"Logged into <{client.name}: {client.metadata.node_side_type.capitalize()} side "
                 f"{client.metadata.node_type.capitalize()}> as <{email}>"
@@ -804,16 +803,18 @@ def login(
         # relative
         from ..node.node import CODE_RELOADER
 
-        CODE_RELOADER[thread_ident()] = client._reload_user_code
+        thread_id = thread_ident()
+        if thread_id is not None:
+            CODE_RELOADER[thread_id] = client._reload_user_code
 
         return client
 
-    def _reload_user_code(self):
+    def _reload_user_code(self) -> None:
         # relative
         from ..service.code.user_code import load_approved_policy_code
 
         user_code_items = self.code.get_all_for_user()
-        load_approved_policy_code(user_code_items)
+        load_approved_policy_code(user_code_items=user_code_items, context=None)
 
     def register(
         self,
@@ -823,7 +824,7 @@ def register(
         password_verify: Optional[str] = None,
         institution: Optional[str] = None,
         website: Optional[str] = None,
-    ):
+    ) -> Optional[Union[SyftError, SyftSigningKey]]:
         if not email:
             email = input("Email: ")
         if not password:
@@ -848,7 +849,10 @@ def register(
         except Exception as e:
             return SyftError(message=str(e))
 
-        if self.metadata.node_side_type == NodeSideType.HIGH_SIDE.value:
+        if (
+            self.metadata
+            and self.metadata.node_side_type == NodeSideType.HIGH_SIDE.value
+        ):
             message = (
                 "You're registering a user to a high side "
                 f"{self.metadata.node_type}, which could "
@@ -857,7 +861,7 @@ def register(
             if self.metadata.show_warnings and not prompt_warning_message(
                 message=message
             ):
-                return
+                return None
 
         response = self.connection.register(new_user=new_user)
         if isinstance(response, tuple):
@@ -894,16 +898,20 @@ def _fetch_node_metadata(self, credentials: SyftSigningKey) -> None:
             metadata.check_version(__version__)
             self.metadata = metadata
 
-    def _fetch_api(self, credentials: SyftSigningKey):
+    def _fetch_api(self, credentials: SyftSigningKey) -> None:
         _api: SyftAPI = self.connection.get_api(
             credentials=credentials,
             communication_protocol=self.communication_protocol,
         )
 
-        def refresh_callback():
+        def refresh_callback() -> None:
             return self._fetch_api(self.credentials)
 
         _api.refresh_api_callback = refresh_callback
+
+        if self.credentials is None:
+            raise ValueError(f"{self}'s credentials (signing key) is None!")
+
         APIRegistry.set_api_for(
             node_uid=self.id,
             user_verify_key=self.credentials.verify_key,
@@ -943,7 +951,7 @@ def register(
     password: str,
     institution: Optional[str] = None,
     website: Optional[str] = None,
-):
+) -> Optional[Union[SyftError, SyftSigningKey]]:
     guest_client = connect(url=url, port=port)
     return guest_client.register(
         name=name,
@@ -960,13 +968,13 @@ def login_as_guest(
     node: Optional[AbstractNode] = None,
     port: Optional[int] = None,
     verbose: bool = True,
-):
+) -> SyftClient:
     _client = connect(url=url, node=node, port=port)
 
     if isinstance(_client, SyftError):
         return _client
 
-    if verbose:
+    if verbose and _client.metadata is not None:
         print(
             f"Logged into <{_client.name}: {_client.metadata.node_side_type.capitalize()}-"
             f"side {_client.metadata.node_type.capitalize()}> as GUEST"
@@ -1039,7 +1047,7 @@ def add_client(
         password: str,
         connection: NodeConnection,
         syft_client: SyftClient,
-    ):
+    ) -> None:
         hash_key = cls._get_key(email, password, connection.get_cache_key())
         cls.__credentials_store__[hash_key] = syft_client
         cls.__client_cache__[syft_client.id] = syft_client
@@ -1050,7 +1058,7 @@ def add_client_by_uid_and_verify_key(
         verify_key: SyftVerifyKey,
         node_uid: UID,
         syft_client: SyftClient,
-    ):
+    ) -> None:
         hash_key = str(node_uid) + str(verify_key)
         cls.__client_cache__[hash_key] = syft_client
 
@@ -1067,8 +1075,8 @@ def get_client(
     ) -> Optional[SyftClient]:
         # we have some bugs here so lets disable until they are fixed.
         return None
-        hash_key = cls._get_key(email, password, connection.get_cache_key())
-        return cls.__credentials_store__.get(hash_key, None)
+        # hash_key = cls._get_key(email, password, connection.get_cache_key())
+        # return cls.__credentials_store__.get(hash_key, None)
 
     @classmethod
     def get_client_for_node_uid(cls, node_uid: UID) -> Optional[SyftClient]:
diff --git a/packages/syft/src/syft/client/connection.py b/packages/syft/src/syft/client/connection.py
index 5b9928c8355..a94cb1c0707 100644
--- a/packages/syft/src/syft/client/connection.py
+++ b/packages/syft/src/syft/client/connection.py
@@ -10,7 +10,7 @@ class NodeConnection(SyftObject):
     __canonical_name__ = "NodeConnection"
     __version__ = SYFT_OBJECT_VERSION_1
 
-    def get_cache_key() -> str:
+    def get_cache_key(self) -> str:
         raise NotImplementedError
 
     def __repr__(self) -> str:
diff --git a/packages/syft/src/syft/client/domain_client.py b/packages/syft/src/syft/client/domain_client.py
index 80679a49f81..35773178b56 100644
--- a/packages/syft/src/syft/client/domain_client.py
+++ b/packages/syft/src/syft/client/domain_client.py
@@ -4,11 +4,14 @@
 # stdlib
 from pathlib import Path
 import re
+from typing import List
 from typing import Optional
 from typing import TYPE_CHECKING
 from typing import Union
+from typing import cast
 
 # third party
+from hagrid.orchestra import NodeHandle
 from loguru import logger
 from tqdm import tqdm
 
@@ -26,8 +29,10 @@
 from ..service.response import SyftSuccess
 from ..service.sync.diff_state import ResolvedSyncState
 from ..service.user.roles import Roles
+from ..service.user.user import UserView
 from ..service.user.user_roles import ServiceRole
 from ..types.blob_storage import BlobFile
+from ..types.syft_object import SyftObject
 from ..types.uid import UID
 from ..util.fonts import fonts_css
 from ..util.util import get_mb_size
@@ -37,13 +42,14 @@
 from .client import SyftClient
 from .client import login
 from .client import login_as_guest
+from .connection import NodeConnection
 
 if TYPE_CHECKING:
     # relative
     from ..service.project.project import Project
 
 
-def _get_files_from_glob(glob_path: str) -> list:
+def _get_files_from_glob(glob_path: str) -> list[Path]:
     files = Path().glob(glob_path)
     return [f for f in files if f.is_file() and not f.name.startswith(".")]
 
@@ -61,7 +67,7 @@ def _contains_subdir(dir: Path) -> bool:
 
 
 def add_default_uploader(
-    user, obj: Union[CreateDataset, CreateAsset]
+    user: UserView, obj: Union[CreateDataset, CreateAsset]
 ) -> Union[CreateDataset, CreateAsset]:
     uploader = None
     for contributor in obj.contributors:
@@ -90,6 +96,9 @@ def upload_dataset(self, dataset: CreateDataset) -> Union[SyftSuccess, SyftError
         # relative
         from ..types.twin_object import TwinObject
 
+        if self.users is None:
+            return SyftError(f"can't get user service for {self}")
+
         user = self.users.get_current_user()
         dataset = add_default_uploader(user, dataset)
         for i in range(len(dataset.asset_list)):
@@ -97,9 +106,12 @@ def upload_dataset(self, dataset: CreateDataset) -> Union[SyftSuccess, SyftError
             dataset.asset_list[i] = add_default_uploader(user, asset)
 
         dataset._check_asset_must_contain_mock()
-        dataset_size = 0
+        dataset_size: float = 0.0
 
         # TODO: Refactor so that object can also be passed to generate warnings
+
+        self.api.connection = cast(NodeConnection, self.api.connection)
+
         metadata = self.api.connection.get_node_metadata(self.api.signing_key)
 
         if (
@@ -134,18 +146,18 @@ def upload_dataset(self, dataset: CreateDataset) -> Union[SyftSuccess, SyftError
             dataset_size += get_mb_size(asset.data)
         dataset.mb_size = dataset_size
         valid = dataset.check()
-        if valid.ok():
-            return self.api.services.dataset.add(dataset=dataset)
-        else:
-            if len(valid.err()) > 0:
-                return tuple(valid.err())
-            return valid.err()
+        if isinstance(valid, SyftError):
+            return valid
+        return self.api.services.dataset.add(dataset=dataset)
 
-    def create_actionobject(self, action_object):
+    def create_actionobject(self, action_object: SyftObject) -> None:
         action_object = action_object.refresh_object()
         action_object.send(self)
 
-    def get_permissions_for_other_node(self, items):
+    def get_permissions_for_other_node(
+        self,
+        items: list[Union[ActionObject, SyftObject]],
+    ) -> dict:
         if len(items) > 0:
             if not len({i.syft_node_location for i in items}) == 1 or (
                 not len({i.syft_client_verify_key for i in items}) == 1
@@ -155,6 +167,10 @@ def get_permissions_for_other_node(self, items):
             api = APIRegistry.api_for(
                 item.syft_node_location, item.syft_client_verify_key
             )
+            if api is None:
+                raise ValueError(
+                    f"Can't access the api. Please log in to {item.syft_node_location}"
+                )
             return api.services.sync.get_permissions(items)
         else:
             return {}
@@ -168,7 +184,7 @@ def apply_state(
 
         action_objects = [x for x in items if isinstance(x, ActionObject)]
         # permissions = self.get_permissions_for_other_node(items)
-        permissions = {}
+        permissions: dict[UID, set[str]] = {}
         for p in resolved_state.new_permissions:
             if p.uid in permissions:
                 permissions[p.uid].add(p.permission_string)
@@ -193,16 +209,17 @@ def apply_state(
     def upload_files(
         self,
         file_list: Union[BlobFile, list[BlobFile], str, list[str], Path, list[Path]],
-        allow_recursive=False,
-        show_files=False,
+        allow_recursive: bool = False,
+        show_files: bool = False,
     ) -> Union[SyftSuccess, SyftError]:
         if not file_list:
             return SyftError(message="No files to upload")
 
         if not isinstance(file_list, list):
-            file_list = [file_list]
+            file_list = [file_list]  # type: ignore[assignment]
+        file_list = cast(list, file_list)
 
-        expanded_file_list = []
+        expanded_file_list: List[Union[BlobFile, Path]] = []
 
         for file in file_list:
             if isinstance(file, BlobFile):
@@ -263,7 +280,7 @@ def connect_to_gateway(
         handle: Optional[NodeHandle] = None,  # noqa: F821
         email: Optional[str] = None,
         password: Optional[str] = None,
-    ) -> None:
+    ) -> Optional[Union[SyftSuccess, SyftError]]:
         if via_client is not None:
             client = via_client
         elif handle is not None:
@@ -279,9 +296,12 @@ def connect_to_gateway(
 
         res = self.exchange_route(client)
         if isinstance(res, SyftSuccess):
-            return SyftSuccess(
-                message=f"Connected {self.metadata.node_type} to {client.name} gateway"
-            )
+            if self.metadata:
+                return SyftSuccess(
+                    message=f"Connected {self.metadata.node_type} to {client.name} gateway"
+                )
+            else:
+                return SyftSuccess(message=f"Connected to {client.name} gateway")
         return res
 
     @property
@@ -374,8 +394,8 @@ def output(self) -> Optional[APIModule]:
 
     def get_project(
         self,
-        name: str = None,
-        uid: UID = None,
+        name: Optional[str] = None,
+        uid: Optional[UID] = None,
     ) -> Optional[Project]:
         """Get project by name or UID"""
 
@@ -442,18 +462,17 @@ def _repr_html_(self) -> str:
 
         url = getattr(self.connection, "url", None)
         node_details = f"<strong>URL:</strong> {url}<br />" if url else ""
-        node_details += (
-            f"<strong>Node Type:</strong> {self.metadata.node_type.capitalize()}<br />"
-        )
-        node_side_type = (
-            "Low Side"
-            if self.metadata.node_side_type == NodeSideType.LOW_SIDE.value
-            else "High Side"
-        )
-        node_details += f"<strong>Node Side Type:</strong> {node_side_type}<br />"
-        node_details += (
-            f"<strong>Syft Version:</strong> {self.metadata.syft_version}<br />"
-        )
+        if self.metadata is not None:
+            node_details += f"<strong>Node Type:</strong> {self.metadata.node_type.capitalize()}<br />"
+            node_side_type = (
+                "Low Side"
+                if self.metadata.node_side_type == NodeSideType.LOW_SIDE.value
+                else "High Side"
+            )
+            node_details += f"<strong>Node Side Type:</strong> {node_side_type}<br />"
+            node_details += (
+                f"<strong>Syft Version:</strong> {self.metadata.syft_version}<br />"
+            )
 
         return f"""
         <style>
diff --git a/packages/syft/src/syft/client/enclave_client.py b/packages/syft/src/syft/client/enclave_client.py
index e0a09167805..59c11aaf50b 100644
--- a/packages/syft/src/syft/client/enclave_client.py
+++ b/packages/syft/src/syft/client/enclave_client.py
@@ -2,14 +2,20 @@
 from __future__ import annotations
 
 # stdlib
+from typing import Any
 from typing import Optional
 from typing import TYPE_CHECKING
+from typing import Union
+
+# third party
+from hagrid.orchestra import NodeHandle
 
 # relative
 from ..abstract_node import NodeSideType
 from ..client.api import APIRegistry
 from ..img.base64 import base64read
 from ..serde.serializable import serializable
+from ..service.metadata.node_metadata import NodeMetadataJSON
 from ..service.network.routes import NodeRouteType
 from ..service.response import SyftError
 from ..service.response import SyftSuccess
@@ -68,7 +74,7 @@ def connect_to_gateway(
         handle: Optional[NodeHandle] = None,  # noqa: F821
         email: Optional[str] = None,
         password: Optional[str] = None,
-    ) -> None:
+    ) -> Optional[Union[SyftSuccess, SyftError]]:
         if via_client is not None:
             client = via_client
         elif handle is not None:
@@ -82,17 +88,20 @@ def connect_to_gateway(
             if isinstance(client, SyftError):
                 return client
 
+        self.metadata: NodeMetadataJSON = self.metadata
         res = self.exchange_route(client)
+
         if isinstance(res, SyftSuccess):
             return SyftSuccess(
                 message=f"Connected {self.metadata.node_type} to {client.name} gateway"
             )
+
         return res
 
     def get_enclave_metadata(self) -> EnclaveMetadata:
         return EnclaveMetadata(route=self.connection.route)
 
-    def request_code_execution(self, code: SubmitUserCode):
+    def request_code_execution(self, code: SubmitUserCode) -> Union[Any, SyftError]:
         # relative
         from ..service.code.user_code_service import SubmitUserCode
 
@@ -100,6 +109,8 @@ def request_code_execution(self, code: SubmitUserCode):
             raise Exception(
                 f"The input code should be of type: {SubmitUserCode} got:{type(code)}"
             )
+        if code.input_policy_init_kwargs is None:
+            raise ValueError(f"code {code}'s input_policy_init_kwargs is None")
 
         enclave_metadata = self.get_enclave_metadata()
 
@@ -154,18 +165,17 @@ def _repr_html_(self) -> str:
 
         url = getattr(self.connection, "url", None)
         node_details = f"<strong>URL:</strong> {url}<br />" if url else ""
-        node_details += (
-            f"<strong>Node Type:</strong> {self.metadata.node_type.capitalize()}<br />"
-        )
-        node_side_type = (
-            "Low Side"
-            if self.metadata.node_side_type == NodeSideType.LOW_SIDE.value
-            else "High Side"
-        )
-        node_details += f"<strong>Node Side Type:</strong> {node_side_type}<br />"
-        node_details += (
-            f"<strong>Syft Version:</strong> {self.metadata.syft_version}<br />"
-        )
+        if self.metadata:
+            node_details += f"<strong>Node Type:</strong> {self.metadata.node_type.capitalize()}<br />"
+            node_side_type = (
+                "Low Side"
+                if self.metadata.node_side_type == NodeSideType.LOW_SIDE.value
+                else "High Side"
+            )
+            node_details += f"<strong>Node Side Type:</strong> {node_side_type}<br />"
+            node_details += (
+                f"<strong>Syft Version:</strong> {self.metadata.syft_version}<br />"
+            )
 
         return f"""
         <style>
diff --git a/packages/syft/src/syft/client/gateway_client.py b/packages/syft/src/syft/client/gateway_client.py
index 2a569cabd22..89cb97a4755 100644
--- a/packages/syft/src/syft/client/gateway_client.py
+++ b/packages/syft/src/syft/client/gateway_client.py
@@ -2,11 +2,9 @@
 from typing import Any
 from typing import List
 from typing import Optional
+from typing import Type
 from typing import Union
 
-# third party
-from typing_extensions import Self
-
 # relative
 from ..abstract_node import NodeSideType
 from ..abstract_node import NodeType
@@ -26,7 +24,7 @@
 class GatewayClient(SyftClient):
     # TODO: add widget repr for gateway client
 
-    def proxy_to(self, peer: Any) -> Self:
+    def proxy_to(self, peer: Any) -> SyftClient:
         # relative
         from .domain_client import DomainClient
         from .enclave_client import EnclaveClient
@@ -34,7 +32,7 @@ def proxy_to(self, peer: Any) -> Self:
         connection = self.connection.with_proxy(peer.id)
         metadata = connection.get_node_metadata(credentials=SyftSigningKey.generate())
         if metadata.node_type == NodeType.DOMAIN.value:
-            client_type = DomainClient
+            client_type: Type[SyftClient] = DomainClient
         elif metadata.node_type == NodeType.ENCLAVE.value:
             client_type = EnclaveClient
         else:
@@ -53,8 +51,8 @@ def proxy_client_for(
         name: str,
         email: Optional[str] = None,
         password: Optional[str] = None,
-        **kwargs,
-    ):
+        **kwargs: Any,
+    ) -> SyftClient:
         peer = None
         if self.api.has_service("network"):
             peer = self.api.services.network.get_peer_by_name(name=name)
@@ -97,18 +95,17 @@ def _repr_html_(self) -> str:
 
         url = getattr(self.connection, "url", None)
         node_details = f"<strong>URL:</strong> {url}<br />" if url else ""
-        node_details += (
-            f"<strong>Node Type:</strong> {self.metadata.node_type.capitalize()}<br />"
-        )
-        node_side_type = (
-            "Low Side"
-            if self.metadata.node_side_type == NodeSideType.LOW_SIDE.value
-            else "High Side"
-        )
-        node_details += f"<strong>Node Side Type:</strong> {node_side_type}<br />"
-        node_details += (
-            f"<strong>Syft Version:</strong> {self.metadata.syft_version}<br />"
-        )
+        if self.metadata:
+            node_details += f"<strong>Node Type:</strong> {self.metadata.node_type.capitalize()}<br />"
+            node_side_type = (
+                "Low Side"
+                if self.metadata.node_side_type == NodeSideType.LOW_SIDE.value
+                else "High Side"
+            )
+            node_details += f"<strong>Node Side Type:</strong> {node_side_type}<br />"
+            node_details += (
+                f"<strong>Syft Version:</strong> {self.metadata.syft_version}<br />"
+            )
 
         return f"""
         <style>
@@ -178,7 +175,7 @@ def _repr_html_(self) -> str:
     def __len__(self) -> int:
         return len(self.retrieve_nodes())
 
-    def __getitem__(self, key: int):
+    def __getitem__(self, key: Union[int, str]) -> SyftClient:
         if not isinstance(key, int):
             raise SyftException(f"Key: {key} must be an integer")
 
diff --git a/packages/syft/src/syft/client/registry.py b/packages/syft/src/syft/client/registry.py
index c23d21b7b8e..b67a3dd1c5d 100644
--- a/packages/syft/src/syft/client/registry.py
+++ b/packages/syft/src/syft/client/registry.py
@@ -23,7 +23,6 @@
 from ..util.logger import error
 from ..util.logger import warning
 from .client import SyftClient as Client
-from .enclave_client import EnclaveClient
 
 NETWORK_REGISTRY_URL = (
     "https://raw.githubusercontent.com/OpenMined/NetworkRegistry/main/gateways.json"
@@ -200,8 +199,10 @@ def check_network(network: Dict) -> Optional[Dict[Any, Any]]:
         return online_networks
 
     @property
-    def online_domains(self) -> List[Tuple[NodePeer, NodeMetadataJSON]]:
-        def check_domain(peer: NodePeer) -> Optional[Tuple[NodePeer, NodeMetadataJSON]]:
+    def online_domains(self) -> List[Tuple[NodePeer, Optional[NodeMetadataJSON]]]:
+        def check_domain(
+            peer: NodePeer,
+        ) -> Optional[tuple[NodePeer, Optional[NodeMetadataJSON]]]:
             try:
                 guest_client = peer.guest_client
                 metadata = guest_client.metadata
@@ -232,14 +233,15 @@ def check_domain(peer: NodePeer) -> Optional[Tuple[NodePeer, NodeMetadataJSON]]:
                 online_domains.append(each)
         return online_domains
 
-    def __make_dict__(self) -> List[Dict[str, str]]:
+    def __make_dict__(self) -> list[dict[str, Any]]:
         on = self.online_domains
         domains = []
-        domain_dict = {}
+        domain_dict: dict[str, Any] = {}
         for domain, metadata in on:
             domain_dict["name"] = domain.name
-            domain_dict["organization"] = metadata.organization
-            domain_dict["version"] = metadata.syft_version
+            if metadata is not None:
+                domain_dict["organization"] = metadata.organization
+                domain_dict["version"] = metadata.syft_version
             route = None
             if len(domain.node_routes) > 0:
                 route = domain.pick_highest_priority_route()
@@ -371,7 +373,7 @@ def create_client(enclave: Dict[str, Any]) -> Client:
             error(f"Failed to login with: {enclave}. {e}")
             raise SyftException(f"Failed to login with: {enclave}. {e}")
 
-    def __getitem__(self, key: Union[str, int]) -> EnclaveClient:
+    def __getitem__(self, key: Union[str, int]) -> Client:
         if isinstance(key, int):
             return self.create_client(enclave=self.online_enclaves[key])
         else:
diff --git a/packages/syft/src/syft/client/search.py b/packages/syft/src/syft/client/search.py
index 66d46c5b3d4..9a979cb6475 100644
--- a/packages/syft/src/syft/client/search.py
+++ b/packages/syft/src/syft/client/search.py
@@ -1,5 +1,6 @@
 # stdlib
 from typing import List
+from typing import Optional
 from typing import Tuple
 from typing import Union
 
@@ -59,7 +60,7 @@ def __init__(self, domains: DomainRegistry):
     @staticmethod
     def __search_one_node(
         peer_tuple: Tuple[NodePeer, NodeMetadataJSON], name: str
-    ) -> List[Dataset]:
+    ) -> Tuple[Optional[SyftClient], List[Dataset]]:
         try:
             peer, _ = peer_tuple
             client = peer.guest_client
@@ -74,7 +75,7 @@ def __search(self, name: str) -> List[Tuple[SyftClient, List[Dataset]]]:
         ]
 
         # filter out SyftError
-        filtered = ((client, result) for client, result in results if result)
+        filtered = [(client, result) for client, result in results if client and result]
         return filtered
 
     def search(self, name: str) -> SearchResults:
diff --git a/packages/syft/src/syft/client/syncing.py b/packages/syft/src/syft/client/syncing.py
index e829a5b0655..cb3d8fc7e3d 100644
--- a/packages/syft/src/syft/client/syncing.py
+++ b/packages/syft/src/syft/client/syncing.py
@@ -12,6 +12,7 @@
 from ..service.job.job_stash import Job
 from ..service.log.log import SyftLog
 from ..service.sync.diff_state import NodeDiff
+from ..service.sync.diff_state import ObjectDiffBatch
 from ..service.sync.diff_state import ResolvedSyncState
 from ..service.sync.sync_state import SyncState
 
@@ -20,7 +21,7 @@ def compare_states(low_state: SyncState, high_state: SyncState) -> NodeDiff:
     return NodeDiff.from_sync_state(low_state=low_state, high_state=high_state)
 
 
-def get_user_input_for_resolve():
+def get_user_input_for_resolve() -> Optional[str]:
     print(
         "Do you want to keep the low state or the high state for these objects? choose 'low' or 'high'"
     )
@@ -36,8 +37,8 @@ def get_user_input_for_resolve():
 
 
 def resolve(
-    state: NodeDiff, decision: Optional[str] = None, share_private_objects=False
-):
+    state: NodeDiff, decision: Optional[str] = None, share_private_objects: bool = False
+) -> tuple[ResolvedSyncState, ResolvedSyncState]:
     # TODO: only add permissions for objects where we manually give permission
     # Maybe default read permission for some objects (high -> low)
     resolved_state_low: ResolvedSyncState = ResolvedSyncState(alias="low")
@@ -81,7 +82,9 @@ def resolve(
     return resolved_state_low, resolved_state_high
 
 
-def get_user_input_for_batch_permissions(batch_diff, share_private_objects=False):
+def get_user_input_for_batch_permissions(
+    batch_diff: ObjectDiffBatch, share_private_objects: bool = False
+) -> None:
     private_high_objects: List[Union[SyftLog, ActionObject]] = []
 
     for diff in batch_diff.diffs:
diff --git a/packages/syft/src/syft/custom_worker/builder.py b/packages/syft/src/syft/custom_worker/builder.py
index 5e479cee71c..8109ac94b43 100644
--- a/packages/syft/src/syft/custom_worker/builder.py
+++ b/packages/syft/src/syft/custom_worker/builder.py
@@ -3,6 +3,7 @@
 import os.path
 from pathlib import Path
 from typing import Any
+from typing import Optional
 
 # relative
 from .builder_docker import DockerBuilder
@@ -39,7 +40,7 @@ def builder(self) -> BuilderBase:
     def build_image(
         self,
         config: WorkerConfig,
-        tag: str = None,
+        tag: Optional[str] = None,
         **kwargs: Any,
     ) -> ImageBuildResult:
         """
@@ -82,7 +83,7 @@ def _build_dockerfile(
         self,
         config: DockerWorkerConfig,
         tag: str,
-        **kwargs,
+        **kwargs: Any,
     ) -> ImageBuildResult:
         return self.builder.build_image(
             dockerfile=config.dockerfile,
diff --git a/packages/syft/src/syft/custom_worker/builder_docker.py b/packages/syft/src/syft/custom_worker/builder_docker.py
index 3f7f16cf185..6b68d1e99c2 100644
--- a/packages/syft/src/syft/custom_worker/builder_docker.py
+++ b/packages/syft/src/syft/custom_worker/builder_docker.py
@@ -2,6 +2,7 @@
 import contextlib
 import io
 from pathlib import Path
+from typing import Any
 from typing import Iterable
 from typing import Optional
 
@@ -22,11 +23,11 @@ class DockerBuilder(BuilderBase):
     def build_image(
         self,
         tag: str,
-        dockerfile: str = None,
-        dockerfile_path: Path = None,
+        dockerfile: Optional[str] = None,
+        dockerfile_path: Optional[Path] = None,
         buildargs: Optional[dict] = None,
-        **kwargs,
-    ):
+        **kwargs: Any,
+    ) -> ImageBuildResult:
         if dockerfile:
             # convert dockerfile string to file-like object
             kwargs["fileobj"] = io.BytesIO(dockerfile.encode("utf-8"))
@@ -53,9 +54,10 @@ def build_image(
     def push_image(
         self,
         tag: str,
-        registry_url: str,
         username: str,
         password: str,
+        registry_url: str,
+        **kwargs: Any,
     ) -> ImagePushResult:
         with contextlib.closing(docker.from_env()) as client:
             if registry_url and username and password:
diff --git a/packages/syft/src/syft/custom_worker/builder_k8s.py b/packages/syft/src/syft/custom_worker/builder_k8s.py
index 1be16d3c0ac..24e494c7756 100644
--- a/packages/syft/src/syft/custom_worker/builder_k8s.py
+++ b/packages/syft/src/syft/custom_worker/builder_k8s.py
@@ -1,6 +1,7 @@
 # stdlib
 from hashlib import sha256
 from pathlib import Path
+from typing import Any
 from typing import Dict
 from typing import List
 from typing import Optional
@@ -33,16 +34,16 @@ class BuildFailed(Exception):
 class KubernetesBuilder(BuilderBase):
     COMPONENT = "builder"
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.client = get_kr8s_client()
 
     def build_image(
         self,
         tag: str,
-        dockerfile: str = None,
-        dockerfile_path: Path = None,
+        dockerfile: Optional[str] = None,
+        dockerfile_path: Optional[Path] = None,
         buildargs: Optional[dict] = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> ImageBuildResult:
         image_digest = None
         logs = None
@@ -102,7 +103,7 @@ def push_image(
         username: str,
         password: str,
         registry_url: str,
-        **kwargs,
+        **kwargs: Any,
     ) -> ImagePushResult:
         exit_code = 1
         logs = None
@@ -354,7 +355,9 @@ def _create_push_job(
         )
         return KubeUtils.create_or_get(job)
 
-    def _create_push_secret(self, id: str, url: str, username: str, password: str):
+    def _create_push_secret(
+        self, id: str, url: str, username: str, password: str
+    ) -> Secret:
         return KubeUtils.create_dockerconfig_secret(
             secret_name=f"push-secret-{id}",
             component=KubernetesBuilder.COMPONENT,
diff --git a/packages/syft/src/syft/custom_worker/builder_types.py b/packages/syft/src/syft/custom_worker/builder_types.py
index 8007bf476e9..9464bafced5 100644
--- a/packages/syft/src/syft/custom_worker/builder_types.py
+++ b/packages/syft/src/syft/custom_worker/builder_types.py
@@ -2,6 +2,7 @@
 from abc import ABC
 from abc import abstractmethod
 from pathlib import Path
+from typing import Any
 from typing import Optional
 
 # third party
@@ -33,20 +34,22 @@ class ImagePushResult(BaseModel):
 class BuilderBase(ABC):
     @abstractmethod
     def build_image(
+        self,
         tag: str,
-        dockerfile: str = None,
-        dockerfile_path: Path = None,
+        dockerfile: Optional[str] = None,
+        dockerfile_path: Optional[Path] = None,
         buildargs: Optional[dict] = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> ImageBuildResult:
         pass
 
     @abstractmethod
     def push_image(
+        self,
         tag: str,
         username: str,
         password: str,
         registry_url: str,
-        **kwargs,
+        **kwargs: Any,
     ) -> ImagePushResult:
         pass
diff --git a/packages/syft/src/syft/custom_worker/config.py b/packages/syft/src/syft/custom_worker/config.py
index c54d4f77c40..58f4b3f626b 100644
--- a/packages/syft/src/syft/custom_worker/config.py
+++ b/packages/syft/src/syft/custom_worker/config.py
@@ -57,7 +57,7 @@ class CustomBuildConfig(SyftBaseModel):
     @validator("python_packages")
     def validate_python_packages(cls, pkgs: List[str]) -> List[str]:
         for pkg in pkgs:
-            ver_parts = ()
+            ver_parts: Union[tuple, list] = ()
             name_ver = pkg.split("==")
             if len(name_ver) != 2:
                 raise ValueError(_malformed_python_package_error_msg(pkg))
@@ -72,13 +72,13 @@ def validate_python_packages(cls, pkgs: List[str]) -> List[str]:
 
         return pkgs
 
-    def merged_python_pkgs(self, sep=" ") -> str:
+    def merged_python_pkgs(self, sep: str = " ") -> str:
         return sep.join(self.python_packages)
 
-    def merged_system_pkgs(self, sep=" ") -> str:
+    def merged_system_pkgs(self, sep: str = " ") -> str:
         return sep.join(self.system_packages)
 
-    def merged_custom_cmds(self, sep=";") -> str:
+    def merged_custom_cmds(self, sep: str = ";") -> str:
         return sep.join(self.custom_cmds)
 
 
@@ -166,7 +166,9 @@ def __str__(self) -> str:
     def set_description(self, description_text: str) -> None:
         self.description = description_text
 
-    def test_image_build(self, tag: str, **kwargs) -> Union[SyftSuccess, SyftError]:
+    def test_image_build(
+        self, tag: str, **kwargs: Any
+    ) -> Union[SyftSuccess, SyftError]:
         try:
             with contextlib.closing(docker.from_env()) as client:
                 if not client.ping():
diff --git a/packages/syft/src/syft/custom_worker/k8s.py b/packages/syft/src/syft/custom_worker/k8s.py
index fb777f6ec6c..2c953ff1297 100644
--- a/packages/syft/src/syft/custom_worker/k8s.py
+++ b/packages/syft/src/syft/custom_worker/k8s.py
@@ -17,6 +17,7 @@
 from kr8s.objects import Pod
 from kr8s.objects import Secret
 from pydantic import BaseModel
+from typing_extensions import Self
 
 # Time after which Job will be deleted
 JOB_COMPLETION_TTL = 60
@@ -47,7 +48,7 @@ class PodCondition(BaseModel):
     ready: bool
 
     @classmethod
-    def from_conditions(cls, conditions: list):
+    def from_conditions(cls, conditions: list) -> Self:
         pod_cond = KubeUtils.list_dict_unpack(conditions, key="type", value="status")
         pod_cond_flags = {k: v == "True" for k, v in pod_cond.items()}
         return cls(
@@ -67,7 +68,7 @@ class ContainerStatus(BaseModel):
     startedAt: Optional[str]  # when running=True
 
     @classmethod
-    def from_status(cls, cstatus: dict):
+    def from_status(cls, cstatus: dict) -> Self:
         cstate = cstatus.get("state", {})
 
         return cls(
@@ -86,7 +87,7 @@ class PodStatus(BaseModel):
     container: ContainerStatus
 
     @classmethod
-    def from_status_dict(cls: "PodStatus", status: dict):
+    def from_status_dict(cls, status: dict) -> Self:
         return cls(
             phase=PodPhase(status.get("phase", "Unknown")),
             condition=PodCondition.from_conditions(status.get("conditions", [])),
@@ -120,8 +121,10 @@ def resolve_pod(client: kr8s.Api, pod: Union[str, Pod]) -> Optional[Pod]:
         for _pod in client.get("pods", pod):
             return _pod
 
+        return None
+
     @staticmethod
-    def get_logs(pods: List[Pod]):
+    def get_logs(pods: List[Pod]) -> str:
         """Combine and return logs for all the pods as string"""
         logs = []
         for pod in pods:
@@ -142,11 +145,13 @@ def get_pod_status(pod: Pod) -> Optional[PodStatus]:
     def get_pod_env(pod: Pod) -> Optional[List[Dict]]:
         """Return the environment variables of the first container in the pod."""
         if not pod:
-            return
+            return None
 
         for container in pod.spec.containers:
             return container.env.to_list()
 
+        return None
+
     @staticmethod
     def get_container_exit_code(pods: List[Pod]) -> List[int]:
         """Return the exit codes of all the containers in the given pods."""
@@ -203,11 +208,11 @@ def create_secret(
         type: str,
         component: str,
         data: str,
-        encoded=True,
+        encoded: bool = True,
     ) -> Secret:
         if not encoded:
             for k, v in data.items():
-                data[k] = KubeUtils.b64encode_secret(v)
+                data[k] = KubeUtils.b64encode_secret(v)  # type: ignore
 
         secret = Secret(
             {
diff --git a/packages/syft/src/syft/custom_worker/runner_k8s.py b/packages/syft/src/syft/custom_worker/runner_k8s.py
index 3b35830c0f4..25d3dbfd2a3 100644
--- a/packages/syft/src/syft/custom_worker/runner_k8s.py
+++ b/packages/syft/src/syft/custom_worker/runner_k8s.py
@@ -1,4 +1,5 @@
 # stdlib
+from typing import Any
 from typing import Dict
 from typing import List
 from typing import Optional
@@ -21,7 +22,7 @@
 
 
 class KubernetesRunner:
-    def __init__(self):
+    def __init__(self) -> None:
         self.client = get_kr8s_client()
 
     def create_pool(
@@ -34,7 +35,7 @@ def create_pool(
         reg_username: Optional[str] = None,
         reg_password: Optional[str] = None,
         reg_url: Optional[str] = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> StatefulSet:
         try:
             # create pull secret if registry credentials are passed
@@ -134,8 +135,8 @@ def _create_image_pull_secret(
         reg_username: str,
         reg_password: str,
         reg_url: str,
-        **kwargs,
-    ):
+        **kwargs: Any,
+    ) -> Secret:
         return KubeUtils.create_dockerconfig_secret(
             secret_name=f"pull-secret-{pool_name}",
             component=pool_name,
@@ -148,11 +149,11 @@ def _create_stateful_set(
         self,
         pool_name: str,
         tag: str,
-        replicas=1,
+        replicas: int = 1,
         env_vars: Optional[List[Dict]] = None,
         mount_secrets: Optional[Dict] = None,
         pull_secret: Optional[Secret] = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> StatefulSet:
         """Create a stateful set for a pool"""
 
diff --git a/packages/syft/src/syft/exceptions/exception.py b/packages/syft/src/syft/exceptions/exception.py
index 6bab71a747a..16f1717686b 100644
--- a/packages/syft/src/syft/exceptions/exception.py
+++ b/packages/syft/src/syft/exceptions/exception.py
@@ -2,6 +2,9 @@
 from typing import List
 from typing import Optional
 
+# third party
+from typing_extensions import Self
+
 # relative
 from ..service.context import NodeServiceContext
 from ..service.response import SyftError
@@ -16,7 +19,7 @@ def __init__(self, message: str, roles: Optional[List[ServiceRole]] = None):
         self.message = message
         self.roles = roles if roles else [ServiceRole.ADMIN]
 
-    def raise_with_context(self, context: NodeServiceContext):
+    def raise_with_context(self, context: NodeServiceContext) -> Self:
         self.context = context
         return self
 
diff --git a/packages/syft/src/syft/external/oblv/auth.py b/packages/syft/src/syft/external/oblv/auth.py
index a3a382aff88..2360e7b477f 100644
--- a/packages/syft/src/syft/external/oblv/auth.py
+++ b/packages/syft/src/syft/external/oblv/auth.py
@@ -1,12 +1,13 @@
 # stdlib
 from getpass import getpass
+from typing import Any
 from typing import Optional
 
 # third party
 from oblv_ctl import authenticate
 
 
-def login(apikey: Optional[str] = None):
+def login(apikey: Optional[str] = None) -> Any:
     if apikey is None:
         apikey = getpass("Please provide your oblv API_KEY to login:")
 
diff --git a/packages/syft/src/syft/external/oblv/deployment_client.py b/packages/syft/src/syft/external/oblv/deployment_client.py
index 6b4c1f6d304..a34a01d225c 100644
--- a/packages/syft/src/syft/external/oblv/deployment_client.py
+++ b/packages/syft/src/syft/external/oblv/deployment_client.py
@@ -14,6 +14,7 @@
 from typing import List
 from typing import Optional
 from typing import TYPE_CHECKING
+from typing import Union
 
 # third party
 from oblv_ctl import OblvClient
@@ -26,7 +27,9 @@
 from ...client.client import login
 from ...client.client import login_as_guest
 from ...client.enclave_client import EnclaveMetadata
+from ...node.credentials import SyftSigningKey
 from ...serde.serializable import serializable
+from ...service.response import SyftError
 from ...types.uid import UID
 from ...util.util import bcolors
 from .constants import LOCAL_MODE
@@ -75,7 +78,7 @@ class DeploymentClient:
     __conn_string: str
     __logs: Any
     __process: Any
-    __enclave_client: SyftClient
+    __enclave_client: Optional[SyftClient]
 
     def __init__(
         self,
@@ -90,14 +93,14 @@ def __init__(
                 "domain_clients should be populated with valid domain nodes"
             )
         self.deployment_id = deployment_id
-        self.key_name = key_name
+        self.key_name: Optional[str] = key_name
         self.oblv_client = oblv_client
         self.domain_clients = domain_clients
         self.__conn_string = ""
         self.__process = None
         self.__logs = None
         self._api = api
-        self.__enclave_client = None
+        self.__enclave_client: Optional[SyftClient] = None
 
     def make_request_to_enclave(
         self,
@@ -245,7 +248,7 @@ def register(
         password: str,
         institution: Optional[str] = None,
         website: Optional[str] = None,
-    ):
+    ) -> Optional[Union[SyftError, SyftSigningKey]]:
         self.check_connection_string()
         guest_client = login_as_guest(url=self.__conn_string)
         return guest_client.register(
diff --git a/packages/syft/src/syft/external/oblv/oblv_service.py b/packages/syft/src/syft/external/oblv/oblv_service.py
index beb4d4cad92..bd69963748a 100644
--- a/packages/syft/src/syft/external/oblv/oblv_service.py
+++ b/packages/syft/src/syft/external/oblv/oblv_service.py
@@ -8,7 +8,6 @@
 from typing import Dict
 from typing import List
 from typing import Optional
-from typing import Tuple
 from typing import cast
 
 # third party
@@ -191,7 +190,7 @@ def make_request_to_enclave(
 
 def create_keys_from_db(
     oblv_keys_stash: OblvKeysStash, verify_key: SyftVerifyKey, oblv_key_name: str
-):
+) -> None:
     oblv_key_path = os.path.expanduser(os.getenv("OBLV_KEY_PATH", "~/.oblv"))
 
     os.makedirs(oblv_key_path, exist_ok=True)
@@ -211,7 +210,7 @@ def create_keys_from_db(
     f_public.close()
 
 
-def generate_oblv_key(oblv_key_name: str) -> Tuple[bytes]:
+def generate_oblv_key(oblv_key_name: str) -> tuple[bytes, bytes]:
     oblv_key_path = os.path.expanduser(os.getenv("OBLV_KEY_PATH", "~/.oblv"))
     os.makedirs(oblv_key_path, exist_ok=True)
 
@@ -256,11 +255,12 @@ def __init__(self, store: DocumentStore) -> None:
     def create_key(
         self,
         context: AuthedServiceContext,
+        oblv_key_name: str,
         override_existing_key: bool = False,
     ) -> Result[Ok, Err]:
         """Domain Public/Private Key pair creation"""
         # TODO 🟣 Check for permission after it is fully integrated
-        public_key, private_key = generate_oblv_key()
+        public_key, private_key = generate_oblv_key(oblv_key_name)
 
         if override_existing_key:
             self.oblv_keys_stash.clear()
diff --git a/packages/syft/src/syft/node/node.py b/packages/syft/src/syft/node/node.py
index c5017e37aea..176c7f19e89 100644
--- a/packages/syft/src/syft/node/node.py
+++ b/packages/syft/src/syft/node/node.py
@@ -18,7 +18,6 @@
 from typing import Dict
 from typing import List
 from typing import Optional
-from typing import Tuple
 from typing import Type
 from typing import Union
 import uuid
@@ -39,6 +38,7 @@
 from ..client.api import SyftAPICall
 from ..client.api import SyftAPIData
 from ..client.api import debox_signed_syftapicall_response
+from ..client.client import SyftClient
 from ..exceptions.exception import PySyftException
 from ..external import OBLV
 from ..protocol.data_protocol import PROTOCOL_TYPE
@@ -46,6 +46,7 @@
 from ..service.action.action_object import Action
 from ..service.action.action_object import ActionObject
 from ..service.action.action_service import ActionService
+from ..service.action.action_store import ActionStore
 from ..service.action.action_store import DictActionStore
 from ..service.action.action_store import MongoActionStore
 from ..service.action.action_store import SQLiteActionStore
@@ -64,6 +65,7 @@
 from ..service.enclave.enclave_service import EnclaveService
 from ..service.job.job_service import JobService
 from ..service.job.job_stash import Job
+from ..service.job.job_stash import JobStash
 from ..service.log.log_service import LogService
 from ..service.metadata.metadata_service import MetadataService
 from ..service.metadata.node_metadata import NodeMetadataV3
@@ -104,9 +106,11 @@
 from ..service.worker.utils import DEFAULT_WORKER_POOL_NAME
 from ..service.worker.utils import create_default_image
 from ..service.worker.worker_image_service import SyftWorkerImageService
+from ..service.worker.worker_pool import WorkerPool
 from ..service.worker.worker_pool_service import SyftWorkerPoolService
 from ..service.worker.worker_pool_stash import SyftWorkerPoolStash
 from ..service.worker.worker_service import WorkerService
+from ..service.worker.worker_stash import WorkerStash
 from ..store.blob_storage import BlobStorageConfig
 from ..store.blob_storage.on_disk import OnDiskBlobStorageClientConfig
 from ..store.blob_storage.on_disk import OnDiskBlobStorageConfig
@@ -159,7 +163,7 @@ def get_node_name() -> Optional[str]:
     return get_env(NODE_NAME, None)
 
 
-def get_node_side_type() -> str:
+def get_node_side_type() -> Optional[str]:
     return get_env(NODE_SIDE_TYPE, "high")
 
 
@@ -191,15 +195,15 @@ def get_container_host() -> Optional[str]:
     return get_env("CONTAINER_HOST")
 
 
-def get_default_worker_image() -> str:
+def get_default_worker_image() -> Optional[str]:
     return get_env("DEFAULT_WORKER_POOL_IMAGE")
 
 
-def get_default_worker_pool_name() -> str:
+def get_default_worker_pool_name() -> Optional[str]:
     return get_env("DEFAULT_WORKER_POOL_NAME", DEFAULT_WORKER_POOL_NAME)
 
 
-def get_default_worker_pool_count(node) -> int:
+def get_default_worker_pool_count(node: Node) -> int:
     return int(
         get_env(
             "DEFAULT_WORKER_POOL_COUNT", node.queue_config.client_config.n_consumers
@@ -207,7 +211,7 @@ def get_default_worker_pool_count(node) -> int:
     )
 
 
-def in_kubernetes() -> Optional[str]:
+def in_kubernetes() -> bool:
     return get_container_host() == "k8s"
 
 
@@ -245,7 +249,7 @@ def get_syft_worker_uid() -> Optional[str]:
 
 
 class AuthNodeContextRegistry:
-    __node_context_registry__: Dict[Tuple, Node] = OrderedDict()
+    __node_context_registry__: Dict[str, NodeServiceContext] = OrderedDict()
 
     @classmethod
     def set_node_context(
@@ -253,7 +257,7 @@ def set_node_context(
         node_uid: Union[UID, str],
         context: NodeServiceContext,
         user_verify_key: Union[SyftVerifyKey, str],
-    ):
+    ) -> None:
         if isinstance(node_uid, str):
             node_uid = UID.from_string(node_uid)
 
@@ -293,9 +297,9 @@ def __init__(
         signing_key: Optional[Union[SyftSigningKey, SigningKey]] = None,
         action_store_config: Optional[StoreConfig] = None,
         document_store_config: Optional[StoreConfig] = None,
-        root_email: str = default_root_email,
-        root_username: str = default_root_username,
-        root_password: str = default_root_password,
+        root_email: Optional[str] = default_root_email,
+        root_username: Optional[str] = default_root_username,
+        root_password: Optional[str] = default_root_password,
         processes: int = 0,
         is_subprocess: bool = False,
         node_type: Union[str, NodeType] = NodeType.DOMAIN,
@@ -400,7 +404,7 @@ def __init__(
             node=self,
         )
 
-        self.client_cache = {}
+        self.client_cache: dict = {}
         if isinstance(node_type, str):
             node_type = NodeType(node_type)
         self.node_type = node_type
@@ -431,7 +435,7 @@ def __init__(
         NodeRegistry.set_node_for(self.id, self)
 
     @property
-    def runs_in_docker(self):
+    def runs_in_docker(self) -> bool:
         path = "/proc/self/cgroup"
         return (
             os.path.exists("/.dockerenv")
@@ -453,7 +457,7 @@ def init_blob_storage(self, config: Optional[BlobStorageConfig] = None) -> None:
         # relative
         from ..store.blob_storage.seaweedfs import SeaweedFSConfig
 
-        if isinstance(config, SeaweedFSConfig):
+        if isinstance(config, SeaweedFSConfig) and self.signing_key:
             blob_storage_service = self.get_service(BlobStorageService)
             remote_profiles = blob_storage_service.remote_profile_stash.get_all(
                 credentials=self.signing_key.verify_key, has_permission=True
@@ -463,14 +467,14 @@ def init_blob_storage(self, config: Optional[BlobStorageConfig] = None) -> None:
                     remote_profile.profile_name
                 ] = remote_profile
 
-    def stop(self):
+    def stop(self) -> None:
         for consumer_list in self.queue_manager.consumers.values():
             for c in consumer_list:
                 c.close()
         for p in self.queue_manager.producers.values():
             p.close()
 
-    def close(self):
+    def close(self) -> None:
         self.stop()
 
     def create_queue_config(
@@ -499,10 +503,10 @@ def create_queue_config(
 
         return queue_config_
 
-    def init_queue_manager(self, queue_config: QueueConfig):
+    def init_queue_manager(self, queue_config: QueueConfig) -> None:
         MessageHandlers = [APICallMessageHandler]
         if self.is_subprocess:
-            return
+            return None
 
         self.queue_manager = QueueManager(config=queue_config)
         for message_handler in MessageHandlers:
@@ -557,8 +561,8 @@ def add_consumer_for_service(
         service_name: str,
         syft_worker_id: UID,
         address: str,
-        message_handler: AbstractMessageHandler = APICallMessageHandler,
-    ):
+        message_handler: Type[AbstractMessageHandler] = APICallMessageHandler,
+    ) -> None:
         consumer: QueueConsumer = self.queue_manager.create_consumer(
             message_handler,
             address=address,
@@ -670,7 +674,7 @@ def is_root(self, credentials: SyftVerifyKey) -> bool:
         return credentials == self.verify_key
 
     @property
-    def root_client(self):
+    def root_client(self) -> SyftClient:
         # relative
         from ..client.client import PythonConnection
 
@@ -679,7 +683,8 @@ def root_client(self):
         if isinstance(client_type, SyftError):
             return client_type
         root_client = client_type(connection=connection, credentials=self.signing_key)
-        root_client.api.refresh_api_callback()
+        if root_client.api.refresh_api_callback is not None:
+            root_client.api.refresh_api_callback()
         return root_client
 
     def _find_klasses_pending_for_migration(
@@ -713,7 +718,7 @@ def _find_klasses_pending_for_migration(
 
         return klasses_to_be_migrated
 
-    def find_and_migrate_data(self):
+    def find_and_migrate_data(self) -> None:
         # Track all object type that need migration for document store
         context = AuthedServiceContext(
             node=self,
@@ -778,24 +783,26 @@ def find_and_migrate_data(self):
         print("Data Migrated to latest version !!!")
 
     @property
-    def guest_client(self):
+    def guest_client(self) -> SyftClient:
         return self.get_guest_client()
 
     @property
-    def current_protocol(self) -> List:
+    def current_protocol(self) -> Union[str, int]:
         data_protocol = get_data_protocol()
         return data_protocol.latest_version
 
-    def get_guest_client(self, verbose: bool = True):
+    def get_guest_client(self, verbose: bool = True) -> SyftClient:
         # relative
         from ..client.client import PythonConnection
 
         connection = PythonConnection(node=self)
-        if verbose:
-            print(
+        if verbose and self.node_side_type:
+            message: str = (
                 f"Logged into <{self.name}: {self.node_side_type.value.capitalize()} "
-                f"side {self.node_type.value.capitalize()} > as GUEST"
             )
+            if self.node_type:
+                message += f"side {self.node_type.value.capitalize()} > as GUEST"
+            print(message)
 
         client_type = connection.get_client_type()
         if isinstance(client_type, SyftError):
@@ -804,7 +811,8 @@ def get_guest_client(self, verbose: bool = True):
         guest_client = client_type(
             connection=connection, credentials=SyftSigningKey.generate()
         )
-        guest_client.api.refresh_api_callback()
+        if guest_client.api.refresh_api_callback is not None:
+            guest_client.api.refresh_api_callback()
         return guest_client
 
     def __repr__(self) -> str:
@@ -840,13 +848,15 @@ def post_init(self) -> None:
         def reload_user_code() -> None:
             user_code_service.load_user_code(context=context)
 
-        CODE_RELOADER[thread_ident()] = reload_user_code
+        ti = thread_ident()
+        if ti is not None:
+            CODE_RELOADER[ti] = reload_user_code
 
     def init_stores(
         self,
         document_store_config: Optional[StoreConfig] = None,
         action_store_config: Optional[StoreConfig] = None,
-    ):
+    ) -> None:
         if document_store_config is None:
             if self.local_db or (self.processes > 0 and not self.is_subprocess):
                 client_config = SQLiteStoreClientConfig(path=self.sqlite_path)
@@ -890,7 +900,7 @@ def init_stores(
             action_store_config.client_config.filename = f"{self.id}.sqlite"
 
         if isinstance(action_store_config, SQLiteStoreConfig):
-            self.action_store = SQLiteActionStore(
+            self.action_store: ActionStore = SQLiteActionStore(
                 store_config=action_store_config,
                 root_verify_key=self.verify_key,
             )
@@ -911,14 +921,14 @@ def init_stores(
         self.queue_stash = QueueStash(store=self.document_store)
 
     @property
-    def job_stash(self):
+    def job_stash(self) -> JobStash:
         return self.get_service("jobservice").stash
 
     @property
-    def worker_stash(self):
+    def worker_stash(self) -> WorkerStash:
         return self.get_service("workerservice").stash
 
-    def _construct_services(self):
+    def _construct_services(self) -> None:
         self.service_path_map = {}
 
         for service_klass in self.services:
@@ -961,7 +971,7 @@ def _construct_services(self):
                 store_services += [OblvService]
 
             if service_klass in store_services:
-                kwargs["store"] = self.document_store
+                kwargs["store"] = self.document_store  # type: ignore[assignment]
             self.service_path_map[service_klass.__name__.lower()] = service_klass(
                 **kwargs
             )
@@ -971,7 +981,7 @@ def get_service_method(self, path_or_func: Union[str, Callable]) -> Callable:
             path_or_func = path_or_func.__qualname__
         return self._get_service_method_from_path(path_or_func)
 
-    def get_service(self, path_or_func: Union[str, Callable]) -> Callable:
+    def get_service(self, path_or_func: Union[str, Callable]) -> AbstractService:
         if callable(path_or_func):
             path_or_func = path_or_func.__qualname__
         return self._get_service_from_path(path_or_func)
@@ -993,6 +1003,8 @@ def _get_service_method_from_path(self, path: str) -> Callable:
     @property
     def settings(self) -> NodeSettingsV2:
         settings_stash = SettingsStash(store=self.document_store)
+        if self.signing_key is None:
+            raise ValueError(f"{self} has no signing key")
         settings = settings_stash.get_all(self.signing_key.verify_key)
         if settings.is_ok() and len(settings.ok()) > 0:
             settings_data = settings.ok()[0]
@@ -1009,6 +1021,8 @@ def metadata(self) -> NodeMetadataV3:
         organization = settings_data.organization
         description = settings_data.description
         show_warnings = settings_data.show_warnings
+        node_type = self.node_type.value if self.node_type else ""
+        node_side_type = self.node_side_type.value if self.node_side_type else ""
 
         return NodeMetadataV3(
             name=name,
@@ -1019,8 +1033,8 @@ def metadata(self) -> NodeMetadataV3:
             syft_version=__version__,
             description=description,
             organization=organization,
-            node_type=self.node_type.value,
-            node_side_type=self.node_side_type.value,
+            node_type=node_type,
+            node_side_type=node_side_type,
             show_warnings=show_warnings,
         )
 
@@ -1030,6 +1044,8 @@ def icon(self) -> str:
 
     @property
     def verify_key(self) -> SyftVerifyKey:
+        if self.signing_key is None:
+            raise ValueError(f"{self} has no signing key")
         return self.signing_key.verify_key
 
     def __hash__(self) -> int:
@@ -1144,7 +1160,7 @@ def handle_api_call(
         self,
         api_call: Union[SyftAPICall, SignedSyftAPICall],
         job_id: Optional[UID] = None,
-        check_call_location=True,
+        check_call_location: bool = True,
     ) -> Result[SignedSyftAPICall, Err]:
         # Get the result
         result = self.handle_api_call_with_unsigned_result(
@@ -1159,7 +1175,7 @@ def handle_api_call_with_unsigned_result(
         self,
         api_call: Union[SyftAPICall, SignedSyftAPICall],
         job_id: Optional[UID] = None,
-        check_call_location=True,
+        check_call_location: bool = True,
     ) -> Union[Result, QueueItem, SyftObject, SyftError]:
         if self.required_signed_calls and isinstance(api_call, SyftAPICall):
             return SyftError(
@@ -1221,9 +1237,9 @@ def handle_api_call_with_unsigned_result(
 
     def add_action_to_queue(
         self,
-        action,
+        action: Action,
         credentials: SyftVerifyKey,
-        parent_job_id=None,
+        parent_job_id: Optional[UID] = None,
         has_execute_permissions: bool = False,
         worker_pool_name: Optional[str] = None,
     ) -> Union[Job, SyftError]:
@@ -1277,10 +1293,10 @@ def add_action_to_queue(
 
     def add_queueitem_to_queue(
         self,
-        queue_item: ActionQueueItem,
+        queue_item: QueueItem,
         credentials: SyftVerifyKey,
-        action=None,
-        parent_job_id=None,
+        action: Optional[Action] = None,
+        parent_job_id: Optional[UID] = None,
     ) -> Union[Job, SyftError]:
         log_id = UID()
         role = self.get_role_for_credentials(credentials=credentials)
@@ -1342,7 +1358,9 @@ def _is_usercode_call_on_owned_kwargs(
         user_code_service = self.get_service("usercodeservice")
         return user_code_service.is_execution_on_owned_args(api_call.kwargs, context)
 
-    def add_api_call_to_queue(self, api_call, parent_job_id=None):
+    def add_api_call_to_queue(
+        self, api_call: SyftAPICall, parent_job_id: Optional[UID] = None
+    ) -> Union[Job, SyftError]:
         unsigned_call = api_call
         if isinstance(api_call, SignedSyftAPICall):
             unsigned_call = api_call.message
@@ -1429,7 +1447,7 @@ def pool_stash(self) -> SyftWorkerPoolStash:
     def user_code_stash(self) -> UserCodeStash:
         return self.get_service(UserCodeService).stash
 
-    def get_default_worker_pool(self):
+    def get_default_worker_pool(self) -> Union[Optional[WorkerPool], SyftError]:
         result = self.pool_stash.get_by_name(
             credentials=self.verify_key,
             pool_name=get_default_worker_pool_name(),
@@ -1466,6 +1484,9 @@ def create_initial_settings(self, admin_email: str) -> Optional[NodeSettingsV2]:
             self.name = random_name()
         try:
             settings_stash = SettingsStash(store=self.document_store)
+            if self.signing_key is None:
+                print("create_initial_settings failed as there is no signing key")
+                return None
             settings_exists = settings_stash.get_all(self.signing_key.verify_key).ok()
             if settings_exists:
                 self.name = settings_exists[0].name
@@ -1483,7 +1504,7 @@ def create_initial_settings(self, admin_email: str) -> Optional[NodeSettingsV2]:
                     deployed_on=datetime.now().date().strftime("%m/%d/%Y"),
                     signup_enabled=flags.CAN_REGISTER,
                     admin_email=admin_email,
-                    node_side_type=self.node_side_type.value,
+                    node_side_type=self.node_side_type.value,  # type: ignore
                     show_warnings=self.enable_warnings,
                 )
                 result = settings_stash.set(
@@ -1493,7 +1514,8 @@ def create_initial_settings(self, admin_email: str) -> Optional[NodeSettingsV2]:
                     return result.ok()
                 return None
         except Exception as e:
-            print("create_worker_metadata failed", e)
+            print(f"create_initial_settings failed with error {e}")
+            return None
 
 
 def create_admin_new(
@@ -1534,6 +1556,8 @@ def create_admin_new(
     except Exception as e:
         print("Unable to create new admin", e)
 
+    return None
+
 
 def create_oblv_key_pair(
     worker: Node,
@@ -1546,7 +1570,7 @@ def create_oblv_key_pair(
 
         oblv_keys_stash = OblvKeysStash(store=worker.document_store)
 
-        if not len(oblv_keys_stash):
+        if not len(oblv_keys_stash) and worker.signing_key:
             public_key, private_key = generate_oblv_key(oblv_key_name=worker.name)
             oblv_keys = OblvKeys(public_key=public_key, private_key=private_key)
             res = oblv_keys_stash.set(worker.signing_key.verify_key, oblv_keys)
@@ -1557,6 +1581,9 @@ def create_oblv_key_pair(
             print(f"Using Existing Public/Private Key pair: {len(oblv_keys_stash)}")
     except Exception as e:
         print("Unable to create Oblv Keys.", e)
+        return None
+
+    return None
 
 
 class NodeRegistry:
@@ -1582,7 +1609,7 @@ def get_all_nodes(cls) -> List[Node]:
         return list(cls.__node_registry__.values())
 
 
-def get_default_worker_tag_by_env(dev_mode=False):
+def get_default_worker_tag_by_env(dev_mode: bool = False) -> Optional[str]:
     if in_kubernetes():
         return get_default_worker_image()
     elif dev_mode:
@@ -1630,7 +1657,7 @@ def create_default_worker_pool(node: Node) -> Optional[SyftError]:
 
         if isinstance(result, SyftError):
             print("Failed to build default worker image: ", result.message)
-            return
+            return None
 
     # Create worker pool if it doesn't exists
     print(
@@ -1663,7 +1690,7 @@ def create_default_worker_pool(node: Node) -> Optional[SyftError]:
 
     if isinstance(result, SyftError):
         print(f"Default worker pool error. {result.message}")
-        return
+        return None
 
     for n in range(worker_to_add_):
         container_status = result[n]
@@ -1672,6 +1699,7 @@ def create_default_worker_pool(node: Node) -> Optional[SyftError]:
                 f"Failed to create container: Worker: {container_status.worker},"
                 f"Error: {container_status.error}"
             )
-            return
+            return None
 
     print("Created default worker pool.")
+    return None
diff --git a/packages/syft/src/syft/node/run.py b/packages/syft/src/syft/node/run.py
index 3b8376fb4e1..10aa942a498 100644
--- a/packages/syft/src/syft/node/run.py
+++ b/packages/syft/src/syft/node/run.py
@@ -2,6 +2,9 @@
 import argparse
 from typing import Optional
 
+# third party
+from hagrid.orchestra import NodeHandle
+
 # relative
 from ..client.deploy import Orchestra
 
@@ -14,7 +17,7 @@ def str_to_bool(bool_str: Optional[str]) -> bool:
     return result
 
 
-def run():
+def run() -> Optional[NodeHandle]:
     parser = argparse.ArgumentParser()
     parser.add_argument("command", help="command: launch", type=str, default="none")
     parser.add_argument(
diff --git a/packages/syft/src/syft/node/server.py b/packages/syft/src/syft/node/server.py
index fc7bbb2bc8d..28032da15fd 100644
--- a/packages/syft/src/syft/node/server.py
+++ b/packages/syft/src/syft/node/server.py
@@ -81,16 +81,16 @@ def run_uvicorn(
     queue_port: Optional[int],
     create_producer: bool,
     n_consumers: int,
-):
+) -> None:
     async def _run_uvicorn(
         name: str,
-        node_type: Enum,
+        node_type: NodeType,
         host: str,
         port: int,
         reset: bool,
         dev_mode: bool,
         node_side_type: Enum,
-    ):
+    ) -> None:
         if node_type not in worker_classes:
             raise NotImplementedError(f"node_type: {node_type} is not supported")
         worker_class = worker_classes[node_type]
@@ -205,7 +205,7 @@ def serve_node(
         ),
     )
 
-    def stop():
+    def stop() -> None:
         print(f"Stopping {name}")
         server_process.terminate()
         server_process.join(3)
@@ -214,7 +214,7 @@ def stop():
             server_process.kill()
             print("killed")
 
-    def start():
+    def start() -> None:
         print(f"Starting {name} server on {host}:{port}")
         server_process.start()
 
diff --git a/packages/syft/src/syft/node/worker_settings.py b/packages/syft/src/syft/node/worker_settings.py
index 106e2e94821..05b28f02c0b 100644
--- a/packages/syft/src/syft/node/worker_settings.py
+++ b/packages/syft/src/syft/node/worker_settings.py
@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 # stdlib
+from typing import Callable
 from typing import Optional
 
 # third party
@@ -55,16 +56,20 @@ class WorkerSettings(SyftObject):
     blob_store_config: Optional[BlobStorageConfig]
     queue_config: Optional[QueueConfig]
 
-    @staticmethod
-    def from_node(node: AbstractNode) -> Self:
-        return WorkerSettings(
+    @classmethod
+    def from_node(cls, node: AbstractNode) -> Self:
+        if node.node_side_type:
+            node_side_type: str = node.node_side_type.value
+        else:
+            node_side_type = NodeSideType.HIGH_SIDE
+        return cls(
             id=node.id,
             name=node.name,
             node_type=node.node_type,
             signing_key=node.signing_key,
             document_store_config=node.document_store_config,
             action_store_config=node.action_store_config,
-            node_side_type=node.node_side_type.value,
+            node_side_type=node_side_type,
             blob_store_config=node.blob_store_config,
             queue_config=node.queue_config,
         )
@@ -74,14 +79,14 @@ def from_node(node: AbstractNode) -> Self:
 
 
 @migrate(WorkerSettings, WorkerSettingsV1)
-def downgrade_workersettings_v2_to_v1():
+def downgrade_workersettings_v2_to_v1() -> list[Callable]:
     return [
         drop(["queue_config"]),
     ]
 
 
 @migrate(WorkerSettingsV1, WorkerSettings)
-def upgrade_workersettings_v1_to_v2():
+def upgrade_workersettings_v1_to_v2() -> list[Callable]:
     # relative
     from ..service.queue.zmq_queue import ZMQQueueConfig
 
diff --git a/packages/syft/src/syft/protocol/data_protocol.py b/packages/syft/src/syft/protocol/data_protocol.py
index 4512b25e9be..079647dd7e7 100644
--- a/packages/syft/src/syft/protocol/data_protocol.py
+++ b/packages/syft/src/syft/protocol/data_protocol.py
@@ -9,6 +9,7 @@
 import re
 from typing import Any
 from typing import Dict
+from typing import Iterable
 from typing import List
 from typing import Optional
 from typing import Tuple
@@ -33,7 +34,7 @@
 PROTOCOL_TYPE = Union[str, int]
 
 
-def natural_key(key: PROTOCOL_TYPE) -> List[int]:
+def natural_key(key: PROTOCOL_TYPE) -> List[Union[int, str, Any]]:
     """Define key for natural ordering of strings."""
     if isinstance(key, int):
         key = str(key)
@@ -128,7 +129,7 @@ def _hash_to_sha256(obj_dict: Dict) -> str:
 
     def build_state(self, stop_key: Optional[str] = None) -> dict:
         sorted_dict = sort_dict_naturally(self.protocol_history)
-        state_dict = defaultdict(dict)
+        state_dict: dict = defaultdict(dict)
         for protocol_number in sorted_dict:
             object_versions = sorted_dict[protocol_number]["object_versions"]
             for canonical_name, versions in object_versions.items():
@@ -165,8 +166,8 @@ def build_state(self, stop_key: Optional[str] = None) -> dict:
         return state_dict
 
     def diff_state(self, state: Dict) -> tuple[Dict, Dict]:
-        compare_dict = defaultdict(dict)  # what versions are in the latest code
-        object_diff = defaultdict(dict)  # diff in latest code with saved json
+        compare_dict: dict = defaultdict(dict)  # what versions are in the latest code
+        object_diff: dict = defaultdict(dict)  # diff in latest code with saved json
         for k in TYPE_BANK:
             (
                 nonrecursive,
@@ -497,7 +498,7 @@ def debox_arg_and_migrate(arg: Any, protocol_state: dict) -> Any:
         arg = arg.value
 
     if isinstance(arg, MutableMapping):
-        iterable_keys = arg.keys()
+        iterable_keys: Iterable = arg.keys()
     elif isinstance(arg, MutableSequence):
         iterable_keys = range(len(arg))
     elif isinstance(arg, tuple):
@@ -548,7 +549,7 @@ def migrate_args_and_kwargs(
         to_protocol = data_protocol.latest_version if to_latest_protocol else None
 
     if to_protocol is None:
-        raise SyftException(message="Protocol version missing.")
+        raise SyftException("Protocol version missing.")
 
     # If latest protocol being used is equal to the protocol to be migrate
     # then skip migration of the object
diff --git a/packages/syft/src/syft/service/action/action_graph.py b/packages/syft/src/syft/service/action/action_graph.py
index 8456f6852a1..edb3fabe548 100644
--- a/packages/syft/src/syft/service/action/action_graph.py
+++ b/packages/syft/src/syft/service/action/action_graph.py
@@ -62,7 +62,7 @@ class NodeActionData(SyftObject):
     __canonical_name__ = "NodeActionData"
     __version__ = SYFT_OBJECT_VERSION_1
 
-    id: Optional[UID]
+    id: Optional[UID]  # type: ignore[assignment]
     type: NodeType
     status: ExecutionStatus = ExecutionStatus.PROCESSING
     retry: int = 0
@@ -211,15 +211,17 @@ def file_path(self) -> Path:
 @serializable(without=["_lock"])
 class NetworkXBackingStore(BaseGraphStore):
     def __init__(self, store_config: StoreConfig, reset: bool = False) -> None:
-        self.path_str = store_config.client_config.file_path.as_posix()
-
+        if store_config.client_config:
+            self.path_str = store_config.client_config.file_path.as_posix()
+        else:
+            self.path_str = ""
         if not reset and os.path.exists(self.path_str):
             self._db = self._load_from_path(self.path_str)
         else:
             self._db = nx.DiGraph()
 
         self.locking_config = store_config.locking_config
-        self._lock = None
+        self._lock: Optional[SyftLock] = None
 
     @property
     def lock(self) -> SyftLock:
diff --git a/packages/syft/src/syft/service/action/action_object.py b/packages/syft/src/syft/service/action/action_object.py
index 719b2ad7c26..b474ebd5128 100644
--- a/packages/syft/src/syft/service/action/action_object.py
+++ b/packages/syft/src/syft/service/action/action_object.py
@@ -19,6 +19,7 @@
 from typing import Tuple
 from typing import Type
 from typing import Union
+from typing import cast
 
 # third party
 import pydantic
@@ -109,7 +110,7 @@ class ActionV1(SyftObject):
     __canonical_name__ = "Action"
     __version__ = SYFT_OBJECT_VERSION_1
 
-    __attr_searchable__: List[str] = []
+    __attr_searchable__: ClassVar[List[str]] = []
 
     path: str
     op: str
@@ -143,7 +144,7 @@ class Action(SyftObject):
     __canonical_name__ = "Action"
     __version__ = SYFT_OBJECT_VERSION_2
 
-    __attr_searchable__: List[str] = []
+    __attr_searchable__: ClassVar[List[str]] = []
 
     path: Optional[str]
     op: Optional[str]
@@ -172,11 +173,11 @@ def full_path(self) -> str:
 
     @property
     def job_display_name(self) -> str:
-        if self.user_code_id is not None:
-            api = APIRegistry.api_for(
-                node_uid=self.syft_node_location,
-                user_verify_key=self.syft_client_verify_key,
-            )
+        api = APIRegistry.api_for(
+            node_uid=self.syft_node_location,
+            user_verify_key=self.syft_client_verify_key,
+        )
+        if self.user_code_id is not None and api is not None:
             user_code = api.services.code.get_by_id(self.user_code_id)
             return user_code.service_func_name
         else:
@@ -419,7 +420,7 @@ def make_action_side_effect(
 
 class TraceResult:
     result: list = []
-    _client: SyftClient = None
+    _client: Optional[SyftClient] = None
     is_tracing: bool = False
 
     @classmethod
@@ -450,7 +451,10 @@ def convert_to_pointers(
     kwarg_dict = {}
     if args is not None:
         for arg in args:
-            if not isinstance(arg, (ActionObject, Asset, UID)):
+            if (
+                not isinstance(arg, (ActionObject, Asset, UID))
+                and api.signing_key is not None  # type: ignore[unreachable]
+            ):
                 arg = ActionObject.from_obj(  # type: ignore[unreachable]
                     syft_action_data=arg,
                     syft_client_verify_key=api.signing_key.verify_key,
@@ -465,7 +469,10 @@ def convert_to_pointers(
 
     if kwargs is not None:
         for k, arg in kwargs.items():
-            if not isinstance(arg, (ActionObject, Asset, UID)):
+            if (
+                not isinstance(arg, (ActionObject, Asset, UID))
+                and api.signing_key is not None  # type: ignore[unreachable]
+            ):
                 arg = ActionObject.from_obj(  # type: ignore[unreachable]
                     syft_action_data=arg,
                     syft_client_verify_key=api.signing_key.verify_key,
@@ -564,7 +571,7 @@ def debox_args_and_kwargs(args: Any, kwargs: Any) -> Tuple[Any, Any]:
     return tuple(filtered_args), filtered_kwargs
 
 
-BASE_PASSTHROUGH_ATTRS = [
+BASE_PASSTHROUGH_ATTRS: list[str] = [
     "is_mock",
     "is_real",
     "is_twin",
@@ -602,7 +609,7 @@ class ActionObjectV1(SyftObject):
     __canonical_name__ = "ActionObject"
     __version__ = SYFT_OBJECT_VERSION_1
 
-    __attr_searchable__: List[str] = []
+    __attr_searchable__: List[str] = []  # type: ignore[misc]
     syft_action_data_cache: Optional[Any] = None
     syft_blob_storage_entry_id: Optional[UID] = None
     syft_pointer_type: ClassVar[Type[ActionObjectPointer]]
@@ -634,7 +641,7 @@ class ActionObjectV2(SyftObject):
     __canonical_name__ = "ActionObject"
     __version__ = SYFT_OBJECT_VERSION_2
 
-    __attr_searchable__: List[str] = []
+    __attr_searchable__: List[str] = []  # type: ignore[misc]
     syft_action_data_cache: Optional[Any] = None
     syft_blob_storage_entry_id: Optional[UID] = None
     syft_pointer_type: ClassVar[Type[ActionObjectPointer]]
@@ -667,7 +674,7 @@ class ActionObject(SyftObject):
     __canonical_name__ = "ActionObject"
     __version__ = SYFT_OBJECT_VERSION_3
 
-    __attr_searchable__: List[str] = []
+    __attr_searchable__: List[str] = []  # type: ignore[misc]
     syft_action_data_cache: Optional[Any] = None
     syft_blob_storage_entry_id: Optional[UID] = None
     syft_pointer_type: ClassVar[Type[ActionObjectPointer]]
@@ -943,7 +950,8 @@ def syft_execute_action(
             node_uid=self.syft_node_uid,
             user_verify_key=self.syft_client_verify_key,
         )
-
+        if api is None:
+            raise ValueError(f"api is None. You must login to {self.syft_node_uid}")
         kwargs = {"action": action}
         api_call = SyftAPICall(
             node_uid=self.syft_node_uid, path="action.execute", args=[], kwargs=kwargs
@@ -959,7 +967,8 @@ def request(self, client: SyftClient) -> Union[Any, SyftError]:
         permission_change = ActionStoreChange(
             linked_obj=action_object_link, apply_permission_type=ActionPermission.READ
         )
-
+        if client.credentials is None:
+            return SyftError(f"{client} has no signing key")
         submit_request = SubmitRequest(
             changes=[permission_change],
             requesting_user_verify_key=client.credentials.verify_key,
@@ -992,7 +1001,7 @@ def _syft_try_to_save_to_store(self, obj: SyftObject) -> None:
         if TraceResult._client is not None:
             api = TraceResult._client.api
 
-        if api is not None:
+        if api is not None and api.signing_key is not None:
             obj._set_obj_location_(api.node_uid, api.signing_key.verify_key)
 
         action = Action(
@@ -1013,6 +1022,12 @@ def _syft_try_to_save_to_store(self, obj: SyftObject) -> None:
                 node_uid=self.syft_node_location,
                 user_verify_key=self.syft_client_verify_key,
             )
+            if api is None:
+                print(
+                    f"failed saving {obj} to blob storage, api is None. You must login to {self.syft_node_location}"
+                )
+
+        api = cast(SyftAPI, api)
         res = api.services.action.execute(action)
         if isinstance(res, SyftError):
             print(f"Failed to to store (arg) {obj} to store, {res}")
@@ -1194,6 +1209,11 @@ def refresh_object(self) -> ActionObject:
             node_uid=self.syft_node_location,
             user_verify_key=self.syft_client_verify_key,
         )
+        if api is None:
+            return SyftError(
+                message=f"api is None. You must login to {self.syft_node_location}"
+            )
+
         res = api.services.action.get(self.id)
         return res
 
@@ -1341,7 +1361,7 @@ def wait(self) -> ActionObject:
         else:
             obj_id = self.id
 
-        while not api.services.action.is_resolved(obj_id):
+        while api and not api.services.action.is_resolved(obj_id):
             time.sleep(1)
 
         return self
@@ -1818,7 +1838,7 @@ def __setattr__(self, name: str, value: Any) -> Any:
     # if we do not implement these boiler plate __method__'s then special infix
     # operations like x + y won't trigger __getattribute__
     # unless there is a super special reason we should write no code in these functions
-    def _repr_markdown_(self) -> str:
+    def _repr_markdown_(self, wrap_as_python: bool = True, indent: int = 0) -> str:
         if self.is_mock:
             res = "TwinPointer(Mock)"
         elif self.is_real:
diff --git a/packages/syft/src/syft/service/action/action_service.py b/packages/syft/src/syft/service/action/action_service.py
index ddd0b86731f..806d2ad6a37 100644
--- a/packages/syft/src/syft/service/action/action_service.py
+++ b/packages/syft/src/syft/service/action/action_service.py
@@ -103,7 +103,7 @@ def _set(
         if isinstance(action_object, ActionObject):
             action_object.syft_created_at = DateTime.now()
         else:
-            action_object.private_obj.syft_created_at = DateTime.now()
+            action_object.private_obj.syft_created_at = DateTime.now()  # type: ignore[unreachable]
             action_object.mock_obj.syft_created_at = DateTime.now()
 
         # If either context or argument is True, has_result_read_permission is True
@@ -231,11 +231,11 @@ def _get(
             )
             # Resolve graph links
             if (
-                not isinstance(obj, TwinObject)
+                not isinstance(obj, TwinObject)  # type: ignore[unreachable]
                 and resolve_nested
                 and isinstance(obj.syft_action_data, ActionDataLink)
             ):
-                if not self.is_resolved(
+                if not self.is_resolved(  # type: ignore[unreachable]
                     context, obj.syft_action_data.action_object_id.id
                 ).ok():
                     return SyftError(message="This object is not resolved yet.")
@@ -400,7 +400,7 @@ def _user_code_execute(
 
     def set_result_to_store(
         self,
-        result_action_object: ActionObject,
+        result_action_object: Union[ActionObject, TwinObject],
         context: AuthedServiceContext,
         output_policy: Optional[OutputPolicy] = None,
     ) -> Union[Result[ActionObject, str], SyftError]:
@@ -430,7 +430,7 @@ def set_result_to_store(
         if isinstance(result_action_object, TwinObject):
             result_blob_id = result_action_object.private.syft_blob_storage_entry_id
         else:
-            result_blob_id = result_action_object.syft_blob_storage_entry_id
+            result_blob_id = result_action_object.syft_blob_storage_entry_id  # type: ignore[unreachable]
 
         # pass permission information to the action store as extra kwargs
         context.extra_kwargs = {"has_result_read_permission": True}
@@ -440,7 +440,7 @@ def set_result_to_store(
         if set_result.is_err():
             return set_result
 
-        blob_storage_service: BlobStorageService = context.node.get_service(
+        blob_storage_service: AbstractService = context.node.get_service(
             BlobStorageService
         )
 
@@ -553,7 +553,7 @@ def set_attribute(
             )
         else:
             # TODO: Implement for twinobject args
-            args = filter_twin_args(args, twin_mode=TwinMode.NONE)
+            args = filter_twin_args(args, twin_mode=TwinMode.NONE)  # type: ignore[unreachable]
             val = args[0]
             setattr(resolved_self.syft_action_data, name, val)
             return Ok(
@@ -580,7 +580,7 @@ def get_attribute(
                 )
             )
         else:
-            val = getattr(resolved_self.syft_action_data, action.op)
+            val = getattr(resolved_self.syft_action_data, action.op)  # type: ignore[unreachable]
             return Ok(wrap_result(action.result_id, val))
 
     def call_method(
@@ -623,7 +623,7 @@ def call_method(
                 )
             )
         else:
-            return execute_object(self, context, resolved_self, action)
+            return execute_object(self, context, resolved_self, action)  # type:ignore[unreachable]
 
     @service_method(path="action.execute", name="execute", roles=GUEST_ROLE_LEVEL)
     def execute(
diff --git a/packages/syft/src/syft/service/blob_storage/service.py b/packages/syft/src/syft/service/blob_storage/service.py
index c3fae648eeb..6781828a287 100644
--- a/packages/syft/src/syft/service/blob_storage/service.py
+++ b/packages/syft/src/syft/service/blob_storage/service.py
@@ -201,7 +201,7 @@ def read(
     ) -> Union[BlobRetrieval, SyftError]:
         result = self.stash.get_by_uid(context.credentials, uid=uid)
         if result.is_ok():
-            obj: BlobStorageEntry = result.ok()
+            obj: Optional[BlobStorageEntry] = result.ok()
             if obj is None:
                 return SyftError(
                     message=f"No blob storage entry exists for uid: {uid}, or you have no permissions to read it"
diff --git a/packages/syft/src/syft/service/code/user_code.py b/packages/syft/src/syft/service/code/user_code.py
index 7541cd65137..ebaa24f3b21 100644
--- a/packages/syft/src/syft/service/code/user_code.py
+++ b/packages/syft/src/syft/service/code/user_code.py
@@ -17,6 +17,7 @@
 import traceback
 from typing import Any
 from typing import Callable
+from typing import ClassVar
 from typing import Dict
 from typing import Generator
 from typing import List
@@ -70,6 +71,7 @@
 from ..dataset.dataset import Asset
 from ..job.job_stash import Job
 from ..output.output_service import ExecutionOutput
+from ..output.output_service import OutputService
 from ..policy.policy import CustomInputPolicy
 from ..policy.policy import CustomOutputPolicy
 from ..policy.policy import EmpyInputPolicy
@@ -389,7 +391,7 @@ class UserCode(SyftObject):
         "service_func_name",
         "code_hash",
     ]
-    __attr_unique__: list = []
+    __attr_unique__: ClassVar[List[str]] = []
     __repr_attrs__ = [
         "service_func_name",
         "input_owners",
@@ -623,6 +625,10 @@ def output_policy(self, value: Any) -> None:  # type: ignore
     @property
     def output_history(self) -> Union[List[ExecutionOutput], SyftError]:
         api = APIRegistry.api_for(self.syft_node_location, self.syft_client_verify_key)
+        if api is None:
+            return SyftError(
+                message=f"Can't access the api. You must login to {self.syft_node_location}"
+            )
         return api.services.output.get_by_user_code_id(self.id)
 
     def get_output_history(
@@ -632,8 +638,8 @@ def get_output_history(
             return SyftError(
                 message="Execution denied, Please wait for the code to be approved"
             )
-
-        output_service = context.node.get_service("outputservice")  # type: ignore
+        node = cast(AbstractNode, context.node)
+        output_service = cast(OutputService, node.get_service("outputservice"))
         return output_service.get_by_user_code_id(context, self.id)
 
     def apply_output(
@@ -649,7 +655,9 @@ def apply_output(
             )
 
         output_ids = filter_only_uids(outputs)
-        output_service = context.node.get_service("outputservice")  # type: ignore
+        context.node = cast(AbstractNode, context.node)
+        output_service = context.node.get_service("outputservice")
+        output_service = cast(OutputService, output_service)
         execution_result = output_service.create(
             context,
             user_code_id=self.id,
@@ -672,6 +680,10 @@ def get_results(self) -> Any:
         from ...client.api import APIRegistry
 
         api = APIRegistry.api_for(self.node_uid, self.syft_client_verify_key)
+        if api is None:
+            return SyftError(
+                message=f"Can't access the api. You must login to {self.node_uid}"
+            )
         return api.services.code.get_results(self)
 
     @property
@@ -793,7 +805,7 @@ def _inner_repr(self, level: int = 0) -> str:
 
         return md
 
-    def _repr_markdown_(self) -> str:
+    def _repr_markdown_(self, wrap_as_python: bool = True, indent: int = 0) -> str:
         return as_markdown_code(self._inner_repr())
 
     @property
@@ -845,7 +857,7 @@ class SubmitUserCodeV2(SyftObject):
     __canonical_name__ = "SubmitUserCode"
     __version__ = SYFT_OBJECT_VERSION_2
 
-    id: Optional[UID]
+    id: Optional[UID]  # type: ignore[assignment]
     code: str
     func_name: str
     signature: inspect.Signature
@@ -864,7 +876,7 @@ class SubmitUserCode(SyftObject):
     __canonical_name__ = "SubmitUserCode"
     __version__ = SYFT_OBJECT_VERSION_3
 
-    id: Optional[UID]
+    id: Optional[UID]  # type: ignore[assignment]
     code: str
     func_name: str
     signature: inspect.Signature
@@ -964,7 +976,10 @@ def _ephemeral_node_call(
             #     node_uid=node_id.node_id, user_verify_key=node_id.verify_key
             # )
             api = APIRegistry.get_by_recent_node_uid(node_uid=node_id.node_id)
-
+            if api is None:
+                return SyftError(
+                    f"Can't access the api. You must login to {node_id.node_id}"
+                )
             # Creating TwinObject from the ids of the kwargs
             # Maybe there are some corner cases where this is not enough
             # And need only ActionObjects
@@ -1127,15 +1142,16 @@ def decorator(f: Any) -> SubmitUserCode:
 
 
 def generate_unique_func_name(context: TransformContext) -> TransformContext:
-    code_hash = context.output["code_hash"]
-    service_func_name = context.output["func_name"]
-    context.output["service_func_name"] = service_func_name
-    func_name = f"user_func_{service_func_name}_{context.credentials}_{code_hash}"
-    user_unique_func_name = (
-        f"user_func_{service_func_name}_{context.credentials}_{time.time()}"
-    )
-    context.output["unique_func_name"] = func_name
-    context.output["user_unique_func_name"] = user_unique_func_name
+    if context.output is not None:
+        code_hash = context.output["code_hash"]
+        service_func_name = context.output["func_name"]
+        context.output["service_func_name"] = service_func_name
+        func_name = f"user_func_{service_func_name}_{context.credentials}_{code_hash}"
+        user_unique_func_name = (
+            f"user_func_{service_func_name}_{context.credentials}_{time.time()}"
+        )
+        context.output["unique_func_name"] = func_name
+        context.output["user_unique_func_name"] = user_unique_func_name
     return context
 
 
@@ -1157,7 +1173,7 @@ def process_code(
     f.decorator_list = []
 
     call_args = function_input_kwargs
-    if "domain" in function_input_kwargs:
+    if "domain" in function_input_kwargs and context.output is not None:
         context.output["uses_domain"] = True
     call_stmt_keywords = [ast.keyword(arg=i, value=[ast.Name(id=i)]) for i in call_args]
     call_stmt = ast.Assign(
@@ -1184,7 +1200,10 @@ def process_code(
 
 
 def new_check_code(context: TransformContext) -> TransformContext:
-    # TODO remove this tech debt hack
+    # TODO: remove this tech debt hack
+    if context.output is None:
+        return context
+
     input_kwargs = context.output["input_policy_init_kwargs"]
     node_view_workaround = False
     for k in input_kwargs.keys():
@@ -1212,25 +1231,28 @@ def new_check_code(context: TransformContext) -> TransformContext:
 
 
 def locate_launch_jobs(context: TransformContext) -> TransformContext:
-    nested_codes = {}
-    tree = ast.parse(context.output["raw_code"])
-
-    # look for domain arg
-    if "domain" in [arg.arg for arg in tree.body[0].args.args]:
-        v = LaunchJobVisitor()
-        v.visit(tree)
-        nested_calls = v.nested_calls
-        user_code_service = context.node.get_service("usercodeService")
-        for call in nested_calls:
-            user_codes = user_code_service.get_by_service_name(context, call)
-            if isinstance(user_codes, SyftError):
-                raise Exception(user_codes.message)
-            # TODO: Not great
-            user_code = user_codes[-1]
-            user_code_link = LinkedObject.from_obj(user_code, node_uid=context.node.id)
-
-            nested_codes[call] = (user_code_link, user_code.nested_codes)
-    context.output["nested_codes"] = nested_codes
+    if context.node is None:
+        raise ValueError(f"context {context}'s node is None")
+    if context.output is not None:
+        nested_codes = {}
+        tree = ast.parse(context.output["raw_code"])
+        # look for domain arg
+        if "domain" in [arg.arg for arg in tree.body[0].args.args]:
+            v = LaunchJobVisitor()
+            v.visit(tree)
+            nested_calls = v.nested_calls
+            user_code_service = context.node.get_service("usercodeService")
+            for call in nested_calls:
+                user_codes = user_code_service.get_by_service_name(context, call)
+                if isinstance(user_codes, SyftError):
+                    raise Exception(user_codes.message)
+                # TODO: Not great
+                user_code = user_codes[-1]
+                user_code_link = LinkedObject.from_obj(
+                    user_code, node_uid=context.node.id
+                )
+                nested_codes[call] = (user_code_link, user_code.nested_codes)
+        context.output["nested_codes"] = nested_codes
     return context
 
 
@@ -1243,9 +1265,12 @@ def compile_byte_code(parsed_code: str) -> Optional[PyCodeObject]:
 
 
 def compile_code(context: TransformContext) -> TransformContext:
+    if context.output is None:
+        return context
+
     byte_code = compile_byte_code(context.output["parsed_code"])
     if byte_code is None:
-        raise Exception(
+        raise ValueError(
             "Unable to compile byte code from parsed code. "
             + context.output["parsed_code"]
         )
@@ -1253,44 +1278,54 @@ def compile_code(context: TransformContext) -> TransformContext:
 
 
 def hash_code(context: TransformContext) -> TransformContext:
+    if context.output is None:
+        return context
+
     code = context.output["code"]
     context.output["raw_code"] = code
     code_hash = hashlib.sha256(code.encode("utf8")).hexdigest()
     context.output["code_hash"] = code_hash
+
     return context
 
 
 def add_credentials_for_key(key: str) -> Callable:
     def add_credentials(context: TransformContext) -> TransformContext:
-        context.output[key] = context.credentials
+        if context.output is not None:
+            context.output[key] = context.credentials
         return context
 
     return add_credentials
 
 
 def check_policy(policy: Any, context: TransformContext) -> TransformContext:
-    policy_service = context.node.get_service(PolicyService)
-    if isinstance(policy, SubmitUserPolicy):
-        policy = policy.to(UserPolicy, context=context)
-    elif isinstance(policy, UID):
-        policy = policy_service.get_policy_by_uid(context, policy)
-        if policy.is_ok():
-            policy = policy.ok()
-
+    if context.node is not None:
+        policy_service = context.node.get_service(PolicyService)
+        if isinstance(policy, SubmitUserPolicy):
+            policy = policy.to(UserPolicy, context=context)
+        elif isinstance(policy, UID):
+            policy = policy_service.get_policy_by_uid(context, policy)
+            if policy.is_ok():
+                policy = policy.ok()
     return policy
 
 
 def check_input_policy(context: TransformContext) -> TransformContext:
+    if context.output is None:
+        return context
+
     ip = context.output["input_policy_type"]
     ip = check_policy(policy=ip, context=context)
     context.output["input_policy_type"] = ip
+
     return context
 
 
 def check_output_policy(context: TransformContext) -> TransformContext:
-    op = context.output["output_policy_type"]
-    op = check_policy(policy=op, context=context)
-    context.output["output_policy_type"] = op
+    if context.output is not None:
+        op = context.output["output_policy_type"]
+        op = check_policy(policy=op, context=context)
+        context.output["output_policy_type"] = op
     return context
 
 
@@ -1298,6 +1333,12 @@ def create_code_status(context: TransformContext) -> TransformContext:
     # relative
     from .user_code_service import UserCodeService
 
+    if context.node is None:
+        raise ValueError(f"{context}'s node is None")
+
+    if context.output is None:
+        return context
+
     input_keys = list(context.output["input_policy_init_kwargs"].keys())
     code_link = LinkedObject.from_uid(
         context.output["id"],
@@ -1343,12 +1384,17 @@ def create_code_status(context: TransformContext) -> TransformContext:
 
 
 def add_submit_time(context: TransformContext) -> TransformContext:
-    context.output["submit_time"] = DateTime.now()
+    if context.output:
+        context.output["submit_time"] = DateTime.now()
     return context
 
 
 def set_default_pool_if_empty(context: TransformContext) -> TransformContext:
-    if context.output.get("worker_pool_name", None) is None:
+    if (
+        context.node
+        and context.output
+        and context.output.get("worker_pool_name", None) is None
+    ):
         default_pool = context.node.get_default_worker_pool()
         context.output["worker_pool_name"] = default_pool.name
     return context
diff --git a/packages/syft/src/syft/service/code/user_code_service.py b/packages/syft/src/syft/service/code/user_code_service.py
index 90d97e181e6..c91792c28e7 100644
--- a/packages/syft/src/syft/service/code/user_code_service.py
+++ b/packages/syft/src/syft/service/code/user_code_service.py
@@ -73,9 +73,9 @@ def submit(
 
     def _submit(
         self, context: AuthedServiceContext, code: Union[UserCode, SubmitUserCode]
-    ) -> Result:
+    ) -> Result[UserCode, str]:
         if not isinstance(code, UserCode):
-            code = code.to(UserCode, context=context)
+            code = code.to(UserCode, context=context)  # type: ignore[unreachable]
 
         result = self.stash.set(context.credentials, code)
         return result
@@ -278,6 +278,10 @@ def get_results(
                     connection=connection,
                     credentials=context.node.signing_key,
                 )
+                if enclave_client.code is None:
+                    return SyftError(
+                        message=f"{enclave_client} can't access the user code api"
+                    )
                 outputs = enclave_client.code.get_results(code.id)
                 if isinstance(outputs, list):
                     for output in outputs:
diff --git a/packages/syft/src/syft/service/code_history/code_history.py b/packages/syft/src/syft/service/code_history/code_history.py
index ed9b2655a75..fcd36d06d26 100644
--- a/packages/syft/src/syft/service/code_history/code_history.py
+++ b/packages/syft/src/syft/service/code_history/code_history.py
@@ -70,8 +70,14 @@ def _repr_html_(self) -> str:
         # rows = sorted(rows, key=lambda x: x["Version"])
         return create_table_template(rows, "CodeHistory", table_icon=None)
 
-    def __getitem__(self, index: int) -> Union[UserCode, SyftError]:
+    def __getitem__(self, index: Union[int, str]) -> Union[UserCode, SyftError]:
+        if isinstance(index, str):
+            raise TypeError(f"index {index} must be an integer, not a string")
         api = APIRegistry.api_for(self.syft_node_location, self.syft_client_verify_key)
+        if api is None:
+            return SyftError(
+                message=f"Can't access the api. You must login to {self.node_uid}"
+            )
         if api.user_role.value >= ServiceRole.DATA_OWNER.value and index < 0:
             return SyftError(
                 message="For security concerns we do not allow negative indexing. \
@@ -97,7 +103,9 @@ def _repr_html_(self) -> str:
     def add_func(self, versions: CodeHistoryView) -> Any:
         self.code_versions[versions.service_func_name] = versions
 
-    def __getitem__(self, name: str) -> Any:
+    def __getitem__(self, name: Union[str, int]) -> Any:
+        if isinstance(name, int):
+            raise TypeError("name argument ({name}) must be a string, not an integer.")
         return self.code_versions[name]
 
     def __getattr__(self, name: str) -> Any:
@@ -123,8 +131,12 @@ class UsersCodeHistoriesDict(SyftObject):
     def available_keys(self) -> str:
         return json.dumps(self.user_dict, sort_keys=True, indent=4)
 
-    def __getitem__(self, key: int) -> Union[CodeHistoriesDict, SyftError]:
+    def __getitem__(self, key: Union[str, int]) -> Union[CodeHistoriesDict, SyftError]:
         api = APIRegistry.api_for(self.node_uid, self.syft_client_verify_key)
+        if api is None:
+            return SyftError(
+                message=f"Can't access the api. You must login to {self.node_uid}"
+            )
         return api.services.code_history.get_history_for_user(key)
 
     def _repr_html_(self) -> str:
diff --git a/packages/syft/src/syft/service/code_history/code_history_service.py b/packages/syft/src/syft/service/code_history/code_history_service.py
index 71be2d0da91..994c39f31de 100644
--- a/packages/syft/src/syft/service/code_history/code_history_service.py
+++ b/packages/syft/src/syft/service/code_history/code_history_service.py
@@ -55,8 +55,7 @@ def submit_version(
             if result.is_err():
                 return SyftError(message=str(result.err()))
             code = result.ok()
-
-        elif isinstance(code, UserCode):
+        elif isinstance(code, UserCode):  # type: ignore[unreachable]
             result = user_code_service.get_by_uid(context=context, uid=code.id)
             if isinstance(result, SyftError):
                 return result
diff --git a/packages/syft/src/syft/service/context.py b/packages/syft/src/syft/service/context.py
index c0810239389..dc0d3c283b1 100644
--- a/packages/syft/src/syft/service/context.py
+++ b/packages/syft/src/syft/service/context.py
@@ -25,7 +25,7 @@
 class NodeServiceContext(Context, SyftObject):
     __canonical_name__ = "NodeServiceContext"
     __version__ = SYFT_OBJECT_VERSION_1
-    id: Optional[UID]
+    id: Optional[UID]  # type: ignore[assignment]
     node: Optional[AbstractNode]
 
 
diff --git a/packages/syft/src/syft/service/data_subject/data_subject.py b/packages/syft/src/syft/service/data_subject/data_subject.py
index 301d24881f3..0bbd47dccc8 100644
--- a/packages/syft/src/syft/service/data_subject/data_subject.py
+++ b/packages/syft/src/syft/service/data_subject/data_subject.py
@@ -64,7 +64,7 @@ def __repr_syft_nested__(self) -> str:
     def __repr__(self) -> str:
         return f"<DataSubject: {self.name}>"
 
-    def _repr_markdown_(self) -> str:
+    def _repr_markdown_(self, wrap_as_python: bool = True, indent: int = 0) -> str:
         _repr_str = f"DataSubject: {self.name}\n"
         _repr_str += f"Description: {self.description}\n"
         _repr_str += f"Aliases: {self.aliases}\n"
@@ -78,7 +78,7 @@ class DataSubjectCreate(SyftObject):
     __canonical_name__ = "DataSubjectCreate"
     __version__ = SYFT_OBJECT_VERSION_1
 
-    id: Optional[UID] = None
+    id: Optional[UID] = None  # type: ignore[assignment]
     name: str
     description: Optional[str]
     aliases: Optional[List[str]] = []
@@ -120,7 +120,7 @@ def member_relationships(self) -> Set[Tuple[str, str]]:
     def __repr__(self) -> str:
         return f"<DataSubject: {self.name}>"
 
-    def _repr_markdown_(self) -> str:
+    def _repr_markdown_(self, wrap_as_python: bool = True, indent: int = 0) -> str:
         _repr_str = f"DataSubject: {self.name}\n"
         _repr_str += f"Description: {self.description}\n"
         _repr_str += f"Aliases: {self.aliases}\n"
@@ -129,7 +129,8 @@ def _repr_markdown_(self) -> str:
 
 
 def remove_members_list(context: TransformContext) -> TransformContext:
-    context.output.pop("members", [])
+    if context.output is not None:
+        context.output.pop("members", [])
     return context
 
 
diff --git a/packages/syft/src/syft/service/data_subject/data_subject_service.py b/packages/syft/src/syft/service/data_subject/data_subject_service.py
index dfed8d7b951..f514566d4c0 100644
--- a/packages/syft/src/syft/service/data_subject/data_subject_service.py
+++ b/packages/syft/src/syft/service/data_subject/data_subject_service.py
@@ -47,7 +47,10 @@ def get_by_name(
         return self.query_one(credentials, qks=qks)
 
     def update(
-        self, credentials: SyftVerifyKey, data_subject: DataSubject
+        self,
+        credentials: SyftVerifyKey,
+        data_subject: DataSubject,
+        has_permission: bool = False,
     ) -> Result[DataSubject, str]:
         res = self.check_type(data_subject, DataSubject)
         # we dont use and_then logic here as it is hard because of the order of the arguments
diff --git a/packages/syft/src/syft/service/dataset/dataset.py b/packages/syft/src/syft/service/dataset/dataset.py
index e6244e935f3..31b20fcb508 100644
--- a/packages/syft/src/syft/service/dataset/dataset.py
+++ b/packages/syft/src/syft/service/dataset/dataset.py
@@ -101,7 +101,7 @@ class MarkdownDescription(SyftObject):
 
     text: str
 
-    def _repr_markdown_(self) -> str:
+    def _repr_markdown_(self, wrap_as_python: bool = True, indent: int = 0) -> str:
         style = """
         <style>
             .jp-RenderedHTMLCommon pre {
@@ -208,7 +208,7 @@ def _repr_html_(self) -> Any:
             {mock_table_line}
             </div>"""
 
-    def _repr_markdown_(self) -> str:
+    def _repr_markdown_(self, wrap_as_python: bool = True, indent: int = 0) -> str:
         _repr_str = f"Asset: {self.name}\n"
         _repr_str += f"Pointer Id: {self.action_id}\n"
         _repr_str += f"Description: {self.description}\n"
@@ -257,8 +257,6 @@ def mock(self) -> Union[SyftError, Any]:
         )
         if api is None:
             return SyftError(message=f"You must login to {self.node_uid}")
-        if api.services is None:
-            return SyftError(message=f"Services for {api} is None")
         result = api.services.action.get_mock(self.action_id)
         try:
             if isinstance(result, SyftObject):
@@ -319,7 +317,7 @@ class CreateAsset(SyftObject):
     __canonical_name__ = "CreateAsset"
     __version__ = SYFT_OBJECT_VERSION_1
 
-    id: Optional[UID] = None
+    id: Optional[UID] = None  # type:ignore[assignment]
     name: str
     description: Optional[MarkdownDescription] = None
     contributors: Set[Contributor] = set()
@@ -457,7 +455,7 @@ def get_shape_or_len(obj: Any) -> Optional[Union[Tuple[int, ...], int]]:
 @serializable()
 class Dataset(SyftObject):
     # version
-    __canonical_name__ = "Dataset"
+    __canonical_name__: str = "Dataset"
     __version__ = SYFT_OBJECT_VERSION_1
 
     id: UID
@@ -558,7 +556,7 @@ def _old_repr_markdown_(self) -> str:
             _repr_str += f"Description: {self.description.text}\n"
         return as_markdown_python_code(_repr_str)
 
-    def _repr_markdown_(self) -> str:
+    def _repr_markdown_(self, wrap_as_python: bool = True, indent: int = 0) -> str:
         # return self._old_repr_markdown_()
         return self._markdown_()
 
@@ -636,8 +634,8 @@ class CreateDataset(Dataset):
 
     __repr_attrs__ = ["name", "url"]
 
-    id: Optional[UID] = None
-    created_at: Optional[DateTime]
+    id: Optional[UID] = None  # type: ignore[assignment]
+    created_at: Optional[DateTime]  # type: ignore[assignment]
     uploader: Optional[Contributor]  # type: ignore[assignment]
 
     class Config:
@@ -740,6 +738,9 @@ def check(self) -> Result[SyftSuccess, List[SyftError]]:
 
 
 def create_and_store_twin(context: TransformContext) -> TransformContext:
+    if context.output is None:
+        raise ValueError("f{context}'s output is None. No trasformation happened")
+
     action_id = context.output["action_id"]
     if action_id is None:
         # relative
@@ -748,37 +749,49 @@ def create_and_store_twin(context: TransformContext) -> TransformContext:
         private_obj = context.output.pop("data", None)
         mock_obj = context.output.pop("mock", None)
         if private_obj is None and mock_obj is None:
-            raise Exception("No data and no action_id means this asset has no data")
+            raise ValueError("No data and no action_id means this asset has no data")
 
         twin = TwinObject(
             private_obj=private_obj,
             mock_obj=mock_obj,
         )
+        if context.node is None:
+            raise ValueError(
+                "f{context}'s node is None, please log in. No trasformation happened"
+            )
         action_service = context.node.get_service("actionservice")
         result = action_service.set(
             context=context.to_node_context(), action_object=twin
         )
         if result.is_err():
-            raise Exception(f"Failed to create and store twin. {result}")
+            raise RuntimeError(f"Failed to create and store twin. Error: {result}")
 
         context.output["action_id"] = twin.id
     else:
         private_obj = context.output.pop("data", None)
         mock_obj = context.output.pop("mock", None)
+
     return context
 
 
 def infer_shape(context: TransformContext) -> TransformContext:
-    if context.output["shape"] is None:
-        if not _is_action_data_empty(context.obj.mock):
+    if context.output is not None and context.output["shape"] is None:
+        if context.obj is not None and not _is_action_data_empty(context.obj.mock):
             context.output["shape"] = get_shape_or_len(context.obj.mock)
+    else:
+        print("f{context}'s output is None. No trasformation happened")
     return context
 
 
-def set_data_subjects(context: TransformContext) -> TransformContext:
+def set_data_subjects(context: TransformContext) -> Union[TransformContext, SyftError]:
+    if context.output is None:
+        return SyftError("f{context}'s output is None. No trasformation happened")
+    if context.node is None:
+        return SyftError(
+            "f{context}'s node is None, please log in. No trasformation happened"
+        )
     data_subjects = context.output["data_subjects"]
     get_data_subject = context.node.get_service_method(DataSubjectService.get_by_name)
-
     resultant_data_subjects = []
     for data_subject in data_subjects:
         result = get_data_subject(context=context, name=data_subject.name)
@@ -790,13 +803,19 @@ def set_data_subjects(context: TransformContext) -> TransformContext:
 
 
 def add_msg_creation_time(context: TransformContext) -> TransformContext:
+    if context.output is None:
+        return context
+
     context.output["created_at"] = DateTime.now()
     return context
 
 
 def add_default_node_uid(context: TransformContext) -> TransformContext:
-    if context.output["node_uid"] is None:
-        context.output["node_uid"] = context.node.id
+    if context.output is not None:
+        if context.output["node_uid"] is None and context.node is not None:
+            context.output["node_uid"] = context.node.id
+    else:
+        print("f{context}'s output is None. No trasformation happened.")
     return context
 
 
@@ -813,18 +832,26 @@ def createasset_to_asset() -> List[Callable]:
 
 
 def convert_asset(context: TransformContext) -> TransformContext:
+    if context.output is None:
+        return context
+
     assets = context.output.pop("asset_list", [])
     for idx, create_asset in enumerate(assets):
         asset_context = TransformContext.from_context(obj=create_asset, context=context)
         assets[idx] = create_asset.to(Asset, context=asset_context)
     context.output["asset_list"] = assets
+
     return context
 
 
 def add_current_date(context: TransformContext) -> TransformContext:
+    if context.output is None:
+        return context
+
     current_date = datetime.now()
     formatted_date = current_date.strftime("%b %d, %Y")
     context.output["updated_at"] = formatted_date
+
     return context
 
 
diff --git a/packages/syft/src/syft/service/dataset/dataset_stash.py b/packages/syft/src/syft/service/dataset/dataset_stash.py
index be35bc0cf3e..19abea2e3eb 100644
--- a/packages/syft/src/syft/service/dataset/dataset_stash.py
+++ b/packages/syft/src/syft/service/dataset/dataset_stash.py
@@ -40,7 +40,10 @@ def get_by_name(
         return self.query_one(credentials=credentials, qks=qks)
 
     def update(
-        self, credentials: SyftVerifyKey, dataset_update: DatasetUpdate
+        self,
+        credentials: SyftVerifyKey,
+        dataset_update: DatasetUpdate,
+        has_permission: bool = False,
     ) -> Result[Dataset, str]:
         res = self.check_type(dataset_update, DatasetUpdate)
         # we dont use and_then logic here as it is hard because of the order of the arguments
diff --git a/packages/syft/src/syft/service/job/job_service.py b/packages/syft/src/syft/service/job/job_service.py
index 057e5c2ef3a..70a6d343ef8 100644
--- a/packages/syft/src/syft/service/job/job_service.py
+++ b/packages/syft/src/syft/service/job/job_service.py
@@ -15,6 +15,7 @@
 from ..action.action_permissions import ActionPermission
 from ..code.user_code import UserCode
 from ..context import AuthedServiceContext
+from ..log.log_service import LogService
 from ..queue.queue_stash import ActionQueueItem
 from ..response import SyftError
 from ..response import SyftSuccess
@@ -219,7 +220,9 @@ def add_read_permission_job_for_code_owner(
     def add_read_permission_log_for_code_owner(
         self, context: AuthedServiceContext, log_id: UID, user_code: UserCode
     ) -> Any:
-        log_service = context.node.get_service("logservice")  # type: ignore
+        context.node = cast(AbstractNode, context.node)
+        log_service = context.node.get_service("logservice")
+        log_service = cast(LogService, log_service)
         return log_service.stash.add_permission(
             ActionObjectPermission(
                 log_id, ActionPermission.READ, user_code.user_verify_key
@@ -254,7 +257,6 @@ def create_job_for_user_code_id(
         self.stash.set(context.credentials, job)
         self.add_read_permission_job_for_code_owner(context, job, user_code)
 
-        context.node = cast(AbstractNode, context.node)
         log_service = context.node.get_service("logservice")
         res = log_service.add(context, job.log_id)
         if isinstance(res, SyftError):
diff --git a/packages/syft/src/syft/service/job/job_stash.py b/packages/syft/src/syft/service/job/job_stash.py
index e99f18a0808..2645d35f882 100644
--- a/packages/syft/src/syft/service/job/job_stash.py
+++ b/packages/syft/src/syft/service/job/job_stash.py
@@ -178,6 +178,10 @@ def worker(self) -> Union[SyftWorker, SyftError]:
             node_uid=self.syft_node_location,
             user_verify_key=self.syft_client_verify_key,
         )
+        if api is None:
+            return SyftError(
+                message=f"Can't access Syft API. You must login to {self.syft_node_location}"
+            )
         return api.services.worker.get(self.job_worker_id)
 
     @property
@@ -268,6 +272,10 @@ def restart(self, kill: bool = False) -> None:
                 node_uid=self.syft_node_location,
                 user_verify_key=self.syft_client_verify_key,
             )
+            if api is None:
+                raise ValueError(
+                    f"Can't access Syft API. You must login to {self.syft_node_location}"
+                )
             call = SyftAPICall(
                 node_uid=self.node_uid,
                 path="job.restart",
@@ -289,6 +297,10 @@ def kill(self) -> Optional[SyftError]:
                 node_uid=self.syft_node_location,
                 user_verify_key=self.syft_client_verify_key,
             )
+            if api is None:
+                return SyftError(
+                    message=f"Can't access Syft API. You must login to {self.syft_node_location}"
+                )
             call = SyftAPICall(
                 node_uid=self.node_uid,
                 path="job.kill",
@@ -308,6 +320,10 @@ def fetch(self) -> None:
             node_uid=self.syft_node_location,
             user_verify_key=self.syft_client_verify_key,
         )
+        if api is None:
+            raise ValueError(
+                f"Can't access Syft API. You must login to {self.syft_node_location}"
+            )
         call = SyftAPICall(
             node_uid=self.node_uid,
             path="job.get",
@@ -330,6 +346,10 @@ def subjobs(self) -> Union[list[QueueItem], SyftError]:
             node_uid=self.syft_node_location,
             user_verify_key=self.syft_client_verify_key,
         )
+        if api is None:
+            return SyftError(
+                message=f"Can't access Syft API. You must login to {self.syft_node_location}"
+            )
         return api.services.job.get_subjobs(self.id)
 
     @property
@@ -338,6 +358,10 @@ def owner(self) -> Union[UserView, SyftError]:
             node_uid=self.syft_node_location,
             user_verify_key=self.syft_client_verify_key,
         )
+        if api is None:
+            return SyftError(
+                message=f"Can't access Syft API. You must login to {self.syft_node_location}"
+            )
         return api.services.user.get_current_user(self.id)
 
     def _get_log_objs(self) -> Union[SyftObject, SyftError]:
@@ -345,6 +369,8 @@ def _get_log_objs(self) -> Union[SyftObject, SyftError]:
             node_uid=self.node_uid,
             user_verify_key=self.syft_client_verify_key,
         )
+        if api is None:
+            raise ValueError(f"api is None. You must login to {self.node_uid}")
         return api.services.log.get(self.log_id)
 
     def logs(
@@ -354,6 +380,8 @@ def logs(
             node_uid=self.syft_node_location,
             user_verify_key=self.syft_client_verify_key,
         )
+        if api is None:
+            return f"Can't access Syft API. You must login to {self.syft_node_location}"
         results = []
         if stdout:
             stdout_log = api.services.log.get_stdout(self.log_id)
@@ -414,7 +442,7 @@ def _coll_repr_(self) -> Dict[str, Any]:
     def has_parent(self) -> bool:
         return self.parent_job_id is not None
 
-    def _repr_markdown_(self) -> str:
+    def _repr_markdown_(self, wrap_as_python: bool = True, indent: int = 0) -> str:
         _ = self.resolve
         logs = self.logs(_print=False)
         if logs is not None:
@@ -444,7 +472,6 @@ def wait(self, job_only: bool = False) -> Union[Any, SyftNotReady]:
             node_uid=self.syft_node_location,
             user_verify_key=self.syft_client_verify_key,
         )
-
         # todo: timeout
         if self.resolved:
             return self.resolve
@@ -452,6 +479,10 @@ def wait(self, job_only: bool = False) -> Union[Any, SyftNotReady]:
         if not job_only and self.result is not None:
             self.result.wait()
 
+        if api is None:
+            raise ValueError(
+                f"Can't access Syft API. You must login to {self.syft_node_location}"
+            )
         print_warning = True
         while True:
             self.fetch()
diff --git a/packages/syft/src/syft/service/metadata/migrations.py b/packages/syft/src/syft/service/metadata/migrations.py
index be36a07e123..5766070d91f 100644
--- a/packages/syft/src/syft/service/metadata/migrations.py
+++ b/packages/syft/src/syft/service/metadata/migrations.py
@@ -35,15 +35,16 @@ def upgrade_metadata_v2_to_v3() -> list[Callable]:
 def _downgrade_metadata_v3_to_v2() -> Callable:
     def set_defaults_from_settings(context: TransformContext) -> TransformContext:
         # Extract from settings if node is attached to context
-        if context.node is not None:
-            context.output["deployed_on"] = context.node.settings.deployed_on
-            context.output["on_board"] = context.node.settings.on_board
-            context.output["signup_enabled"] = context.node.settings.signup_enabled
-            context.output["admin_email"] = context.node.settings.admin_email
-        else:
-            # Else set default value
-            context.output["signup_enabled"] = False
-            context.output["admin_email"] = ""
+        if context.output is not None:
+            if context.node is not None:
+                context.output["deployed_on"] = context.node.settings.deployed_on
+                context.output["on_board"] = context.node.settings.on_board
+                context.output["signup_enabled"] = context.node.settings.signup_enabled
+                context.output["admin_email"] = context.node.settings.admin_email
+            else:
+                # Else set default value
+                context.output["signup_enabled"] = False
+                context.output["admin_email"] = ""
 
         return context
 
diff --git a/packages/syft/src/syft/service/metadata/node_metadata.py b/packages/syft/src/syft/service/metadata/node_metadata.py
index 13eb097b0ac..2dca67662fb 100644
--- a/packages/syft/src/syft/service/metadata/node_metadata.py
+++ b/packages/syft/src/syft/service/metadata/node_metadata.py
@@ -55,7 +55,7 @@ class NodeMetadataUpdate(SyftObject):
     organization: Optional[str]
     description: Optional[str]
     on_board: Optional[bool]
-    id: Optional[UID]
+    id: Optional[UID]  # type: ignore[assignment]
     verify_key: Optional[SyftVerifyKey]
     highest_object_version: Optional[int]
     lowest_object_version: Optional[int]
diff --git a/packages/syft/src/syft/service/network/network_service.py b/packages/syft/src/syft/service/network/network_service.py
index 16a13ec3aac..499dddb3798 100644
--- a/packages/syft/src/syft/service/network/network_service.py
+++ b/packages/syft/src/syft/service/network/network_service.py
@@ -70,7 +70,10 @@ def get_by_name(
         return self.query_one(credentials=credentials, qks=qks)
 
     def update(
-        self, credentials: SyftVerifyKey, peer: NodePeer
+        self,
+        credentials: SyftVerifyKey,
+        peer: NodePeer,
+        has_permission: bool = False,
     ) -> Result[NodePeer, str]:
         valid = self.check_type(peer, NodePeer)
         if valid.is_err():
@@ -229,7 +232,6 @@ def add_peer(
         except Exception as e:
             return SyftError(message=str(e))
 
-        context.node = cast(AbstractNode, context.node)
         result = self.stash.update_peer(context.node.verify_key, peer)
         if result.is_err():
             return SyftError(message=str(result.err()))
@@ -243,7 +245,6 @@ def add_peer(
 
         # Q,TODO: Should the returned node peer also be signed
         # as the challenge is already signed
-        context.node = cast(AbstractNode, context.node)
         challenge_signature = context.node.signing_key.signing_key.sign(
             challenge
         ).signature
@@ -310,7 +311,6 @@ def verify_route(
                 )
             )
         peer.update_routes([route])
-        context.node = cast(AbstractNode, context.node)
         result = self.stash.update_peer(context.node.verify_key, peer)
         if result.is_err():
             return SyftError(message=str(result.err()))
@@ -376,13 +376,15 @@ def get_peers_by_type(
 
 
 def from_grid_url(context: TransformContext) -> TransformContext:
-    url = context.obj.url.as_container_host()
-    context.output["host_or_ip"] = url.host_or_ip
-    context.output["protocol"] = url.protocol
-    context.output["port"] = url.port
-    context.output["private"] = False
-    context.output["proxy_target_uid"] = context.obj.proxy_target_uid
-    context.output["priority"] = 1
+    if context.obj is not None and context.output is not None:
+        url = context.obj.url.as_container_host()
+        context.output["host_or_ip"] = url.host_or_ip
+        context.output["protocol"] = url.protocol
+        context.output["port"] = url.port
+        context.output["private"] = False
+        context.output["proxy_target_uid"] = context.obj.proxy_target_uid
+        context.output["priority"] = 1
+
     return context
 
 
@@ -392,9 +394,10 @@ def http_connection_to_node_route() -> List[Callable]:
 
 
 def get_python_node_route(context: TransformContext) -> TransformContext:
-    context.output["id"] = context.obj.node.id
-    context.output["worker_settings"] = WorkerSettings.from_node(context.obj.node)
-    context.output["proxy_target_uid"] = context.obj.proxy_target_uid
+    if context.output is not None and context.obj is not None:
+        context.output["id"] = context.obj.node.id
+        context.output["worker_settings"] = WorkerSettings.from_node(context.obj.node)
+        context.output["proxy_target_uid"] = context.obj.proxy_target_uid
     return context
 
 
diff --git a/packages/syft/src/syft/service/network/node_peer.py b/packages/syft/src/syft/service/network/node_peer.py
index cc9764947e5..4a8da92732d 100644
--- a/packages/syft/src/syft/service/network/node_peer.py
+++ b/packages/syft/src/syft/service/network/node_peer.py
@@ -35,7 +35,7 @@ class NodePeer(SyftObject):
     __attr_unique__ = ["verify_key"]
     __repr_attrs__ = ["name", "node_type", "admin_email"]
 
-    id: Optional[UID]
+    id: Optional[UID]  # type: ignore[assignment]
     name: str
     verify_key: SyftVerifyKey
     node_routes: List[NodeRouteType] = []
diff --git a/packages/syft/src/syft/service/network/routes.py b/packages/syft/src/syft/service/network/routes.py
index eb64cca0546..15027a97ab8 100644
--- a/packages/syft/src/syft/service/network/routes.py
+++ b/packages/syft/src/syft/service/network/routes.py
@@ -145,4 +145,4 @@ def connection_to_route(connection: NodeConnection) -> NodeRoute:
     if isinstance(connection, HTTPConnection):
         return connection.to(HTTPNodeRoute)
     else:
-        return connection.to(PythonNodeRoute)
+        return connection.to(PythonNodeRoute)  # type: ignore[unreachable]
diff --git a/packages/syft/src/syft/service/notification/notifications.py b/packages/syft/src/syft/service/notification/notifications.py
index fd8be6675d1..1a4e5a9794c 100644
--- a/packages/syft/src/syft/service/notification/notifications.py
+++ b/packages/syft/src/syft/service/notification/notifications.py
@@ -45,7 +45,7 @@ class ReplyNotification(SyftObject):
 
     text: str
     target_msg: UID
-    id: Optional[UID]
+    id: Optional[UID]  # type: ignore[assignment]
     from_user_verify_key: Optional[SyftVerifyKey]
 
 
@@ -107,14 +107,22 @@ def _coll_repr_(self) -> dict[str, str]:
 
     def mark_read(self) -> None:
         api = APIRegistry.api_for(
-            self.node_uid, user_verify_key=self.syft_client_verify_key
+            node_uid=self.node_uid, user_verify_key=self.syft_client_verify_key
         )
+        if api is None:
+            raise ValueError(
+                f"Can't access Syft API. You must login to {self.node_uid}"
+            )
         return api.services.notifications.mark_as_read(uid=self.id)
 
     def mark_unread(self) -> None:
         api = APIRegistry.api_for(
             self.node_uid, user_verify_key=self.syft_client_verify_key
         )
+        if api is None:
+            raise ValueError(
+                f"Can't access Syft API. You must login to {self.node_uid}"
+            )
         return api.services.notifications.mark_as_unread(uid=self.id)
 
     def determine_status(self) -> Enum:
@@ -132,14 +140,17 @@ class CreateNotification(Notification):
     __canonical_name__ = "CreateNotification"
     __version__ = SYFT_OBJECT_VERSION_1
 
-    id: Optional[UID]
-    node_uid: Optional[UID]
-    from_user_verify_key: Optional[SyftVerifyKey]
-    created_at: Optional[DateTime]
+    id: Optional[UID]  # type: ignore[assignment]
+    node_uid: Optional[UID]  # type: ignore[assignment]
+    from_user_verify_key: Optional[SyftVerifyKey]  # type: ignore[assignment]
+    created_at: Optional[DateTime]  # type: ignore[assignment]
 
 
 def add_msg_creation_time(context: TransformContext) -> TransformContext:
-    context.output["created_at"] = DateTime.now()
+    if context.output is not None:
+        context.output["created_at"] = DateTime.now()
+    else:
+        print("f{context}'s output is None. No trasformation happened.")
     return context
 
 
diff --git a/packages/syft/src/syft/service/object_search/migration_state_service.py b/packages/syft/src/syft/service/object_search/migration_state_service.py
index fefb28dc60c..c16360a4354 100644
--- a/packages/syft/src/syft/service/object_search/migration_state_service.py
+++ b/packages/syft/src/syft/service/object_search/migration_state_service.py
@@ -15,7 +15,7 @@
 @serializable()
 class MigrateStateService(AbstractService):
     store: DocumentStore
-    stash: SyftObjectMigrationState
+    stash: SyftMigrationStateStash
 
     def __init__(self, store: DocumentStore) -> None:
         self.store = store
diff --git a/packages/syft/src/syft/service/object_search/object_migration_state.py b/packages/syft/src/syft/service/object_search/object_migration_state.py
index 686c1ccb8fd..e6bab0fb8b3 100644
--- a/packages/syft/src/syft/service/object_search/object_migration_state.py
+++ b/packages/syft/src/syft/service/object_search/object_migration_state.py
@@ -33,7 +33,7 @@ def latest_version(self) -> Optional[int]:
         available_versions = SyftMigrationRegistry.get_versions(
             canonical_name=self.canonical_name,
         )
-        if available_versions is None:
+        if not available_versions:
             return None
 
         return sorted(available_versions, reverse=True)[0]
@@ -62,6 +62,7 @@ def set(
         credentials: SyftVerifyKey,
         migration_state: SyftObjectMigrationState,
         add_permissions: Optional[List[ActionObjectPermission]] = None,
+        ignore_duplicates: bool = False,
     ) -> Result[SyftObjectMigrationState, str]:
         res = self.check_type(migration_state, self.object_type)
         # we dont use and_then logic here as it is hard because of the order of the arguments
diff --git a/packages/syft/src/syft/service/output/output_service.py b/packages/syft/src/syft/service/output/output_service.py
index 15253fe8f1e..12abcf46c1c 100644
--- a/packages/syft/src/syft/service/output/output_service.py
+++ b/packages/syft/src/syft/service/output/output_service.py
@@ -1,5 +1,6 @@
 # stdlib
 from typing import Any
+from typing import ClassVar
 from typing import Dict
 from typing import List
 from typing import Optional
@@ -54,8 +55,17 @@ class ExecutionOutput(SyftObject):
     # Output policy is not a linked object because its saved on the usercode
     output_policy_id: Optional[UID] = None
 
-    __attr_searchable__: List[str] = ["user_code_id", "created_at", "output_policy_id"]
-    __repr_attrs__: List[str] = ["created_at", "user_code_id", "job_id", "output_ids"]
+    __attr_searchable__: ClassVar[List[str]] = [
+        "user_code_id",
+        "created_at",
+        "output_policy_id",
+    ]
+    __repr_attrs__: ClassVar[List[str]] = [
+        "created_at",
+        "user_code_id",
+        "job_id",
+        "output_ids",
+    ]
 
     @pydantic.root_validator(pre=True)
     def add_user_code_id(cls, values: dict) -> dict:
@@ -108,12 +118,17 @@ def from_ids(
 
     @property
     def outputs(self) -> Optional[Union[List[ActionObject], Dict[str, ActionObject]]]:
-        action_service = APIRegistry.api_for(
+        api = APIRegistry.api_for(
             node_uid=self.syft_node_location,
             user_verify_key=self.syft_client_verify_key,
-        ).services.action
-        # TODO error handling for action_service.get
+        )
+        if api is None:
+            raise ValueError(
+                f"Can't access the api. Please log in to {self.syft_node_location}"
+            )
+        action_service = api.services.action
 
+        # TODO: error handling for action_service.get
         if isinstance(self.output_ids, dict):
             return {k: action_service.get(v) for k, v in self.output_ids.items()}
         elif isinstance(self.output_ids, list):
diff --git a/packages/syft/src/syft/service/policy/policy.py b/packages/syft/src/syft/service/policy/policy.py
index c4110de93b0..8b91c996d98 100644
--- a/packages/syft/src/syft/service/policy/policy.py
+++ b/packages/syft/src/syft/service/policy/policy.py
@@ -71,7 +71,7 @@ def extract_uid(v: Any) -> UID:
     return value
 
 
-def filter_only_uids(results: Any) -> Union[List[UID], Dict[str, UID]]:
+def filter_only_uids(results: Any) -> Union[list[UID], dict[str, UID], UID]:
     if not hasattr(results, "__len__"):
         results = [results]
 
@@ -90,7 +90,7 @@ def filter_only_uids(results: Any) -> Union[List[UID], Dict[str, UID]]:
 
 class Policy(SyftObject):
     # version
-    __canonical_name__ = "Policy"
+    __canonical_name__: str = "Policy"
     __version__ = SYFT_OBJECT_VERSION_1
 
     id: UID
@@ -130,7 +130,7 @@ class UserPolicyStatus(Enum):
     APPROVED = "approved"
 
 
-def partition_by_node(kwargs: Dict[str, Any]) -> Dict[str, UID]:
+def partition_by_node(kwargs: Dict[str, Any]) -> dict[NodeIdentity, dict[str, UID]]:
     # relative
     from ...client.api import APIRegistry
     from ...client.api import NodeIdentity
@@ -262,7 +262,7 @@ def retrieve_from_db(
 
 
 def allowed_ids_only(
-    allowed_inputs: Dict[str, UID],
+    allowed_inputs: dict[NodeIdentity, Any],
     kwargs: Dict[str, Any],
     context: AuthedServiceContext,
 ) -> Dict[str, UID]:
@@ -368,6 +368,10 @@ class OutputPolicyExecuteCount(OutputPolicy):
     @property
     def count(self) -> Union[SyftError, int]:
         api = APIRegistry.api_for(self.syft_node_location, self.syft_client_verify_key)
+        if api is None:
+            raise ValueError(
+                f"api is None. You must login to {self.syft_node_location}"
+            )
         output_history = api.services.output.get_by_output_policy_id(self.id)
 
         if isinstance(output_history, SyftError):
@@ -386,8 +390,9 @@ def is_valid(self) -> Union[SyftSuccess, SyftError]:  # type: ignore
             message=f"Policy is no longer valid. count: {execution_count} >= limit: {self.limit}"
         )
 
-    def _is_valid(self, context: AuthedServiceContext) -> Union[SyftSuccess, SyftError]:  # type: ignore
-        output_service = context.node.get_service("outputservice")  # type: ignore
+    def _is_valid(self, context: AuthedServiceContext) -> Union[SyftSuccess, SyftError]:
+        context.node = cast(AbstractNode, context.node)
+        output_service = context.node.get_service("outputservice")
         output_history = output_service.get_by_output_policy_id(context, self.id)
         if isinstance(output_history, SyftError):
             return output_history
@@ -460,7 +465,7 @@ class CustomInputPolicy(metaclass=CustomPolicy):
 
 @serializable()
 class UserPolicy(Policy):
-    __canonical_name__ = "UserPolicy"
+    __canonical_name__: str = "UserPolicy"
     __version__ = SYFT_OBJECT_VERSION_1
 
     id: UID
@@ -534,7 +539,7 @@ class SubmitUserPolicy(Policy):
     __canonical_name__ = "SubmitUserPolicy"
     __version__ = SYFT_OBJECT_VERSION_1
 
-    id: Optional[UID]
+    id: Optional[UID]  # type: ignore[assignment]
     code: str
     class_name: str
     input_kwargs: List[str]
@@ -554,20 +559,27 @@ def from_obj(policy_obj: CustomPolicy) -> SubmitUserPolicy:
 
 
 def hash_code(context: TransformContext) -> TransformContext:
+    if context.output is None:
+        return context
     code = context.output["code"]
     del context.output["code"]
     context.output["raw_code"] = code
     code_hash = hashlib.sha256(code.encode("utf8")).hexdigest()
     context.output["code_hash"] = code_hash
+
     return context
 
 
 def generate_unique_class_name(context: TransformContext) -> TransformContext:
     # TODO: Do we need to check if the initial name contains underscores?
-    code_hash = context.output["code_hash"]
-    service_class_name = context.output["class_name"]
-    unique_name = f"{service_class_name}_{context.credentials}_{code_hash}"
-    context.output["unique_name"] = unique_name
+    if context.output is not None:
+        code_hash = context.output["code_hash"]
+        service_class_name = context.output["class_name"]
+        unique_name = f"{service_class_name}_{context.credentials}_{code_hash}"
+        context.output["unique_name"] = unique_name
+    else:
+        print("f{context}'s output is None. No trasformation happened.")
+
     return context
 
 
@@ -666,6 +678,9 @@ def check_class_code(context: TransformContext) -> TransformContext:
     # check for Policy template -> __init__, apply_output, public_state
     # parse init signature
     # check dangerous libraries, maybe compile_restricted already does that
+    if context.output is None:
+        return context
+
     try:
         processed_code = process_class_code(
             raw_code=context.output["raw_code"],
@@ -674,34 +689,45 @@ def check_class_code(context: TransformContext) -> TransformContext:
         context.output["parsed_code"] = processed_code
     except Exception as e:
         raise e
+
     return context
 
 
 def compile_code(context: TransformContext) -> TransformContext:
-    byte_code = compile_byte_code(context.output["parsed_code"])
-    if byte_code is None:
-        raise Exception(
-            "Unable to compile byte code from parsed code. "
-            + context.output["parsed_code"]
-        )
+    if context.output is not None:
+        byte_code = compile_byte_code(context.output["parsed_code"])
+        if byte_code is None:
+            raise Exception(
+                "Unable to compile byte code from parsed code. "
+                + context.output["parsed_code"]
+            )
+    else:
+        print("f{context}'s output is None. No trasformation happened.")
+
     return context
 
 
 def add_credentials_for_key(key: str) -> Callable:
     def add_credentials(context: TransformContext) -> TransformContext:
-        context.output[key] = context.credentials
+        if context.output is not None:
+            context.output[key] = context.credentials
+
         return context
 
     return add_credentials
 
 
 def generate_signature(context: TransformContext) -> TransformContext:
+    if context.output is None:
+        return context
+
     params = [
         Parameter(name=k, kind=Parameter.POSITIONAL_OR_KEYWORD)
         for k in context.output["input_kwargs"]
     ]
     sig = Signature(parameters=params)
     context.output["signature"] = sig
+
     return context
 
 
diff --git a/packages/syft/src/syft/service/project/project.py b/packages/syft/src/syft/service/project/project.py
index 22cd617917b..d487c97fdd3 100644
--- a/packages/syft/src/syft/service/project/project.py
+++ b/packages/syft/src/syft/service/project/project.py
@@ -58,6 +58,7 @@
 from ..response import SyftInfo
 from ..response import SyftNotReady
 from ..response import SyftSuccess
+from ..user.user import UserView
 
 
 @serializable()
@@ -146,7 +147,7 @@ def valid_descendant(
             return valid
 
         if prev_event:
-            prev_event_id = prev_event.id
+            prev_event_id: Optional[UID] = prev_event.id
             prev_event_hash = prev_event.event_hash
             prev_seq_no = prev_event.seq_no
         else:
@@ -298,7 +299,7 @@ def request(self) -> Request:
         "request.changes[-1].code.service_func_name",
     ]
 
-    def _repr_markdown_(self) -> str:
+    def _repr_markdown_(self, wrap_as_python: bool = True, indent: int = 0) -> str:
         func_name = None
         if len(self.request.changes) > 0:
             func_name = self.request.changes[-1].code.service_func_name
@@ -332,13 +333,12 @@ def status(self, project: Project) -> Optional[Union[SyftInfo, SyftError]]:
 
         During Request  status calculation, we do not allow multiple responses
         """
-        responses = project.get_children(self)
+        responses: list[ProjectEvent] = project.get_children(self)
         if len(responses) == 0:
             return SyftInfo(
                 "No one has responded to the request yet. Kindly recheck later 🙂"
             )
-
-        if len(responses) > 1:
+        elif len(responses) > 1:
             return SyftError(
                 message="The Request Contains more than one Response"
                 "which is currently not possible"
@@ -348,7 +348,7 @@ def status(self, project: Project) -> Optional[Union[SyftInfo, SyftError]]:
             )
         response = responses[0]
         if not isinstance(response, ProjectRequestResponse):
-            return SyftError(
+            return SyftError(  # type: ignore[unreachable]
                 message=f"Response : {type(response)} is not of type ProjectRequestResponse"
             )
 
@@ -587,7 +587,7 @@ def status(
         respondents = {}
         for poll_answer in poll_answers[::-1]:
             if not isinstance(poll_answer, AnswerProjectPoll):
-                return SyftError(
+                return SyftError(  # type: ignore[unreachable]
                     message=f"Poll answer: {type(poll_answer)} is not of type AnswerProjectPoll"
                 )
             creator_verify_key = poll_answer.creator_verify_key
@@ -627,7 +627,7 @@ def __hash__(self) -> int:
 def add_code_request_to_project(
     project: Union[ProjectSubmit, Project],
     code: SubmitUserCode,
-    client: SyftClient,
+    client: Union[SyftClient, Any],
     reason: Optional[str] = None,
 ) -> Union[SyftError, SyftSuccess]:
     # TODO: fix the mypy issue
@@ -681,7 +681,7 @@ class Project(SyftObject):
         "event_id_hashmap",
     ]
 
-    id: Optional[UID]
+    id: Optional[UID]  # type: ignore[assignment]
     name: str
     description: Optional[str]
     members: List[NodeIdentity]
@@ -998,7 +998,7 @@ def reply_message(
         reply_event: Union[ProjectMessage, ProjectThreadMessage]
         if isinstance(message, ProjectMessage):
             reply_event = message.reply(reply)
-        elif isinstance(message, ProjectThreadMessage):
+        elif isinstance(message, ProjectThreadMessage):  # type: ignore[unreachable]
             reply_event = ProjectThreadMessage(
                 message=reply, parent_event_id=message.parent_event_id
             )
@@ -1043,7 +1043,7 @@ def answer_poll(
             poll = self.event_id_hashmap[poll]
 
         if not isinstance(poll, ProjectMultipleChoicePoll):
-            return SyftError(
+            return SyftError(  # type: ignore[unreachable]
                 message=f"You can only reply to a poll: {type(poll)}"
                 "Kindly re-check the poll"
             )
@@ -1087,7 +1087,7 @@ def approve_request(
             if isinstance(request_event, SyftError):
                 return request_event
         else:
-            return SyftError(
+            return SyftError(  # type: ignore[unreachable]
                 message=f"You can only approve a request: {type(request)}"
                 "Kindly re-check the request"
             )
@@ -1209,7 +1209,10 @@ def __init__(self, *args: Any, **kwargs: Any):
         self.users = [UserIdentity.from_client(client) for client in self.clients]
 
         # Assign logged in user name as project creator
-        self.username = self.clients[0].me.name or ""
+        if isinstance(self.clients[0].me, UserView):
+            self.username = self.clients[0].me.name
+        else:
+            self.username = ""
 
         # Convert SyftClients to NodeIdentities
         self.members = list(map(self.to_node_identity, self.members))
@@ -1252,7 +1255,7 @@ def get_syft_clients(
     def to_node_identity(val: Union[SyftClient, NodeIdentity]) -> NodeIdentity:
         if isinstance(val, NodeIdentity):
             return val
-        elif isinstance(val, SyftClient):
+        elif isinstance(val, SyftClient) and val.metadata is not None:
             metadata = val.metadata.to(NodeMetadataV3)
             return metadata.to(NodeIdentity)
         else:
@@ -1353,19 +1356,21 @@ def add_members_as_owners(members: List[SyftVerifyKey]) -> Set[str]:
 
 
 def elect_leader(context: TransformContext) -> TransformContext:
-    if len(context.output["members"]) == 0:
-        raise Exception("Project's require at least one member")
-
-    context.output["state_sync_leader"] = context.output["members"][0]
+    if context.output is not None:
+        if len(context.output["members"]) == 0:
+            raise ValueError("Project's require at least one member")
+        context.output["state_sync_leader"] = context.output["members"][0]
 
     return context
 
 
 def check_permissions(context: TransformContext) -> TransformContext:
+    if context.output is None:
+        return context
+
     if len(context.output["members"]) > 1:
         # more than 1 node
         pass
-
     # check at least one owner
     if len(context.output["project_permissions"]) == 0:
         project_permissions = context.output["project_permissions"]
@@ -1378,7 +1383,8 @@ def check_permissions(context: TransformContext) -> TransformContext:
 
 
 def add_creator_name(context: TransformContext) -> TransformContext:
-    context.output["username"] = context.obj.username
+    if context.output is not None and context.obj is not None:
+        context.output["username"] = context.obj.username
     return context
 
 
diff --git a/packages/syft/src/syft/service/project/project_service.py b/packages/syft/src/syft/service/project/project_service.py
index afed1eaefc9..6de6c644259 100644
--- a/packages/syft/src/syft/service/project/project_service.py
+++ b/packages/syft/src/syft/service/project/project_service.py
@@ -105,10 +105,11 @@ def create_project(
                     verify_key=leader_node.verify_key,
                 )
                 if peer.is_err():
+                    this_node_id = context.node.id.short() if context.node.id else ""
                     return SyftError(
                         message=(
                             f"Leader Node(id={leader_node.id.short()}) is not a "
-                            f"peer of this Node(id={context.node.id.short()})"
+                            f"peer of this Node(id={this_node_id})"
                         )
                     )
                 leader_node_peer = peer.ok()
diff --git a/packages/syft/src/syft/service/queue/queue.py b/packages/syft/src/syft/service/queue/queue.py
index b72fd11b2ac..fb4eb83cf17 100644
--- a/packages/syft/src/syft/service/queue/queue.py
+++ b/packages/syft/src/syft/service/queue/queue.py
@@ -5,6 +5,7 @@
 from typing import Optional
 from typing import Type
 from typing import Union
+from typing import cast
 
 # third party
 import psutil
@@ -146,6 +147,8 @@ def handle_message_multiprocessing(
     # this is a temp hack to prevent some multithreading issues
     time.sleep(0.5)
     queue_config = worker_settings.queue_config
+    if queue_config is None:
+        raise ValueError(f"{worker_settings} has no queue configurations!")
     queue_config.client_config.create_producer = False
     queue_config.client_config.n_consumers = 0
 
@@ -305,7 +308,7 @@ def handle_message(message: bytes, syft_worker_id: UID) -> None:
         queue_item.node_uid = worker.id
 
         job_item.status = JobStatus.PROCESSING
-        job_item.node_uid = worker.id
+        job_item.node_uid = cast(UID, worker.id)
         job_item.updated_at = DateTime.now()
 
         # try:
diff --git a/packages/syft/src/syft/service/queue/queue_stash.py b/packages/syft/src/syft/service/queue/queue_stash.py
index e98641dc83a..34cc3265583 100644
--- a/packages/syft/src/syft/service/queue/queue_stash.py
+++ b/packages/syft/src/syft/service/queue/queue_stash.py
@@ -105,7 +105,7 @@ class QueueItem(SyftObject):
     def __repr__(self) -> str:
         return f"<QueueItem: {self.id}>: {self.status}"
 
-    def _repr_markdown_(self) -> str:
+    def _repr_markdown_(self, wrap_as_python: bool = True, indent: int = 0) -> str:
         return f"<QueueItem: {self.id}>: {self.status}"
 
     @property
diff --git a/packages/syft/src/syft/service/queue/zmq_queue.py b/packages/syft/src/syft/service/queue/zmq_queue.py
index 215dcdfe5c2..a2bc6512dfc 100644
--- a/packages/syft/src/syft/service/queue/zmq_queue.py
+++ b/packages/syft/src/syft/service/queue/zmq_queue.py
@@ -41,6 +41,7 @@
 from ...util.util import get_queue_address
 from ..response import SyftError
 from ..response import SyftSuccess
+from ..service import AbstractService
 from ..worker.worker_pool import ConsumerState
 from ..worker.worker_stash import WorkerStash
 from .base_queue import AbstractMessageHandler
@@ -200,7 +201,7 @@ def close(self) -> None:
             self._stop.clear()
 
     @property
-    def action_service(self) -> Callable:
+    def action_service(self) -> AbstractService:
         if self.auth_context.node is not None:
             return self.auth_context.node.get_service("ActionService")
         else:
@@ -793,7 +794,7 @@ class ZMQClientConfigV1(SyftObject, QueueClientConfig):
     __canonical_name__ = "ZMQClientConfig"
     __version__ = SYFT_OBJECT_VERSION_1
 
-    id: Optional[UID]
+    id: Optional[UID]  # type: ignore[assignment]
     hostname: str = "127.0.0.1"
 
 
@@ -801,7 +802,7 @@ class ZMQClientConfigV2(SyftObject, QueueClientConfig):
     __canonical_name__ = "ZMQClientConfig"
     __version__ = SYFT_OBJECT_VERSION_2
 
-    id: Optional[UID]
+    id: Optional[UID]  # type: ignore[assignment]
     hostname: str = "127.0.0.1"
     queue_port: Optional[int] = None
     # TODO: setting this to false until we can fix the ZMQ
@@ -815,7 +816,7 @@ class ZMQClientConfig(SyftObject, QueueClientConfig):
     __canonical_name__ = "ZMQClientConfig"
     __version__ = SYFT_OBJECT_VERSION_3
 
-    id: Optional[UID]
+    id: Optional[UID]  # type: ignore[assignment]
     hostname: str = "127.0.0.1"
     queue_port: Optional[int] = None
     # TODO: setting this to false until we can fix the ZMQ
diff --git a/packages/syft/src/syft/service/request/request.py b/packages/syft/src/syft/service/request/request.py
index 65f34c542fb..38b97c9cdad 100644
--- a/packages/syft/src/syft/service/request/request.py
+++ b/packages/syft/src/syft/service/request/request.py
@@ -89,7 +89,7 @@ class ChangeStatus(SyftObject):
     __canonical_name__ = "ChangeStatus"
     __version__ = SYFT_OBJECT_VERSION_1
 
-    id: Optional[UID]
+    id: Optional[UID]  # type: ignore[assignment]
     change_id: UID
     applied: bool = False
 
@@ -114,7 +114,7 @@ def _run(
         try:
             if context.node is None:
                 return Err(SyftError(message=f"context {context}'s node is None"))
-            action_service: ActionService = context.node.get_service(ActionService)
+            action_service: ActionService = context.node.get_service(ActionService)  # type: ignore[assignment]
             blob_storage_service = context.node.get_service(BlobStorageService)
             action_store = action_service.store
 
@@ -405,8 +405,10 @@ def _repr_html_(self) -> Any:
                 f"outputs are <strong>shared</strong> with the owners of {owners_string} once computed"
             )
 
-        metadata = api.services.metadata.get_metadata()
-        node_name = api.node_name.capitalize() if api.node_name is not None else ""
+        if api is not None:
+            metadata = api.services.metadata.get_metadata()
+            node_name = api.node_name.capitalize() if api.node_name is not None else ""
+            node_type = metadata.node_type.value.capitalize()
 
         email_str = (
             f"({self.requesting_user_email})" if self.requesting_user_email else ""
@@ -429,7 +431,7 @@ def _repr_html_(self) -> Any:
                 {shared_with_line}
                 <p><strong>Status: </strong>{self.status}</p>
                 <p><strong>Requested on: </strong> {node_name} of type <strong> \
-                    {metadata.node_type.value.capitalize()}</strong></p>
+                    {node_type}</strong></p>
                 <p><strong>Requested by:</strong> {self.requesting_user_name} {email_str} {institution_str}</p>
                 <p><strong>Changes: </strong> {str_changes}</p>
             </div>
@@ -526,8 +528,13 @@ def approve(
             self.node_uid,
             self.syft_client_verify_key,
         )
+        if api is None:
+            return SyftError(message=f"api is None. You must login to {self.node_uid}")
         # TODO: Refactor so that object can also be passed to generate warnings
-        metadata = api.connection.get_node_metadata(api.signing_key)
+        if api.connection:
+            metadata = api.connection.get_node_metadata(api.signing_key)
+        else:
+            metadata = None
         message, is_enclave = None, False
 
         is_code_request = not isinstance(self.codes, SyftError)
@@ -542,13 +549,13 @@ def approve(
 
         if is_enclave:
             message = "On approval, the result will be released to the enclave."
-        elif metadata.node_side_type == NodeSideType.HIGH_SIDE.value:
+        elif metadata and metadata.node_side_type == NodeSideType.HIGH_SIDE.value:
             message = (
                 "You're approving a request on "
                 f"{metadata.node_side_type} side {metadata.node_type} "
                 "which may host datasets with private information."
             )
-        if message and metadata.show_warnings and not disable_warnings:
+        if message and metadata and metadata.show_warnings and not disable_warnings:
             prompt_warning_message(message=message, confirm=True)
 
         print(f"Approving request for domain {api.node_name}")
@@ -567,6 +574,8 @@ def deny(self, reason: str) -> Union[SyftSuccess, SyftError]:
             self.node_uid,
             self.syft_client_verify_key,
         )
+        if api is None:
+            return SyftError(message=f"api is None. You must login to {self.node_uid}")
         return api.services.request.undo(uid=self.id, reason=reason)
 
     def approve_with_client(self, client: SyftClient) -> Result[SyftSuccess, SyftError]:
@@ -640,6 +649,8 @@ def save(self, context: AuthedServiceContext) -> Result[SyftSuccess, SyftError]:
     def _get_latest_or_create_job(self) -> Union[Job, SyftError]:
         """Get the latest job for this requests user_code, or creates one if no jobs exist"""
         api = APIRegistry.api_for(self.node_uid, self.syft_client_verify_key)
+        if api is None:
+            return SyftError(message=f"api is None. You must login to {self.node_uid}")
         job_service = api.services.job
 
         existing_jobs = job_service.get_by_user_code_id(self.code.id)
@@ -664,6 +675,8 @@ def _get_latest_or_create_job(self) -> Union[Job, SyftError]:
 
     def _is_action_object_from_job(self, action_object: ActionObject) -> Optional[Job]:  # type: ignore
         api = APIRegistry.api_for(self.node_uid, self.syft_client_verify_key)
+        if api is None:
+            raise ValueError(f"Can't access the api. You must login to {self.node_uid}")
         job_service = api.services.job
         existing_jobs = job_service.get_by_user_code_id(self.code.id)
         for job in existing_jobs:
@@ -717,8 +730,11 @@ def accept_by_depositing_result(
 
         api = APIRegistry.api_for(self.node_uid, self.syft_client_verify_key)
         if not api:
-            raise Exception(f"Login to {self.node_uid} first.")
-
+            raise Exception(
+                f"No access to Syft API. Please login to {self.node_uid} first."
+            )
+        if api.signing_key is None:
+            raise ValueError(f"{api}'s signing key is None")
         is_approved = user_code_status_change.approved
 
         permission_request = self.approve(approve_nested=True)
@@ -840,7 +856,6 @@ def accept_by_depositing_result(
         )
         job.apply_info(job_info)
 
-        api = APIRegistry.api_for(self.node_uid, self.syft_client_verify_key)
         job_service = api.services.job
         res = job_service.update(job)
         if isinstance(res, SyftError):
@@ -856,7 +871,11 @@ def sync_job(
                 message="This JobInfo includes a Result. Please use Request.accept_by_depositing_result instead."
             )
 
-        api = APIRegistry.api_for(self.node_uid, self.syft_client_verify_key)
+        api = APIRegistry.api_for(
+            node_uid=self.node_uid, user_verify_key=self.syft_client_verify_key
+        )
+        if api is None:
+            return SyftError(message=f"api is None. You must login to {self.node_uid}")
         job_service = api.services.job
 
         job = self._get_latest_or_create_job()
@@ -905,6 +924,9 @@ class SubmitRequest(SyftObject):
 
 
 def hash_changes(context: TransformContext) -> TransformContext:
+    if context.output is None:
+        return context
+
     request_time = context.output["request_time"]
     key = context.output["requesting_user_verify_key"]
     changes = context.output["changes"]
@@ -917,38 +939,44 @@ def hash_changes(context: TransformContext) -> TransformContext:
     final_hash = hashlib.sha256(time_hash + key_hash + changes_hash).hexdigest()
 
     context.output["request_hash"] = final_hash
+
     return context
 
 
 def add_request_time(context: TransformContext) -> TransformContext:
-    context.output["request_time"] = DateTime.now()
+    if context.output is not None:
+        context.output["request_time"] = DateTime.now()
     return context
 
 
 def check_requesting_user_verify_key(context: TransformContext) -> TransformContext:
-    if context.obj.requesting_user_verify_key and context.node.is_root(
-        context.credentials
-    ):
-        context.output[
-            "requesting_user_verify_key"
-        ] = context.obj.requesting_user_verify_key
-    else:
-        context.output["requesting_user_verify_key"] = context.credentials
+    if context.output and context.node and context.obj:
+        if context.obj.requesting_user_verify_key and context.node.is_root(
+            context.credentials
+        ):
+            context.output[
+                "requesting_user_verify_key"
+            ] = context.obj.requesting_user_verify_key
+        else:
+            context.output["requesting_user_verify_key"] = context.credentials
+
     return context
 
 
 def add_requesting_user_info(context: TransformContext) -> TransformContext:
-    try:
-        user_key = context.output["requesting_user_verify_key"]
-        user_service = context.node.get_service("UserService")
-        user = user_service.get_by_verify_key(user_key)
-        context.output["requesting_user_name"] = user.name
-        context.output["requesting_user_email"] = user.email
-        context.output["requesting_user_institution"] = (
-            user.institution if user.institution else ""
-        )
-    except Exception:
-        context.output["requesting_user_name"] = "guest_user"
+    if context.output is not None and context.node is not None:
+        try:
+            user_key = context.output["requesting_user_verify_key"]
+            user_service = context.node.get_service("UserService")
+            user = user_service.get_by_verify_key(user_key)
+            context.output["requesting_user_name"] = user.name
+            context.output["requesting_user_email"] = user.email
+            context.output["requesting_user_institution"] = (
+                user.institution if user.institution else ""
+            )
+        except Exception:
+            context.output["requesting_user_name"] = "guest_user"
+
     return context
 
 
@@ -1184,7 +1212,7 @@ def __repr_syft_nested__(self) -> str:
             msg += ". Nested Requests not resolved"
         return msg
 
-    def _repr_markdown_(self) -> str:
+    def _repr_markdown_(self, wrap_as_python: bool = True, indent: int = 0) -> str:
         code = self.code
         input_policy_type = (
             code.input_policy_type.__canonical_name__
diff --git a/packages/syft/src/syft/service/service.py b/packages/syft/src/syft/service/service.py
index fa9a233e9fe..42f65aeafe5 100644
--- a/packages/syft/src/syft/service/service.py
+++ b/packages/syft/src/syft/service/service.py
@@ -10,6 +10,7 @@
 from typing import List
 from typing import Optional
 from typing import Set
+from typing import TYPE_CHECKING
 from typing import Tuple
 from typing import Type
 from typing import Union
@@ -46,6 +47,10 @@
 from .user.user_roles import ServiceRole
 from .warnings import APIEndpointWarning
 
+if TYPE_CHECKING:
+    # relative
+    from ..client.api import APIModule
+
 TYPE_TO_SERVICE: dict = {}
 SERVICE_TO_TYPES: defaultdict = defaultdict(set)
 
@@ -77,6 +82,9 @@ def resolve_link(
             obj = Ok(obj)
         return obj
 
+    def get_all(*arg: Any, **kwargs: Any) -> Any:
+        pass
+
 
 @serializable()
 class BaseConfig(SyftBaseObject):
@@ -439,7 +447,7 @@ def from_api_or_context(
     func_or_path: str,
     syft_node_location: Optional[UID] = None,
     syft_client_verify_key: Optional[SyftVerifyKey] = None,
-) -> Optional[Union[Callable, SyftError, partial]]:
+) -> Optional[Union["APIModule", SyftError, partial]]:
     # relative
     from ..client.api import APIRegistry
     from ..node.node import AuthNodeContextRegistry
@@ -464,7 +472,7 @@ def from_api_or_context(
         node_uid=syft_node_location,
         user_verify_key=syft_client_verify_key,
     )
-    if node_context is not None:
+    if node_context is not None and node_context.node is not None:
         user_config_registry = UserServiceConfigRegistry.from_role(
             node_context.role,
         )
diff --git a/packages/syft/src/syft/service/settings/migrations.py b/packages/syft/src/syft/service/settings/migrations.py
index 42ac9935bb7..f31b74110fa 100644
--- a/packages/syft/src/syft/service/settings/migrations.py
+++ b/packages/syft/src/syft/service/settings/migrations.py
@@ -11,7 +11,8 @@
 
 def set_from_node_to_key(node_attr: str, key: str) -> Callable:
     def extract_from_node(context: TransformContext) -> TransformContext:
-        context.output[key] = getattr(context.node, node_attr)
+        if context.output is not None:
+            context.output[key] = getattr(context.node, node_attr)
         return context
 
     return extract_from_node
diff --git a/packages/syft/src/syft/service/settings/settings_stash.py b/packages/syft/src/syft/service/settings/settings_stash.py
index 35aa58486e8..fb2f2bb9582 100644
--- a/packages/syft/src/syft/service/settings/settings_stash.py
+++ b/packages/syft/src/syft/service/settings/settings_stash.py
@@ -1,5 +1,6 @@
 # stdlib
 from typing import List
+from typing import Optional
 
 # third party
 from result import Result
@@ -13,6 +14,7 @@
 from ...store.document_store import PartitionSettings
 from ...types.uid import UID
 from ...util.telemetry import instrument
+from ..action.action_permissions import ActionObjectPermission
 from .settings import NodeSettingsV2
 
 NamePartitionKey = PartitionKey(key="name", type_=str)
@@ -31,7 +33,11 @@ def __init__(self, store: DocumentStore) -> None:
         super().__init__(store=store)
 
     def set(
-        self, credentials: SyftVerifyKey, settings: NodeSettingsV2
+        self,
+        credentials: SyftVerifyKey,
+        settings: NodeSettingsV2,
+        add_permissions: Optional[List[ActionObjectPermission]] = None,
+        ignore_duplicates: bool = False,
     ) -> Result[NodeSettingsV2, str]:
         res = self.check_type(settings, self.object_type)
         # we dont use and_then logic here as it is hard because of the order of the arguments
@@ -40,7 +46,10 @@ def set(
         return super().set(credentials=credentials, obj=res.ok())
 
     def update(
-        self, credentials: SyftVerifyKey, settings: NodeSettingsV2
+        self,
+        credentials: SyftVerifyKey,
+        settings: NodeSettingsV2,
+        has_permission: bool = False,
     ) -> Result[NodeSettingsV2, str]:
         res = self.check_type(settings, self.object_type)
         # we dont use and_then logic here as it is hard because of the order of the arguments
diff --git a/packages/syft/src/syft/service/sync/diff_state.py b/packages/syft/src/syft/service/sync/diff_state.py
index 54beb360d41..5fdf2ee6761 100644
--- a/packages/syft/src/syft/service/sync/diff_state.py
+++ b/packages/syft/src/syft/service/sync/diff_state.py
@@ -174,13 +174,13 @@ class ObjectDiff(SyftObject):  # StateTuple (compare 2 objects)
     @classmethod
     def from_objects(
         cls,
-        low_obj: SyftObject,
-        high_obj: SyftObject,
+        low_obj: Optional[SyftObject],
+        high_obj: Optional[SyftObject],
         low_permissions: List[ActionObjectPermission],
         high_permissions: List[ActionObjectPermission],
     ) -> "ObjectDiff":
         if low_obj is None and high_obj is None:
-            raise Exception("Both objects are None")
+            raise ValueError("Both low and high objects are None")
         obj_type = type(low_obj if low_obj is not None else high_obj)
 
         if low_obj is None or high_obj is None:
@@ -218,7 +218,7 @@ def object_id(self) -> UID:
         return uid
 
     @property
-    def non_empty_object(self) -> SyftObject:
+    def non_empty_object(self) -> Optional[SyftObject]:
         return self.low_obj or self.high_obj
 
     @property
@@ -271,6 +271,7 @@ def diff_side_str(self, side: str) -> str:
         return res
 
     def state_str(self, side: str) -> str:
+        other_obj: Optional[SyftObject] = None
         if side == "high":
             obj = self.high_obj
             other_obj = self.low_obj
@@ -286,7 +287,7 @@ def state_str(self, side: str) -> str:
         if isinstance(obj, ActionObject):
             return obj.__repr__()
 
-        if other_obj is None:
+        if other_obj is None:  # type: ignore[unreachable]
             attrs_str = ""
             attrs = getattr(obj, "__repr_attrs__", [])
             for attr in attrs:
@@ -306,7 +307,7 @@ def state_str(self, side: str) -> str:
 
         return attr_text
 
-    def get_obj(self) -> SyftObject:
+    def get_obj(self) -> Optional[SyftObject]:
         if self.status == "NEW":
             return self.low_obj if self.low_obj is not None else self.high_obj
         else:
@@ -416,7 +417,7 @@ class ObjectDiffBatch(SyftObject):
     @property
     def visual_hierarchy(self) -> Tuple[Type, dict]:
         # Returns
-        root_obj = (
+        root_obj: Union[Request, UserCodeStatusCollection, ExecutionOutput, Any] = (
             self.root.low_obj if self.root.low_obj is not None else self.root.high_obj
         )
         if isinstance(root_obj, Request):
@@ -459,8 +460,8 @@ def __repr__(self) -> str:
 {self.hierarchy_str('high')}
 """
 
-    def _repr_markdown_(self) -> None:
-        return None  # Turns off the _repr_markdown_ of SyftObject
+    def _repr_markdown_(self, wrap_as_python: bool = True, indent: int = 0) -> str:
+        return ""  # Turns off the _repr_markdown_ of SyftObject
 
     def _get_visual_hierarchy(self, node: ObjectDiff) -> dict[ObjectDiff, dict]:
         _, child_types_map = self.visual_hierarchy
@@ -681,7 +682,7 @@ def _build_hierarchy_helper(
         return hierarchies
 
     def objs_to_sync(self) -> List[SyftObject]:
-        objs = []
+        objs: list[SyftObject] = []
         for diff in self.diffs:
             if diff.status == "NEW":
                 objs.append(diff.get_obj())
diff --git a/packages/syft/src/syft/service/sync/sync_service.py b/packages/syft/src/syft/service/sync/sync_service.py
index e78c1a7d503..d25c2904e11 100644
--- a/packages/syft/src/syft/service/sync/sync_service.py
+++ b/packages/syft/src/syft/service/sync/sync_service.py
@@ -5,11 +5,13 @@
 from typing import List
 from typing import Set
 from typing import Union
+from typing import cast
 
 # third party
 from result import Result
 
 # relative
+from ...abstract_node import AbstractNode
 from ...client.api import NodeIdentity
 from ...node.credentials import SyftVerifyKey
 from ...serde.serializable import serializable
@@ -166,7 +168,7 @@ def sync_items(
                     context, item, other_node_permissions
                 )
             else:
-                item = self.transform_item(context, item)
+                item = self.transform_item(context, item)  # type: ignore[unreachable]
                 res = self.set_object(context, item)
 
                 if res.is_ok():
@@ -212,7 +214,7 @@ def get_state(
     ) -> Union[SyncState, SyftError]:
         new_state = SyncState()
 
-        node = context.node
+        node = cast(AbstractNode, context.node)
 
         services_to_sync = [
             "projectservice",
@@ -225,7 +227,7 @@ def get_state(
         ]
 
         for service_name in services_to_sync:
-            service = node.get_service(service_name)  # type: ignore
+            service = node.get_service(service_name)
             items = service.get_all(context)
             new_state.add_objects(items, api=node.root_client.api)  # type: ignore
 
diff --git a/packages/syft/src/syft/service/user/user.py b/packages/syft/src/syft/service/user/user.py
index 71a07d2dfb0..d6c0c3c2124 100644
--- a/packages/syft/src/syft/service/user/user.py
+++ b/packages/syft/src/syft/service/user/user.py
@@ -6,6 +6,7 @@
 from typing import List
 from typing import Optional
 from typing import Tuple
+from typing import Type
 from typing import Union
 
 # third party
@@ -62,7 +63,7 @@ class User(SyftObject):
     __canonical_name__ = "User"
     __version__ = SYFT_OBJECT_VERSION_2
 
-    id: Optional[UID]
+    id: Optional[UID]  # type: ignore[assignment]
 
     @pydantic.validator("email", pre=True, always=True)
     def make_email(cls, v: EmailStr) -> EmailStr:
@@ -93,6 +94,9 @@ def default_role(role: ServiceRole) -> Callable:
 
 
 def hash_password(context: TransformContext) -> TransformContext:
+    if context.output is None:
+        return context
+
     if context.output["password"] is not None and (
         (context.output["password_verify"] is None)
         or context.output["password"] == context.output["password_verify"]
@@ -100,13 +104,16 @@ def hash_password(context: TransformContext) -> TransformContext:
         salt, hashed = salt_and_hash_password(context.output["password"], 12)
         context.output["hashed_password"] = hashed
         context.output["salt"] = salt
+
     return context
 
 
 def generate_key(context: TransformContext) -> TransformContext:
-    signing_key = SyftSigningKey.generate()
-    context.output["signing_key"] = signing_key
-    context.output["verify_key"] = signing_key.verify_key
+    if context.output is not None:
+        signing_key = SyftSigningKey.generate()
+        context.output["signing_key"] = signing_key
+        context.output["verify_key"] = signing_key.verify_key
+
     return context
 
 
@@ -175,7 +182,7 @@ class UserCreateV1(UserUpdateV1):
     role: Optional[ServiceRole] = None  # type: ignore[assignment]
     password: str
     password_verify: Optional[str] = None  # type: ignore[assignment]
-    verify_key: Optional[SyftVerifyKey]
+    verify_key: Optional[SyftVerifyKey]  # type: ignore[assignment]
     institution: Optional[str]  # type: ignore[assignment]
     website: Optional[str]  # type: ignore[assignment]
     created_by: Optional[SyftSigningKey]
@@ -191,7 +198,7 @@ class UserCreate(UserUpdate):
     role: Optional[ServiceRole] = None  # type: ignore[assignment]
     password: str
     password_verify: Optional[str] = None  # type: ignore[assignment]
-    verify_key: Optional[SyftVerifyKey]
+    verify_key: Optional[SyftVerifyKey]  # type: ignore[assignment]
     institution: Optional[str]  # type: ignore[assignment]
     website: Optional[str]  # type: ignore[assignment]
     created_by: Optional[SyftSigningKey]
@@ -252,8 +259,7 @@ def _set_password(self, new_password: str) -> Union[SyftError, SyftSuccess]:
         )
         if api is None:
             return SyftError(message=f"You must login to {self.node_uid}")
-        if api.services is None:
-            return SyftError(message=f"Services for api {api} is None")
+
         api.services.user.update(
             uid=self.id, user_update=UserUpdate(password=new_password)
         )
@@ -290,8 +296,6 @@ def set_email(self, email: str) -> Union[SyftSuccess, SyftError]:
         except ValidationError:
             return SyftError(message="{email} is not a valid email address.")
 
-        if api.services is None:
-            return SyftError(message=f"Services for {api} is None")
         result = api.services.user.update(uid=self.id, user_update=user_update)
 
         if isinstance(result, SyftError):
@@ -305,11 +309,11 @@ def set_email(self, email: str) -> Union[SyftSuccess, SyftError]:
 
     def update(
         self,
-        name: Union[Empty, str] = Empty,
-        institution: Union[Empty, str] = Empty,
-        website: Union[str, Empty] = Empty,
-        role: Union[str, Empty] = Empty,
-        mock_execution_permission: Union[bool, Empty] = Empty,
+        name: Union[Type[Empty], str] = Empty,
+        institution: Union[Type[Empty], str] = Empty,
+        website: Union[Type[Empty], str] = Empty,
+        role: Union[Type[Empty], str] = Empty,
+        mock_execution_permission: Union[Type[Empty], bool] = Empty,
     ) -> Union[SyftSuccess, SyftError]:
         """Used to update name, institution, website of a user."""
         api = APIRegistry.api_for(
@@ -325,8 +329,6 @@ def update(
             role=role,
             mock_execution_permission=mock_execution_permission,
         )
-        if api.services is None:
-            return SyftError(message=f"Services for {api} is None")
         result = api.services.user.update(uid=self.id, user_update=user_update)
 
         if isinstance(result, SyftError):
diff --git a/packages/syft/src/syft/service/user/user_service.py b/packages/syft/src/syft/service/user/user_service.py
index e46273c4197..d8c08615ee3 100644
--- a/packages/syft/src/syft/service/user/user_service.py
+++ b/packages/syft/src/syft/service/user/user_service.py
@@ -225,12 +225,12 @@ def get_current_user(
     def update(
         self, context: AuthedServiceContext, uid: UID, user_update: UserUpdate
     ) -> Union[UserView, SyftError]:
-        updates_role = user_update.role is not Empty
+        updates_role = user_update.role is not Empty  # type: ignore[comparison-overlap]
         can_edit_roles = ServiceRoleCapability.CAN_EDIT_ROLES in context.capabilities()
 
         if updates_role and not can_edit_roles:
             return SyftError(message=f"{context.role} is not allowed to edit roles")
-        if (user_update.mock_execution_permission is not Empty) and not can_edit_roles:
+        if (user_update.mock_execution_permission is not Empty) and not can_edit_roles:  # type: ignore[comparison-overlap]
             return SyftError(
                 message=f"{context.role} is not allowed to update permissions"
             )
diff --git a/packages/syft/src/syft/service/warnings.py b/packages/syft/src/syft/service/warnings.py
index 553531046a8..10038d2026e 100644
--- a/packages/syft/src/syft/service/warnings.py
+++ b/packages/syft/src/syft/service/warnings.py
@@ -1,6 +1,7 @@
 # stdlib
 from typing import Any
 from typing import Optional
+from typing import cast
 
 # third party
 from IPython.display import display
@@ -10,6 +11,7 @@
 # relative
 from ..abstract_node import AbstractNode
 from ..abstract_node import NodeSideType
+from ..abstract_node import NodeType
 from ..node.credentials import SyftCredentials
 from ..serde.serializable import serializable
 from ..types.base import SyftBaseModel
@@ -75,17 +77,19 @@ def message_from(self, context: Optional[WarningContext] = None) -> Self:
         if context is not None:
             node = context.node
             if node is not None:
-                node_side_type = node.node_side_type
+                node_side_type = cast(NodeSideType, node.node_side_type)
                 node_type = node.node_type
+
                 _msg = (
                     "which could host datasets with private information."
                     if node_side_type.value == NodeSideType.HIGH_SIDE.value
                     else "which only hosts mock or synthetic data."
                 )
-                message = (
-                    "You're performing an operation on "
-                    f"{node_side_type.value} side {node_type.value}, {_msg}"
-                )
+                if node_type is not None:
+                    message = (
+                        "You're performing an operation on "
+                        f"{node_side_type.value} side {node_type.value}, {_msg}"
+                    )
                 confirmation = node_side_type.value == NodeSideType.HIGH_SIDE.value
 
         return CRUDWarning(confirmation=confirmation, message=message)
@@ -101,17 +105,19 @@ def message_from(self, context: Optional[WarningContext] = None) -> Self:
         if context is not None:
             node = context.node
             if node is not None:
-                node_side_type = node.node_side_type
+                node_side_type = cast(NodeSideType, node.node_side_type)
                 node_type = node.node_type
+
                 _msg = (
                     "which could host datasets with private information."
                     if node_side_type.value == NodeSideType.HIGH_SIDE.value
                     else "which only hosts mock or synthetic data."
                 )
-                message = (
-                    "You're performing an operation on "
-                    f"{node_side_type.value} side {node_type.value}, {_msg}"
-                )
+                if node_type is not None:
+                    message = (
+                        "You're performing an operation on "
+                        f"{node_side_type.value} side {node_type.value}, {_msg}"
+                    )
 
         return CRUDReminder(confirmation=confirmation, message=message)
 
@@ -124,8 +130,8 @@ def message_from(self, context: Optional[WarningContext] = None) -> Self:
         if context is not None:
             node = context.node
             if node is not None:
-                node_side_type = node.node_side_type
-                node_type = node.node_type
+                node_side_type = cast(NodeSideType, node.node_side_type)
+                node_type = cast(NodeType, node.node_type)
                 if node_side_type.value == NodeSideType.LOW_SIDE.value:
                     message = (
                         "You're performing an operation on "
@@ -144,8 +150,8 @@ def message_from(self, context: Optional[WarningContext] = None) -> Self:
         if context is not None:
             node = context.node
             if node is not None:
-                node_side_type = node.node_side_type
-                node_type = node.node_type
+                node_side_type = cast(NodeSideType, node.node_side_type)
+                node_type = cast(NodeType, node.node_type)
                 if node_side_type.value == NodeSideType.HIGH_SIDE.value:
                     message = (
                         "You're performing an operation on "
diff --git a/packages/syft/src/syft/service/worker/image_registry_service.py b/packages/syft/src/syft/service/worker/image_registry_service.py
index 8acbd9e6f4b..bf4a111a282 100644
--- a/packages/syft/src/syft/service/worker/image_registry_service.py
+++ b/packages/syft/src/syft/service/worker/image_registry_service.py
@@ -62,7 +62,7 @@ def add(
     def delete(
         self,
         context: AuthedServiceContext,
-        uid: UID = None,
+        uid: Optional[UID] = None,
         url: Optional[str] = None,
     ) -> Union[SyftSuccess, SyftError]:
         # TODO - we need to make sure that there are no workers running an image bound to this registry
diff --git a/packages/syft/src/syft/service/worker/utils.py b/packages/syft/src/syft/service/worker/utils.py
index d9d467f8b7b..4be1ee1ff61 100644
--- a/packages/syft/src/syft/service/worker/utils.py
+++ b/packages/syft/src/syft/service/worker/utils.py
@@ -430,7 +430,7 @@ def run_workers_in_kubernetes(
 
     # create worker object
     for pod in pool_pods:
-        status = runner.get_pod_status(pod)
+        status: Optional[Union[PodStatus, WorkerStatus]] = runner.get_pod_status(pod)
         status, healthcheck, error = map_pod_to_worker_status(status)
 
         # this worker id will be the same as the one in the worker
diff --git a/packages/syft/src/syft/service/worker/worker_image_service.py b/packages/syft/src/syft/service/worker/worker_image_service.py
index 9359fffce58..0c737c2d799 100644
--- a/packages/syft/src/syft/service/worker/worker_image_service.py
+++ b/packages/syft/src/syft/service/worker/worker_image_service.py
@@ -94,7 +94,7 @@ def build(
 
         if registry_uid:
             # get registry from image registry service
-            image_registry_service: SyftImageRegistryService = context.node.get_service(
+            image_registry_service: AbstractService = context.node.get_service(
                 SyftImageRegistryService
             )
             registry_result = image_registry_service.get_by_id(context, registry_uid)
diff --git a/packages/syft/src/syft/service/worker/worker_pool.py b/packages/syft/src/syft/service/worker/worker_pool.py
index 13c1cf1c158..947571cde2e 100644
--- a/packages/syft/src/syft/service/worker/worker_pool.py
+++ b/packages/syft/src/syft/service/worker/worker_pool.py
@@ -86,8 +86,6 @@ def logs(self) -> Union[str, SyftError]:
         )
         if api is None:
             return SyftError(message=f"You must login to {self.node_uid}")
-        if api.services is None:
-            return SyftError(message=f"Services for {api} is None")
         return api.services.worker.logs(uid=self.id)
 
     def get_job_repr(self) -> str:
@@ -98,8 +96,6 @@ def get_job_repr(self) -> str:
             )
             if api is None:
                 return SyftError(message=f"You must login to {self.node_uid}")
-            if api.services is None:
-                return f"Services for api {api} is None"
             job = api.services.job.get(self.job_id)
             if job.action.user_code_id is not None:
                 func_name = api.services.code.get_by_id(
@@ -118,8 +114,6 @@ def refresh_status(self) -> Optional[SyftError]:
         )
         if api is None:
             return SyftError(message=f"You must login to {self.node_uid}")
-        if api.services is None:
-            return SyftError(message=f"Services for {api} is None")
 
         res = api.services.worker.status(uid=self.id)
         if isinstance(res, SyftError):
@@ -187,7 +181,7 @@ def image(self) -> Optional[Union[SyftWorkerImage, SyftError]]:
             return None
 
     @property
-    def running_workers(self) -> Union[List[UID], SyftError]:
+    def running_workers(self) -> Union[List[SyftWorker], SyftError]:
         """Query the running workers using an API call to the server"""
         _running_workers = []
         for worker in self.workers:
@@ -197,7 +191,7 @@ def running_workers(self) -> Union[List[UID], SyftError]:
         return _running_workers
 
     @property
-    def healthy_workers(self) -> Union[List[UID], SyftError]:
+    def healthy_workers(self) -> Union[List[SyftWorker], SyftError]:
         """
         Query the healthy workers using an API call to the server
         """
@@ -255,7 +249,7 @@ def workers(self) -> List[SyftWorker]:
         resolved_workers = []
         for worker in self.worker_list:
             resolved_worker = worker.resolve
-            if resolved_worker is None:
+            if isinstance(resolved_worker, SyftError) or resolved_worker is None:
                 continue
             resolved_worker.refresh_status()
             resolved_workers.append(resolved_worker)
diff --git a/packages/syft/src/syft/service/worker/worker_pool_service.py b/packages/syft/src/syft/service/worker/worker_pool_service.py
index b1e198e4602..cdd2f83aa35 100644
--- a/packages/syft/src/syft/service/worker/worker_pool_service.py
+++ b/packages/syft/src/syft/service/worker/worker_pool_service.py
@@ -117,7 +117,7 @@ def launch(
 
         worker_image: SyftWorkerImage = result.ok()
         context.node = cast(AbstractNode, context.node)
-        worker_service: WorkerService = context.node.get_service("WorkerService")
+        worker_service: AbstractService = context.node.get_service("WorkerService")
         worker_stash = worker_service.stash
 
         # Create worker pool from given image, with the given worker pool
@@ -406,7 +406,7 @@ def add_workers(
         worker_image: SyftWorkerImage = result.ok()
 
         context.node = cast(AbstractNode, context.node)
-        worker_service: WorkerService = context.node.get_service("WorkerService")
+        worker_service: AbstractService = context.node.get_service("WorkerService")
         worker_stash = worker_service.stash
 
         # Add workers to given pool from the given image
@@ -586,7 +586,7 @@ def sync_pool_from_request(
                 pool_name = change.pool_name
                 num_workers = change.num_workers
                 image_uid = change.image_uid
-            elif isinstance(change, CreateCustomImageChange):
+            elif isinstance(change, CreateCustomImageChange):  # type: ignore[unreachable]
                 config = change.config
                 tag = change.tag
 
@@ -598,7 +598,7 @@ def sync_pool_from_request(
                 image_uid=image_uid,
             )
         elif config is not None:
-            return self.create_image_and_pool_request(
+            return self.create_image_and_pool_request(  # type: ignore[unreachable]
                 context=context,
                 pool_name=pool_name,
                 num_workers=num_workers,
@@ -699,7 +699,7 @@ def _create_workers_in_pool(
         )
 
         if isinstance(result, OkErr):
-            node = cast(AbstractNode, context.node)
+            node = context.node
             if result.is_ok():
                 worker_obj = LinkedObject.from_obj(
                     obj=result.ok(),
diff --git a/packages/syft/src/syft/service/worker/worker_service.py b/packages/syft/src/syft/service/worker/worker_service.py
index 2002302a28a..86db5af2329 100644
--- a/packages/syft/src/syft/service/worker/worker_service.py
+++ b/packages/syft/src/syft/service/worker/worker_service.py
@@ -14,6 +14,7 @@
 # relative
 from ...abstract_node import AbstractNode
 from ...custom_worker.k8s import IN_KUBERNETES
+from ...custom_worker.k8s import PodStatus
 from ...custom_worker.runner_k8s import KubernetesRunner
 from ...node.credentials import SyftVerifyKey
 from ...serde.serializable import serializable
@@ -68,14 +69,14 @@ def start_workers(
     @service_method(
         path="worker.get_all", name="get_all", roles=DATA_SCIENTIST_ROLE_LEVEL
     )
-    def list(self, context: AuthedServiceContext) -> Union[SyftSuccess, SyftError]:
+    def list(self, context: AuthedServiceContext) -> Union[list[SyftWorker], SyftError]:
         """List all the workers."""
         result = self.stash.get_all(context.credentials)
 
         if result.is_err():
             return SyftError(message=f"Failed to fetch workers. {result.err()}")
 
-        workers: List[SyftWorker] = result.ok()
+        workers: list[SyftWorker] = result.ok()
 
         if context.node is not None and context.node.in_memory_workers:
             return workers
@@ -172,8 +173,8 @@ def delete(
         # relative
         from .worker_pool_service import SyftWorkerPoolService
 
-        worker_pool_service: SyftWorkerPoolService = context.node.get_service(
-            "SyftWorkerPoolService"
+        worker_pool_service: AbstractService = context.node.get_service(
+            SyftWorkerPoolService
         )
         worker_pool_stash = worker_pool_service.stash
         result = worker_pool_stash.get_by_name(
@@ -256,7 +257,7 @@ def refresh_worker_status(
     workers: List[SyftWorker],
     worker_stash: WorkerStash,
     credentials: SyftVerifyKey,
-) -> List[SyftWorker]:
+) -> list[SyftWorker]:
     if IN_KUBERNETES:
         result = refresh_status_kubernetes(workers)
     else:
@@ -282,7 +283,9 @@ def refresh_status_kubernetes(workers: List[SyftWorker]) -> List[SyftWorker]:
     updated_workers = []
     runner = KubernetesRunner()
     for worker in workers:
-        status = runner.get_pod_status(pod_name=worker.name)
+        status: Optional[Union[PodStatus, WorkerStatus]] = runner.get_pod_status(
+            pod=worker.name
+        )
         if not status:
             return SyftError(message=f"Pod does not exist. name={worker.name}")
         status, health, _ = map_pod_to_worker_status(status)
diff --git a/packages/syft/src/syft/store/blob_storage/__init__.py b/packages/syft/src/syft/store/blob_storage/__init__.py
index bb86b6ef25a..fb75e5f8e8a 100644
--- a/packages/syft/src/syft/store/blob_storage/__init__.py
+++ b/packages/syft/src/syft/store/blob_storage/__init__.py
@@ -42,8 +42,12 @@
 
 
 # stdlib
+from io import BytesIO
 import os
 from pathlib import Path
+from typing import Any
+from typing import Callable
+from typing import Generator
 from typing import Optional
 from typing import Type
 from typing import Union
@@ -101,14 +105,14 @@ class BlobRetrieval(SyftObject):
 
 
 @migrate(BlobRetrieval, BlobRetrievalV1)
-def downgrade_blobretrieval_v2_to_v1():
+def downgrade_blobretrieval_v2_to_v1() -> list[Callable]:
     return [
         drop(["syft_blob_storage_entry_id", "file_size"]),
     ]
 
 
 @migrate(BlobRetrievalV1, BlobRetrieval)
-def upgrade_blobretrieval_v1_to_v2():
+def upgrade_blobretrieval_v1_to_v2() -> list[Callable]:
     return [
         make_set_default("syft_blob_storage_entry_id", None),
         make_set_default("file_size", 1),
@@ -131,7 +135,9 @@ class SyftObjectRetrieval(BlobRetrieval):
     syft_object: bytes
     path: Path
 
-    def _read_data(self, stream=False, _deserialize=True, **kwargs):
+    def _read_data(
+        self, stream: bool = False, _deserialize: bool = True, **kwargs: Any
+    ) -> Any:
         # development setup, we can access the same filesystem
         if os.access(self.path, os.R_OK) and self.path.is_file():
             with open(self.path, "rb") as fp:
@@ -151,19 +157,19 @@ def _read_data(self, stream=False, _deserialize=True, **kwargs):
         else:
             return res
 
-    def read(self, _deserialize=True) -> Union[SyftObject, SyftError]:
+    def read(self, _deserialize: bool = True) -> Union[SyftObject, SyftError]:
         return self._read_data(_deserialize=_deserialize)
 
 
 @migrate(SyftObjectRetrieval, SyftObjectRetrievalV2)
-def downgrade_syftobjretrival_v3_to_v2():
+def downgrade_syftobjretrival_v3_to_v2() -> list[Callable]:
     return [
         drop(["path"]),
     ]
 
 
 @migrate(SyftObjectRetrievalV2, SyftObjectRetrieval)
-def upgrade_syftobjretrival_v2_to_v3():
+def upgrade_syftobjretrival_v2_to_v3() -> list[Callable]:
     return [
         make_set_default("path", Path("")),
     ]
@@ -177,8 +183,11 @@ class BlobRetrievalByURLV1(BlobRetrievalV1):
 
 
 def syft_iter_content(
-    blob_url, chunk_size, max_retries=MAX_RETRIES, timeout=DEFAULT_TIMEOUT
-):
+    blob_url: Union[str, GridURL],
+    chunk_size: int,
+    max_retries: int = MAX_RETRIES,
+    timeout: int = DEFAULT_TIMEOUT,
+) -> Generator:
     """custom iter content with smart retries (start from last byte read)"""
     current_byte = 0
     for attempt in range(max_retries):
@@ -231,7 +240,13 @@ def read(self) -> Union[SyftObject, SyftError]:
         else:
             return self._read_data()
 
-    def _read_data(self, stream=False, chunk_size=DEFAULT_CHUNK_SIZE, *args, **kwargs):
+    def _read_data(
+        self,
+        stream: bool = False,
+        chunk_size: int = DEFAULT_CHUNK_SIZE,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Any:
         # relative
         from ...client.api import APIRegistry
 
@@ -239,7 +254,7 @@ def _read_data(self, stream=False, chunk_size=DEFAULT_CHUNK_SIZE, *args, **kwarg
             node_uid=self.syft_node_location,
             user_verify_key=self.syft_client_verify_key,
         )
-        if api is not None and isinstance(self.url, GridURL):
+        if api and api.connection and isinstance(self.url, GridURL):
             blob_url = api.connection.to_blob_route(
                 self.url.url_path, host=self.url.host_or_ip
             )
@@ -262,14 +277,14 @@ def _read_data(self, stream=False, chunk_size=DEFAULT_CHUNK_SIZE, *args, **kwarg
 
 
 @migrate(BlobRetrievalByURLV2, BlobRetrievalByURLV1)
-def downgrade_blobretrivalbyurl_v2_to_v1():
+def downgrade_blobretrivalbyurl_v2_to_v1() -> list[Callable]:
     return [
         drop(["syft_blob_storage_entry_id", "file_size"]),
     ]
 
 
 @migrate(BlobRetrievalByURLV1, BlobRetrievalByURLV2)
-def upgrade_blobretrivalbyurl_v1_to_v2():
+def upgrade_blobretrivalbyurl_v1_to_v2() -> list[Callable]:
     return [
         make_set_default("syft_blob_storage_entry_id", None),
         make_set_default("file_size", 1),
@@ -277,14 +292,14 @@ def upgrade_blobretrivalbyurl_v1_to_v2():
 
 
 @migrate(BlobRetrievalByURL, BlobRetrievalByURLV2)
-def downgrade_blobretrivalbyurl_v3_to_v2():
+def downgrade_blobretrivalbyurl_v3_to_v2() -> list[Callable]:
     return [
         str_url_to_grid_url,
     ]
 
 
 @migrate(BlobRetrievalByURLV2, BlobRetrievalByURL)
-def upgrade_blobretrivalbyurl_v2_to_v3():
+def upgrade_blobretrivalbyurl_v2_to_v3() -> list[Callable]:
     return []
 
 
@@ -295,8 +310,8 @@ class BlobDeposit(SyftObject):
 
     blob_storage_entry_id: UID
 
-    def write(self, data: bytes) -> Union[SyftSuccess, SyftError]:
-        pass
+    def write(self, data: BytesIO) -> Union[SyftSuccess, SyftError]:
+        raise NotImplementedError
 
 
 @serializable()
@@ -308,7 +323,7 @@ class BlobStorageConnection:
     def __enter__(self) -> Self:
         raise NotImplementedError
 
-    def __exit__(self, *exc) -> None:
+    def __exit__(self, *exc: Any) -> None:
         raise NotImplementedError
 
     def read(self, fp: SecureFilePathLocation, type_: Optional[Type]) -> BlobRetrieval:
diff --git a/packages/syft/src/syft/store/blob_storage/on_disk.py b/packages/syft/src/syft/store/blob_storage/on_disk.py
index 1ceebfdb129..4805d36bf0b 100644
--- a/packages/syft/src/syft/store/blob_storage/on_disk.py
+++ b/packages/syft/src/syft/store/blob_storage/on_disk.py
@@ -41,6 +41,8 @@ def write(self, data: BytesIO) -> Union[SyftSuccess, SyftError]:
             syft_node_location=self.syft_node_location,
             syft_client_verify_key=self.syft_client_verify_key,
         )
+        if write_to_disk_method is None:
+            return SyftError(message="write_to_disk_method is None")
         return write_to_disk_method(data=data.read(), uid=self.blob_storage_entry_id)
 
 
@@ -53,11 +55,11 @@ def __init__(self, base_directory: Path) -> None:
     def __enter__(self) -> Self:
         return self
 
-    def __exit__(self, *exc) -> None:
+    def __exit__(self, *exc: Any) -> None:
         pass
 
     def read(
-        self, fp: SecureFilePathLocation, type_: Optional[Type], **kwargs
+        self, fp: SecureFilePathLocation, type_: Optional[Type], **kwargs: Any
     ) -> BlobRetrieval:
         file_path = self._base_directory / fp.path
         return SyftObjectRetrieval(
diff --git a/packages/syft/src/syft/store/blob_storage/seaweedfs.py b/packages/syft/src/syft/store/blob_storage/seaweedfs.py
index 85524236a37..09aebe3278b 100644
--- a/packages/syft/src/syft/store/blob_storage/seaweedfs.py
+++ b/packages/syft/src/syft/store/blob_storage/seaweedfs.py
@@ -3,7 +3,10 @@
 import math
 from queue import Queue
 import threading
+from typing import Any
+from typing import Callable
 from typing import Dict
+from typing import Generator
 from typing import List
 from typing import Optional
 from typing import Type
@@ -94,7 +97,7 @@ def write(self, data: BytesIO) -> Union[SyftSuccess, SyftError]:
                     self.urls,
                     start=1,
                 ):
-                    if api is not None:
+                    if api is not None and api.connection is not None:
                         blob_url = api.connection.to_blob_route(
                             url.url_path, host=url.host_or_ip
                         )
@@ -103,10 +106,12 @@ def write(self, data: BytesIO) -> Union[SyftSuccess, SyftError]:
 
                     # read a chunk untill we have read part_size
                     class PartGenerator:
-                        def __init__(self):
+                        def __init__(self) -> None:
                             self.no_lines = 0
 
-                        def async_generator(self, chunk_size=DEFAULT_UPLOAD_CHUNK_SIZE):
+                        def async_generator(
+                            self, chunk_size: int = DEFAULT_UPLOAD_CHUNK_SIZE
+                        ) -> Generator:
                             item_queue: Queue = Queue()
                             threading.Thread(
                                 target=self.add_chunks_to_queue,
@@ -120,8 +125,10 @@ def async_generator(self, chunk_size=DEFAULT_UPLOAD_CHUNK_SIZE):
                                 item = item_queue.get()
 
                         def add_chunks_to_queue(
-                            self, queue, chunk_size=DEFAULT_UPLOAD_CHUNK_SIZE
-                        ):
+                            self,
+                            queue: Queue,
+                            chunk_size: int = DEFAULT_UPLOAD_CHUNK_SIZE,
+                        ) -> None:
                             """Creates a data geneator for the part"""
                             n = 0
 
@@ -160,20 +167,22 @@ def add_chunks_to_queue(
             syft_node_location=self.syft_node_location,
             syft_client_verify_key=self.syft_client_verify_key,
         )
+        if mark_write_complete_method is None:
+            return SyftError(message="mark_write_complete_method is None")
         return mark_write_complete_method(
             etags=etags, uid=self.blob_storage_entry_id, no_lines=no_lines
         )
 
 
 @migrate(SeaweedFSBlobDeposit, SeaweedFSBlobDepositV1)
-def downgrade_seaweedblobdeposit_v2_to_v1():
+def downgrade_seaweedblobdeposit_v2_to_v1() -> list[Callable]:
     return [
         drop(["size"]),
     ]
 
 
 @migrate(SeaweedFSBlobDepositV1, SeaweedFSBlobDeposit)
-def upgrade_seaweedblobdeposit_v1_to_v2():
+def upgrade_seaweedblobdeposit_v1_to_v2() -> list[Callable]:
     return [
         make_set_default("size", 1),
     ]
@@ -240,11 +249,14 @@ def __init__(
     def __enter__(self) -> Self:
         return self
 
-    def __exit__(self, *exc) -> None:
+    def __exit__(self, *exc: Any) -> None:
         self.client.close()
 
     def read(
-        self, fp: SecureFilePathLocation, type_: Optional[Type], bucket_name=None
+        self,
+        fp: SecureFilePathLocation,
+        type_: Optional[Type],
+        bucket_name: Optional[str] = None,
     ) -> BlobRetrieval:
         if bucket_name is None:
             bucket_name = self.default_bucket_name
diff --git a/packages/syft/src/syft/store/dict_document_store.py b/packages/syft/src/syft/store/dict_document_store.py
index 516a2fc85c5..6b5ee9bd8fe 100644
--- a/packages/syft/src/syft/store/dict_document_store.py
+++ b/packages/syft/src/syft/store/dict_document_store.py
@@ -18,11 +18,12 @@
 
 
 @serializable()
-class DictBackingStore(dict, KeyValueBackingStore):
+class DictBackingStore(dict, KeyValueBackingStore):  # type: ignore[misc]
+    # TODO: fix the mypy issue
     """Dictionary-based Store core logic"""
 
     def __init__(self, *args: Any, **kwargs: Any) -> None:
-        super(dict).__init__()
+        super().__init__()
         self._ddtype = kwargs.get("ddtype", None)
 
     def __getitem__(self, key: Any) -> Any:
@@ -46,7 +47,7 @@ class DictStorePartition(KeyValueStorePartition):
             DictStore specific configuration
     """
 
-    def prune(self):
+    def prune(self) -> None:
         self.init_store()
 
 
@@ -71,7 +72,7 @@ def __init__(
             store_config = DictStoreConfig()
         super().__init__(root_verify_key=root_verify_key, store_config=store_config)
 
-    def reset(self):
+    def reset(self) -> None:
         for _, partition in self.partitions.items():
             partition.prune()
 
diff --git a/packages/syft/src/syft/store/document_store.py b/packages/syft/src/syft/store/document_store.py
index 72332449cea..d56b9434471 100644
--- a/packages/syft/src/syft/store/document_store.py
+++ b/packages/syft/src/syft/store/document_store.py
@@ -59,7 +59,7 @@ def first_or_none(result: Any) -> Ok:
 
 if sys.version_info >= (3, 9):
 
-    def is_generic_alias(t: type):
+    def is_generic_alias(t: type) -> bool:
         return isinstance(t, (types.GenericAlias, typing._GenericAlias))
 
 else:
@@ -117,7 +117,7 @@ class PartitionKeys(BaseModel):
     pks: Union[PartitionKey, Tuple[PartitionKey, ...], List[PartitionKey]]
 
     @property
-    def all(self) -> List[PartitionKey]:
+    def all(self) -> Union[tuple[PartitionKey, ...], list[PartitionKey]]:
         # make sure we always return a list even if there's a single value
         return self.pks if isinstance(self.pks, (tuple, list)) else [self.pks]
 
@@ -170,8 +170,9 @@ def from_obj(partition_key: PartitionKey, obj: Any) -> QueryKey:
                 # object has a method for getting these types
                 # we can't use properties because we don't seem to be able to get the
                 # return types
-                if isinstance(pk_value, (types.FunctionType, types.MethodType)):
-                    pk_value = pk_value()
+                # TODO: fix the mypy issue
+                if isinstance(pk_value, (types.FunctionType, types.MethodType)):  # type: ignore[unreachable]
+                    pk_value = pk_value()  # type: ignore[unreachable]
 
             if pk_value and not isinstance(pk_value, pk_type):
                 raise Exception(
@@ -180,11 +181,11 @@ def from_obj(partition_key: PartitionKey, obj: Any) -> QueryKey:
         return QueryKey(key=pk_key, type_=pk_type, value=pk_value)
 
     @property
-    def as_dict(self):
+    def as_dict(self) -> dict[str, Any]:
         return {self.key: self.value}
 
     @property
-    def as_dict_mongo(self):
+    def as_dict_mongo(self) -> dict[str, Any]:
         key = self.key
         if key == "id":
             key = "_id"
@@ -199,8 +200,8 @@ class PartitionKeysWithUID(PartitionKeys):
     uid_pk: PartitionKey
 
     @property
-    def all(self) -> List[PartitionKey]:
-        all_keys = self.pks if isinstance(self.pks, (tuple, list)) else [self.pks]
+    def all(self) -> Union[tuple[PartitionKey, ...], list[PartitionKey]]:
+        all_keys = list(self.pks) if isinstance(self.pks, (tuple, list)) else [self.pks]
         if self.uid_pk not in all_keys:
             all_keys.insert(0, self.uid_pk)
         return all_keys
@@ -211,7 +212,7 @@ class QueryKeys(SyftBaseModel):
     qks: Union[QueryKey, Tuple[QueryKey, ...], List[QueryKey]]
 
     @property
-    def all(self) -> List[QueryKey]:
+    def all(self) -> Union[tuple[QueryKey, ...], list[QueryKey]]:
         # make sure we always return a list even if there's a single value
         return self.qks if isinstance(self.qks, (tuple, list)) else [self.qks]
 
@@ -260,7 +261,7 @@ def from_dict(qks_dict: Dict[str, Any]) -> QueryKeys:
         return QueryKeys(qks=qks)
 
     @property
-    def as_dict(self):
+    def as_dict(self) -> dict:
         qk_dict = {}
         for qk in self.all:
             qk_key = qk.key
@@ -269,7 +270,7 @@ def as_dict(self):
         return qk_dict
 
     @property
-    def as_dict_mongo(self):
+    def as_dict_mongo(self) -> dict:
         qk_dict = {}
         for qk in self.all:
             qk_key = qk.key
@@ -316,7 +317,7 @@ class StorePartition:
 
     def __init__(
         self,
-        root_verify_key: SyftVerifyKey,
+        root_verify_key: Optional[SyftVerifyKey],
         settings: PartitionSettings,
         store_config: StoreConfig,
     ) -> None:
@@ -352,7 +353,9 @@ def store_query_keys(self, objs: Any) -> QueryKeys:
         return QueryKeys(qks=[self.store_query_key(obj) for obj in objs])
 
     # Thread-safe methods
-    def _thread_safe_cbk(self, cbk: Callable, *args, **kwargs):
+    def _thread_safe_cbk(
+        self, cbk: Callable, *args: Any, **kwargs: Any
+    ) -> Union[Any, Err]:
         locked = self.lock.acquire(blocking=True)
         if not locked:
             print("FAILED TO LOCK")
@@ -423,7 +426,7 @@ def update(
         credentials: SyftVerifyKey,
         qk: QueryKey,
         obj: SyftObject,
-        has_permission=False,
+        has_permission: bool = False,
     ) -> Result[SyftObject, str]:
         return self._thread_safe_cbk(
             self._update,
@@ -444,7 +447,7 @@ def get_all_from_store(
         )
 
     def delete(
-        self, credentials: SyftVerifyKey, qk: QueryKey, has_permission=False
+        self, credentials: SyftVerifyKey, qk: QueryKey, has_permission: bool = False
     ) -> Result[SyftSuccess, Err]:
         return self._thread_safe_cbk(
             self._delete, credentials, qk, has_permission=has_permission
@@ -475,12 +478,21 @@ def migrate_data(
     # These methods are called from the public thread-safe API, and will hang the process.
     def _set(
         self,
+        credentials: SyftVerifyKey,
         obj: SyftObject,
+        add_permissions: Optional[List[ActionObjectPermission]] = None,
         ignore_duplicates: bool = False,
     ) -> Result[SyftObject, str]:
         raise NotImplementedError
 
-    def _update(self, qk: QueryKey, obj: SyftObject) -> Result[SyftObject, str]:
+    def _update(
+        self,
+        credentials: SyftVerifyKey,
+        qk: QueryKey,
+        obj: SyftObject,
+        has_permission: bool = False,
+        overwrite: bool = False,
+    ) -> Result[SyftObject, str]:
         raise NotImplementedError
 
     def _get_all_from_store(
@@ -491,10 +503,17 @@ def _get_all_from_store(
     ) -> Result[List[SyftObject], str]:
         raise NotImplementedError
 
-    def _delete(self, qk: QueryKey) -> Result[SyftSuccess, Err]:
+    def _delete(
+        self, credentials: SyftVerifyKey, qk: QueryKey, has_permission: bool = False
+    ) -> Result[SyftSuccess, Err]:
         raise NotImplementedError
 
-    def _all(self) -> Result[List[BaseStash.object_type], str]:
+    def _all(
+        self,
+        credentials: SyftVerifyKey,
+        order_by: Optional[PartitionKey] = None,
+        has_permission: Optional[bool] = False,
+    ) -> Result[List[BaseStash.object_type], str]:
         raise NotImplementedError
 
     def add_permission(self, permission: ActionObjectPermission) -> None:
@@ -688,7 +707,7 @@ def find_and_delete(
         return self.delete(credentials=credentials, qk=qk)
 
     def delete(
-        self, credentials: SyftVerifyKey, qk: QueryKey, has_permission=False
+        self, credentials: SyftVerifyKey, qk: QueryKey, has_permission: bool = False
     ) -> Result[SyftSuccess, Err]:
         return self.partition.delete(
             credentials=credentials, qk=qk, has_permission=has_permission
@@ -698,7 +717,7 @@ def update(
         self,
         credentials: SyftVerifyKey,
         obj: BaseStash.object_type,
-        has_permission=False,
+        has_permission: bool = False,
     ) -> Result[BaseStash.object_type, str]:
         qk = self.partition.store_query_key(obj)
         return self.partition.update(
diff --git a/packages/syft/src/syft/store/kv_document_store.py b/packages/syft/src/syft/store/kv_document_store.py
index f68fe7d0f8d..1b8ce0f9280 100644
--- a/packages/syft/src/syft/store/kv_document_store.py
+++ b/packages/syft/src/syft/store/kv_document_store.py
@@ -60,16 +60,16 @@ def __repr__(self) -> str:
     def __len__(self) -> int:
         raise NotImplementedError
 
-    def __delitem__(self, key: str):
+    def __delitem__(self, key: str) -> None:
         raise NotImplementedError
 
-    def clear(self) -> Self:
+    def clear(self) -> None:
         raise NotImplementedError
 
     def copy(self) -> Self:
         raise NotImplementedError
 
-    def update(self, *args: Any, **kwargs: Any) -> Self:
+    def update(self, *args: Any, **kwargs: Any) -> None:
         raise NotImplementedError
 
     def keys(self) -> Any:
@@ -177,8 +177,8 @@ def _set(
         ignore_duplicates: bool = False,
     ) -> Result[SyftObject, str]:
         try:
-            if obj.id is None:
-                obj.id = UID()
+            # if obj.id is None:
+            # obj.id = UID()
             store_query_key: QueryKey = self.settings.store_key.with_obj(obj)
             uid = store_query_key.value
             write_permission = ActionObjectWRITE(uid=uid, credentials=credentials)
@@ -250,7 +250,7 @@ def add_permission(self, permission: ActionObjectPermission) -> None:
         permissions.add(permission.permission_string)
         self.permissions[permission.uid] = permissions
 
-    def remove_permission(self, permission: ActionObjectPermission):
+    def remove_permission(self, permission: ActionObjectPermission) -> None:
         permissions = self.permissions[permission.uid]
         permissions.remove(permission.permission_string)
         self.permissions[permission.uid] = permissions
@@ -264,7 +264,10 @@ def has_permission(self, permission: ActionObjectPermission) -> bool:
             raise Exception(f"ObjectPermission type: {permission.permission} not valid")
 
         # TODO: fix for other admins
-        if self.root_verify_key.verify == permission.credentials.verify:
+        if (
+            permission.credentials
+            and self.root_verify_key.verify == permission.credentials.verify
+        ):
             return True
 
         if (
@@ -372,8 +375,8 @@ def _update(
         credentials: SyftVerifyKey,
         qk: QueryKey,
         obj: SyftObject,
-        has_permission=False,
-        overwrite=False,
+        has_permission: bool = False,
+        overwrite: bool = False,
     ) -> Result[SyftObject, str]:
         try:
             if qk.value not in self.data:
@@ -451,7 +454,7 @@ def create(self, obj: SyftObject) -> Result[SyftObject, str]:
         pass
 
     def _delete(
-        self, credentials: SyftVerifyKey, qk: QueryKey, has_permission=False
+        self, credentials: SyftVerifyKey, qk: QueryKey, has_permission: bool = False
     ) -> Result[SyftSuccess, Err]:
         try:
             if has_permission or self.has_permission(
@@ -488,9 +491,9 @@ def _delete_search_keys_for(self, obj: SyftObject) -> Result[SyftSuccess, str]:
     def _get_keys_index(self, qks: QueryKeys) -> Result[Set[Any], str]:
         try:
             # match AND
-            subsets = []
+            subsets: list = []
             for qk in qks.all:
-                subset = {}
+                subset: set = set()
                 pk_key, pk_value = qk.key, qk.value
                 if pk_key not in self.unique_keys:
                     return Err(f"Failed to query index with {qk}")
@@ -517,7 +520,7 @@ def _find_keys_search(self, qks: QueryKeys) -> Result[Set[QueryKey], str]:
             # match AND
             subsets = []
             for qk in qks.all:
-                subset = {}
+                subset: set = set()
                 pk_key, pk_value = qk.key, qk.value
                 if pk_key not in self.searchable_keys:
                     return Err(f"Failed to search with {qk}")
diff --git a/packages/syft/src/syft/store/linked_obj.py b/packages/syft/src/syft/store/linked_obj.py
index e28ff1821c1..b2ddad102e5 100644
--- a/packages/syft/src/syft/store/linked_obj.py
+++ b/packages/syft/src/syft/store/linked_obj.py
@@ -46,15 +46,20 @@ def resolve(self) -> SyftObject:
             node_uid=self.node_uid,
             user_verify_key=self.syft_client_verify_key,
         )
+        if api is None:
+            raise ValueError(f"api is None. You must login to {self.node_uid}")
+
         return api.services.notifications.resolve_object(self)
 
     def resolve_with_context(self, context: NodeServiceContext) -> Any:
+        if context.node is None:
+            raise ValueError(f"context {context}'s node is None")
         return context.node.get_service(self.service_type).resolve_link(
             context=context, linked_obj=self
         )
 
     def update_with_context(
-        self, context: NodeServiceContext, obj: Any
+        self, context: Union[NodeServiceContext, ChangeContext, Any], obj: Any
     ) -> Union[SyftSuccess, SyftError]:
         if isinstance(context, AuthedServiceContext):
             credentials = context.credentials
@@ -62,15 +67,19 @@ def update_with_context(
             credentials = context.approving_user_credentials
         else:
             return SyftError(message="wrong context passed")
-        result = context.node.get_service(self.service_type).stash.update(
-            credentials, obj
-        )
+        if context.node is None:
+            return SyftError(message=f"context {context}'s node is None")
+        service = context.node.get_service(self.service_type)
+        if hasattr(service, "stash"):
+            result = service.stash.update(credentials, obj)
+        else:
+            return SyftError(message=f"service {service} does not have a stash")
         return result
 
     @classmethod
     def from_obj(
         cls,
-        obj: SyftObject,
+        obj: Union[SyftObject, Type[SyftObject]],
         service_type: Optional[Type[Any]] = None,
         node_uid: Optional[UID] = None,
     ) -> Self:
@@ -121,6 +130,8 @@ def with_context(
         if object_uid is None:
             raise Exception(f"{cls} Requires an object UID")
 
+        if context.node is None:
+            raise ValueError(f"context {context}'s node is None")
         node_uid = context.node.id
 
         return LinkedObject(
@@ -130,14 +141,15 @@ def with_context(
             object_uid=object_uid,
         )
 
-    @staticmethod
+    @classmethod
     def from_uid(
+        cls,
         object_uid: UID,
         object_type: Type[SyftObject],
         service_type: Type[Any],
         node_uid: UID,
     ) -> Self:
-        return LinkedObject(
+        return cls(
             node_uid=node_uid,
             service_type=service_type,
             object_type=object_type,
diff --git a/packages/syft/src/syft/store/locks.py b/packages/syft/src/syft/store/locks.py
index a32bcd67c8d..2249e39c977 100644
--- a/packages/syft/src/syft/store/locks.py
+++ b/packages/syft/src/syft/store/locks.py
@@ -5,14 +5,17 @@
 from pathlib import Path
 import threading
 import time
+from typing import Any
 from typing import Callable
 from typing import Dict
 from typing import Optional
+from typing import Union
 import uuid
 
 # third party
 from pydantic import BaseModel
 import redis
+from redis.client import Redis
 from sherlock.lock import BaseLock
 from sherlock.lock import FileLock
 from sherlock.lock import RedisLock
@@ -94,13 +97,13 @@ class ThreadingLock(BaseLock):
     Threading-based Lock. Used to provide the same API as the rest of the locks.
     """
 
-    def __init__(self, expire: int, **kwargs):
+    def __init__(self, expire: int, **kwargs: Any) -> None:
         self.expire = expire
-        self.locked_timestamp = 0
+        self.locked_timestamp: float = 0.0
         self.lock = threading.Lock()
 
     @property
-    def _locked(self):
+    def _locked(self) -> bool:
         """
         Implementation of method to check if lock has been acquired. Must be
         :returns: if the lock is acquired or not
@@ -116,7 +119,7 @@ def _locked(self):
 
         return self.lock.locked()
 
-    def _acquire(self):
+    def _acquire(self) -> bool:
         """
         Implementation of acquiring a lock in a non-blocking fashion.
         :returns: if the lock was successfully acquired or not
@@ -137,7 +140,7 @@ def _acquire(self):
             self.locked_timestamp = time.time()
         return status
 
-    def _release(self):
+    def _release(self) -> None:
         """
         Implementation of releasing an acquired lock.
         """
@@ -166,7 +169,7 @@ class PatchedFileLock(FileLock):
 
     """
 
-    def __init__(self, *args, **kwargs) -> None:
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         self._lock_file_enabled = True
         try:
             super().__init__(*args, **kwargs)
@@ -203,7 +206,7 @@ def _thread_safe_cbk(self, cbk: Callable) -> bool:
     def _acquire(self) -> bool:
         return self._thread_safe_cbk(self._acquire_file_lock)
 
-    def _release(self) -> None:
+    def _release(self) -> bool:
         res = self._thread_safe_cbk(self._release_file_lock)
         return res
 
@@ -245,12 +248,12 @@ def _acquire_file_lock(self) -> bool:
             self._data_file.write_text(json.dumps(data))
 
             # We succeeded in writing to the file so we now hold the lock.
-            self._owner = owner
+            self._owner: Optional[str] = owner
 
             return True
 
     @property
-    def _locked(self):
+    def _locked(self) -> bool:
         if self._lock_py_thread.locked():
             return True
 
@@ -340,7 +343,7 @@ def __init__(self, config: LockingConfig):
         elif isinstance(config, ThreadingLockingConfig):
             self._lock = ThreadingLock(**base_params)
         elif isinstance(config, FileLockingConfig):
-            client = config.client_path
+            client: Optional[Union[Path, Redis]] = config.client_path
             self._lock = PatchedFileLock(
                 **base_params,
                 client=client,
@@ -356,7 +359,7 @@ def __init__(self, config: LockingConfig):
             raise ValueError("Unsupported config type")
 
     @property
-    def _locked(self):
+    def _locked(self) -> bool:
         """
         Implementation of method to check if lock has been acquired.
 
@@ -365,8 +368,7 @@ def _locked(self):
         """
         if self.passthrough:
             return False
-
-        return self._lock.locked()
+        return self._lock.locked() if self._lock else False
 
     def acquire(self, blocking: bool = True) -> bool:
         """
@@ -380,9 +382,9 @@ def acquire(self, blocking: bool = True) -> bool:
         if not blocking:
             return self._acquire()
 
-        timeout = self.timeout
+        timeout: float = float(self.timeout)
         start_time = time.time()
-        elapsed = 0
+        elapsed: float = 0.0
         while timeout >= elapsed:
             if not self._acquire():
                 time.sleep(self.retry_interval)
@@ -407,21 +409,22 @@ def _acquire(self) -> bool:
             return True
 
         try:
-            return self._lock._acquire()
+            return self._lock._acquire() if self._lock else False
         except BaseException:
             return False
 
-    def _release(self):
+    def _release(self) -> Optional[bool]:
         """
         Implementation of releasing an acquired lock.
         """
         if self.passthrough:
-            return
-
+            return None
+        if not self._lock:
+            return None
         try:
             return self._lock._release()
         except BaseException:
-            pass
+            return None
 
     def _renew(self) -> bool:
         """
@@ -430,4 +433,4 @@ def _renew(self) -> bool:
         if self.passthrough:
             return True
 
-        return self._lock._renew()
+        return self._lock._renew() if self._lock else False
diff --git a/packages/syft/src/syft/store/mongo_client.py b/packages/syft/src/syft/store/mongo_client.py
index 49662cadab1..c5fc0fae783 100644
--- a/packages/syft/src/syft/store/mongo_client.py
+++ b/packages/syft/src/syft/store/mongo_client.py
@@ -126,7 +126,7 @@ class MongoStoreClientConfig(StoreClientConfig):
 
 
 class MongoClientCache:
-    __client_cache__: Dict[str, Type["MongoClient"]] = {}
+    __client_cache__: Dict[int, Optional[Type["MongoClient"]]] = {}
     _lock: Lock = Lock()
 
     @classmethod
@@ -239,6 +239,6 @@ def with_collection_permissions(
 
         return Ok(collection_permissions)
 
-    def close(self):
+    def close(self) -> None:
         self.client.close()
         MongoClientCache.__client_cache__.pop(hash(str(self.config)), None)
diff --git a/packages/syft/src/syft/store/mongo_document_store.py b/packages/syft/src/syft/store/mongo_document_store.py
index 1f8891124c1..0e012cde66f 100644
--- a/packages/syft/src/syft/store/mongo_document_store.py
+++ b/packages/syft/src/syft/store/mongo_document_store.py
@@ -1,11 +1,11 @@
 # stdlib
 from typing import Any
+from typing import Callable
 from typing import Dict
 from typing import List
 from typing import Optional
 from typing import Set
 from typing import Type
-from typing import Union
 
 # third party
 from pymongo import ASCENDING
@@ -62,11 +62,11 @@ class MongoDict(SyftBaseObject):
     def dict(self) -> Dict[Any, Any]:
         return dict(zip(self.keys, self.values))
 
-    @staticmethod
-    def from_dict(input: Dict[Any, Any]) -> Self:
-        return MongoDict(keys=list(input.keys()), values=list(input.values()))
+    @classmethod
+    def from_dict(cls, input: Dict[Any, Any]) -> Self:
+        return cls(keys=list(input.keys()), values=list(input.values()))
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return self.dict.__repr__()
 
 
@@ -82,30 +82,34 @@ def _repr_debug_(value: Any) -> str:
 
 def to_mongo(context: TransformContext) -> TransformContext:
     output = {}
-    unique_keys_dict = context.obj._syft_unique_keys_dict()
-    search_keys_dict = context.obj._syft_searchable_keys_dict()
-    all_dict = unique_keys_dict
-    all_dict.update(search_keys_dict)
-    for k in all_dict:
-        value = getattr(context.obj, k, "")
-        # if the value is a method, store its value
-        if callable(value):
-            output[k] = value()
-        else:
-            output[k] = value
+    if context.obj:
+        unique_keys_dict = context.obj._syft_unique_keys_dict()
+        search_keys_dict = context.obj._syft_searchable_keys_dict()
+        all_dict = unique_keys_dict
+        all_dict.update(search_keys_dict)
+        for k in all_dict:
+            value = getattr(context.obj, k, "")
+            # if the value is a method, store its value
+            if callable(value):
+                output[k] = value()
+            else:
+                output[k] = value
 
-    if "id" in context.output:
+        output["__canonical_name__"] = context.obj.__canonical_name__
+        output["__version__"] = context.obj.__version__
+        output["__blob__"] = _serialize(context.obj, to_bytes=True)
+        output["__arepr__"] = _repr_debug_(context.obj)  # a comes first in alphabet
+
+    if context.output and "id" in context.output:
         output["_id"] = context.output["id"]
-    output["__canonical_name__"] = context.obj.__canonical_name__
-    output["__version__"] = context.obj.__version__
-    output["__blob__"] = _serialize(context.obj, to_bytes=True)
-    output["__arepr__"] = _repr_debug_(context.obj)  # a comes first in alphabet
+
     context.output = output
+
     return context
 
 
 @transform(SyftObject, MongoBsonObject)
-def syft_obj_to_mongo():
+def syft_obj_to_mongo() -> list[Callable]:
     return [to_mongo]
 
 
@@ -127,7 +131,7 @@ class MongoStorePartition(StorePartition):
             Mongo specific configuration
     """
 
-    storage_type: StorableObjectType = MongoBsonObject
+    storage_type: Type[StorableObjectType] = MongoBsonObject
 
     def init_store(self) -> Result[Ok, Err]:
         store_status = super().init_store()
@@ -167,7 +171,9 @@ def _create_update_index(self) -> Result[Ok, Err]:
             return collection_status
         collection: MongoCollection = collection_status.ok()
 
-        def check_index_keys(current_keys, new_index_keys):
+        def check_index_keys(
+            current_keys: list[tuple[str, int]], new_index_keys: list[tuple[str, int]]
+        ) -> bool:
             current_keys.sort()
             new_index_keys.sort()
             return current_keys == new_index_keys
@@ -231,7 +237,7 @@ def permissions(self) -> Result[MongoCollection, Err]:
 
         return Ok(self._permissions)
 
-    def set(self, *args, **kwargs):
+    def set(self, *args: Any, **kwargs: Any) -> Result[SyftObject, str]:
         return self._set(*args, **kwargs)
 
     def _set(
@@ -244,7 +250,7 @@ def _set(
         # TODO: Refactor this function since now it's doing both set and
         # update at the same time
         write_permission = ActionObjectWRITE(uid=obj.id, credentials=credentials)
-        can_write = self.has_permission(write_permission)
+        can_write: bool = self.has_permission(write_permission)
 
         store_query_key: QueryKey = self.settings.store_key.with_obj(obj)
         collection_status = self.collection
@@ -258,7 +264,7 @@ def _set(
         if (not store_key_exists) and (not self.item_keys_exist(obj, collection)):
             # attempt to claim ownership for writing
             ownership_result = self.take_ownership(uid=obj.id, credentials=credentials)
-            can_write: bool = ownership_result.is_ok()
+            can_write = ownership_result.is_ok()
         elif not ignore_duplicates:
             unique_query_keys: QueryKeys = self.settings.unique_keys.with_obj(obj)
             keys = ", ".join(f"`{key.key}`" for key in unique_query_keys.all)
@@ -291,7 +297,7 @@ def _set(
         else:
             return Err(f"No permission to write object with id {obj.id}")
 
-    def item_keys_exist(self, obj, collection):
+    def item_keys_exist(self, obj: SyftObject, collection: MongoCollection) -> bool:
         qks: QueryKeys = self.settings.unique_keys.with_obj(obj)
         query = {"$or": [{k: v} for k, v in qks.as_dict_mongo.items()]}
         res = collection.find_one(query)
@@ -303,6 +309,7 @@ def _update(
         qk: QueryKey,
         obj: SyftObject,
         has_permission: bool = False,
+        overwrite: bool = False,
     ) -> Result[SyftObject, str]:
         collection_status = self.collection
         if collection_status.is_err():
@@ -355,13 +362,13 @@ def _find_index_or_search_keys(
         order_by: Optional[PartitionKey] = None,
     ) -> Result[List[SyftObject], str]:
         # TODO: pass index as hint to find method
-        qks = QueryKeys(qks=(index_qks.all + search_qks.all))
+        qks = QueryKeys(qks=(list(index_qks.all) + list(search_qks.all)))
         return self._get_all_from_store(
             credentials=credentials, qks=qks, order_by=order_by
         )
 
     @property
-    def data(self):
+    def data(self) -> dict:
         values: List = self._all(credentials=None, has_permission=True).ok()
         return {v.id: v for v in values}
 
@@ -447,7 +454,10 @@ def has_permission(self, permission: ActionObjectPermission) -> bool:
             return False
 
         # TODO: fix for other admins
-        if self.root_verify_key.verify == permission.credentials.verify:
+        if (
+            permission.credentials
+            and self.root_verify_key.verify == permission.credentials.verify
+        ):
             return True
 
         if permission.permission_string in permissions["permissions"]:
@@ -535,8 +545,8 @@ def take_ownership(
             return collection_status
         collection: MongoCollection = collection_status.ok()
 
-        data: List[UID] = collection.find_one({"_id": uid})
-        permissions: List[UID] = collection_permissions.find_one({"_id": uid})
+        data: Optional[List[UID]] = collection.find_one({"_id": uid})
+        permissions: Optional[List[UID]] = collection_permissions.find_one({"_id": uid})
 
         # first person using this UID can claim ownership
         if permissions is None and data is None:
@@ -557,7 +567,7 @@ def _all(
         credentials: SyftVerifyKey,
         order_by: Optional[PartitionKey] = None,
         has_permission: Optional[bool] = False,
-    ):
+    ) -> Result[List[SyftObject], str]:
         qks = QueryKeys(qks=())
         return self._get_all_from_store(
             credentials=credentials,
@@ -566,7 +576,7 @@ def _all(
             has_permission=has_permission,
         )
 
-    def __len__(self):
+    def __len__(self) -> int:
         collection_status = self.collection
         if collection_status.is_err():
             return 0
@@ -653,7 +663,7 @@ def __init__(
         self.ddtype = ddtype
         self.init_client()
 
-    def init_client(self) -> Union[None, Err]:
+    def init_client(self) -> Optional[Err]:
         self.client = MongoClient(config=self.store_config.client_config)
 
         collection_status = self.client.with_collection(
@@ -664,12 +674,13 @@ def init_client(self) -> Union[None, Err]:
         if collection_status.is_err():
             return collection_status
         self._collection: MongoCollection = collection_status.ok()
+        return None
 
     @property
     def collection(self) -> Result[MongoCollection, Err]:
         if not hasattr(self, "_collection"):
             res = self.init_client()
-            if res.is_err():
+            if res is not None and res.is_err():
                 return res
 
         return Ok(self._collection)
@@ -757,7 +768,7 @@ def _len(self) -> int:
     def __len__(self) -> int:
         return self._len()
 
-    def _delete(self, key: UID) -> None:
+    def _delete(self, key: UID) -> Result[SyftSuccess, Err]:
         collection_status = self.collection
         if collection_status.is_err():
             return collection_status
@@ -765,8 +776,9 @@ def _delete(self, key: UID) -> None:
         result = collection.delete_one({"_id": key})
         if result.deleted_count != 1:
             raise KeyError(f"{key} does not exist")
+        return Ok(SyftSuccess(message="Deleted"))
 
-    def __delitem__(self, key: str):
+    def __delitem__(self, key: str) -> None:
         self._delete(key)
 
     def _delete_all(self) -> None:
@@ -776,7 +788,7 @@ def _delete_all(self) -> None:
         collection: MongoCollection = collection_status.ok()
         collection.delete_many({})
 
-    def clear(self) -> Self:
+    def clear(self) -> None:
         self._delete_all()
 
     def _get_all(self) -> Any:
@@ -818,14 +830,14 @@ def copy(self) -> Self:
         # 🟡 TODO
         raise NotImplementedError
 
-    def update(self, *args: Any, **kwargs: Any) -> Self:
+    def update(self, *args: Any, **kwargs: Any) -> None:
         """
         Inserts the specified items to the dictionary.
         """
         # 🟡 TODO
         raise NotImplementedError
 
-    def __del__(self):
+    def __del__(self) -> None:
         """
         Close the mongo client connection:
             - Cleanup client resources and disconnect from MongoDB
diff --git a/packages/syft/src/syft/store/sqlite_document_store.py b/packages/syft/src/syft/store/sqlite_document_store.py
index fe1201ef92b..172aba160a8 100644
--- a/packages/syft/src/syft/store/sqlite_document_store.py
+++ b/packages/syft/src/syft/store/sqlite_document_store.py
@@ -58,7 +58,7 @@ def _repr_debug_(value: Any) -> str:
     return repr(value)
 
 
-def raise_exception(table_name: str, e: Exception):
+def raise_exception(table_name: str, e: Exception) -> None:
     if "disk I/O error" in str(e):
         message = f"Error usually related to concurrent writes. {str(e)}"
         raise Exception(message)
@@ -101,8 +101,10 @@ def __init__(
         self.settings = settings
         self.store_config = store_config
         self._ddtype = ddtype
-        self.file_path = self.store_config.client_config.file_path
-        self.db_filename = store_config.client_config.filename
+        if self.store_config.client_config:
+            self.file_path = self.store_config.client_config.file_path
+        if store_config.client_config:
+            self.db_filename = store_config.client_config.filename
 
         # if tempfile.TemporaryDirectory() varies from process to process
         # could this cause different locks on the same file
@@ -127,16 +129,17 @@ def _connect(self) -> None:
         if not path.exists():
             path.parent.mkdir(parents=True, exist_ok=True)
 
-        connection = sqlite3.connect(
-            self.file_path,
-            timeout=self.store_config.client_config.timeout,
-            check_same_thread=False,  # do we need this if we use the lock?
-            # check_same_thread=self.store_config.client_config.check_same_thread,
-        )
-        # TODO: Review OSX compatibility.
-        # Set journal mode to WAL.
-        # connection.execute("pragma journal_mode=wal")
-        SQLITE_CONNECTION_POOL_DB[cache_key(self.db_filename)] = connection
+        if self.store_config.client_config:
+            connection = sqlite3.connect(
+                self.file_path,
+                timeout=self.store_config.client_config.timeout,
+                check_same_thread=False,  # do we need this if we use the lock?
+                # check_same_thread=self.store_config.client_config.check_same_thread,
+            )
+            # TODO: Review OSX compatibility.
+            # Set journal mode to WAL.
+            # connection.execute("pragma journal_mode=wal")
+            SQLITE_CONNECTION_POOL_DB[cache_key(self.db_filename)] = connection
 
     def create_table(self) -> None:
         try:
@@ -183,7 +186,7 @@ def _execute(
     ) -> Result[Ok[sqlite3.Cursor], Err[str]]:
         with SyftLock(self.lock_config):
             cursor: Optional[sqlite3.Cursor] = None
-            err = None
+            # err = None
             try:
                 cursor = self.cur.execute(sql, *args)
             except Exception as e:
@@ -196,8 +199,8 @@ def _execute(
             # err = Err(str(e))
             self.db.commit()  # Commit if everything went ok
 
-            if err is not None:
-                return err
+            # if err is not None:
+            #     return err
 
             return Ok(cursor)
 
@@ -323,10 +326,10 @@ def __repr__(self) -> str:
     def __len__(self) -> int:
         return self._len()
 
-    def __delitem__(self, key: str):
+    def __delitem__(self, key: str) -> None:
         self._delete(key)
 
-    def clear(self) -> Self:
+    def clear(self) -> None:
         self._delete_all()
 
     def copy(self) -> Self:
@@ -352,7 +355,7 @@ def __contains__(self, key: Any) -> bool:
     def __iter__(self) -> Any:
         return iter(self.keys())
 
-    def __del__(self):
+    def __del__(self) -> None:
         try:
             self._close()
         except BaseException:
diff --git a/packages/syft/src/syft/types/blob_storage.py b/packages/syft/src/syft/types/blob_storage.py
index 13bddf3729e..2bf25f0b7fe 100644
--- a/packages/syft/src/syft/types/blob_storage.py
+++ b/packages/syft/src/syft/types/blob_storage.py
@@ -8,9 +8,12 @@
 import threading
 from time import sleep
 from typing import Any
+from typing import Callable
 from typing import ClassVar
+from typing import Iterator
 from typing import List
 from typing import Optional
+from typing import TYPE_CHECKING
 from typing import Type
 from typing import Union
 
@@ -21,10 +24,13 @@
 from typing_extensions import Self
 
 # relative
+from ..client.api import SyftAPI
+from ..client.client import SyftClient
 from ..node.credentials import SyftVerifyKey
 from ..serde import serialize
 from ..serde.serializable import serializable
 from ..service.action.action_object import ActionObject
+from ..service.action.action_object import ActionObjectPointer
 from ..service.action.action_object import ActionObjectV2
 from ..service.action.action_object import BASE_PASSTHROUGH_ATTRS
 from ..service.action.action_types import action_types
@@ -44,6 +50,12 @@
 from .syft_object import SyftObject
 from .uid import UID
 
+if TYPE_CHECKING:
+    # relative
+    from ..store.blob_storage import BlobRetrievalByURL
+    from ..store.blob_storage import BlobStorageConnection
+
+
 READ_EXPIRATION_TIME = 1800  # seconds
 DEFAULT_CHUNK_SIZE = 10000 * 1024
 
@@ -82,24 +94,32 @@ class BlobFile(SyftObject):
 
     __repr_attrs__ = ["id", "file_name"]
 
-    def read(self, stream=False, chunk_size=DEFAULT_CHUNK_SIZE, force=False):
+    def read(
+        self,
+        stream: bool = False,
+        chunk_size: int = DEFAULT_CHUNK_SIZE,
+        force: bool = False,
+    ) -> Any:
         # get blob retrieval object from api + syft_blob_storage_entry_id
         read_method = from_api_or_context(
             "blob_storage.read", self.syft_node_location, self.syft_client_verify_key
         )
-        blob_retrieval_object = read_method(self.syft_blob_storage_entry_id)
-        return blob_retrieval_object._read_data(
-            stream=stream, chunk_size=chunk_size, _deserialize=False
-        )
+        if read_method is not None:
+            blob_retrieval_object = read_method(self.syft_blob_storage_entry_id)
+            return blob_retrieval_object._read_data(
+                stream=stream, chunk_size=chunk_size, _deserialize=False
+            )
+        else:
+            return None
 
     @classmethod
-    def upload_from_path(self, path, client):
+    def upload_from_path(cls, path: Union[str, Path], client: SyftClient) -> Any:
         # syft absolute
         import syft as sy
 
         return sy.ActionObject.from_path(path=path).send(client).syft_action_data
 
-    def _upload_to_blobstorage_from_api(self, api):
+    def _upload_to_blobstorage_from_api(self, api: SyftAPI) -> Optional[SyftError]:
         if self.path is None:
             raise ValueError("cannot upload BlobFile, no path specified")
         storage_entry = CreateBlobStorageEntry.from_path(self.path)
@@ -118,12 +138,14 @@ def _upload_to_blobstorage_from_api(self, api):
         self.syft_blob_storage_entry_id = blob_deposit_object.blob_storage_entry_id
         self.uploaded = True
 
-    def upload_to_blobstorage(self, client):
+        return None
+
+    def upload_to_blobstorage(self, client: SyftClient) -> Optional[SyftError]:
         self.syft_node_location = client.id
         self.syft_client_verify_key = client.verify_key
         return self._upload_to_blobstorage_from_api(client.api)
 
-    def _iter_lines(self, chunk_size=DEFAULT_CHUNK_SIZE):
+    def _iter_lines(self, chunk_size: int = DEFAULT_CHUNK_SIZE) -> Iterator[bytes]:
         """Synchronous version of the async iter_lines. This implementation
         is also optimized in terms of splitting chunks, making it faster for
         larger lines"""
@@ -131,7 +153,7 @@ def _iter_lines(self, chunk_size=DEFAULT_CHUNK_SIZE):
         for chunk in self.read(stream=True, chunk_size=chunk_size):
             if b"\n" in chunk:
                 if pending is not None:
-                    chunk = pending + chunk
+                    chunk = pending + chunk  # type: ignore[unreachable]
                 lines = chunk.splitlines()
                 if lines and lines[-1] and chunk and lines[-1][-1] == chunk[-1]:
                     pending = lines.pop()
@@ -147,7 +169,13 @@ def _iter_lines(self, chunk_size=DEFAULT_CHUNK_SIZE):
         if pending is not None:
             yield pending
 
-    def read_queue(self, queue, chunk_size, progress=False, buffer_lines=10000):
+    def read_queue(
+        self,
+        queue: Queue,
+        chunk_size: int,
+        progress: bool = False,
+        buffer_lines: int = 10000,
+    ) -> None:
         total_read = 0
         for _i, line in enumerate(self._iter_lines(chunk_size=chunk_size)):
             line_size = len(line) + 1  # add byte for \n
@@ -166,7 +194,9 @@ def read_queue(self, queue, chunk_size, progress=False, buffer_lines=10000):
         # Put anything not a string at the end
         queue.put(0)
 
-    def iter_lines(self, chunk_size=DEFAULT_CHUNK_SIZE, progress=False):
+    def iter_lines(
+        self, chunk_size: int = DEFAULT_CHUNK_SIZE, progress: bool = False
+    ) -> Iterator[str]:
         item_queue: Queue = Queue()
         threading.Thread(
             target=self.read_queue,
@@ -178,19 +208,19 @@ def iter_lines(self, chunk_size=DEFAULT_CHUNK_SIZE, progress=False):
             yield item
             item = item_queue.get()
 
-    def _coll_repr_(self):
+    def _coll_repr_(self) -> dict[str, str]:
         return {"file_name": self.file_name}
 
 
 @migrate(BlobFile, BlobFileV1)
-def downgrade_blobfile_v2_to_v1():
+def downgrade_blobfile_v2_to_v1() -> list[Callable]:
     return [
         drop(["syft_blob_storage_entry_id", "file_size"]),
     ]
 
 
 @migrate(BlobFileV1, BlobFile)
-def upgrade_blobfile_v1_to_v2():
+def upgrade_blobfile_v1_to_v2() -> list[Callable]:
     return [
         make_set_default("syft_blob_storage_entry_id", None),
         make_set_default("file_size", None),
@@ -201,7 +231,7 @@ class BlobFileType(type):
     pass
 
 
-class BlobFileObjectPointer:
+class BlobFileObjectPointer(ActionObjectPointer):
     pass
 
 
@@ -236,7 +266,13 @@ class SecureFilePathLocation(SyftObject):
     def __repr__(self) -> str:
         return f"{self.path}"
 
-    def generate_url(self, *args):
+    def generate_url(
+        self,
+        connection: "BlobStorageConnection",
+        type_: Optional[Type],
+        bucket_name: Optional[str],
+        *args: Any,
+    ) -> "BlobRetrievalByURL":
         raise NotImplementedError
 
 
@@ -255,7 +291,13 @@ class SeaweedSecureFilePathLocation(SecureFilePathLocation):
 
     upload_id: Optional[str] = None
 
-    def generate_url(self, connection, type_, bucket_name):
+    def generate_url(
+        self,
+        connection: "BlobStorageConnection",
+        type_: Optional[Type],
+        bucket_name: Optional[str],
+        *args: Any,
+    ) -> "BlobRetrievalByURL":
         try:
             url = connection.client.generate_presigned_url(
                 ClientMethod="get_object",
@@ -274,12 +316,12 @@ def generate_url(self, connection, type_, bucket_name):
 
 
 @migrate(SeaweedSecureFilePathLocationV1, SeaweedSecureFilePathLocation)
-def upgrade_seaweedsecurefilepathlocation_v1_to_v2():
+def upgrade_seaweedsecurefilepathlocation_v1_to_v2() -> list[Callable]:
     return [make_set_default("bucket_name", "")]
 
 
 @migrate(SeaweedSecureFilePathLocation, SeaweedSecureFilePathLocationV1)
-def downgrade_seaweedsecurefilepathlocation_v2_to_v1():
+def downgrade_seaweedsecurefilepathlocation_v2_to_v1() -> list[Callable]:
     return [
         drop(["bucket_name"]),
     ]
@@ -294,7 +336,9 @@ class AzureSecureFilePathLocation(SecureFilePathLocation):
     azure_profile_name: str  # Used by Seaweedfs to refer to a remote config
     bucket_name: str
 
-    def generate_url(self, connection, type_, *args):
+    def generate_url(
+        self, connection: "BlobStorageConnection", type_: Optional[Type], *args: Any
+    ) -> "BlobRetrievalByURL":
         # SAS is almost the same thing as the presigned url
         config = connection.config.remote_profiles[self.azure_profile_name]
         account_name = config.account_name
@@ -351,14 +395,14 @@ class BlobStorageEntry(SyftObject):
 
 
 @migrate(BlobStorageEntry, BlobStorageEntryV1)
-def downgrade_blobstorageentry_v2_to_v1():
+def downgrade_blobstorageentry_v2_to_v1() -> list[Callable]:
     return [
         drop(["no_lines", "bucket_name"]),
     ]
 
 
 @migrate(BlobStorageEntryV1, BlobStorageEntry)
-def upgrade_blobstorageentry_v1_to_v2():
+def upgrade_blobstorageentry_v1_to_v2() -> list[Callable]:
     return [make_set_default("no_lines", 1), make_set_default("bucket_name", None)]
 
 
@@ -384,14 +428,14 @@ class BlobStorageMetadata(SyftObject):
 
 
 @migrate(BlobStorageMetadata, BlobStorageMetadataV1)
-def downgrade_blobmeta_v2_to_v1():
+def downgrade_blobmeta_v2_to_v1() -> list[Callable]:
     return [
         drop(["no_lines"]),
     ]
 
 
 @migrate(BlobStorageMetadataV1, BlobStorageMetadata)
-def upgrade_blobmeta_v1_to_v2():
+def upgrade_blobmeta_v1_to_v2() -> list[Callable]:
     return [make_set_default("no_lines", 1)]
 
 
@@ -419,7 +463,7 @@ def from_path(cls, fp: Union[str, Path], mimetype: Optional[str] = None) -> Self
         if not path.is_file():
             raise SyftException(f"{fp} is not a file.")
 
-        if fp.suffix.lower() == ".jsonl":
+        if path.suffix.lower() == ".jsonl":
             mimetype = "application/json-lines"
         if mimetype is None:
             mime_types = mimetypes.guess_type(fp)
@@ -444,7 +488,7 @@ def file_name(self) -> str:
 
 
 @transform(BlobStorageEntry, BlobStorageMetadata)
-def storage_entry_to_metadata():
+def storage_entry_to_metadata() -> list[Callable]:
     return [keep(["id", "type_", "mimetype", "file_size"])]
 
 
diff --git a/packages/syft/src/syft/types/datetime.py b/packages/syft/src/syft/types/datetime.py
index 578f5f49976..32b356a4a96 100644
--- a/packages/syft/src/syft/types/datetime.py
+++ b/packages/syft/src/syft/types/datetime.py
@@ -1,6 +1,7 @@
 # stdlib
 from datetime import datetime
 from functools import total_ordering
+from typing import Any
 from typing import Optional
 
 # third party
@@ -19,7 +20,7 @@ class DateTime(SyftObject):
     __canonical_name__ = "DateTime"
     __version__ = SYFT_OBJECT_VERSION_1
 
-    id: Optional[UID]
+    id: Optional[UID]  # type: ignore
     utc_timestamp: float
 
     @classmethod
@@ -33,7 +34,7 @@ def __str__(self) -> str:
     def __hash__(self) -> int:
         return hash(self.utc_timestamp)
 
-    def __eq__(self, other: Self) -> bool:
+    def __eq__(self, other: Any) -> bool:
         if other is None:
             return False
         return self.utc_timestamp == other.utc_timestamp
diff --git a/packages/syft/src/syft/types/grid_url.py b/packages/syft/src/syft/types/grid_url.py
index 9100c03704e..61287649d03 100644
--- a/packages/syft/src/syft/types/grid_url.py
+++ b/packages/syft/src/syft/types/grid_url.py
@@ -21,7 +21,7 @@
 @serializable(attrs=["protocol", "host_or_ip", "port", "path", "query"])
 class GridURL:
     @classmethod
-    def from_url(cls, url: Union[str, GridURL]) -> Self:
+    def from_url(cls, url: Union[str, GridURL]) -> GridURL:
         if isinstance(url, GridURL):
             return url
         try:
@@ -37,7 +37,7 @@ def from_url(cls, url: Union[str, GridURL]) -> Self:
             host_or_ip = host_or_ip_parts[0]
             if parts.scheme == "https":
                 port = 443
-            return cls(
+            return GridURL(
                 host_or_ip=host_or_ip,
                 path=parts.path,
                 port=port,
@@ -141,7 +141,7 @@ def base_url_no_port(self) -> str:
     def url_path(self) -> str:
         return f"{self.path}{self.query_string}"
 
-    def to_tls(self) -> Self:
+    def to_tls(self) -> GridURL:
         if self.protocol == "https":
             return self
 
@@ -165,7 +165,7 @@ def __str__(self) -> str:
     def __hash__(self) -> int:
         return hash(self.__str__())
 
-    def __copy__(self) -> Self:
+    def __copy__(self) -> GridURL:
         return self.__class__.from_url(self.url)
 
     def set_port(self, port: int) -> Self:
diff --git a/packages/syft/src/syft/types/identity.py b/packages/syft/src/syft/types/identity.py
index a3359570ebb..52c61ef8c0d 100644
--- a/packages/syft/src/syft/types/identity.py
+++ b/packages/syft/src/syft/types/identity.py
@@ -29,6 +29,8 @@ def __repr__(self) -> str:
 
     @classmethod
     def from_client(cls, client: SyftClient) -> Self:
+        if not client.credentials:
+            raise ValueError(f"{client} has no signing key!")
         return cls(node_id=client.id, verify_key=client.credentials.verify_key)
 
 
diff --git a/packages/syft/src/syft/types/syft_metaclass.py b/packages/syft/src/syft/types/syft_metaclass.py
index 762213b7ba4..4fd067b232a 100644
--- a/packages/syft/src/syft/types/syft_metaclass.py
+++ b/packages/syft/src/syft/types/syft_metaclass.py
@@ -100,7 +100,7 @@ def optionalize(
 
         cls.__init__ = __init__
 
-        def iter_exclude_empty(self) -> TupleGenerator:
+        def iter_exclude_empty(self: BaseModel) -> TupleGenerator:
             for key, value in self.__dict__.items():
                 if value is not Empty:
                     yield key, value
diff --git a/packages/syft/src/syft/types/syft_migration.py b/packages/syft/src/syft/types/syft_migration.py
index 86f99320d8e..6f7e10795de 100644
--- a/packages/syft/src/syft/types/syft_migration.py
+++ b/packages/syft/src/syft/types/syft_migration.py
@@ -39,7 +39,7 @@ def migrate(
             f"{klass_from_str} has version: {version_from}, {klass_to_str} has version: {version_to}"
         )
 
-    def decorator(function: Callable):
+    def decorator(function: Callable) -> Callable:
         transforms = function()
 
         wrapper = generate_transform_wrapper(
diff --git a/packages/syft/src/syft/types/syft_object.py b/packages/syft/src/syft/types/syft_object.py
index e06c62d78e6..d8a00ca084d 100644
--- a/packages/syft/src/syft/types/syft_object.py
+++ b/packages/syft/src/syft/types/syft_object.py
@@ -14,6 +14,7 @@
 from typing import Callable
 from typing import ClassVar
 from typing import Dict
+from typing import Iterable
 from typing import KeysView
 from typing import List
 from typing import Optional
@@ -31,6 +32,7 @@
 from pydantic.fields import Undefined
 from result import OkErr
 from typeguard import check_type
+from typing_extensions import Self
 
 # relative
 from ..node.credentials import SyftVerifyKey
@@ -81,7 +83,7 @@
 
 
 class SyftHashableObject:
-    __hash_exclude_attrs__ = []
+    __hash_exclude_attrs__: list = []
 
     def __hash__(self) -> int:
         return int.from_bytes(self.__sha256__(), byteorder="big")
@@ -106,7 +108,7 @@ class Config:
     syft_node_location: Optional[UID]
     syft_client_verify_key: Optional[SyftVerifyKey]
 
-    def _set_obj_location_(self, node_uid: UID, credentials: SyftVerifyKey):
+    def _set_obj_location_(self, node_uid: UID, credentials: SyftVerifyKey) -> None:
         self.syft_node_location = node_uid
         self.syft_client_verify_key = credentials
 
@@ -119,7 +121,9 @@ class Context(SyftBaseObject):
 
 
 class SyftObjectRegistry:
-    __object_version_registry__: Dict[str, Type["SyftObject"]] = {}
+    __object_version_registry__: Dict[
+        str, Union[Type["SyftObject"], Type["SyftObjectRegistry"]]
+    ] = {}
     __object_transform_registry__: Dict[str, Callable] = {}
 
     def __init_subclass__(cls, **kwargs: Any) -> None:
@@ -150,7 +154,9 @@ def __init_subclass__(cls, **kwargs: Any) -> None:
                 cls.__object_version_registry__[mapping_string] = cls
 
     @classmethod
-    def versioned_class(cls, name: str, version: int) -> Optional[Type["SyftObject"]]:
+    def versioned_class(
+        cls, name: str, version: int
+    ) -> Optional[Union[Type["SyftObject"], Type["SyftObjectRegistry"]]]:
         mapping_string = f"{name}_{version}"
         if mapping_string not in cls.__object_version_registry__:
             return None
@@ -219,7 +225,7 @@ def __init_subclass__(cls, **kwargs: Any) -> None:
         cls.register_version(klass=klass)
 
     @classmethod
-    def register_version(cls, klass: type):
+    def register_version(cls, klass: type) -> None:
         if hasattr(klass, "__canonical_name__") and hasattr(klass, "__version__"):
             mapping_string = klass.__canonical_name__
             klass_version = klass.__version__
@@ -309,6 +315,10 @@ def get_migration(
                             return cls.__migration_transform_registry__[klass_from][
                                 mapping_string
                             ]
+        raise ValueError(
+            f"No migration found for class type: {type_from} to "
+            f"type: {type_to} in the migration registry."
+        )
 
     @classmethod
     def get_migration_for_version(
@@ -341,7 +351,7 @@ def get_migration_for_version(
         )
 
 
-print_type_cache = defaultdict(list)
+print_type_cache: dict = defaultdict(list)
 
 
 base_attrs_sync_ignore = [
@@ -380,7 +390,7 @@ def make_id(cls, values: Dict[str, Any]) -> Dict[str, Any]:
 
     __repr_attrs__: ClassVar[List[str]] = []  # show these in html repr collections
     __attr_custom_repr__: ClassVar[
-        List[str]
+        Optional[List[str]]
     ] = None  # show these in html repr of an object
 
     def __syft_get_funcs__(self) -> List[Tuple[str, Signature]]:
@@ -428,7 +438,7 @@ def _repr_debug_(self) -> str:
             _repr_str += f"  {attr}: {value_type} = {value}\n"
         return _repr_str
 
-    def _repr_markdown_(self, wrap_as_python=True, indent=0) -> str:
+    def _repr_markdown_(self, wrap_as_python: bool = True, indent: int = 0) -> str:
         s_indent = " " * indent * 2
         class_name = get_qualname_for(type(self))
         if self.__attr_custom_repr__ is not None:
@@ -436,7 +446,7 @@ def _repr_markdown_(self, wrap_as_python=True, indent=0) -> str:
         elif self.__repr_attrs__ is not None:
             fields = self.__repr_attrs__
         else:
-            fields = list(getattr(self, "__fields__", {}).keys())
+            fields = list(getattr(self, "__fields__", {}).keys())  # type: ignore[unreachable]
 
         if "id" not in fields:
             fields = ["id"] + fields
@@ -445,7 +455,7 @@ def _repr_markdown_(self, wrap_as_python=True, indent=0) -> str:
         fields = [x for x in fields if x not in dynam_attrs]
         _repr_str = f"{s_indent}class {class_name}:\n"
         for attr in fields:
-            value = self
+            value: Any = self
             # if it's a compound string
             if "." in attr:
                 # break it into it's bits & fetch the attr
@@ -491,8 +501,8 @@ def keys(self) -> KeysView[str]:
         return self.__dict__.keys()
 
     # allows splatting with **
-    def __getitem__(self, key: str) -> Any:
-        return self.__dict__.__getitem__(key)
+    def __getitem__(self, key: Union[str, int]) -> Any:
+        return self.__dict__.__getitem__(key)  # type: ignore
 
     def _upgrade_version(self, latest: bool = True) -> "SyftObject":
         constructor = SyftObjectRegistry.versioned_class(
@@ -546,12 +556,12 @@ def dict(
         exclude_unset: bool = False,
         exclude_defaults: bool = False,
         exclude_none: bool = False,
-    ):
+    ) -> dict:
         if exclude is None:
             exclude = set()
 
         for attr in DYNAMIC_SYFT_ATTRIBUTES:
-            exclude.add(attr)
+            exclude.add(attr)  # type: ignore
         return super().dict(
             include=include,
             exclude=exclude,
@@ -565,7 +575,7 @@ def dict(
     def __post_init__(self) -> None:
         pass
 
-    def _syft_set_validate_private_attrs_(self, **kwargs):
+    def _syft_set_validate_private_attrs_(self, **kwargs: Any) -> None:
         # Validate and set private attributes
         # https://github.com/pydantic/pydantic/issues/2105
         for attr, decl in self.__private_attributes__.items():
@@ -587,7 +597,7 @@ def _syft_set_validate_private_attrs_(self, **kwargs):
                         f"{attr}\n field required (type=value_error.missing)"
                     )
 
-    def __init__(self, **kwargs) -> None:
+    def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)
         self._syft_set_validate_private_attrs_(**kwargs)
         self.__post_init__()
@@ -639,7 +649,7 @@ def migrate_to(self, version: int, context: Optional[Context] = None) -> Any:
             )
         return self
 
-    def syft_eq(self, ext_obj) -> bool:
+    def syft_eq(self, ext_obj: Optional[Self]) -> bool:
         if ext_obj is None:
             return False
         attrs_to_check = self.__dict__.keys()
@@ -656,7 +666,7 @@ def syft_eq(self, ext_obj) -> bool:
                     return False
         return True
 
-    def get_diffs(self, ext_obj) -> List["AttrDiff"]:
+    def get_diffs(self, ext_obj: Self) -> List["AttrDiff"]:
         # self is low, ext is high
         # relative
         from ..service.sync.diff_state import AttrDiff
@@ -706,14 +716,18 @@ def short_qual_name(name: str) -> str:
     return name.split(".")[-1]
 
 
-def short_uid(uid: UID) -> str:
+def short_uid(uid: Optional[UID]) -> Optional[str]:
     if uid is None:
         return uid
     else:
         return str(uid)[:6] + "..."
 
 
-def get_repr_values_table(_self, is_homogenous, extra_fields=None):
+def get_repr_values_table(
+    _self: Union[Mapping, Iterable],
+    is_homogenous: bool,
+    extra_fields: Optional[list] = None,
+) -> dict:
     if extra_fields is None:
         extra_fields = []
 
@@ -801,14 +815,14 @@ def get_repr_values_table(_self, is_homogenous, extra_fields=None):
     return df.to_dict("records")
 
 
-def list_dict_repr_html(self) -> str:
+def list_dict_repr_html(self: Union[Mapping, Set, Iterable]) -> str:
     try:
         max_check = 1
         items_checked = 0
         has_syft = False
-        extra_fields = []
+        extra_fields: list = []
         if isinstance(self, Mapping):
-            values = list(self.values())
+            values: Any = list(self.values())
         elif isinstance(self, Set):
             values = list(self)
         else:
@@ -823,7 +837,7 @@ def list_dict_repr_html(self) -> str:
                 break
 
             if hasattr(type(item), "mro") and type(item) != type:
-                mro = type(item).mro()
+                mro: Union[list, str] = type(item).mro()
             elif hasattr(item, "mro") and type(item) != type:
                 mro = item.mro()
             else:
@@ -885,6 +899,9 @@ def to(self, projection: type, context: Optional[Context] = None) -> Any:
         transform = SyftObjectRegistry.get_transform(type(self), projection)
         return transform(self, context)
 
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+
 
 class PartialSyftObject(SyftObject, metaclass=PartialModelMetaclass):
     """Syft Object to which partial arguments can be provided."""
@@ -892,7 +909,7 @@ class PartialSyftObject(SyftObject, metaclass=PartialModelMetaclass):
     __canonical_name__ = "PartialSyftObject"
     __version__ = SYFT_OBJECT_VERSION_1
 
-    def __init__(self, *args, **kwargs) -> None:
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         # Filter out Empty values from args and kwargs
         args_, kwargs_ = (), {}
         for arg in args:
@@ -947,7 +964,7 @@ def attach_attribute_to_syft_object(result: Any, attr_dict: Dict[str, Any]) -> A
         result = result.value
 
     if isinstance(result, MutableMapping):
-        iterable_keys = result.keys()
+        iterable_keys: Iterable = result.keys()
     elif isinstance(result, MutableSequence):
         iterable_keys = range(len(result))
     elif isinstance(result, tuple):
diff --git a/packages/syft/src/syft/types/transforms.py b/packages/syft/src/syft/types/transforms.py
index d4d7a0c38ca..af0be902f2f 100644
--- a/packages/syft/src/syft/types/transforms.py
+++ b/packages/syft/src/syft/types/transforms.py
@@ -33,14 +33,16 @@ class TransformContext(Context):
     credentials: Optional[SyftVerifyKey]
     obj: Optional[Any]
 
-    @staticmethod
-    def from_context(obj: Any, context: Optional[Context] = None) -> Self:
-        t_context = TransformContext()
+    @classmethod
+    def from_context(cls, obj: Any, context: Optional[Context] = None) -> Self:
+        t_context = cls()
         t_context.obj = obj
         try:
             t_context.output = dict(obj)
         except Exception:
             t_context.output = obj.to_dict()
+        if context is None:
+            return t_context
         if hasattr(context, "credentials"):
             t_context.credentials = context.credentials
         if hasattr(context, "node"):
@@ -67,7 +69,7 @@ def geteitherattr(
 
 def make_set_default(key: str, value: Any) -> Callable:
     def set_default(context: TransformContext) -> TransformContext:
-        if not geteitherattr(context.obj, context.output, key, None):
+        if context.output and not geteitherattr(context.obj, context.output, key, None):
             context.output[key] = value
         return context
 
@@ -76,9 +78,10 @@ def set_default(context: TransformContext) -> TransformContext:
 
 def drop(list_keys: List[str]) -> Callable:
     def drop_keys(context: TransformContext) -> TransformContext:
-        for key in list_keys:
-            if key in context.output:
-                del context.output[key]
+        if context.output:
+            for key in list_keys:
+                if key in context.output:
+                    del context.output[key]
         return context
 
     return drop_keys
@@ -86,9 +89,12 @@ def drop_keys(context: TransformContext) -> TransformContext:
 
 def rename(old_key: str, new_key: str) -> Callable:
     def drop_keys(context: TransformContext) -> TransformContext:
-        context.output[new_key] = geteitherattr(context.obj, context.output, old_key)
-        if old_key in context.output:
-            del context.output[old_key]
+        if context.output:
+            context.output[new_key] = geteitherattr(
+                context.obj, context.output, old_key
+            )
+            if old_key in context.output:
+                del context.output[old_key]
         return context
 
     return drop_keys
@@ -96,6 +102,9 @@ def drop_keys(context: TransformContext) -> TransformContext:
 
 def keep(list_keys: List[str]) -> Callable:
     def drop_keys(context: TransformContext) -> TransformContext:
+        if context.output is None:
+            return context
+
         for key in list_keys:
             if key not in context.output:
                 context.output[key] = getattr(context.obj, key, None)
@@ -111,7 +120,9 @@ def drop_keys(context: TransformContext) -> TransformContext:
     return drop_keys
 
 
-def convert_types(list_keys: List[str], types: Union[type, List[type]]) -> Callable:
+def convert_types(
+    list_keys: List[str], types: Union[type, List[type]]
+) -> Callable[[TransformContext], TransformContext]:
     if not isinstance(types, list):
         types = [types] * len(list_keys)
 
@@ -119,42 +130,49 @@ def convert_types(list_keys: List[str], types: Union[type, List[type]]) -> Calla
         raise Exception("convert types lists must be the same length")
 
     def run_convert_types(context: TransformContext) -> TransformContext:
-        for key, _type in zip(list_keys, types):
-            context.output[key] = _type(geteitherattr(context.obj, context.output, key))
+        if context.output:
+            for key, _type in zip(list_keys, types):
+                context.output[key] = _type(
+                    geteitherattr(context.obj, context.output, key)
+                )
         return context
 
     return run_convert_types
 
 
 def generate_id(context: TransformContext) -> TransformContext:
+    if context.output is None:
+        return context
     if "id" not in context.output or not isinstance(context.output["id"], UID):
         context.output["id"] = UID()
     return context
 
 
 def validate_url(context: TransformContext) -> TransformContext:
-    if context.output["url"] is not None:
+    if context.output and context.output["url"] is not None:
         context.output["url"] = GridURL.from_url(context.output["url"]).url_no_port
     return context
 
 
 def validate_email(context: TransformContext) -> TransformContext:
-    if context.output["email"] is not None:
+    if context.output and context.output["email"] is not None:
         context.output["email"] = EmailStr(context.output["email"])
         EmailStr.validate(context.output["email"])
     return context
 
 
 def str_url_to_grid_url(context: TransformContext) -> TransformContext:
-    url = context.output.get("url", None)
-    if url is not None and isinstance(url, str):
-        context.output["url"] = GridURL.from_url(str)
+    if context.output:
+        url = context.output.get("url", None)
+        if url is not None and isinstance(url, str):
+            context.output["url"] = GridURL.from_url(str)
     return context
 
 
 def add_credentials_for_key(key: str) -> Callable:
     def add_credentials(context: TransformContext) -> TransformContext:
-        context.output[key] = context.credentials
+        if context.output is not None:
+            context.output[key] = context.credentials
         return context
 
     return add_credentials
@@ -162,7 +180,8 @@ def add_credentials(context: TransformContext) -> TransformContext:
 
 def add_node_uid_for_key(key: str) -> Callable:
     def add_node_uid(context: TransformContext) -> TransformContext:
-        context.output[key] = context.node.id
+        if context.output is not None and context.node is not None:
+            context.output[key] = context.node.id
         return context
 
     return add_node_uid
@@ -188,7 +207,7 @@ def validate_klass_and_version(
     klass_to: Union[Type, str],
     version_from: Optional[int] = None,
     version_to: Optional[int] = None,
-):
+) -> tuple[str, Optional[int], str, Optional[int]]:
     if not isinstance(klass_from, (type, str)):
         raise NotImplementedError(
             "Arguments to `klass_from` should be either of `Type` or `str` type."
@@ -238,7 +257,7 @@ def transform_method(
         version_to=version_to,
     )
 
-    def decorator(function: Callable):
+    def decorator(function: Callable) -> Callable:
         SyftObjectRegistry.add_transform(
             klass_from=klass_from_str,
             version_from=version_from,
@@ -270,7 +289,7 @@ def transform(
         version_to=version_to,
     )
 
-    def decorator(function: Callable):
+    def decorator(function: Callable) -> Callable:
         transforms = function()
 
         wrapper = generate_transform_wrapper(
diff --git a/packages/syft/src/syft/types/twin_object.py b/packages/syft/src/syft/types/twin_object.py
index 5529daaff53..fe7a0db1495 100644
--- a/packages/syft/src/syft/types/twin_object.py
+++ b/packages/syft/src/syft/types/twin_object.py
@@ -3,6 +3,7 @@
 
 # stdlib
 from typing import Any
+from typing import ClassVar
 from typing import Dict
 from typing import Optional
 
@@ -14,6 +15,7 @@
 from ..service.action.action_object import ActionObject
 from ..service.action.action_object import TwinMode
 from ..service.action.action_types import action_types
+from ..service.response import SyftError
 from .syft_object import SyftObject
 from .uid import UID
 
@@ -32,7 +34,7 @@ class TwinObject(SyftObject):
     __canonical_name__ = "TwinObject"
     __version__ = 1
 
-    __attr_searchable__ = []
+    __attr_searchable__: ClassVar[list[str]] = []
 
     id: UID
     private_obj: ActionObject
@@ -49,7 +51,7 @@ def make_private_obj_id(cls, v: Optional[UID], values: Dict) -> UID:
         return values["private_obj"].id if v is None else v
 
     @pydantic.validator("mock_obj", pre=True, always=True)
-    def make_mock_obj(cls, v: ActionObject):
+    def make_mock_obj(cls, v: ActionObject) -> ActionObject:
         return to_action_object(v)
 
     @pydantic.validator("mock_obj_id", pre=True, always=True)
@@ -72,7 +74,7 @@ def mock(self) -> ActionObject:
         mock.id = twin_id
         return mock
 
-    def _save_to_blob_storage(self):
+    def _save_to_blob_storage(self) -> Optional[SyftError]:
         # Set node location and verify key
         self.private_obj._set_obj_location_(
             self.syft_node_location,
diff --git a/packages/syft/src/syft/types/uid.py b/packages/syft/src/syft/types/uid.py
index 68f68e8a639..a2867e2e561 100644
--- a/packages/syft/src/syft/types/uid.py
+++ b/packages/syft/src/syft/types/uid.py
@@ -40,7 +40,7 @@ class UID:
     __slots__ = "value"
     value: uuid_type
 
-    def __init__(self, value: Optional[Union[uuid_type, str, bytes]] = None):
+    def __init__(self, value: Optional[Union[uuid_type, str, bytes, "UID"]] = None):
         """Initializes the internal id using the uuid package.
 
         This initializes the object. Normal use for this object is
@@ -80,6 +80,7 @@ def from_string(value: str) -> "UID":
         except ValueError as e:
             critical(f"Unable to convert {value} to UUID. {e}")
             traceback_and_raise(e)
+            raise
 
     @staticmethod
     def with_seed(value: str) -> "UID":
@@ -215,7 +216,7 @@ class LineageID(UID):
 
     def __init__(
         self,
-        value: Optional[Union[uuid_type, str, bytes]] = None,
+        value: Optional[Union[uuid_type, str, bytes, "LineageID"]] = None,
         syft_history_hash: Optional[int] = None,
     ):
         if isinstance(value, LineageID):
@@ -232,7 +233,7 @@ def __init__(
     def id(self) -> UID:
         return UID(self.value)
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         return hash((self.syft_history_hash, self.value))
 
     def __eq__(self, other: Any) -> bool:
diff --git a/packages/syft/src/syft/util/schema.py b/packages/syft/src/syft/util/schema.py
index 55edd83962a..c5c3e8e12ee 100644
--- a/packages/syft/src/syft/util/schema.py
+++ b/packages/syft/src/syft/util/schema.py
@@ -29,7 +29,7 @@
 
 
 def make_fake_type(_type_str: str) -> dict[str, Any]:
-    jsonschema: dict = {}
+    jsonschema: dict[str, Any] = {}
     jsonschema["title"] = _type_str
     jsonschema["type"] = "object"
     jsonschema["properties"] = {}
@@ -37,7 +37,7 @@ def make_fake_type(_type_str: str) -> dict[str, Any]:
     return jsonschema
 
 
-def get_type_mapping(_type: Any) -> str:
+def get_type_mapping(_type: Type) -> str:
     if _type in primitive_mapping:
         return primitive_mapping[_type]
     return _type.__name__
@@ -62,9 +62,9 @@ def get_types(cls: Type, keys: List[str]) -> Optional[Dict[str, Type]]:
 
 
 def convert_attribute_types(
-    cls: Any, attribute_list: Any, attribute_types: Any
+    cls: Type, attribute_list: list[str], attribute_types: list[Type]
 ) -> dict[str, Any]:
-    jsonschema: dict = {}
+    jsonschema: dict[str, Any] = {}
     jsonschema["title"] = cls.__name__
     jsonschema["type"] = "object"
     jsonschema["properties"] = {}
@@ -81,7 +81,7 @@ def process_type_bank(type_bank: Dict[str, Tuple[Any, ...]]) -> Dict[str, Dict]:
     # first pass gets each type into basic json schema format
     json_mappings = {}
     count = 0
-    converted_types: defaultdict = defaultdict(int)
+    converted_types: Dict[str, int] = defaultdict(int)
     for k in type_bank:
         count += 1
         t = type_bank[k]
diff --git a/packages/syft/src/syft/util/version_compare.py b/packages/syft/src/syft/util/version_compare.py
index 606606bb6e8..ffef1102ad6 100644
--- a/packages/syft/src/syft/util/version_compare.py
+++ b/packages/syft/src/syft/util/version_compare.py
@@ -33,7 +33,9 @@ def get_operator(version_string: str) -> Tuple[str, Callable, str]:
     return version_string, op, op_char
 
 
-def check_rule(version_string: str, LATEST_STABLE_SYFT: str, __version__: str) -> tuple:
+def check_rule(
+    version_string: str, LATEST_STABLE_SYFT: str, __version__: str
+) -> tuple[Any, list[str], list[str]]:
     version_string, op, op_char = get_operator(version_string)
     syft_version = version.parse(__version__)
     stable_version = version.parse(LATEST_STABLE_SYFT)
diff --git a/packages/syft/tests/syft/service/sync/sync_flow_test.py b/packages/syft/tests/syft/service/sync/sync_flow_test.py
index 3882a0905f5..e007baf6a03 100644
--- a/packages/syft/tests/syft/service/sync/sync_flow_test.py
+++ b/packages/syft/tests/syft/service/sync/sync_flow_test.py
@@ -1,8 +1,10 @@
 # stdlib
+import sys
 from textwrap import dedent
 
 # third party
 import numpy as np
+import pytest
 
 # syft absolute
 import syft as sy
@@ -12,6 +14,8 @@
 from syft.service.action.action_object import ActionObject
 
 
+@pytest.mark.flaky(reruns=5, reruns_delay=1)
+@pytest.mark.skipif(sys.platform == "win32", reason="does not run on windows")
 def test_sync_flow():
     low_worker = sy.Worker(
         name="low-test",