From 98f13a4a2eba732758c31f5ccef0eff39b250e3e Mon Sep 17 00:00:00 2001
From: DaoAdvocate <12145726+rihp@users.noreply.github.com>
Date: Tue, 8 Nov 2022 14:00:18 +0100
Subject: [PATCH 01/21] wip: cleaner clientconfig

---
 packages/polywrap-client/tests/test_client.py        | 4 ++--
 packages/polywrap-core/polywrap_core/types/client.py | 5 +++--
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/packages/polywrap-client/tests/test_client.py b/packages/polywrap-client/tests/test_client.py
index fcb3c8db..59b42be0 100644
--- a/packages/polywrap-client/tests/test_client.py
+++ b/packages/polywrap-client/tests/test_client.py
@@ -86,12 +86,12 @@ async def test_env():
 
     client = PolywrapClient(
         config=PolywrapClientConfig(
-            envs=[Env(uri=uri, env=env)],
+            envs={uri: env},
             resolver=uri_resolver,
         )
     )
     options = InvokerOptions(
-        uri=uri, method="externalEnvMethod", args={}, encode_result=False
+        uri=uri, method="externalEnvMethod", args={}, encode_result=False, env=env
     )
     result = await client.invoke(options)
 
diff --git a/packages/polywrap-core/polywrap_core/types/client.py b/packages/polywrap-core/polywrap_core/types/client.py
index 46845bac..bfa239a0 100644
--- a/packages/polywrap-core/polywrap_core/types/client.py
+++ b/packages/polywrap-core/polywrap_core/types/client.py
@@ -2,7 +2,7 @@
 
 from abc import abstractmethod
 from dataclasses import dataclass, field
-from typing import List, Optional, Union
+from typing import List, Optional, Union, Dict, Any
 
 from polywrap_manifest import AnyWrapManifest, DeserializeManifestOptions
 from polywrap_result import Result
@@ -17,7 +17,8 @@
 
 @dataclass(slots=True, kw_only=True)
 class ClientConfig:
-    envs: List[Env] = field(default_factory=list)
+    # TODO  is this a naive solution? the `Any` type should be more specific (str | Uri | int, etc.)
+    envs: Dict[Uri, Dict[str, Any]] = field(default_factory=dict) 
     interfaces: List[InterfaceImplementations] = field(default_factory=list)
     resolver: IUriResolver
 

From ba0ca7556cd51acfec790a8267599d8d18de9fae Mon Sep 17 00:00:00 2001
From: DaoAdvocate <12145726+rihp@users.noreply.github.com>
Date: Tue, 8 Nov 2022 14:42:16 +0100
Subject: [PATCH 02/21] wip: error: __wrap_abort: Missing required property:
 externalArray: UInt32

---
 packages/polywrap-client/tests/test_client.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/packages/polywrap-client/tests/test_client.py b/packages/polywrap-client/tests/test_client.py
index 59b42be0..102cc586 100644
--- a/packages/polywrap-client/tests/test_client.py
+++ b/packages/polywrap-client/tests/test_client.py
@@ -90,9 +90,11 @@ async def test_env():
             resolver=uri_resolver,
         )
     )
+    print(client._config)
     options = InvokerOptions(
-        uri=uri, method="externalEnvMethod", args={}, encode_result=False, env=env
+        uri=uri, method="externalEnvMethod", args={}, encode_result=False
     )
+    
     result = await client.invoke(options)
 
     assert result.unwrap() == env

From 8c19da1753e70675b820381fb6ef0c44c2a2b9e9 Mon Sep 17 00:00:00 2001
From: DaoAdvocate <12145726+rihp@users.noreply.github.com>
Date: Wed, 9 Nov 2022 19:19:26 +0100
Subject: [PATCH 03/21] wip: get_env and get_env_from_uri refactor

---
 .../polywrap-client/polywrap_client/client.py | 37 +++++++++++++++----
 packages/polywrap-client/tests/test_client.py | 28 +++++++++++---
 .../polywrap_core/types/client.py             |  2 +-
 3 files changed, 54 insertions(+), 13 deletions(-)

diff --git a/packages/polywrap-client/polywrap_client/client.py b/packages/polywrap-client/polywrap_client/client.py
index 0cb96ebe..a2623a54 100644
--- a/packages/polywrap-client/polywrap_client/client.py
+++ b/packages/polywrap-client/polywrap_client/client.py
@@ -2,7 +2,7 @@
 
 from dataclasses import dataclass
 from textwrap import dedent
-from typing import Any, List, Optional, Union, cast
+from typing import Any, List, Optional, Union, cast,Dict
 
 from polywrap_core import (
     Client,
@@ -51,8 +51,9 @@ def get_uri_resolver(
     ) -> IUriResolver:
         return self._config.resolver
 
-    def get_envs(self, options: Optional[GetEnvsOptions] = None) -> List[Env]:
-        return self._config.envs
+    def get_envs(self, options: Optional[GetEnvsOptions] = None) -> Dict[Uri, Dict[str, Any]]:
+        envs = self._config.envs
+        return envs
 
     def get_interfaces(self) -> List[InterfaceImplementations]:
         return self._config.interfaces
@@ -65,10 +66,28 @@ def get_implementations(self, uri: Uri) -> Result[List[Uri]]:
         else:
             return Err.from_str(f"Unable to find implementations for uri: {uri}")
 
-    def get_env_by_uri(
-        self, uri: Uri, options: Optional[GetEnvsOptions] = None
+    def get_env_by_uri(self, uri: Uri, options: Optional[GetEnvsOptions] = None
     ) -> Union[Env, None]:
-        return next(filter(lambda env: env.uri == uri, self.get_envs()), None)
+
+        print("uri=", uri)
+        print(type(uri))
+        print("---------")
+        print("uri.uri=", uri.uri)
+        print("type(uri)", type(uri.uri))
+        print("---------")
+        print(f"{self.get_envs()=}")
+        print(f"{type(self.get_envs())=}")
+        print(f"{dir(self.get_envs())}")
+        #print(f"{self.get_envs()}")
+        #print(f"{self.get_envs()=}")
+        print("---------")
+        print("options=", options)
+        print(type(options))
+        print("---------")        
+        fn = lambda env: env.uri == uri.uri
+        #print(fn(uri))
+        envs = self.get_envs()
+        return envs
 
     async def get_file(
         self, uri: Uri, options: GetFileOptions
@@ -140,8 +159,12 @@ async def invoke(self, options: InvokerOptions) -> Result[Any]:
             return cast(Err, wrapper_result)
         wrapper = wrapper_result.unwrap()
 
+        print(self.get_env_by_uri(options.uri))
         env = self.get_env_by_uri(options.uri)
-        options.env = options.env or (env.env if env else None)
+        print(f"{env=}")
+        #print(f"{env.env=}")
+        print('options=', options)
+        options.env = options.env or (env if env else None)
 
         result = await wrapper.invoke(options, invoker=self)
         if result.is_err():
diff --git a/packages/polywrap-client/tests/test_client.py b/packages/polywrap-client/tests/test_client.py
index 102cc586..f07353b9 100644
--- a/packages/polywrap-client/tests/test_client.py
+++ b/packages/polywrap-client/tests/test_client.py
@@ -14,7 +14,7 @@ async def test_invoke():
     )
     args = {"arg": "hello polywrap"}
     options = InvokerOptions(
-        uri=uri, method="simpleMethod", args=args, encode_result=False
+        uri=uri, method="simpleMethod", args=args, encode_result=False, env={}
     )
     result = await client.invoke(options)
 
@@ -36,7 +36,7 @@ async def test_subinvoke():
         f'fs/{Path(__file__).parent.joinpath("cases", "simple-subinvoke", "invoke").absolute()}'
     )
     args = {"a": 1, "b": 2}
-    options = InvokerOptions(uri=uri, method="add", args=args, encode_result=False)
+    options = InvokerOptions(uri=uri, method="add", args=args, env={}, encode_result=False)
     result = await client.invoke(options)
 
     assert result.unwrap() == "1 + 2 = 3"
@@ -68,13 +68,30 @@ async def test_interface_implementation():
     )
     args = {"arg": {"str": "hello", "uint8": 2}}
     options = InvokerOptions(
-        uri=uri, method="moduleMethod", args=args, encode_result=False
+        uri=uri, method="moduleMethod", args=args, encode_result=False, env={}
     )
     result = await client.invoke(options)
 
     assert result.unwrap() == {"str": "hello", "uint8": 2}
 
 
+def test_get_env_by_uri():
+    uri_resolver = BaseUriResolver(
+        file_reader=SimpleFileReader(),
+        redirects={},
+    )
+    uri = Uri(f'fs/{Path(__file__).parent.joinpath("cases", "simple-env").absolute()}')
+    env = {"externalArray": [1, 2, 3], "externalString": "hello"}
+
+    client = PolywrapClient(
+        config=PolywrapClientConfig(
+            envs={uri: env},
+            resolver=uri_resolver,
+        )
+    )
+    assert client.get_env_by_uri(uri) == env
+
+
 async def test_env():
     uri_resolver = BaseUriResolver(
         file_reader=SimpleFileReader(),
@@ -92,9 +109,10 @@ async def test_env():
     )
     print(client._config)
     options = InvokerOptions(
-        uri=uri, method="externalEnvMethod", args={}, encode_result=False
+        uri=uri, method="externalEnvMethod", args={}, encode_result=False, 
+        env={}
     )
