faster-eth-abi 5.2.15__cp314-cp314t-win32.whl → 5.2.16__cp314-cp314t-win32.whl

faster_eth_abi/codec.py

@@ -1,4 +1,11 @@
 # mypy: disable-error-code="overload-overlap"
+"""
+API for ABI encoding and decoding.
+
+Defines the main encoder and decoder classes, providing methods for binary serialization
+and deserialization of values according to ABI type specifications.
+"""
+
 from typing import (
     Any,
     Iterable,
@@ -7,6 +14,9 @@ from typing import (
     overload,
 )
 
+from eth_typing import (
+    HexAddress,
+)
 from eth_typing.abi import (
     Decodable,
     TypeStr,
@@ -27,6 +37,7 @@ from faster_eth_abi.registry import (
     ABIRegistry,
 )
 from faster_eth_abi.typing import (
+    AddressTypeStr,
     BoolTypeStr,
     BytesTypeStr,
     IntTypeStr,
@@ -91,7 +102,7 @@ class ABIEncoder(BaseABICoder):
             encoder = self._registry.get_encoder(typ)
         except MultipleEntriesFound:
             raise
-        except:
+        except Exception:
             return False
 
         validate = getattr(encoder, "validate_value", encoder)
@@ -128,6 +139,15 @@ class ABIDecoder(BaseABICoder):
 
     # len == 1
 
+    @overload
+    def decode(
+        self,
+        types: Tuple[AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[HexAddress]:
+        ...
+
     @overload
     def decode(
         self,
@@ -164,8 +184,80 @@ class ABIDecoder(BaseABICoder):
     ) -> Tuple[bool]:
         ...
 
+    @overload
+    def decode(
+        self,
+        types: Tuple[TypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Any]:
+        ...
+
     # len == 2
 
+    @overload
+    def decode(
+        self,
+        types: Tuple[AddressTypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[HexAddress, HexAddress]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[AddressTypeStr, BytesTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[HexAddress, bytes]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[AddressTypeStr, StringTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[HexAddress, str]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[AddressTypeStr, DecodesToIntTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[HexAddress, int]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[AddressTypeStr, BoolTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[HexAddress, bool]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[AddressTypeStr, TypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[HexAddress, Any]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[BytesTypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[bytes, HexAddress]:
+        ...
+
     @overload
     def decode(
         self,
@@ -211,6 +303,15 @@ class ABIDecoder(BaseABICoder):
     ) -> Tuple[bytes, Any]:
         ...
 
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, HexAddress]:
+        ...
+
     @overload
     def decode(
         self,
@@ -256,6 +357,15 @@ class ABIDecoder(BaseABICoder):
     ) -> Tuple[str, Any]:
         ...
 
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, HexAddress]:
+        ...
+
     @overload
     def decode(
         self,
@@ -301,6 +411,15 @@ class ABIDecoder(BaseABICoder):
     ) -> Tuple[int, Any]:
         ...
 
+    @overload
+    def decode(
+        self,
+        types: Tuple[BoolTypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[bool, HexAddress]:
+        ...
+
     @overload
     def decode(
         self,
@@ -346,6 +465,15 @@ class ABIDecoder(BaseABICoder):
     ) -> Tuple[bool, Any]:
         ...
 
+    @overload
+    def decode(
+        self,
+        types: Tuple[TypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Any, HexAddress]:
+        ...
+
     @overload
     def decode(
         self,
@@ -398,574 +526,1177 @@ class ABIDecoder(BaseABICoder):
     @overload
     def decode(
         self,
-        types: Tuple[BytesTypeStr, BytesTypeStr, BytesTypeStr],
+        types: Tuple[AddressTypeStr, AddressTypeStr, AddressTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[bytes, bytes, bytes]:
+    ) -> Tuple[HexAddress, HexAddress, HexAddress]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[BytesTypeStr, BytesTypeStr, StringTypeStr],
+        types: Tuple[AddressTypeStr, AddressTypeStr, BytesTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[bytes, bytes, str]:
+    ) -> Tuple[HexAddress, HexAddress, bytes]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[BytesTypeStr, BytesTypeStr, DecodesToIntTypeStr],
+        types: Tuple[AddressTypeStr, AddressTypeStr, StringTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[bytes, bytes, int]:
+    ) -> Tuple[HexAddress, HexAddress, str]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[BytesTypeStr, BytesTypeStr, BoolTypeStr],
+        types: Tuple[AddressTypeStr, AddressTypeStr, DecodesToIntTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[bytes, bytes, bool]:
+    ) -> Tuple[HexAddress, HexAddress, int]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[BytesTypeStr, BytesTypeStr, TypeStr],
+        types: Tuple[AddressTypeStr, AddressTypeStr, BoolTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[bytes, bytes, Any]:
+    ) -> Tuple[HexAddress, HexAddress, bool]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[BytesTypeStr, StringTypeStr, BytesTypeStr],
+        types: Tuple[AddressTypeStr, AddressTypeStr, TypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[bytes, str, bytes]:
+    ) -> Tuple[HexAddress, HexAddress, Any]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[BytesTypeStr, StringTypeStr, StringTypeStr],
+        types: Tuple[AddressTypeStr, BytesTypeStr, AddressTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[bytes, str, str]:
+    ) -> Tuple[HexAddress, bytes, HexAddress]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[BytesTypeStr, StringTypeStr, DecodesToIntTypeStr],
+        types: Tuple[AddressTypeStr, BytesTypeStr, BytesTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[bytes, str, int]:
+    ) -> Tuple[HexAddress, bytes, bytes]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[BytesTypeStr, StringTypeStr, BoolTypeStr],
+        types: Tuple[AddressTypeStr, BytesTypeStr, StringTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[bytes, str, bool]:
+    ) -> Tuple[HexAddress, bytes, str]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[BytesTypeStr, StringTypeStr, TypeStr],
+        types: Tuple[AddressTypeStr, BytesTypeStr, DecodesToIntTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[bytes, str, Any]:
+    ) -> Tuple[HexAddress, bytes, int]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[BytesTypeStr, DecodesToIntTypeStr, BytesTypeStr],
+        types: Tuple[AddressTypeStr, BytesTypeStr, BoolTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[bytes, int, bytes]:
+    ) -> Tuple[HexAddress, bytes, bool]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[BytesTypeStr, DecodesToIntTypeStr, StringTypeStr],
+        types: Tuple[AddressTypeStr, BytesTypeStr, TypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[bytes, int, str]:
+    ) -> Tuple[HexAddress, bytes, Any]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[BytesTypeStr, DecodesToIntTypeStr, DecodesToIntTypeStr],
+        types: Tuple[AddressTypeStr, StringTypeStr, AddressTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[bytes, int, int]:
+    ) -> Tuple[HexAddress, str, HexAddress]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[BytesTypeStr, DecodesToIntTypeStr, BoolTypeStr],
+        types: Tuple[AddressTypeStr, StringTypeStr, BytesTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[bytes, int, bool]:
+    ) -> Tuple[HexAddress, str, bytes]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[BytesTypeStr, DecodesToIntTypeStr, TypeStr],
+        types: Tuple[AddressTypeStr, StringTypeStr, StringTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[bytes, int, Any]:
+    ) -> Tuple[HexAddress, str, str]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[BytesTypeStr, BoolTypeStr, BytesTypeStr],
+        types: Tuple[AddressTypeStr, StringTypeStr, DecodesToIntTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[bytes, bool, bytes]:
+    ) -> Tuple[HexAddress, str, int]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[BytesTypeStr, BoolTypeStr, StringTypeStr],
+        types: Tuple[AddressTypeStr, StringTypeStr, BoolTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[bytes, bool, str]:
+    ) -> Tuple[HexAddress, str, bool]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[BytesTypeStr, BoolTypeStr, DecodesToIntTypeStr],
+        types: Tuple[AddressTypeStr, StringTypeStr, TypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[bytes, bool, int]:
+    ) -> Tuple[HexAddress, str, Any]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[BytesTypeStr, BoolTypeStr, BoolTypeStr],
+        types: Tuple[AddressTypeStr, DecodesToIntTypeStr, AddressTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[bytes, bool, bool]:
+    ) -> Tuple[HexAddress, int, HexAddress]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[BytesTypeStr, BoolTypeStr, TypeStr],
+        types: Tuple[AddressTypeStr, DecodesToIntTypeStr, BytesTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[bytes, bool, Any]:
+    ) -> Tuple[HexAddress, int, bytes]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[BytesTypeStr, TypeStr, BytesTypeStr],
+        types: Tuple[AddressTypeStr, DecodesToIntTypeStr, StringTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[bytes, Any, bytes]:
+    ) -> Tuple[HexAddress, int, str]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[BytesTypeStr, TypeStr, StringTypeStr],
+        types: Tuple[AddressTypeStr, DecodesToIntTypeStr, DecodesToIntTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[bytes, Any, str]:
+    ) -> Tuple[HexAddress, int, int]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[BytesTypeStr, TypeStr, DecodesToIntTypeStr],
+        types: Tuple[AddressTypeStr, DecodesToIntTypeStr, BoolTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[bytes, Any, int]:
+    ) -> Tuple[HexAddress, int, bool]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[BytesTypeStr, TypeStr, BoolTypeStr],
+        types: Tuple[AddressTypeStr, DecodesToIntTypeStr, TypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[bytes, Any, bool]:
+    ) -> Tuple[HexAddress, int, Any]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[BytesTypeStr, TypeStr, TypeStr],
+        types: Tuple[AddressTypeStr, BoolTypeStr, AddressTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[bytes, Any, Any]:
+    ) -> Tuple[HexAddress, bool, HexAddress]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[StringTypeStr, BytesTypeStr, BytesTypeStr],
+        types: Tuple[AddressTypeStr, BoolTypeStr, BytesTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[str, bytes, bytes]:
+    ) -> Tuple[HexAddress, bool, bytes]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[StringTypeStr, BytesTypeStr, StringTypeStr],
+        types: Tuple[AddressTypeStr, BoolTypeStr, StringTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[str, bytes, str]:
+    ) -> Tuple[HexAddress, bool, str]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[StringTypeStr, BytesTypeStr, DecodesToIntTypeStr],
+        types: Tuple[AddressTypeStr, BoolTypeStr, DecodesToIntTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[str, bytes, int]:
+    ) -> Tuple[HexAddress, bool, int]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[StringTypeStr, BytesTypeStr, BoolTypeStr],
+        types: Tuple[AddressTypeStr, BoolTypeStr, BoolTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[str, bytes, bool]:
+    ) -> Tuple[HexAddress, bool, bool]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[StringTypeStr, BytesTypeStr, TypeStr],
+        types: Tuple[AddressTypeStr, BoolTypeStr, TypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[str, bytes, Any]:
+    ) -> Tuple[HexAddress, bool, Any]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[StringTypeStr, StringTypeStr, BytesTypeStr],
+        types: Tuple[AddressTypeStr, TypeStr, AddressTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[str, str, bytes]:
+    ) -> Tuple[HexAddress, Any, HexAddress]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[StringTypeStr, StringTypeStr, StringTypeStr],
+        types: Tuple[AddressTypeStr, TypeStr, BytesTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[str, str, str]:
+    ) -> Tuple[HexAddress, Any, bytes]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[StringTypeStr, StringTypeStr, DecodesToIntTypeStr],
+        types: Tuple[AddressTypeStr, TypeStr, StringTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[str, str, int]:
+    ) -> Tuple[HexAddress, Any, str]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[StringTypeStr, StringTypeStr, BoolTypeStr],
+        types: Tuple[AddressTypeStr, TypeStr, DecodesToIntTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[str, str, bool]:
+    ) -> Tuple[HexAddress, Any, int]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[StringTypeStr, StringTypeStr, TypeStr],
+        types: Tuple[AddressTypeStr, TypeStr, BoolTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[str, str, Any]:
+    ) -> Tuple[HexAddress, Any, bool]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[StringTypeStr, DecodesToIntTypeStr, BytesTypeStr],
+        types: Tuple[AddressTypeStr, TypeStr, TypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[str, int, bytes]:
+    ) -> Tuple[HexAddress, Any, Any]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[StringTypeStr, DecodesToIntTypeStr, StringTypeStr],
+        types: Tuple[BytesTypeStr, AddressTypeStr, AddressTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[str, int, str]:
+    ) -> Tuple[bytes, HexAddress, HexAddress]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[StringTypeStr, DecodesToIntTypeStr, DecodesToIntTypeStr],
+        types: Tuple[BytesTypeStr, AddressTypeStr, BytesTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[str, int, int]:
+    ) -> Tuple[bytes, HexAddress, bytes]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[StringTypeStr, DecodesToIntTypeStr, BoolTypeStr],
+        types: Tuple[BytesTypeStr, AddressTypeStr, StringTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[str, int, bool]:
+    ) -> Tuple[bytes, HexAddress, str]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[StringTypeStr, DecodesToIntTypeStr, TypeStr],
+        types: Tuple[BytesTypeStr, AddressTypeStr, DecodesToIntTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[str, int, Any]:
+    ) -> Tuple[bytes, HexAddress, int]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[StringTypeStr, BoolTypeStr, BytesTypeStr],
+        types: Tuple[BytesTypeStr, AddressTypeStr, BoolTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[str, bool, bytes]:
+    ) -> Tuple[bytes, HexAddress, bool]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[StringTypeStr, BoolTypeStr, StringTypeStr],
+        types: Tuple[BytesTypeStr, AddressTypeStr, TypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[str, bool, str]:
+    ) -> Tuple[bytes, HexAddress, Any]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[StringTypeStr, BoolTypeStr, DecodesToIntTypeStr],
+        types: Tuple[BytesTypeStr, BytesTypeStr, AddressTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[str, bool, int]:
+    ) -> Tuple[bytes, bytes, HexAddress]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[StringTypeStr, BoolTypeStr, BoolTypeStr],
+        types: Tuple[BytesTypeStr, BytesTypeStr, BytesTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[str, bool, bool]:
+    ) -> Tuple[bytes, bytes, bytes]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[StringTypeStr, BoolTypeStr, TypeStr],
+        types: Tuple[BytesTypeStr, BytesTypeStr, StringTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[str, bool, Any]:
+    ) -> Tuple[bytes, bytes, str]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[StringTypeStr, TypeStr, BytesTypeStr],
+        types: Tuple[BytesTypeStr, BytesTypeStr, DecodesToIntTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[str, Any, bytes]:
+    ) -> Tuple[bytes, bytes, int]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[StringTypeStr, TypeStr, StringTypeStr],
+        types: Tuple[BytesTypeStr, BytesTypeStr, BoolTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[str, Any, str]:
+    ) -> Tuple[bytes, bytes, bool]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[StringTypeStr, TypeStr, DecodesToIntTypeStr],
+        types: Tuple[BytesTypeStr, BytesTypeStr, TypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[str, Any, int]:
+    ) -> Tuple[bytes, bytes, Any]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[StringTypeStr, TypeStr, BoolTypeStr],
+        types: Tuple[BytesTypeStr, StringTypeStr, AddressTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[str, Any, bool]:
+    ) -> Tuple[bytes, str, HexAddress]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[StringTypeStr, TypeStr, TypeStr],
+        types: Tuple[BytesTypeStr, StringTypeStr, BytesTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[str, Any, Any]:
+    ) -> Tuple[bytes, str, bytes]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[DecodesToIntTypeStr, BytesTypeStr, BytesTypeStr],
+        types: Tuple[BytesTypeStr, StringTypeStr, StringTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[int, bytes, bytes]:
+    ) -> Tuple[bytes, str, str]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[DecodesToIntTypeStr, BytesTypeStr, StringTypeStr],
+        types: Tuple[BytesTypeStr, StringTypeStr, DecodesToIntTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[int, bytes, str]:
+    ) -> Tuple[bytes, str, int]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[DecodesToIntTypeStr, BytesTypeStr, DecodesToIntTypeStr],
+        types: Tuple[BytesTypeStr, StringTypeStr, BoolTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[int, bytes, int]:
+    ) -> Tuple[bytes, str, bool]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[DecodesToIntTypeStr, BytesTypeStr, BoolTypeStr],
+        types: Tuple[BytesTypeStr, StringTypeStr, TypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[int, bytes, bool]:
+    ) -> Tuple[bytes, str, Any]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[DecodesToIntTypeStr, BytesTypeStr, TypeStr],
+        types: Tuple[BytesTypeStr, DecodesToIntTypeStr, AddressTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[int, bytes, Any]:
+    ) -> Tuple[bytes, int, HexAddress]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[DecodesToIntTypeStr, StringTypeStr, BytesTypeStr],
+        types: Tuple[BytesTypeStr, DecodesToIntTypeStr, BytesTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[int, str, bytes]:
+    ) -> Tuple[bytes, int, bytes]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[DecodesToIntTypeStr, StringTypeStr, StringTypeStr],
+        types: Tuple[BytesTypeStr, DecodesToIntTypeStr, StringTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[int, str, str]:
+    ) -> Tuple[bytes, int, str]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[DecodesToIntTypeStr, StringTypeStr, DecodesToIntTypeStr],
+        types: Tuple[BytesTypeStr, DecodesToIntTypeStr, DecodesToIntTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[int, str, int]:
+    ) -> Tuple[bytes, int, int]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[DecodesToIntTypeStr, StringTypeStr, BoolTypeStr],
+        types: Tuple[BytesTypeStr, DecodesToIntTypeStr, BoolTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[int, str, bool]:
+    ) -> Tuple[bytes, int, bool]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[DecodesToIntTypeStr, StringTypeStr, TypeStr],
+        types: Tuple[BytesTypeStr, DecodesToIntTypeStr, TypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[int, str, Any]:
+    ) -> Tuple[bytes, int, Any]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[DecodesToIntTypeStr, DecodesToIntTypeStr, BytesTypeStr],
+        types: Tuple[BytesTypeStr, BoolTypeStr, AddressTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[int, int, bytes]:
+    ) -> Tuple[bytes, bool, HexAddress]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[DecodesToIntTypeStr, DecodesToIntTypeStr, StringTypeStr],
+        types: Tuple[BytesTypeStr, BoolTypeStr, BytesTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[int, int, str]:
+    ) -> Tuple[bytes, bool, bytes]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[DecodesToIntTypeStr, DecodesToIntTypeStr, DecodesToIntTypeStr],
+        types: Tuple[BytesTypeStr, BoolTypeStr, StringTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[int, int, int]:
+    ) -> Tuple[bytes, bool, str]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[DecodesToIntTypeStr, DecodesToIntTypeStr, BoolTypeStr],
+        types: Tuple[BytesTypeStr, BoolTypeStr, DecodesToIntTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[bytes, bool, int]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[BytesTypeStr, BoolTypeStr, BoolTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[bytes, bool, bool]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[BytesTypeStr, BoolTypeStr, TypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[bytes, bool, Any]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[BytesTypeStr, TypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[bytes, Any, HexAddress]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[BytesTypeStr, TypeStr, BytesTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[bytes, Any, bytes]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[BytesTypeStr, TypeStr, StringTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[bytes, Any, str]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[BytesTypeStr, TypeStr, DecodesToIntTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[bytes, Any, int]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[BytesTypeStr, TypeStr, BoolTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[bytes, Any, bool]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[BytesTypeStr, TypeStr, TypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[bytes, Any, Any]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, AddressTypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, HexAddress, HexAddress]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, AddressTypeStr, BytesTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, HexAddress, bytes]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, AddressTypeStr, StringTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, HexAddress, str]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, AddressTypeStr, DecodesToIntTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, HexAddress, int]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, AddressTypeStr, BoolTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, HexAddress, bool]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, AddressTypeStr, TypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, HexAddress, Any]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, BytesTypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, bytes, HexAddress]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, BytesTypeStr, BytesTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, bytes, bytes]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, BytesTypeStr, StringTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, bytes, str]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, BytesTypeStr, DecodesToIntTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, bytes, int]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, BytesTypeStr, BoolTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, bytes, bool]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, BytesTypeStr, TypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, bytes, Any]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, StringTypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, str, HexAddress]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, StringTypeStr, BytesTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, str, bytes]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, StringTypeStr, StringTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, str, str]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, StringTypeStr, DecodesToIntTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, str, int]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, StringTypeStr, BoolTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, str, bool]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, StringTypeStr, TypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, str, Any]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, DecodesToIntTypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, int, HexAddress]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, DecodesToIntTypeStr, BytesTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, int, bytes]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, DecodesToIntTypeStr, StringTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, int, str]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, DecodesToIntTypeStr, DecodesToIntTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, int, int]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, DecodesToIntTypeStr, BoolTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, int, bool]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, DecodesToIntTypeStr, TypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, int, Any]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, BoolTypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, bool, HexAddress]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, BoolTypeStr, BytesTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, bool, bytes]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, BoolTypeStr, StringTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, bool, str]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, BoolTypeStr, DecodesToIntTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, bool, int]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, BoolTypeStr, BoolTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, bool, bool]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, BoolTypeStr, TypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, bool, Any]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, TypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, Any, HexAddress]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, TypeStr, BytesTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, Any, bytes]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, TypeStr, StringTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, Any, str]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, TypeStr, DecodesToIntTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, Any, int]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, TypeStr, BoolTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, Any, bool]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[StringTypeStr, TypeStr, TypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[str, Any, Any]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, AddressTypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, HexAddress, HexAddress]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, AddressTypeStr, BytesTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, HexAddress, bytes]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, AddressTypeStr, StringTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, HexAddress, str]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, AddressTypeStr, DecodesToIntTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, HexAddress, int]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, AddressTypeStr, BoolTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, HexAddress, bool]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, AddressTypeStr, TypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, HexAddress, Any]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, BytesTypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, bytes, HexAddress]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, BytesTypeStr, BytesTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, bytes, bytes]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, BytesTypeStr, StringTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, bytes, str]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, BytesTypeStr, DecodesToIntTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, bytes, int]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, BytesTypeStr, BoolTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, bytes, bool]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, BytesTypeStr, TypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, bytes, Any]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, StringTypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, str, HexAddress]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, StringTypeStr, BytesTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, str, bytes]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, StringTypeStr, StringTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, str, str]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, StringTypeStr, DecodesToIntTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, str, int]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, StringTypeStr, BoolTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, str, bool]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, StringTypeStr, TypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, str, Any]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, DecodesToIntTypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, int, HexAddress]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, DecodesToIntTypeStr, BytesTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, int, bytes]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, DecodesToIntTypeStr, StringTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, int, str]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, DecodesToIntTypeStr, DecodesToIntTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, int, int]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, DecodesToIntTypeStr, BoolTypeStr],
         data: Decodable,
         strict: bool = True,
     ) -> Tuple[int, int, bool]:
