Implement SolEncode and SolDecode for H160 and H256

Author: davidsemakula

crates/primitives/src/sol.rs

@@ -32,6 +32,10 @@ use ink_prelude::{
 };
 
 pub use bytes::AsSolBytes;
+use primitive_types::{
+    H160,
+    H256,
+};
 pub use types::{
     SolTypeDecode,
     SolTypeEncode,
@@ -233,15 +237,14 @@ impl_refs_encode! {
     [] Box<T>,
 }
 
-// AccountId
+// AccountId <-> bytes32
 impl SolDecode for AccountId {
     type SolType = AsSolBytes<[u8; 32]>;
 
     fn from_sol_type(value: Self::SolType) -> Self {
         AccountId(value.0)
     }
 }
-
 impl SolEncode for AccountId {
     type SolType = AsSolBytes<[u8; 32]>;
 
@@ -260,15 +263,14 @@ impl SolEncode for AccountId {
     }
 }
 
-// Hash
+// Hash <-> bytes32
 impl SolDecode for Hash {
     type SolType = AsSolBytes<[u8; 32]>;
 
     fn from_sol_type(value: Self::SolType) -> Self {
         Hash::from(value.0)
     }
 }
-
 impl SolEncode for Hash {
     type SolType = AsSolBytes<[u8; 32]>;
 
@@ -286,3 +288,58 @@ impl SolEncode for Hash {
         Cow::Owned(AsSolBytes::<[u8; 32]>((*self).into()))
     }
 }
+
+// H256 <-> bytes32
+impl SolDecode for H256 {
+    type SolType = AsSolBytes<[u8; 32]>;
+
+    fn from_sol_type(value: Self::SolType) -> Self {
+        H256(value.0)
+    }
+}
+impl SolEncode for H256 {
+    type SolType = AsSolBytes<[u8; 32]>;
+
+    fn encode(&self) -> Vec<u8> {
+        // Override for better performance.
+        sol_data::FixedBytes::abi_encode(&self.0)
+    }
+
+    fn to_sol_type(&self) -> Cow<Self::SolType> {
+        // NOTE: Not actually used for encoding because of `encode` override above (for
+        // better performance).
+        // Arbitrary newtype wrappers can achieve similar performance (without overriding
+        // `encode`) by using  `AsSolBytes<[u8; 32]>` as the inner type and returning
+        // `Cow::Borrowed(&self.0)`.
+        Cow::Owned(AsSolBytes(self.0))
+    }
+}
+
+// H160 <-> bytes20
+// TODO: (@davidsemakula) Evaluate if it's worth removing to mapping, changing it
+// `address` before v6 release. Rationale: while this mapping is technically correct, it
+// may be confusing for ink! devs, or just needless increase the cognitive load.
+impl SolDecode for H160 {
+    type SolType = AsSolBytes<[u8; 20]>;
+
+    fn from_sol_type(value: Self::SolType) -> Self {
+        H160(value.0)
+    }
+}
+impl SolEncode for H160 {
+    type SolType = AsSolBytes<[u8; 20]>;
+
+    fn encode(&self) -> Vec<u8> {
+        // Override for better performance.
+        sol_data::FixedBytes::abi_encode(&self.0)
+    }
+
+    fn to_sol_type(&self) -> Cow<Self::SolType> {
+        // NOTE: Not actually used for encoding because of `encode` override above (for
+        // better performance).
+        // Arbitrary newtype wrappers can achieve similar performance (without overriding
+        // `encode`) by using  `AsSolBytes<[u8; 32]>` as the inner type and returning
+        // `Cow::Borrowed(&self.0)`.
+        Cow::Owned(AsSolBytes(self.0))
+    }
+}

crates/primitives/src/sol/tests.rs

@@ -29,7 +29,11 @@ use ink_prelude::{
     string::String,
     vec::Vec,
 };
-use primitive_types::U256;
+use primitive_types::{
+    H160,
+    H256,
+    U256,
+};
 
 use crate::{
     sol::{
@@ -309,3 +313,32 @@ fn hash_works() {
         decoded_alloy.unwrap().0.as_slice()
     );
 }
+
+#[test]
+fn h256_works() {
+    let hash = H256([1; 32]);
+    let bytes = SolFixedBytes([1; 32]);
+
+    let encoded = <H256 as SolEncode>::encode(&hash);
+    let encoded_alloy = <SolFixedBytes<32> as SolValue>::abi_encode(&bytes);
+    assert_eq!(encoded, encoded_alloy);
+
+    let decoded = <H256 as SolDecode>::decode(&encoded);
+    let decoded_alloy = <SolFixedBytes<32> as SolValue>::abi_decode(&encoded, true);
+    assert_eq!(decoded.unwrap().0, decoded_alloy.unwrap().0);
+}
+
+#[test]
+fn h160_works() {
+    // NOTE: We're currently mapping `H160` to `bytes20`.
+    let hash = H160([1; 20]);
+    let bytes = SolFixedBytes([1; 20]);
+
+    let encoded = <H160 as SolEncode>::encode(&hash);
+    let encoded_alloy = <SolFixedBytes<20> as SolValue>::abi_encode(&bytes);
+    assert_eq!(encoded, encoded_alloy);
+
+    let decoded = <H160 as SolDecode>::decode(&encoded);
+    let decoded_alloy = <SolFixedBytes<20> as SolValue>::abi_decode(&encoded, true);
+    assert_eq!(decoded.unwrap().0, decoded_alloy.unwrap().0);
+}