-    
+
     result = await client.invoke(options)
 
     assert result.unwrap() == env
diff --git a/packages/polywrap-core/polywrap_core/types/client.py b/packages/polywrap-core/polywrap_core/types/client.py
index bfa239a0..ade91804 100644
--- a/packages/polywrap-core/polywrap_core/types/client.py
+++ b/packages/polywrap-core/polywrap_core/types/client.py
@@ -50,7 +50,7 @@ def get_interfaces(self) -> List[InterfaceImplementations]:
         pass
 
     @abstractmethod
-    def get_envs(self, options: Optional[GetEnvsOptions] = None) -> List[Env]:
+    def get_envs(self, options: Optional[GetEnvsOptions] = None) -> Dict[Uri, Dict[str, Any]]:
         pass
 
     @abstractmethod

From eb611cc275e8fa88c383a21823d2aa041bf43dd9 Mon Sep 17 00:00:00 2001
From: DaoAdvocate <12145726+rihp@users.noreply.github.com>
Date: Wed, 9 Nov 2022 19:50:02 +0100
Subject: [PATCH 04/21] change in client requires improvement in msgpack

---
 packages/polywrap-client/polywrap_client/client.py   | 11 ++++++++---
 packages/polywrap-client/tests/test_client.py        |  6 +++---
 packages/polywrap-core/polywrap_core/types/client.py |  4 ++--
 packages/polywrap-wasm/polywrap_wasm/wasm_wrapper.py |  2 +-
 4 files changed, 14 insertions(+), 9 deletions(-)

diff --git a/packages/polywrap-client/polywrap_client/client.py b/packages/polywrap-client/polywrap_client/client.py
index a2623a54..6b880db7 100644
--- a/packages/polywrap-client/polywrap_client/client.py
+++ b/packages/polywrap-client/polywrap_client/client.py
@@ -51,7 +51,7 @@ def get_uri_resolver(
     ) -> IUriResolver:
         return self._config.resolver
 
-    def get_envs(self, options: Optional[GetEnvsOptions] = None) -> Dict[Uri, Dict[str, Any]]:
+    def get_envs(self, options: Optional[GetEnvsOptions] = None) -> Union[Dict[Uri, Dict[str, Any]], None]:
         envs = self._config.envs
         return envs
 
@@ -67,7 +67,7 @@ def get_implementations(self, uri: Uri) -> Result[List[Uri]]:
             return Err.from_str(f"Unable to find implementations for uri: {uri}")
 
     def get_env_by_uri(self, uri: Uri, options: Optional[GetEnvsOptions] = None
-    ) -> Union[Env, None]:
+    ) -> Union[Env, Dict[str, Any], None]:
 
         print("uri=", uri)
         print(type(uri))
@@ -84,9 +84,14 @@ def get_env_by_uri(self, uri: Uri, options: Optional[GetEnvsOptions] = None
         print("options=", options)
         print(type(options))
         print("---------")        
-        fn = lambda env: env.uri == uri.uri
+        #fn = lambda env: env.uri == uri.uri
         #print(fn(uri))
         envs = self.get_envs()
+
+        print("---------")
+        print(f"{envs}=")
+        print(type(envs))
+        print("---------") 
         return envs
 
     async def get_file(
diff --git a/packages/polywrap-client/tests/test_client.py b/packages/polywrap-client/tests/test_client.py
index f07353b9..1b4ac912 100644
--- a/packages/polywrap-client/tests/test_client.py
+++ b/packages/polywrap-client/tests/test_client.py
@@ -1,5 +1,5 @@
 from pathlib import Path
-
+import pytest
 from polywrap_client import PolywrapClient
 from polywrap_core import Uri, InvokerOptions, InterfaceImplementations, Env
 from polywrap_uri_resolvers import BaseUriResolver, SimpleFileReader
@@ -89,9 +89,9 @@ def test_get_env_by_uri():
             resolver=uri_resolver,
         )
     )
-    assert client.get_env_by_uri(uri) == env
-
+    assert client.get_env_by_uri(uri) == {uri:env}
 
+# @pytest.mark.skip("not being tested yet")
 async def test_env():
     uri_resolver = BaseUriResolver(
         file_reader=SimpleFileReader(),
diff --git a/packages/polywrap-core/polywrap_core/types/client.py b/packages/polywrap-core/polywrap_core/types/client.py
index ade91804..b11124f4 100644
--- a/packages/polywrap-core/polywrap_core/types/client.py
+++ b/packages/polywrap-core/polywrap_core/types/client.py
@@ -50,13 +50,13 @@ def get_interfaces(self) -> List[InterfaceImplementations]:
         pass
 
     @abstractmethod
-    def get_envs(self, options: Optional[GetEnvsOptions] = None) -> Dict[Uri, Dict[str, Any]]:
+    def get_envs(self, options: Optional[GetEnvsOptions] = None) -> Union[Dict[Uri, Dict[str, Any]], None]:
         pass
 
     @abstractmethod
     def get_env_by_uri(
         self, uri: Uri, options: Optional[GetEnvsOptions] = None
-    ) -> Union[Env, None]:
+    ) -> Union[Env, Dict[str, Any], None]:
         pass
 
     @abstractmethod
diff --git a/packages/polywrap-wasm/polywrap_wasm/wasm_wrapper.py b/packages/polywrap-wasm/polywrap_wasm/wasm_wrapper.py
index c3879454..466326fd 100644
--- a/packages/polywrap-wasm/polywrap_wasm/wasm_wrapper.py
+++ b/packages/polywrap-wasm/polywrap_wasm/wasm_wrapper.py
@@ -62,7 +62,7 @@ async def invoke(
         state.env = (
             options.env
             if isinstance(options.env, (bytes, bytearray))
-            else msgpack_encode(options.env)
+            else msgpack_encode(options.env.env)
         )
 
         if not (state.method and state.args and state.env):

From c7fd20813fd29119e1e009f35094926ef2ccc0cd Mon Sep 17 00:00:00 2001
From: DaoAdvocate <12145726+rihp@users.noreply.github.com>
Date: Wed, 9 Nov 2022 23:07:39 +0100
Subject: [PATCH 05/21] wip: msgpack cannot encode Uris, looking for workaround

---
 .../polywrap-client/polywrap_client/client.py | 44 ++++++++++---------
 packages/polywrap-client/tests/test_client.py |  7 +--
 2 files changed, 27 insertions(+), 24 deletions(-)

diff --git a/packages/polywrap-client/polywrap_client/client.py b/packages/polywrap-client/polywrap_client/client.py
index 6b880db7..9206e173 100644
--- a/packages/polywrap-client/polywrap_client/client.py
+++ b/packages/polywrap-client/polywrap_client/client.py
@@ -67,30 +67,32 @@ def get_implementations(self, uri: Uri) -> Result[List[Uri]]:
             return Err.from_str(f"Unable to find implementations for uri: {uri}")
 
     def get_env_by_uri(self, uri: Uri, options: Optional[GetEnvsOptions] = None
-    ) -> Union[Env, Dict[str, Any], None]:
-
-        print("uri=", uri)
+    ) -> Union[Env, Dict[Uri, Dict[str, Any]], None]:
+        print(f"--> Continue by calling get_env_by_uri: {uri=}") 
+        # print("uri=", uri)
         print(type(uri))
+        # print("---------")
+        # print("uri.uri=", uri.uri)
+        # print("type(uri)", type(uri.uri))
         print("---------")
-        print("uri.uri=", uri.uri)
-        print("type(uri)", type(uri.uri))
-        print("---------")
-        print(f"{self.get_envs()=}")
-        print(f"{type(self.get_envs())=}")
-        print(f"{dir(self.get_envs())}")
-        #print(f"{self.get_envs()}")
-        #print(f"{self.get_envs()=}")
-        print("---------")
-        print("options=", options)
-        print(type(options))
-        print("---------")        
+        # print(f"{self.get_envs()=}")
+        # print(f"{type(self.get_envs())=}")
+        # print(f"{dir(self.get_envs())}")
+        # #print(f"{self.get_envs()}")
+        # #print(f"{self.get_envs()=}")
+        # print("---------")
+        # print("options=", options)
+        # print(type(options))
+        # print("---------")        
         #fn = lambda env: env.uri == uri.uri
         #print(fn(uri))
         envs = self.get_envs()
 
-        print("---------")
-        print(f"{envs}=")
-        print(type(envs))
+        # print("---------")
+        print(f"{envs=}")
+        # if isinstance(envs, dict):
+        #     print(type(envs.get(uri)))
+        #     return envs.get(uri)
         print("---------") 
         return envs
 
@@ -164,11 +166,11 @@ async def invoke(self, options: InvokerOptions) -> Result[Any]:
             return cast(Err, wrapper_result)
         wrapper = wrapper_result.unwrap()
 
-        print(self.get_env_by_uri(options.uri))
+        # print(self.get_env_by_uri(options.uri))
         env = self.get_env_by_uri(options.uri)