@@ -980,6 +1711,15 @@ class ABIDecoder(BaseABICoder):
     ) -> Tuple[int, int, Any]:
         ...
 
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, BoolTypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, bool, HexAddress]:
+        ...
+
     @overload
     def decode(
         self,
@@ -1001,73 +1741,145 @@ class ABIDecoder(BaseABICoder):
     @overload
     def decode(
         self,
-        types: Tuple[DecodesToIntTypeStr, BoolTypeStr, DecodesToIntTypeStr],
+        types: Tuple[DecodesToIntTypeStr, BoolTypeStr, DecodesToIntTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, bool, int]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, BoolTypeStr, BoolTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, bool, bool]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, BoolTypeStr, TypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, bool, Any]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, TypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, Any, HexAddress]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, TypeStr, BytesTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, Any, bytes]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, TypeStr, StringTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, Any, str]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, TypeStr, DecodesToIntTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, Any, int]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, TypeStr, BoolTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[int, Any, bool]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[DecodesToIntTypeStr, TypeStr, TypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[int, bool, int]:
+    ) -> Tuple[int, Any, Any]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[DecodesToIntTypeStr, BoolTypeStr, BoolTypeStr],
+        types: Tuple[BoolTypeStr, AddressTypeStr, AddressTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[int, bool, bool]:
+    ) -> Tuple[bool, HexAddress, HexAddress]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[DecodesToIntTypeStr, BoolTypeStr, TypeStr],
+        types: Tuple[BoolTypeStr, AddressTypeStr, BytesTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[int, bool, Any]:
+    ) -> Tuple[bool, HexAddress, bytes]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[DecodesToIntTypeStr, TypeStr, BytesTypeStr],
+        types: Tuple[BoolTypeStr, AddressTypeStr, StringTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[int, Any, bytes]:
+    ) -> Tuple[bool, HexAddress, str]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[DecodesToIntTypeStr, TypeStr, StringTypeStr],
+        types: Tuple[BoolTypeStr, AddressTypeStr, DecodesToIntTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[int, Any, str]:
+    ) -> Tuple[bool, HexAddress, int]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[DecodesToIntTypeStr, TypeStr, DecodesToIntTypeStr],
+        types: Tuple[BoolTypeStr, AddressTypeStr, BoolTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[int, Any, int]:
+    ) -> Tuple[bool, HexAddress, bool]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[DecodesToIntTypeStr, TypeStr, BoolTypeStr],
+        types: Tuple[BoolTypeStr, AddressTypeStr, TypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[int, Any, bool]:
+    ) -> Tuple[bool, HexAddress, Any]:
         ...
 
     @overload
     def decode(
         self,
-        types: Tuple[DecodesToIntTypeStr, TypeStr, TypeStr],
+        types: Tuple[BoolTypeStr, BytesTypeStr, AddressTypeStr],
         data: Decodable,
         strict: bool = True,
-    ) -> Tuple[int, Any, Any]:
+    ) -> Tuple[bool, bytes, HexAddress]:
         ...
 
     @overload
