primitives: Solidity ABI encode/decode for function params

Author: davidsemakula

crates/primitives/src/sol.rs

@@ -15,6 +15,7 @@
 //! Abstractions for implementing Solidity ABI encoding/decoding for arbitrary Rust types.
 
 mod bytes;
+mod params;
 mod types;
 
 #[cfg(test)]
@@ -40,6 +41,10 @@ use primitive_types::{
 
 pub use self::{
     bytes::SolBytes,
+    params::{
+        SolParamsDecode,
+        SolParamsEncode,
+    },
     types::{
         SolTypeDecode,
         SolTypeEncode,
@@ -149,6 +154,11 @@ pub trait SolEncode<'a> {
     const SOL_NAME: &'static str =
         <<Self::SolType as SolTypeEncode>::AlloyType as AlloySolType>::SOL_NAME;
 
+    /// Whether the ABI encoded size is dynamic.
+    #[doc(hidden)]
+    const DYNAMIC: bool =
+        <<Self::SolType as SolTypeEncode>::AlloyType as AlloySolType>::DYNAMIC;
+
     /// Solidity ABI encode the value.
     fn encode(&'a self) -> Vec<u8> {
         <Self::SolType as SolTypeEncode>::encode(&self.to_sol_type())

crates/primitives/src/sol/params.rs

@@ -0,0 +1,66 @@
+// Copyright (C) ink! contributors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use alloy_sol_types::{
+    abi,
+    SolType as AlloySolType,
+};
+use impl_trait_for_tuples::impl_for_tuples;
+
+use super::{
+    SolTypeDecode,
+    SolTypeEncode,
+};
+
+/// Solidity ABI decode function parameters.
+///
+/// # Note
+///
+/// This trait is sealed and cannot be implemented for types outside `ink_primitives`.
+pub trait SolParamsDecode: Sized + super::types::private::Sealed {
+    /// Solidity ABI decode function parameters into this type.
+    fn decode(data: &[u8]) -> Result<Self, alloy_sol_types::Error>;
+}
+
+/// Solidity ABI encode function parameters.
+///
+/// # Note
+///
+/// This trait is sealed and cannot be implemented for types outside `ink_primitives`.
+pub trait SolParamsEncode: super::types::private::Sealed {
+    /// Solidity ABI encode the value as function parameters.
+    fn encode(&self) -> Vec<u8>;
+}
+
+// We follow the Rust standard library's convention of implementing traits for tuples up
+// to twelve items long.
+// Ref: <https://doc.rust-lang.org/std/primitive.tuple.html#trait-implementations>
+#[impl_for_tuples(12)]
+#[tuple_types_custom_trait_bound(SolTypeDecode)]
+impl SolParamsDecode for Tuple {
+    fn decode(data: &[u8]) -> Result<Self, alloy_sol_types::Error> {
+        abi::decode_params::<
+            <<Self as SolTypeDecode>::AlloyType as AlloySolType>::Token<'_>,
+        >(data)
+        .and_then(<Self as SolTypeDecode>::detokenize)
+    }
+}
+
+#[impl_for_tuples(12)]
+#[tuple_types_custom_trait_bound(SolTypeEncode)]
+impl SolParamsEncode for Tuple {
+    fn encode(&self) -> Vec<u8> {
+        abi::encode_params(&self.tokenize())
+    }
+}

crates/primitives/src/sol/tests.rs

@@ -39,6 +39,8 @@ use crate::{
         SolBytes,
         SolDecode,
         SolEncode,
+        SolParamsDecode,
+        SolParamsEncode,
         SolTypeDecode,
         SolTypeEncode,
     },
@@ -548,3 +550,74 @@ fn encode_refs_works() {
         []
     );
 }
+
+macro_rules! test_case_params {
+    ($ty: ty, $val: expr) => {
+        test_case_params!($ty, $val, $ty, alloy_sol_types::SolValue, $val, [], [])
+    };
+    ($ty: ty, $val: expr, $sol_ty: ty, $sol_trait: ty) => {
+        test_case_params!($ty, $val, $sol_ty, $sol_trait, $val, [], [])
+    };
+    ($ty: ty, $val: expr, $sol_ty: ty, $sol_trait: ty, $sol_val: expr, [$($ty_cvt: tt)*], [$($sol_ty_cvt: tt)*]) => {
+        // `SolParamsEncode` test.
+        let encoded = <$ty as SolParamsEncode>::encode(&$val);
+        let encoded_alloy = <$sol_ty as $sol_trait>::abi_encode_params(&$sol_val);
+        assert_eq!(encoded, encoded_alloy);
+
+        // `SolParamsDecode` test.
+        let decoded = <$ty as SolParamsDecode>::decode(&encoded);
+        let decoded_alloy = <$sol_ty as $sol_trait>::abi_decode_params(&encoded);
+        assert_eq!(decoded$($ty_cvt)*, decoded_alloy$($sol_ty_cvt)*);
+    };
+}
+
+#[test]
+fn params_works() {
+    test_case_params!((), ());
+    test_case_params!((bool,), (true,));
+    // `SolValue` isn't implemented for `u8`.
+    test_case_params!((u8,), (100u8,), (sol_data::Uint<8>,), AlloySolType);
+    test_case_params!(
+        (bool, i8, u32, String),
+        (true, 100i8, 1_000_000u32, String::from("Hello, world!"))
+    );
+
+    // simple sequences/collections.
+    test_case_params!(([i8; 32],), ([100i8; 32],));
+    test_case_params!((Vec<i8>,), (Vec::from([100i8; 64]),));
+    test_case_params!(([i8; 32], Vec<i8>), ([100i8; 32], Vec::from([100i8; 64])));
+
+    // sequences of addresses.
+    test_case_params!(
+        ([Address; 4],), ([Address::from([1; 20]); 4],),
+        ([AlloyAddress; 4],), SolValue, ([AlloyAddress::from([1; 20]); 4],),
+        [.unwrap().0.map(|val| val.0)], [.unwrap().0.map(|val| val.0)]
+    );
+    test_case_params!(
+        (Vec<Address>,), (Vec::from([Address::from([1; 20]); 4]),),
+        (Vec<AlloyAddress>,), SolValue, (Vec::from([AlloyAddress::from([1; 20]); 4]),),
+        [.unwrap().0.into_iter().map(|val| val.0).collect::<Vec<_>>()], [.unwrap().0.into_iter().map(|val| val.0).collect::<Vec<_>>()]
+    );
+
+    // fixed-size byte arrays.
+    test_case_params!(
+        (SolBytes<[u8; 32]>,),
+        (SolBytes([100u8; 32]),),
+        (AlloyFixedBytes<32>,),
+        SolValue,
+        (AlloyFixedBytes([100u8; 32]),),
+        [.unwrap().0.0],
+        [.unwrap().0.0]
+    );
+
+    // dynamic size byte arrays.
+    test_case_params!(
+        (SolBytes<Vec<u8>>,),
+        (SolBytes(Vec::from([100u8; 64])),),
+        (AlloyBytes,),
+        SolValue,
+        (AlloyBytes::from([100u8; 64]),),
+        [.unwrap().0.0],
+        [.unwrap().0.0]
+    );
+}