-        print(f"{env=}")
+        # print(f"{env=}")
         #print(f"{env.env=}")
-        print('options=', options)
+        # print('options=', options)
         options.env = options.env or (env if env else None)
 
         result = await wrapper.invoke(options, invoker=self)
diff --git a/packages/polywrap-client/tests/test_client.py b/packages/polywrap-client/tests/test_client.py
index 1b4ac912..ee60d251 100644
--- a/packages/polywrap-client/tests/test_client.py
+++ b/packages/polywrap-client/tests/test_client.py
@@ -89,7 +89,7 @@ def test_get_env_by_uri():
             resolver=uri_resolver,
         )
     )
-    assert client.get_env_by_uri(uri) == {uri:env}
+    assert client.get_env_by_uri(uri).get(uri) == env
 
 # @pytest.mark.skip("not being tested yet")
 async def test_env():
@@ -107,10 +107,11 @@ async def test_env():
             resolver=uri_resolver,
         )
     )
-    print(client._config)
+    print(f"--> Begin by configuring the client with the env: {env}")
+    # print(f"{client._config=}")
     options = InvokerOptions(
         uri=uri, method="externalEnvMethod", args={}, encode_result=False, 
-        env={}
+        # env={}
     )
 
     result = await client.invoke(options)

From fdffa9ebf1eb0a03fd4ab1ab2adde5d9513d4641 Mon Sep 17 00:00:00 2001
From: DaoAdvocate <12145726+rihp@users.noreply.github.com>
Date: Wed, 9 Nov 2022 23:09:40 +0100
Subject: [PATCH 06/21] wip

---
 .../polywrap_msgpack/__init__.py              | 46 ++++++++++++++++++-
 .../polywrap_wasm/wasm_wrapper.py             |  2 +-
 2 files changed, 45 insertions(+), 3 deletions(-)