@@ -1115,6 +1927,15 @@ class ABIDecoder(BaseABICoder):
     ) -> Tuple[bool, bytes, Any]:
         ...
 
+    @overload
+    def decode(
+        self,
+        types: Tuple[BoolTypeStr, StringTypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[bool, str, HexAddress]:
+        ...
+
     @overload
     def decode(
         self,
@@ -1160,6 +1981,15 @@ class ABIDecoder(BaseABICoder):
     ) -> Tuple[bool, str, Any]:
         ...
 
+    @overload
+    def decode(
+        self,
+        types: Tuple[BoolTypeStr, DecodesToIntTypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[bool, int, HexAddress]:
+        ...
+
     @overload
     def decode(
         self,
@@ -1205,6 +2035,15 @@ class ABIDecoder(BaseABICoder):
     ) -> Tuple[bool, int, Any]:
         ...
 
+    @overload
+    def decode(
+        self,
+        types: Tuple[BoolTypeStr, BoolTypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[bool, bool, HexAddress]:
+        ...
+
     @overload
     def decode(
         self,
@@ -1250,6 +2089,15 @@ class ABIDecoder(BaseABICoder):
     ) -> Tuple[bool, bool, Any]:
         ...
 
+    @overload
+    def decode(
+        self,
+        types: Tuple[BoolTypeStr, TypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[bool, Any, HexAddress]:
+        ...
+
     @overload
     def decode(
         self,
@@ -1297,6 +2145,69 @@ class ABIDecoder(BaseABICoder):
 
     # --- Fallbacks for len == 3 ---
 
+    @overload
+    def decode(
+        self,
+        types: Tuple[TypeStr, AddressTypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Any, HexAddress, HexAddress]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[TypeStr, AddressTypeStr, BytesTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Any, HexAddress, bytes]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[TypeStr, AddressTypeStr, StringTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Any, HexAddress, str]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[TypeStr, AddressTypeStr, DecodesToIntTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Any, HexAddress, int]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[TypeStr, AddressTypeStr, BoolTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Any, HexAddress, bool]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[TypeStr, AddressTypeStr, TypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Any, HexAddress, Any]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Tuple[TypeStr, BytesTypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Any, bytes, HexAddress]:
+        ...
+
     @overload
     def decode(
         self,
@@ -1342,6 +2253,15 @@ class ABIDecoder(BaseABICoder):
     ) -> Tuple[Any, bytes, Any]:
         ...
 
+    @overload
+    def decode(
+        self,
+        types: Tuple[TypeStr, StringTypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Any, str, HexAddress]:
+        ...
+
     @overload
     def decode(
         self,
@@ -1387,6 +2307,15 @@ class ABIDecoder(BaseABICoder):
     ) -> Tuple[Any, str, Any]:
         ...
 
+    @overload
+    def decode(
+        self,
+        types: Tuple[TypeStr, DecodesToIntTypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Any, int, HexAddress]:
+        ...
+
     @overload
     def decode(
         self,
@@ -1432,6 +2361,15 @@ class ABIDecoder(BaseABICoder):
     ) -> Tuple[Any, int, Any]:
         ...
 
+    @overload
+    def decode(
+        self,
+        types: Tuple[TypeStr, BoolTypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Any, bool, HexAddress]:
+        ...
+
     @overload
     def decode(
         self,
@@ -1477,6 +2415,15 @@ class ABIDecoder(BaseABICoder):
     ) -> Tuple[Any, bool, Any]:
         ...
 
+    @overload
+    def decode(
+        self,
+        types: Tuple[TypeStr, TypeStr, AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Any, Any, HexAddress]:
+        ...
+
     @overload
     def decode(
         self,
@@ -1524,6 +2471,15 @@ class ABIDecoder(BaseABICoder):
 
     # non-tuple types input
 
+    @overload
+    def decode(
+        self,
+        types: Iterable[AddressTypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[HexAddress, ...]:
+        ...
+
     @overload
     def decode(
         self,
@@ -1561,6 +2517,43 @@ class ABIDecoder(BaseABICoder):
         ...
 
     # fallback to union types, still better than Any
+
+    @overload
+    def decode(
+        self,
+        types: Iterable[Union[AddressTypeStr, BytesTypeStr]],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Union[HexAddress, bytes], ...]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Iterable[Union[AddressTypeStr, StringTypeStr]],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Union[HexAddress, str], ...]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Iterable[Union[AddressTypeStr, DecodesToIntTypeStr]],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Union[HexAddress, int], ...]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Iterable[Union[AddressTypeStr, BoolTypeStr]],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Union[HexAddress, bool], ...]:
+        ...
+
     @overload
     def decode(
         self,
@@ -1615,6 +2608,60 @@ class ABIDecoder(BaseABICoder):
     ) -> Tuple[Union[int, bool], ...]:
         ...
 
+    @overload
+    def decode(
+        self,
+        types: Iterable[Union[AddressTypeStr, BytesTypeStr, StringTypeStr]],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Union[HexAddress, bytes, str], ...]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Iterable[Union[AddressTypeStr, BytesTypeStr, DecodesToIntTypeStr]],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Union[HexAddress, bytes, int], ...]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Iterable[Union[AddressTypeStr, BytesTypeStr, BoolTypeStr]],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Union[HexAddress, bytes, bool], ...]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Iterable[Union[AddressTypeStr, StringTypeStr, DecodesToIntTypeStr]],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Union[HexAddress, str, int], ...]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Iterable[Union[AddressTypeStr, StringTypeStr, BoolTypeStr]],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Union[HexAddress, str, bool], ...]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Iterable[Union[AddressTypeStr, DecodesToIntTypeStr, BoolTypeStr]],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Union[HexAddress, int, bool], ...]:
+        ...
+
     @overload
     def decode(
         self,
@@ -1651,6 +2698,50 @@ class ABIDecoder(BaseABICoder):
     ) -> Tuple[Union[str, int, bool], ...]:
         ...
 
+    @overload
+    def decode(
+        self,
+        types: Iterable[
+            Union[AddressTypeStr, BytesTypeStr, StringTypeStr, DecodesToIntTypeStr]
+        ],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Union[HexAddress, bytes, str, int], ...]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Iterable[
+            Union[AddressTypeStr, BytesTypeStr, StringTypeStr, BoolTypeStr]
+        ],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Union[HexAddress, bytes, str, bool], ...]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Iterable[
+            Union[AddressTypeStr, BytesTypeStr, DecodesToIntTypeStr, BoolTypeStr]
+        ],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Union[HexAddress, bytes, int, bool], ...]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Iterable[
+            Union[AddressTypeStr, StringTypeStr, DecodesToIntTypeStr, BoolTypeStr]
+        ],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Union[AddressTypeStr, str, int, bool], ...]:
+        ...
+
     @overload
     def decode(
         self,
@@ -1662,6 +2753,32 @@ class ABIDecoder(BaseABICoder):
     ) -> Tuple[Union[bytes, str, int, bool], ...]:
         ...
 
+    @overload
+    def decode(
+        self,
+        types: Iterable[
+            Union[
+                AddressTypeStr,
+                BytesTypeStr,
+                StringTypeStr,
+                DecodesToIntTypeStr,
+                BoolTypeStr,
+            ]
+        ],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Union[HexAddress, bytes, str, int, bool], ...]:
+        ...
+
+    @overload
+    def decode(
+        self,
+        types: Iterable[TypeStr],
+        data: Decodable,
+        strict: bool = True,
+    ) -> Tuple[Any, ...]:
+        ...
+
     def decode(
         self,
         types: Iterable[TypeStr],