diff --git a/packages/polywrap-msgpack/polywrap_msgpack/__init__.py b/packages/polywrap-msgpack/polywrap_msgpack/__init__.py
index d3452640..5d434d06 100644
--- a/packages/polywrap-msgpack/polywrap_msgpack/__init__.py
+++ b/packages/polywrap-msgpack/polywrap_msgpack/__init__.py
@@ -52,10 +52,27 @@ def sanitize(value: Any) -> Any:
     """
     if isinstance(value, dict):
         dictionary: Dict[Any, Any] = value
-        for key, val in dictionary.items():
+        for key, val in list(dictionary.items()):
+            # try:
+            #     print(f"{key=}")
+            #     print(f"{key.uri=}")
+            # except:
+            #     pass
             if isinstance(key, str):
+                print(f"{key=}")
+                print(f"{type(key)=}")
+                print(f"{val=}")
+                print(f"{type(val)=}")
                 dictionary[key] = sanitize(val)
-            else:
+            elif key.uri:
+                print(f"Found Key and it has uri")
+                print(f"{type(key)=}")
+                print(f"{key.uri=}")
+                print(f"{type(key.uri)=}")
+                print(f"{val=}")
+                print(f"{type(val)=}")
+                dictionary[key] = sanitize(val)
+            else:                
                 raise ValueError(
                     f"expected dict key to be str received {key} with type {type(key)}"
                 )
@@ -72,12 +89,37 @@ def sanitize(value: Any) -> Any:
     if isinstance(value, complex):
         return str(value)
     if hasattr(value, "__slots__"):
+        answer: Dict[str,Any] = {}
+        for s in getattr(value, "__slots__"):
+            print(f"{s=}")
+            if hasattr(value, s):
+                answer.update({s: sanitize(getattr(value, s))})
+            if hasattr(value.uri, 'authority'):
+                # print(value[s])
+                answer.update({s: sanitize(getattr(value.uri, 'uri'))})
+                print(f"!- Found {value.uri=}")
+                print(f"!- Found {value.uri.authority=}")
+            
+        return answer
+
         return {
             s: sanitize(getattr(value, s))
             for s in getattr(value, "__slots__")
             if hasattr(value, s)
         }
     if hasattr(value, "__dict__"):
+        answer: Dict[str, Any] = {}
+        for k, v in vars(value).items():
+            print(f"{k=}")
+            print(f"{v=}")
+            if not isinstance(k, str):
+                answer.update({k.uri:sanitize(v)})
+            if isinstance(k, str):
+                answer.update({k:sanitize(v)})
+            # elif k.uri:
+            #     answer.update({k.uri:sanitize(v)})
+            
+        return answer
         return {k: sanitize(v) for k, v in vars(value).items()}
     return value
 
diff --git a/packages/polywrap-wasm/polywrap_wasm/wasm_wrapper.py b/packages/polywrap-wasm/polywrap_wasm/wasm_wrapper.py
index 466326fd..c3879454 100644
--- a/packages/polywrap-wasm/polywrap_wasm/wasm_wrapper.py
+++ b/packages/polywrap-wasm/polywrap_wasm/wasm_wrapper.py
@@ -62,7 +62,7 @@ async def invoke(
         state.env = (
             options.env
             if isinstance(options.env, (bytes, bytearray))
-            else msgpack_encode(options.env.env)
+            else msgpack_encode(options.env)
         )
 
         if not (state.method and state.args and state.env):

From 894e603bfe4a8b3d7a9a06ef1e4006083111a29e Mon Sep 17 00:00:00 2001
From: DaoAdvocate <12145726+rihp@users.noreply.github.com>
Date: Thu, 10 Nov 2022 17:03:47 +0100
Subject: [PATCH 07/21] typeError: cannot serialize uri object

---
 packages/polywrap-client/polywrap_client/client.py       | 9 ++++++---
 packages/polywrap-core/polywrap_core/types/client.py     | 2 +-
 .../polywrap_core/utils/get_env_from_uri_history.py      | 4 ++--
 3 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/packages/polywrap-client/polywrap_client/client.py b/packages/polywrap-client/polywrap_client/client.py
index 9206e173..1ea9c7e0 100644
--- a/packages/polywrap-client/polywrap_client/client.py
+++ b/packages/polywrap-client/polywrap_client/client.py
@@ -40,7 +40,10 @@ class PolywrapClient(Client):
     def __init__(self, config: Optional[PolywrapClientConfig] = None):
         # TODO: this is naive solution need to use polywrap-client-config-builder once we have it
         self._config = config or PolywrapClientConfig(
-            resolver=FsUriResolver(file_reader=SimpleFileReader())
+            resolver=FsUriResolver(file_reader=SimpleFileReader()),
+            envs={},
+            interfaces={},
+
         )
 
     def get_config(self):
@@ -52,7 +55,7 @@ def get_uri_resolver(
         return self._config.resolver
 
     def get_envs(self, options: Optional[GetEnvsOptions] = None) -> Union[Dict[Uri, Dict[str, Any]], None]:
-        envs = self._config.envs
+        envs: Dict[Uri, Any] = self._config.envs
         return envs
 
     def get_interfaces(self) -> List[InterfaceImplementations]:
@@ -67,7 +70,7 @@ def get_implementations(self, uri: Uri) -> Result[List[Uri]]:
             return Err.from_str(f"Unable to find implementations for uri: {uri}")
 
     def get_env_by_uri(self, uri: Uri, options: Optional[GetEnvsOptions] = None
-    ) -> Union[Env, Dict[Uri, Dict[str, Any]], None]:
+    ) -> Union[Dict[str, Any], None]:
         print(f"--> Continue by calling get_env_by_uri: {uri=}") 
         # print("uri=", uri)
         print(type(uri))
diff --git a/packages/polywrap-core/polywrap_core/types/client.py b/packages/polywrap-core/polywrap_core/types/client.py
index b11124f4..c5b5727b 100644
--- a/packages/polywrap-core/polywrap_core/types/client.py
+++ b/packages/polywrap-core/polywrap_core/types/client.py
@@ -56,7 +56,7 @@ def get_envs(self, options: Optional[GetEnvsOptions] = None) -> Union[Dict[Uri,
     @abstractmethod
     def get_env_by_uri(
         self, uri: Uri, options: Optional[GetEnvsOptions] = None
-    ) -> Union[Env, Dict[str, Any], None]:
+    ) -> Union[Dict[str, Any], None]:
         pass
 
     @abstractmethod
diff --git a/packages/polywrap-core/polywrap_core/utils/get_env_from_uri_history.py b/packages/polywrap-core/polywrap_core/utils/get_env_from_uri_history.py
index dab39dd0..02db2e04 100644
--- a/packages/polywrap-core/polywrap_core/utils/get_env_from_uri_history.py
+++ b/packages/polywrap-core/polywrap_core/utils/get_env_from_uri_history.py
@@ -1,10 +1,10 @@
-from typing import List, Union
+from typing import List, Union, Dict, Any
 
 from ..types import Client, Env, Uri
 
 
 def get_env_from_uri_history(
     uri_history: List[Uri], client: Client
-) -> Union[Env, None]:
+) -> Union[Env, Dict[str, Any], None]:
     for uri in uri_history:
         return client.get_env_by_uri(uri)

From aea8115914a353aab85b335eea5c9c28054947c5 Mon Sep 17 00:00:00 2001
From: DaoAdvocate <12145726+rihp@users.noreply.github.com>
Date: Thu, 10 Nov 2022 17:11:28 +0100
Subject: [PATCH 08/21] cleaning_code

---
 .../polywrap-client/polywrap_client/client.py | 23 +------------------
 1 file changed, 1 insertion(+), 22 deletions(-)

diff --git a/packages/polywrap-client/polywrap_client/client.py b/packages/polywrap-client/polywrap_client/client.py
index 1ea9c7e0..34e3aff8 100644
--- a/packages/polywrap-client/polywrap_client/client.py
+++ b/packages/polywrap-client/polywrap_client/client.py
@@ -55,7 +55,7 @@ def get_uri_resolver(
         return self._config.resolver
 
     def get_envs(self, options: Optional[GetEnvsOptions] = None) -> Union[Dict[Uri, Dict[str, Any]], None]:
-        envs: Dict[Uri, Any] = self._config.envs
+        envs: Dict[Uri, Dict[str, Any]] = self._config.envs
         return envs
 
     def get_interfaces(self) -> List[InterfaceImplementations]:
@@ -72,30 +72,9 @@ def get_implementations(self, uri: Uri) -> Result[List[Uri]]:
     def get_env_by_uri(self, uri: Uri, options: Optional[GetEnvsOptions] = None
     ) -> Union[Dict[str, Any], None]:
         print(f"--> Continue by calling get_env_by_uri: {uri=}") 
-        # print("uri=", uri)
         print(type(uri))
-        # print("---------")
-        # print("uri.uri=", uri.uri)
-        # print("type(uri)", type(uri.uri))
-        print("---------")
-        # print(f"{self.get_envs()=}")
-        # print(f"{type(self.get_envs())=}")
-        # print(f"{dir(self.get_envs())}")
-        # #print(f"{self.get_envs()}")
-        # #print(f"{self.get_envs()=}")
-        # print("---------")
-        # print("options=", options)
-        # print(type(options))
-        # print("---------")        
-        #fn = lambda env: env.uri == uri.uri
-        #print(fn(uri))
         envs = self.get_envs()
-
-        # print("---------")
         print(f"{envs=}")
-        # if isinstance(envs, dict):
-        #     print(type(envs.get(uri)))
-        #     return envs.get(uri)
         print("---------") 
         return envs
 

From eab8a16dfe875627b35f5027fa62df3abdb1798b Mon Sep 17 00:00:00 2001
From: DaoAdvocate <12145726+rihp@users.noreply.github.com>
Date: Thu, 10 Nov 2022 17:24:59 +0100
Subject: [PATCH 09/21] all_tests_passing

---
 packages/polywrap-client/polywrap_client/client.py           | 5 ++++-
 packages/polywrap-client/tests/test_client.py                | 3 ++-
 .../polywrap_core/utils/get_env_from_uri_history.py          | 4 ++--
 3 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/packages/polywrap-client/polywrap_client/client.py b/packages/polywrap-client/polywrap_client/client.py
index 34e3aff8..d35b0cbc 100644
--- a/packages/polywrap-client/polywrap_client/client.py
+++ b/packages/polywrap-client/polywrap_client/client.py
@@ -76,7 +76,10 @@ def get_env_by_uri(self, uri: Uri, options: Optional[GetEnvsOptions] = None
         envs = self.get_envs()
         print(f"{envs=}")
         print("---------") 
-        return envs
+        if hasattr(envs, 'get'):
+            return envs.get(uri)
+        else:
+             return None
 
     async def get_file(
         self, uri: Uri, options: GetFileOptions
diff --git a/packages/polywrap-client/tests/test_client.py b/packages/polywrap-client/tests/test_client.py
index ee60d251..6181a9c0 100644
--- a/packages/polywrap-client/tests/test_client.py
+++ b/packages/polywrap-client/tests/test_client.py
@@ -89,7 +89,8 @@ def test_get_env_by_uri():
             resolver=uri_resolver,
         )
     )
-    assert client.get_env_by_uri(uri).get(uri) == env
+    print()
+    assert client.get_env_by_uri(uri) == env
 
 # @pytest.mark.skip("not being tested yet")
 async def test_env():
diff --git a/packages/polywrap-core/polywrap_core/utils/get_env_from_uri_history.py b/packages/polywrap-core/polywrap_core/utils/get_env_from_uri_history.py
index 02db2e04..dab39dd0 100644
--- a/packages/polywrap-core/polywrap_core/utils/get_env_from_uri_history.py
+++ b/packages/polywrap-core/polywrap_core/utils/get_env_from_uri_history.py
@@ -1,10 +1,10 @@
-from typing import List, Union, Dict, Any
+from typing import List, Union
 
 from ..types import Client, Env, Uri
 
 
 def get_env_from_uri_history(
     uri_history: List[Uri], client: Client
-) -> Union[Env, Dict[str, Any], None]:
+) -> Union[Env, None]:
     for uri in uri_history:
         return client.get_env_by_uri(uri)

From 10b1e20241aedd76af3d7b0351f30991ab620919 Mon Sep 17 00:00:00 2001
From: DaoAdvocate <12145726+rihp@users.noreply.github.com>
Date: Thu, 10 Nov 2022 17:34:24 +0100
Subject: [PATCH 10/21] removing_comments

---
 .../polywrap-client/polywrap_client/client.py |  8 ------
 packages/polywrap-client/tests/test_client.py |  4 ---
 packages/polywrap-client/tests/test_sha3.py   |  2 --
 .../polywrap_msgpack/__init__.py              | 26 +++----------------
 4 files changed, 3 insertions(+), 37 deletions(-)

diff --git a/packages/polywrap-client/polywrap_client/client.py b/packages/polywrap-client/polywrap_client/client.py
index d35b0cbc..49c6132f 100644
--- a/packages/polywrap-client/polywrap_client/client.py
+++ b/packages/polywrap-client/polywrap_client/client.py
@@ -71,11 +71,8 @@ def get_implementations(self, uri: Uri) -> Result[List[Uri]]:
 
     def get_env_by_uri(self, uri: Uri, options: Optional[GetEnvsOptions] = None
     ) -> Union[Dict[str, Any], None]:
-        print(f"--> Continue by calling get_env_by_uri: {uri=}") 
         print(type(uri))
         envs = self.get_envs()
-        print(f"{envs=}")
-        print("---------") 
         if hasattr(envs, 'get'):
             return envs.get(uri)
         else:
@@ -150,12 +147,7 @@ async def invoke(self, options: InvokerOptions) -> Result[Any]:
         if wrapper_result.is_err():
             return cast(Err, wrapper_result)
         wrapper = wrapper_result.unwrap()
-
-        # print(self.get_env_by_uri(options.uri))
         env = self.get_env_by_uri(options.uri)
-        # print(f"{env=}")
-        #print(f"{env.env=}")
-        # print('options=', options)
         options.env = options.env or (env if env else None)
 
         result = await wrapper.invoke(options, invoker=self)
diff --git a/packages/polywrap-client/tests/test_client.py b/packages/polywrap-client/tests/test_client.py
index 6181a9c0..a5862828 100644
--- a/packages/polywrap-client/tests/test_client.py
+++ b/packages/polywrap-client/tests/test_client.py
@@ -89,10 +89,8 @@ def test_get_env_by_uri():
             resolver=uri_resolver,
         )
     )
-    print()
     assert client.get_env_by_uri(uri) == env
 
-# @pytest.mark.skip("not being tested yet")
 async def test_env():
     uri_resolver = BaseUriResolver(
         file_reader=SimpleFileReader(),
@@ -109,10 +107,8 @@ async def test_env():
         )
     )
     print(f"--> Begin by configuring the client with the env: {env}")
-    # print(f"{client._config=}")
     options = InvokerOptions(
         uri=uri, method="externalEnvMethod", args={}, encode_result=False, 
-        # env={}
     )
 
     result = await client.invoke(options)
diff --git a/packages/polywrap-client/tests/test_sha3.py b/packages/polywrap-client/tests/test_sha3.py
index eb116fc9..4aa52ee9 100644
--- a/packages/polywrap-client/tests/test_sha3.py
+++ b/packages/polywrap-client/tests/test_sha3.py
@@ -19,7 +19,6 @@ async def test_invoke_sha3_512():
     result = await client.invoke(options)
     s = hashlib.sha512()
     s.update(b"hello polywrap!")
-    print(result)
     assert result.result == s.digest()
 
 @pytest.mark.skip(reason="can't invoke sha3 wrapper due to an error related to wasmtime")
@@ -90,7 +89,6 @@ async def test_invoke_hex_keccak_256():
 async def test_invoke_buffer_keccak_256():
     options = InvokerOptions(uri=uri, method="buffer_keccak_256", args=args, encode_result=False)
     result = await client.invoke(options)
-    print(result)
     # TODO:  Not sure exactly what this function `buffer_keccak_256` is doing in order to assert it properly
     assert result.result == False
 
diff --git a/packages/polywrap-msgpack/polywrap_msgpack/__init__.py b/packages/polywrap-msgpack/polywrap_msgpack/__init__.py
index 5d434d06..e7f25ed6 100644
--- a/packages/polywrap-msgpack/polywrap_msgpack/__init__.py
+++ b/packages/polywrap-msgpack/polywrap_msgpack/__init__.py
@@ -53,24 +53,9 @@ def sanitize(value: Any) -> Any:
     if isinstance(value, dict):
         dictionary: Dict[Any, Any] = value
         for key, val in list(dictionary.items()):
-            # try:
-            #     print(f"{key=}")
-            #     print(f"{key.uri=}")
-            # except:
-            #     pass
             if isinstance(key, str):
-                print(f"{key=}")
-                print(f"{type(key)=}")
-                print(f"{val=}")
-                print(f"{type(val)=}")
                 dictionary[key] = sanitize(val)
             elif key.uri:
-                print(f"Found Key and it has uri")
-                print(f"{type(key)=}")
-                print(f"{key.uri=}")
-                print(f"{type(key.uri)=}")
-                print(f"{val=}")
-                print(f"{type(val)=}")
                 dictionary[key] = sanitize(val)
             else:                
                 raise ValueError(
@@ -91,17 +76,14 @@ def sanitize(value: Any) -> Any:
     if hasattr(value, "__slots__"):
         answer: Dict[str,Any] = {}
         for s in getattr(value, "__slots__"):
-            print(f"{s=}")
             if hasattr(value, s):
                 answer.update({s: sanitize(getattr(value, s))})
             if hasattr(value.uri, 'authority'):
-                # print(value[s])
                 answer.update({s: sanitize(getattr(value.uri, 'uri'))})
-                print(f"!- Found {value.uri=}")
-                print(f"!- Found {value.uri.authority=}")
+
             
         return answer
-
+        #previous implementation
         return {
             s: sanitize(getattr(value, s))
             for s in getattr(value, "__slots__")
@@ -110,9 +92,7 @@ def sanitize(value: Any) -> Any:
     if hasattr(value, "__dict__"):
         answer: Dict[str, Any] = {}
         for k, v in vars(value).items():
-            print(f"{k=}")
-            print(f"{v=}")
-            if not isinstance(k, str):
+            if hasattr(k, 'uri'):
                 answer.update({k.uri:sanitize(v)})
             if isinstance(k, str):
                 answer.update({k:sanitize(v)})

From 954da64486b95716aa7887a5adda1c182b7d88c0 Mon Sep 17 00:00:00 2001
From: DaoAdvocate <12145726+rihp@users.noreply.github.com>
Date: Thu, 10 Nov 2022 17:42:48 +0100
Subject: [PATCH 11/21] typeckeck_fix_client

---
 packages/polywrap-client/polywrap_client/client.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/packages/polywrap-client/polywrap_client/client.py b/packages/polywrap-client/polywrap_client/client.py
index 49c6132f..44bafe27 100644
--- a/packages/polywrap-client/polywrap_client/client.py
+++ b/packages/polywrap-client/polywrap_client/client.py
@@ -73,8 +73,10 @@ def get_env_by_uri(self, uri: Uri, options: Optional[GetEnvsOptions] = None
     ) -> Union[Dict[str, Any], None]:
         print(type(uri))
         envs = self.get_envs()
-        if hasattr(envs, 'get'):
-            return envs.get(uri)
+        if envs is not None:
+            if hasattr(envs, 'get'):
+                result = envs.get(uri)
+                return result
         else:
              return None
 

From 24246d423dfb11745c0f601b3dfe41ba061f04ba Mon Sep 17 00:00:00 2001
From: DaoAdvocate <12145726+rihp@users.noreply.github.com>
Date: Thu, 10 Nov 2022 17:49:01 +0100
Subject: [PATCH 12/21] core typecheck fixes

---
 .../polywrap_core/utils/get_env_from_uri_history.py           | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/polywrap-core/polywrap_core/utils/get_env_from_uri_history.py b/packages/polywrap-core/polywrap_core/utils/get_env_from_uri_history.py
index dab39dd0..6c9ef177 100644
--- a/packages/polywrap-core/polywrap_core/utils/get_env_from_uri_history.py
+++ b/packages/polywrap-core/polywrap_core/utils/get_env_from_uri_history.py
@@ -1,10 +1,10 @@
-from typing import List, Union
+from typing import List, Union, Dict, Any
 
 from ..types import Client, Env, Uri
 
 
 def get_env_from_uri_history(
     uri_history: List[Uri], client: Client
-) -> Union[Env, None]:
+) -> Union[Dict[str, Any], None]:
     for uri in uri_history:
         return client.get_env_by_uri(uri)

From 51b77f261e7ad201762f77e524253353e2873268 Mon Sep 17 00:00:00 2001
From: DaoAdvocate <12145726+rihp@users.noreply.github.com>
Date: Fri, 11 Nov 2022 09:53:24 +0100
Subject: [PATCH 13/21] CI_CD_build_fixes

---
 .../polywrap_msgpack/__init__.py              | 20 ++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/packages/polywrap-msgpack/polywrap_msgpack/__init__.py b/packages/polywrap-msgpack/polywrap_msgpack/__init__.py
index e7f25ed6..d6440454 100644
--- a/packages/polywrap-msgpack/polywrap_msgpack/__init__.py
+++ b/packages/polywrap-msgpack/polywrap_msgpack/__init__.py
@@ -91,15 +91,17 @@ def sanitize(value: Any) -> Any:
         }
     if hasattr(value, "__dict__"):
         answer: Dict[str, Any] = {}
-        for k, v in vars(value).items():
-            if hasattr(k, 'uri'):
-                answer.update({k.uri:sanitize(v)})
-            if isinstance(k, str):
-                answer.update({k:sanitize(v)})
-            # elif k.uri:
-            #     answer.update({k.uri:sanitize(v)})
-            
-        return answer
+        # TODO:  Maybe this implementation is not correct
+        # for k, v in vars(value).items():
+        #     if hasattr(k, 'uri'):
+        #         print(f">>>>> {k=}")
+        #         new_key:str = k.uri
+        #         answer.update({new_key:sanitize(v)})
+        #     if isinstance(k, str):
+        #         answer.update({k:sanitize(v)})
+        #     # elif k.uri:
+        #     #     answer.update({k.uri:sanitize(v)})
+        # return answer
         return {k: sanitize(v) for k, v in vars(value).items()}
     return value
 

From b952ce4704c4e860263d6d128a462979313b0119 Mon Sep 17 00:00:00 2001
From: DaoAdvocate <12145726+rihp@users.noreply.github.com>
Date: Fri, 11 Nov 2022 10:00:15 +0100
Subject: [PATCH 14/21] CI_CD_build_fixes

---
 .../polywrap_msgpack/__init__.py              | 22 +++++++++----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/packages/polywrap-msgpack/polywrap_msgpack/__init__.py b/packages/polywrap-msgpack/polywrap_msgpack/__init__.py
index d6440454..a972240b 100644
--- a/packages/polywrap-msgpack/polywrap_msgpack/__init__.py
+++ b/packages/polywrap-msgpack/polywrap_msgpack/__init__.py
@@ -74,15 +74,14 @@ def sanitize(value: Any) -> Any:
     if isinstance(value, complex):
         return str(value)
     if hasattr(value, "__slots__"):
-        answer: Dict[str,Any] = {}
-        for s in getattr(value, "__slots__"):
-            if hasattr(value, s):
-                answer.update({s: sanitize(getattr(value, s))})
-            if hasattr(value.uri, 'authority'):
-                answer.update({s: sanitize(getattr(value.uri, 'uri'))})
-
-            
-        return answer
+        # TODO:  Maybe this new implementation is not correct
+        # answer: Dict[str,Any] = {}
+        # for s in getattr(value, "__slots__"):
+        #     if hasattr(value, s):
+        #         answer.update({s: sanitize(getattr(value, s))})
+        #     if hasattr(value.uri, 'authority'):
+        #         answer.update({s: sanitize(getattr(value.uri, 'uri'))})
+        # return answer
         #previous implementation
         return {
             s: sanitize(getattr(value, s))
@@ -90,8 +89,8 @@ def sanitize(value: Any) -> Any:
             if hasattr(value, s)
         }
     if hasattr(value, "__dict__"):
-        answer: Dict[str, Any] = {}
-        # TODO:  Maybe this implementation is not correct
+        # TODO:  Maybe this new implementation is not correct
+        # answer: Dict[str, Any] = {}
         # for k, v in vars(value).items():
         #     if hasattr(k, 'uri'):
         #         print(f">>>>> {k=}")
@@ -102,6 +101,7 @@ def sanitize(value: Any) -> Any:
         #     # elif k.uri:
         #     #     answer.update({k.uri:sanitize(v)})
         # return answer
+        # previous implementation
         return {k: sanitize(v) for k, v in vars(value).items()}
     return value
 

From 445994bdc1dfb6e31a80efad6023cf3e6ee29098 Mon Sep 17 00:00:00 2001
From: DaoAdvocate <12145726+rihp@users.noreply.github.com>
Date: Fri, 11 Nov 2022 10:06:51 +0100
Subject: [PATCH 15/21] Clean_up

---
 .../polywrap_msgpack/__init__.py              | 22 -------------------
 1 file changed, 22 deletions(-)

diff --git a/packages/polywrap-msgpack/polywrap_msgpack/__init__.py b/packages/polywrap-msgpack/polywrap_msgpack/__init__.py
index a972240b..1d16b85a 100644
--- a/packages/polywrap-msgpack/polywrap_msgpack/__init__.py
+++ b/packages/polywrap-msgpack/polywrap_msgpack/__init__.py
@@ -74,34 +74,12 @@ def sanitize(value: Any) -> Any:
     if isinstance(value, complex):
         return str(value)
     if hasattr(value, "__slots__"):
-        # TODO:  Maybe this new implementation is not correct
-        # answer: Dict[str,Any] = {}
-        # for s in getattr(value, "__slots__"):
-        #     if hasattr(value, s):
-        #         answer.update({s: sanitize(getattr(value, s))})
-        #     if hasattr(value.uri, 'authority'):
-        #         answer.update({s: sanitize(getattr(value.uri, 'uri'))})
-        # return answer
-        #previous implementation
         return {
             s: sanitize(getattr(value, s))
             for s in getattr(value, "__slots__")
             if hasattr(value, s)
         }
     if hasattr(value, "__dict__"):
-        # TODO:  Maybe this new implementation is not correct
-        # answer: Dict[str, Any] = {}
-        # for k, v in vars(value).items():
-        #     if hasattr(k, 'uri'):
-        #         print(f">>>>> {k=}")
-        #         new_key:str = k.uri
-        #         answer.update({new_key:sanitize(v)})
-        #     if isinstance(k, str):
-        #         answer.update({k:sanitize(v)})
-        #     # elif k.uri:
-        #     #     answer.update({k.uri:sanitize(v)})
-        # return answer
-        # previous implementation
         return {k: sanitize(v) for k, v in vars(value).items()}
     return value
 

From eeed4b4c2955435d3fdc37c671faefee8bbc14bb Mon Sep 17 00:00:00 2001
From: DaoAdvocate <12145726+rihp@users.noreply.github.com>
Date: Fri, 11 Nov 2022 10:07:09 +0100
Subject: [PATCH 16/21] Clean_up

---
 packages/polywrap-client/polywrap_client/client.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/packages/polywrap-client/polywrap_client/client.py b/packages/polywrap-client/polywrap_client/client.py
index 44bafe27..b4dab4c4 100644
--- a/packages/polywrap-client/polywrap_client/client.py
+++ b/packages/polywrap-client/polywrap_client/client.py
@@ -71,7 +71,6 @@ def get_implementations(self, uri: Uri) -> Result[List[Uri]]:
 
     def get_env_by_uri(self, uri: Uri, options: Optional[GetEnvsOptions] = None
     ) -> Union[Dict[str, Any], None]:
-        print(type(uri))
         envs = self.get_envs()
         if envs is not None:
             if hasattr(envs, 'get'):

From fca83c9ca7b2e82e43b3ce5ee75efa49128cb709 Mon Sep 17 00:00:00 2001
From: DaoAdvocate <12145726+rihp@users.noreply.github.com>
Date: Fri, 11 Nov 2022 10:54:14 +0100
Subject: [PATCH 17/21] interfaceimplementations refactor!

---
 .../polywrap-client/polywrap_client/client.py | 23 ++++++++++++++-----
 packages/polywrap-client/tests/test_client.py | 21 ++++++++++-------
 .../polywrap_core/types/client.py             |  4 ++--
 3 files changed, 32 insertions(+), 16 deletions(-)

diff --git a/packages/polywrap-client/polywrap_client/client.py b/packages/polywrap-client/polywrap_client/client.py
index b4dab4c4..572fb150 100644
--- a/packages/polywrap-client/polywrap_client/client.py
+++ b/packages/polywrap-client/polywrap_client/client.py
@@ -58,16 +58,27 @@ def get_envs(self, options: Optional[GetEnvsOptions] = None) -> Union[Dict[Uri,
         envs: Dict[Uri, Dict[str, Any]] = self._config.envs
         return envs
 
-    def get_interfaces(self) -> List[InterfaceImplementations]:
-        return self._config.interfaces
+    def get_interfaces(self) -> Dict[Uri, List[Uri]]:
+        interfaces: Dict[Uri, List[Uri]] = self._config.interfaces
+        return interfaces
 
     def get_implementations(self, uri: Uri) -> Result[List[Uri]]:
-        if interface_implementations := next(
-            filter(lambda x: x.interface == uri, self._config.interfaces), None
-        ):
-            return Ok(interface_implementations.implementations)
+        interfaces: Dict[Uri, List[Uri]] = self.get_interfaces()
+        if interfaces.get(uri):
+            print(f"{type(interfaces)=}")
+            print(f"{interfaces=}")
+            print(f"{interfaces.get(uri)=}")
+            
+            return Ok(interfaces.get(uri))
         else:
             return Err.from_str(f"Unable to find implementations for uri: {uri}")
+        # previous implementation
+        # if interface_implementations := next(
+        #     filter(lambda x: x.interface == uri, self._config.interfaces), None
+        # ):
+        #     return Ok(interface_implementations.implementations)
+        # else:
+        #     return Err.from_str(f"Unable to find implementations for uri: {uri}")
 
     def get_env_by_uri(self, uri: Uri, options: Optional[GetEnvsOptions] = None
     ) -> Union[Dict[str, Any], None]:
diff --git a/packages/polywrap-client/tests/test_client.py b/packages/polywrap-client/tests/test_client.py
index a5862828..4039f45a 100644
--- a/packages/polywrap-client/tests/test_client.py
+++ b/packages/polywrap-client/tests/test_client.py
@@ -3,7 +3,7 @@
 from polywrap_client import PolywrapClient
 from polywrap_core import Uri, InvokerOptions, InterfaceImplementations, Env
 from polywrap_uri_resolvers import BaseUriResolver, SimpleFileReader
-
+from polywrap_result import Err, Ok, Result
 from polywrap_client.client import PolywrapClientConfig
 
 
@@ -48,19 +48,24 @@ async def test_interface_implementation():
         redirects={},
     )
 
+    interface_uri = Uri("ens/interface.eth")
     impl_uri = Uri(
         f'fs/{Path(__file__).parent.joinpath("cases", "simple-interface", "implementation").absolute()}'
     )
 
     client = PolywrapClient(
         config=PolywrapClientConfig(
-            envs=[],
+            envs={},
             resolver=uri_resolver,
-            interfaces=[
-                InterfaceImplementations(
-                    interface=Uri("ens/interface.eth"), implementations=[impl_uri]
-                )
-            ],
+            # Dict[Uri, List[Uri]]
+
+            interfaces= {interface_uri : [impl_uri]}
+            # previous implementations
+            # interfaces=[
+            #     InterfaceImplementations(
+            #         interface=Uri("ens/interface.eth"), implementations=[impl_uri]
+            #     )
+            # ],
         )
     )
     uri = Uri(
@@ -71,7 +76,7 @@ async def test_interface_implementation():
         uri=uri, method="moduleMethod", args=args, encode_result=False, env={}
     )
     result = await client.invoke(options)
-
+    assert client.get_implementations(interface_uri) == Ok([impl_uri])
     assert result.unwrap() == {"str": "hello", "uint8": 2}
 
 
diff --git a/packages/polywrap-core/polywrap_core/types/client.py b/packages/polywrap-core/polywrap_core/types/client.py
index c5b5727b..b7d044a6 100644
--- a/packages/polywrap-core/polywrap_core/types/client.py
+++ b/packages/polywrap-core/polywrap_core/types/client.py
@@ -19,7 +19,7 @@
 class ClientConfig:
     # TODO  is this a naive solution? the `Any` type should be more specific (str | Uri | int, etc.)
     envs: Dict[Uri, Dict[str, Any]] = field(default_factory=dict) 
-    interfaces: List[InterfaceImplementations] = field(default_factory=list)
+    interfaces: Dict[Uri, List[Uri]] = field(default_factory=dict)
     resolver: IUriResolver
 
 
@@ -46,7 +46,7 @@ class GetManifestOptions(DeserializeManifestOptions):
 
 class Client(Invoker, UriResolverHandler):
     @abstractmethod
-    def get_interfaces(self) -> List[InterfaceImplementations]:
+    def get_interfaces(self) -> Dict[Uri, List[Uri]]:
         pass
 
     @abstractmethod

From a18ada34f45fb9eeac8fe8f2283244ee0a08187a Mon Sep 17 00:00:00 2001
From: DaoAdvocate <12145726+rihp@users.noreply.github.com>
Date: Fri, 11 Nov 2022 11:40:47 +0100
Subject: [PATCH 18/21] cleanup and typechecks

---
 packages/polywrap-client/polywrap_client/client.py   | 12 +++---------
 packages/polywrap-client/tests/test_client.py        | 12 ++----------
 .../polywrap_core/types/interface_implementation.py  |  2 +-
 3 files changed, 6 insertions(+), 20 deletions(-)

diff --git a/packages/polywrap-client/polywrap_client/client.py b/packages/polywrap-client/polywrap_client/client.py
index 572fb150..04b1303e 100644
--- a/packages/polywrap-client/polywrap_client/client.py
+++ b/packages/polywrap-client/polywrap_client/client.py
@@ -2,7 +2,7 @@
 
 from dataclasses import dataclass
 from textwrap import dedent
-from typing import Any, List, Optional, Union, cast,Dict
+from typing import Any, Dict, List, Optional, Union, cast
 
 from polywrap_core import (
     Client,
@@ -62,7 +62,7 @@ def get_interfaces(self) -> Dict[Uri, List[Uri]]:
         interfaces: Dict[Uri, List[Uri]] = self._config.interfaces
         return interfaces
 
-    def get_implementations(self, uri: Uri) -> Result[List[Uri]]:
+    def get_implementations(self, uri: Uri) -> Result[Union[List[Uri], None] ]:
         interfaces: Dict[Uri, List[Uri]] = self.get_interfaces()
         if interfaces.get(uri):
             print(f"{type(interfaces)=}")
@@ -72,13 +72,7 @@ def get_implementations(self, uri: Uri) -> Result[List[Uri]]:
             return Ok(interfaces.get(uri))
         else:
             return Err.from_str(f"Unable to find implementations for uri: {uri}")
-        # previous implementation
-        # if interface_implementations := next(
-        #     filter(lambda x: x.interface == uri, self._config.interfaces), None
-        # ):
-        #     return Ok(interface_implementations.implementations)
-        # else:
-        #     return Err.from_str(f"Unable to find implementations for uri: {uri}")
+
 
     def get_env_by_uri(self, uri: Uri, options: Optional[GetEnvsOptions] = None
     ) -> Union[Dict[str, Any], None]:
diff --git a/packages/polywrap-client/tests/test_client.py b/packages/polywrap-client/tests/test_client.py
index 4039f45a..ee5a3073 100644
--- a/packages/polywrap-client/tests/test_client.py
+++ b/packages/polywrap-client/tests/test_client.py
@@ -1,9 +1,9 @@
 from pathlib import Path
 import pytest
 from polywrap_client import PolywrapClient
-from polywrap_core import Uri, InvokerOptions, InterfaceImplementations, Env
+from polywrap_core import Uri, InvokerOptions
 from polywrap_uri_resolvers import BaseUriResolver, SimpleFileReader
-from polywrap_result import Err, Ok, Result
+from polywrap_result import Ok
 from polywrap_client.client import PolywrapClientConfig
 
 
@@ -57,15 +57,7 @@ async def test_interface_implementation():
         config=PolywrapClientConfig(
             envs={},
             resolver=uri_resolver,
-            # Dict[Uri, List[Uri]]
-
             interfaces= {interface_uri : [impl_uri]}
-            # previous implementations
-            # interfaces=[
-            #     InterfaceImplementations(
-            #         interface=Uri("ens/interface.eth"), implementations=[impl_uri]
-            #     )
-            # ],
         )
     )
     uri = Uri(
diff --git a/packages/polywrap-core/polywrap_core/types/interface_implementation.py b/packages/polywrap-core/polywrap_core/types/interface_implementation.py
index b46ae79d..d0bbc307 100644
--- a/packages/polywrap-core/polywrap_core/types/interface_implementation.py
+++ b/packages/polywrap-core/polywrap_core/types/interface_implementation.py
@@ -5,7 +5,7 @@
 
 from .uri import Uri
 
-
+# TODO:  Should we remove this interfaceimplementation?
 @dataclass(slots=True, kw_only=True)
 class InterfaceImplementations:
     interface: Uri

From e77ba662294a21bb429fd245c6e14f7aa7a8fe20 Mon Sep 17 00:00:00 2001
From: Niraj Kamdar <nirajkamdar27@pm.me>
Date: Sun, 13 Nov 2022 15:37:26 +0530
Subject: [PATCH 19/21] refactor: client and msgpack

---
 packages/polywrap-client/polywrap_client/client.py    |  2 --
 .../polywrap-msgpack/polywrap_msgpack/__init__.py     | 11 ++---------
 2 files changed, 2 insertions(+), 11 deletions(-)

diff --git a/packages/polywrap-client/polywrap_client/client.py b/packages/polywrap-client/polywrap_client/client.py
index 04b1303e..014f9e97 100644
--- a/packages/polywrap-client/polywrap_client/client.py
+++ b/packages/polywrap-client/polywrap_client/client.py
@@ -7,12 +7,10 @@
 from polywrap_core import (
     Client,
     ClientConfig,
-    Env,
     GetEnvsOptions,
     GetFileOptions,
     GetManifestOptions,
     GetUriResolversOptions,
-    InterfaceImplementations,
     InvokerOptions,
     IUriResolutionContext,
     IUriResolver,
diff --git a/packages/polywrap-msgpack/polywrap_msgpack/__init__.py b/packages/polywrap-msgpack/polywrap_msgpack/__init__.py
index 1d16b85a..af0fc63c 100644
--- a/packages/polywrap-msgpack/polywrap_msgpack/__init__.py
+++ b/packages/polywrap-msgpack/polywrap_msgpack/__init__.py
@@ -52,15 +52,8 @@ def sanitize(value: Any) -> Any:
     """
     if isinstance(value, dict):
         dictionary: Dict[Any, Any] = value
-        for key, val in list(dictionary.items()):
-            if isinstance(key, str):
-                dictionary[key] = sanitize(val)
-            elif key.uri:
-                dictionary[key] = sanitize(val)
-            else:                
-                raise ValueError(
-                    f"expected dict key to be str received {key} with type {type(key)}"
-                )
+        for key, val in dictionary.items():
+            dictionary[str(key)] = sanitize(val)
         return dictionary
     if isinstance(value, list):
         array: List[Any] = value

From 53ca20defc0704b2dd0bf249f55e6253ce5b452c Mon Sep 17 00:00:00 2001
From: Niraj Kamdar <nirajkamdar27@pm.me>
Date: Sun, 13 Nov 2022 15:53:33 +0530
Subject: [PATCH 20/21] refactor(client): remove unnecessary code and improve
 code quality

---
 .../polywrap-client/polywrap_client/client.py | 32 ++++++-------------
 packages/polywrap-client/tests/test_client.py | 10 +++---
 .../polywrap_core/types/__init__.py           |  1 -
 .../polywrap_core/types/client.py             | 20 ++++--------
 .../polywrap-core/polywrap_core/types/env.py  | 19 +----------
 .../types/interface_implementation.py         | 12 -------
 .../polywrap_core/types/invoke.py             |  5 +--
 7 files changed, 23 insertions(+), 76 deletions(-)
 delete mode 100644 packages/polywrap-core/polywrap_core/types/interface_implementation.py

diff --git a/packages/polywrap-client/polywrap_client/client.py b/packages/polywrap-client/polywrap_client/client.py
index 014f9e97..31cc6c9b 100644
--- a/packages/polywrap-client/polywrap_client/client.py
+++ b/packages/polywrap-client/polywrap_client/client.py
@@ -7,7 +7,6 @@
 from polywrap_core import (
     Client,
     ClientConfig,
-    GetEnvsOptions,
     GetFileOptions,
     GetManifestOptions,
     GetUriResolversOptions,
@@ -15,6 +14,7 @@
     IUriResolutionContext,
     IUriResolver,
     TryResolveUriOptions,
+    Env,
     Uri,
     UriPackage,
     UriPackageOrWrapper,
@@ -38,10 +38,7 @@ class PolywrapClient(Client):
     def __init__(self, config: Optional[PolywrapClientConfig] = None):
         # TODO: this is naive solution need to use polywrap-client-config-builder once we have it
         self._config = config or PolywrapClientConfig(
-            resolver=FsUriResolver(file_reader=SimpleFileReader()),
-            envs={},
-            interfaces={},
-
+            resolver=FsUriResolver(file_reader=SimpleFileReader())
         )
 
     def get_config(self):
@@ -52,35 +49,25 @@ def get_uri_resolver(
     ) -> IUriResolver:
         return self._config.resolver
 
-    def get_envs(self, options: Optional[GetEnvsOptions] = None) -> Union[Dict[Uri, Dict[str, Any]], None]:
-        envs: Dict[Uri, Dict[str, Any]] = self._config.envs
+    def get_envs(self) -> Dict[Uri, Env]:
+        envs: Dict[Uri, Env] = self._config.envs
         return envs
 
     def get_interfaces(self) -> Dict[Uri, List[Uri]]:
         interfaces: Dict[Uri, List[Uri]] = self._config.interfaces
         return interfaces
 
-    def get_implementations(self, uri: Uri) -> Result[Union[List[Uri], None] ]:
+    def get_implementations(self, uri: Uri) -> Result[Union[List[Uri], None]]:
         interfaces: Dict[Uri, List[Uri]] = self.get_interfaces()
         if interfaces.get(uri):
-            print(f"{type(interfaces)=}")
-            print(f"{interfaces=}")
-            print(f"{interfaces.get(uri)=}")
-            
             return Ok(interfaces.get(uri))
         else:
             return Err.from_str(f"Unable to find implementations for uri: {uri}")
 
-
-    def get_env_by_uri(self, uri: Uri, options: Optional[GetEnvsOptions] = None
+    def get_env_by_uri(
+        self, uri: Uri
     ) -> Union[Dict[str, Any], None]:
-        envs = self.get_envs()
-        if envs is not None:
-            if hasattr(envs, 'get'):
-                result = envs.get(uri)
-                return result
-        else:
-             return None
+        return self._config.envs.get(uri)
 
     async def get_file(
         self, uri: Uri, options: GetFileOptions
@@ -151,8 +138,7 @@ async def invoke(self, options: InvokerOptions) -> Result[Any]:
         if wrapper_result.is_err():
             return cast(Err, wrapper_result)
         wrapper = wrapper_result.unwrap()
-        env = self.get_env_by_uri(options.uri)
-        options.env = options.env or (env if env else None)
+        options.env = options.env or self.get_env_by_uri(options.uri)
 
         result = await wrapper.invoke(options, invoker=self)
         if result.is_err():
diff --git a/packages/polywrap-client/tests/test_client.py b/packages/polywrap-client/tests/test_client.py
index ee5a3073..623195fc 100644
--- a/packages/polywrap-client/tests/test_client.py
+++ b/packages/polywrap-client/tests/test_client.py
@@ -14,7 +14,7 @@ async def test_invoke():
     )
     args = {"arg": "hello polywrap"}
     options = InvokerOptions(
-        uri=uri, method="simpleMethod", args=args, encode_result=False, env={}
+        uri=uri, method="simpleMethod", args=args, encode_result=False
     )
     result = await client.invoke(options)
 
@@ -31,12 +31,12 @@ async def test_subinvoke():
         },
     )
 
-    client = PolywrapClient(config=PolywrapClientConfig(envs=[], resolver=uri_resolver))
+    client = PolywrapClient(config=PolywrapClientConfig(resolver=uri_resolver))
     uri = Uri(
         f'fs/{Path(__file__).parent.joinpath("cases", "simple-subinvoke", "invoke").absolute()}'
     )
     args = {"a": 1, "b": 2}
-    options = InvokerOptions(uri=uri, method="add", args=args, env={}, encode_result=False)
+    options = InvokerOptions(uri=uri, method="add", args=args, encode_result=False)
     result = await client.invoke(options)
 
     assert result.unwrap() == "1 + 2 = 3"
@@ -55,7 +55,6 @@ async def test_interface_implementation():
 
     client = PolywrapClient(
         config=PolywrapClientConfig(
-            envs={},
             resolver=uri_resolver,
             interfaces= {interface_uri : [impl_uri]}
         )
@@ -65,7 +64,7 @@ async def test_interface_implementation():
     )
     args = {"arg": {"str": "hello", "uint8": 2}}
     options = InvokerOptions(
-        uri=uri, method="moduleMethod", args=args, encode_result=False, env={}
+        uri=uri, method="moduleMethod", args=args, encode_result=False
     )
     result = await client.invoke(options)
     assert client.get_implementations(interface_uri) == Ok([impl_uri])
@@ -103,7 +102,6 @@ async def test_env():
             resolver=uri_resolver,
         )
     )
-    print(f"--> Begin by configuring the client with the env: {env}")
     options = InvokerOptions(
         uri=uri, method="externalEnvMethod", args={}, encode_result=False, 
     )
diff --git a/packages/polywrap-core/polywrap_core/types/__init__.py b/packages/polywrap-core/polywrap_core/types/__init__.py
index ba6656d6..d49e4073 100644
--- a/packages/polywrap-core/polywrap_core/types/__init__.py
+++ b/packages/polywrap-core/polywrap_core/types/__init__.py
@@ -1,5 +1,4 @@
 from .client import *
-from .env import *
 from .file_reader import *
 from .invoke import *
 from .uri import *
diff --git a/packages/polywrap-core/polywrap_core/types/client.py b/packages/polywrap-core/polywrap_core/types/client.py
index b7d044a6..dec9b712 100644
--- a/packages/polywrap-core/polywrap_core/types/client.py
+++ b/packages/polywrap-core/polywrap_core/types/client.py
@@ -2,32 +2,24 @@
 
 from abc import abstractmethod
 from dataclasses import dataclass, field
-from typing import List, Optional, Union, Dict, Any
+from typing import List, Optional, Union, Dict
 
 from polywrap_manifest import AnyWrapManifest, DeserializeManifestOptions
 from polywrap_result import Result
 
-from .env import Env
-from .interface_implementation import InterfaceImplementations
 from .invoke import Invoker
 from .uri import Uri
+from .env import Env
 from .uri_resolver import IUriResolver
 from .uri_resolver_handler import UriResolverHandler
 
-
 @dataclass(slots=True, kw_only=True)
 class ClientConfig:
-    # TODO  is this a naive solution? the `Any` type should be more specific (str | Uri | int, etc.)
-    envs: Dict[Uri, Dict[str, Any]] = field(default_factory=dict) 
+    envs: Dict[Uri, Env] = field(default_factory=dict) 
     interfaces: Dict[Uri, List[Uri]] = field(default_factory=dict)
     resolver: IUriResolver
 
 
-@dataclass(slots=True, kw_only=True)
-class GetEnvsOptions:
-    pass
-
-
 @dataclass(slots=True, kw_only=True)
 class GetUriResolversOptions:
     pass
@@ -50,13 +42,13 @@ def get_interfaces(self) -> Dict[Uri, List[Uri]]:
         pass
 
     @abstractmethod
-    def get_envs(self, options: Optional[GetEnvsOptions] = None) -> Union[Dict[Uri, Dict[str, Any]], None]:
+    def get_envs(self) -> Dict[Uri, Env]:
         pass
 
     @abstractmethod
     def get_env_by_uri(
-        self, uri: Uri, options: Optional[GetEnvsOptions] = None
-    ) -> Union[Dict[str, Any], None]:
+        self, uri: Uri
+    ) -> Union[Env, None]:
         pass
 
     @abstractmethod
diff --git a/packages/polywrap-core/polywrap_core/types/env.py b/packages/polywrap-core/polywrap_core/types/env.py
index ff1f914a..48dfa894 100644
--- a/packages/polywrap-core/polywrap_core/types/env.py
+++ b/packages/polywrap-core/polywrap_core/types/env.py
@@ -1,20 +1,3 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
 from typing import Any, Dict
 
-from .uri import Uri
-
-
-@dataclass(slots=True, kw_only=True)
-class Env:
-    """
-    this type can be used to set env for a wrapper in the client
-
-    Args:
-        uri: Uri of wrapper
-        env: env variables used by the module
-    """
-
-    uri: Uri
-    env: Dict[str, Any] = field(default_factory=dict)
+Env = Dict[str, Any]
diff --git a/packages/polywrap-core/polywrap_core/types/interface_implementation.py b/packages/polywrap-core/polywrap_core/types/interface_implementation.py
deleted file mode 100644
index d0bbc307..00000000
--- a/packages/polywrap-core/polywrap_core/types/interface_implementation.py
+++ /dev/null
@@ -1,12 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import List
-
-from .uri import Uri
-
-# TODO:  Should we remove this interfaceimplementation?
-@dataclass(slots=True, kw_only=True)
-class InterfaceImplementations:
-    interface: Uri
-    implementations: List[Uri]
diff --git a/packages/polywrap-core/polywrap_core/types/invoke.py b/packages/polywrap-core/polywrap_core/types/invoke.py
index 7c474cd8..47634396 100644
--- a/packages/polywrap-core/polywrap_core/types/invoke.py
+++ b/packages/polywrap-core/polywrap_core/types/invoke.py
@@ -7,6 +7,7 @@
 from polywrap_result import Result
 
 from .uri import Uri
+from .env import Env
 from .uri_resolution_context import IUriResolutionContext
 
 
@@ -26,7 +27,7 @@ class InvokeOptions:
     uri: Uri
     method: str
     args: Optional[Union[Dict[str, Any], bytes]] = field(default_factory=dict)
-    env: Optional[Dict[str, Any]] = None
+    env: Optional[Env] = None
     resolution_context: Optional[IUriResolutionContext] = None
 
 
@@ -55,7 +56,7 @@ async def invoke(self, options: InvokerOptions) -> Result[Any]:
         pass
 
     @abstractmethod
-    def get_implementations(self, uri: Uri) -> Result[List[Uri]]:
+    def get_implementations(self, uri: Uri) -> Result[Union[List[Uri], None]]:
         pass
 
 

From 55246d3dd7603a814f09b18e9fc2c8c1f4ccf1c4 Mon Sep 17 00:00:00 2001
From: Niraj Kamdar <nirajkamdar27@pm.me>
Date: Sun, 13 Nov 2022 15:55:04 +0530
Subject: [PATCH 21/21] refactor(client): use Env alias type

---
 packages/polywrap-client/polywrap_client/client.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/polywrap-client/polywrap_client/client.py b/packages/polywrap-client/polywrap_client/client.py
index 31cc6c9b..b12368cb 100644
--- a/packages/polywrap-client/polywrap_client/client.py
+++ b/packages/polywrap-client/polywrap_client/client.py
@@ -66,7 +66,7 @@ def get_implementations(self, uri: Uri) -> Result[Union[List[Uri], None]]:
 
     def get_env_by_uri(
         self, uri: Uri
-    ) -> Union[Dict[str, Any], None]:
+    ) -> Union[Env, None]:
         return self._config.envs.get(uri)
 
     async def get_file(