Implement SolDecode, SolTypeDecode and support SolBytes for boxed slices (#2476)

* Implement `SolDecode` and `SolTypeDecode` for boxed slices (i.e. `Box<[T]>` and Box<str>)

* tests: boxed slices (i.e. `Box<[T]>` and `Box<str>`)

* docs: Update Solidity mappings

* Make `SolTypeDecode::detokenize` fallible

* Add support for `Box<[u8]>` to `SolBytes`

* docs: Update Solidity mappings

* tests: boxed byte slices

* Update changelog

* fix: `SolEncode` for `Box<[T]>`

* fix: core/std imports

* docs: Update Solidity mappings

Author: davidsemakula

CHANGELOG.md

@@ -221,6 +221,7 @@ You can find binary releases of the node [here](https://github.com/use-ink/ink-n
 - Implement contract invocation in off-chain environment engine - [#1957](https://github.com/paritytech/ink/pull/1988)
 - Abstractions for mapping arbitrary Rust types to Solidity ABI compatible types - [#2441](https://github.com/use-ink/ink/pull/2441)
 - Documentation for contract abi arg and provided Rust/ink! to Solidity type mappings - [2463](https://github.com/use-ink/ink/pull/2463)
+- Implement `SolDecode`, `SolTypeDecode` and support `SolBytes` for boxed slices - [2476](https://github.com/use-ink/ink/pull/2476)
 
 ## Fixed
 - [E2E] Have port parsing handle comma-separated list ‒ [#2336](https://github.com/use-ink/ink/pull/2336)

Cargo.lock

@@ -201,22 +201,25 @@ pub fn selector_bytes(input: TokenStream) -> TokenStream {
 ///   | `uN` for `N ∈ {8,16,32,64,128}` | `uintN` | e.g `u8` ↔ `uint8` |
 ///   | [`ink::U256`][ink-u256] | `uint256` ||
 ///   | `String` | `string` ||
-///   | [`ink::Address`][ink-address] / [`H160`][ink-h160] | `address` | `ink::Address` is a type alias for the `ink::H160` type used for addresses in `pallet-revive` |
+///   | `Box<str>` | `string` ||
+///   | [`ink::Address`][ink-address] / [`ink::H160`][ink-h160] | `address` | `ink::Address` is a type alias for the `ink::H160` type used for addresses in `pallet-revive` |
 ///   | `[T; N]` for `const N: usize` | `T[N]` | e.g. `[i8; 64]` ↔ `int8[64]` |
 ///   | `Vec<T>` | `T[]` | e.g. `Vec<i8>` ↔ `int8[]` |
-///   | [`ink::SolBytes<u8>`][ink-sol-bytes] |  `bytes1` ||
-///   | [`ink::SolBytes<[u8; N]>`][ink-sol-bytes] for `1 <= N <= 32` |  `bytesN` | e.g. `ink::SolBytes<[u8; 1]>` ↔ `bytes1` |
-///   | [`ink::SolBytes<Vec<u8>>`][ink-sol-bytes] |  `bytes` ||
+///   | `Box<[T]>` | `T[]` | e.g. `Box<[i8]>` ↔ `int8[]` |
+///   | [`ink::SolBytes<u8>`][ink-sol-bytes] | `bytes1` ||
+///   | [`ink::SolBytes<[u8; N]>`][ink-sol-bytes] for `1 <= N <= 32` | `bytesN` | e.g. `ink::SolBytes<[u8; 1]>` ↔ `bytes1` |
+///   | [`ink::SolBytes<Vec<u8>>`][ink-sol-bytes] | `bytes` ||
+///   | [`ink::SolBytes<Box<[u8]>>`][ink-sol-bytes] | `bytes` ||
 ///   | `(T1, T2, T3, ... T12)` | `(U1, U2, U3, ... U12)` | where `T1` ↔ `U1`, ... `T12` ↔ `U12` e.g. `(bool, u8, Address)` ↔ `(bool, uint8, address)` |
 ///
 ///   [`SolEncode`][sol-trait-encode] is additionally implemented for reference and smart
 ///   pointer types below:
 ///
 ///   | Rust/ink! type | Solidity ABI type | Notes |
 ///   | -------------- | ----------------- | ----- |
-///   | `&str`, `&mut str`, `Box<str>` | `string` ||
+///   | `&str`, `&mut str` | `string` ||
 ///   | `&T`, `&mut T`, `Box<T>` | `T` | e.g. `&i8 ↔ int8` |
-///   | `&[T]`, `&mut [T]`, `Box<[T]>` | `T[]` | e.g. `&[i8]` ↔ `int8[]` |
+///   | `&[T]`, `&mut [T]` | `T[]` | e.g. `&[i8]` ↔ `int8[]` |
 ///
 ///   See the rustdoc for [`SolEncode`][sol-trait-encode] and
 ///   [`SolDecode`][sol-trait-decode] for instructions for implementing the traits for

crates/ink/macro/src/lib.rs

@@ -35,6 +35,7 @@ sp-core = { workspace = true }
 sp-io = { git = "https://github.com/paritytech/polkadot-sdk", rev = "28a7ae71cc0eac747bf346804279217a68f700da", default-features = false, features = ["disable_panic_handler", "disable_oom", "disable_allocator"] }
 sp-runtime-interface = { git = "https://github.com/paritytech/polkadot-sdk", rev = "28a7ae71cc0eac747bf346804279217a68f700da", default-features = false, features = ["disable_target_static_assertions"] }
 impl-trait-for-tuples = { workspace = true }
+itertools = { workspace = true }
 
 [dev-dependencies]
 ink = { workspace = true, default-features = false }

crates/primitives/Cargo.toml

@@ -206,6 +206,7 @@ impl_primitive! {
     u8, u16, u32, u64, u128, U256,
     // string
     String,
+    Box<str>,
     // address
     Address,
 }
@@ -247,6 +248,29 @@ impl<'a, T: SolEncode<'a>> SolEncode<'a> for Vec<T> {
     }
 }
 
+// Rust `Box<[T]>` (i.e. boxed slice) <-> Solidity dynamic size array (i.e. `T[]`).
+impl<T: SolDecode> SolDecode for Box<[T]> {
+    type SolType = Box<[T::SolType]>;
+
+    fn from_sol_type(value: Self::SolType) -> Self {
+        // TODO: (@davidsemakula) Switch to method call syntax when edition is 2024
+        // (i.e. `value.into_iter()`).
+        // See <https://doc.rust-lang.org/edition-guide/rust-2024/intoiterator-box-slice.html> for details.
+        Box::from_iter(
+            core::iter::IntoIterator::into_iter(value)
+                .map(<T as SolDecode>::from_sol_type),
+        )
+    }
+}
+
+impl<'a, T: SolEncode<'a>> SolEncode<'a> for Box<[T]> {
+    type SolType = Box<[T::SolType]>;
+
+    fn to_sol_type(&'a self) -> Self::SolType {
+        self.iter().map(<T as SolEncode>::to_sol_type).collect()
+    }
+}
+
 // 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>
@@ -314,7 +338,7 @@ macro_rules! impl_str_ref_encode {
     };
 }
 
-impl_str_ref_encode!(&'a str, &'a mut str, Box<str>);
+impl_str_ref_encode!(&'a str, &'a mut str);
 
 macro_rules! impl_slice_ref_encode {
     ($($ty: ty),+ $(,)*) => {
@@ -330,7 +354,7 @@ macro_rules! impl_slice_ref_encode {
     };
 }
 
-impl_slice_ref_encode!(&'a [T], &'a mut [T], Box<[T]>);
+impl_slice_ref_encode!(&'a [T], &'a mut [T]);
 
 // AccountId <-> bytes32
 impl SolDecode for AccountId {

crates/primitives/src/sol.rs

@@ -24,7 +24,10 @@ use core::{
     borrow::Borrow,
     ops::Deref,
 };
-use ink_prelude::vec::Vec;
+use ink_prelude::{
+    boxed::Box,
+    vec::Vec,
+};
 use scale::{
     Decode,
     Encode,
@@ -46,7 +49,8 @@ use crate::sol::{
 /// | -------------- | ----------------- | ----- |
 /// | `SolBytes<u8>` |  `bytes1` ||
 /// | `SolBytes<[u8; N]>` for `1 <= N <= 32` |  `bytesN` | e.g. `SolBytes<[u8; 32]>` <=> `bytes32` |
-/// | `SolBytes<Vec<u8>>` |  `bytes` ||
+/// | `SolBytes<Vec<u8>>` | `bytes` ||
+/// | `SolBytes<Box<[u8]>>` | `bytes` ||
 ///
 /// Ref: <https://docs.soliditylang.org/en/latest/types.html#fixed-size-byte-arrays>
 ///
@@ -55,14 +59,16 @@ use crate::sol::{
 #[cfg_attr(feature = "std", derive(TypeInfo))]
 pub struct SolBytes<T: SolBytesType>(pub T);
 
-// Implement `SolTypeDecode` and `SolTypeEncode` for `SolBytes<T>`.
+// Implements `SolTypeDecode` and `SolTypeEncode` for `SolBytes<T>`.
 impl<T: SolBytesType> SolTypeDecode for SolBytes<T> {
     type AlloyType = T::AlloyType;
 
-    fn detokenize(token: <Self::AlloyType as AlloySolType>::Token<'_>) -> Self {
+    fn detokenize(
+        token: <Self::AlloyType as AlloySolType>::Token<'_>,
+    ) -> Result<Self, alloy_sol_types::Error> {
         // Takes advantage of optimized `SolBytesType::detokenize` implementations and
         // skips unnecessary conversions to `T::AlloyType::RustType`.
-        Self(<T as SolBytesType>::detokenize(token))
+        Ok(Self(<T as SolBytesType>::detokenize(token)))
     }
 }
 
@@ -76,7 +82,7 @@ impl<T: SolBytesType> SolTypeEncode for SolBytes<T> {
 
 impl<T: SolBytesType> crate::sol::types::private::Sealed for SolBytes<T> {}
 
-// Implement `SolDecode` and `SolEncode` for `SolBytes<T>`.
+// Implements `SolDecode` and `SolEncode` for `SolBytes<T>`.
 impl<T: SolBytesType> SolDecode for SolBytes<T> {
     type SolType = SolBytes<T>;
 
@@ -93,7 +99,7 @@ impl<'a, T: SolBytesType + 'a> SolEncode<'a> for SolBytes<T> {
     }
 }
 
-// Implement core/standard traits for cheap representations as the inner type.
+// Implements core/standard traits for cheap representations as the inner type.
 impl<T: SolBytesType> Deref for SolBytes<T> {
     type Target = T;
 
@@ -141,7 +147,7 @@ pub trait SolBytesType: private::Sealed {
     fn detokenize(token: <Self::AlloyType as AlloySolType>::Token<'_>) -> Self;
 }
 
-// Implement `SolBytesType` for `u8`, `[u8; N]` and `Vec<u8>`.
+// Implements `SolBytesType` for `u8`, `[u8; N]`, `Vec<u8>` and `Box<[u8]>`.
 impl SolBytesType for u8
 where
     sol_data::ByteCount<1>: sol_data::SupportedFixedBytes,
@@ -210,6 +216,25 @@ impl SolBytesType for Vec<u8> {
 
 impl private::Sealed for Vec<u8> {}
 
+impl SolBytesType for Box<[u8]> {
+    type AlloyType = sol_data::Bytes;
+
+    fn detokenize(token: <Self::AlloyType as AlloySolType>::Token<'_>) -> Self {
+        // Converts token directly into `Box<[u8]>`, skipping the conversion to
+        // `alloy_sol_types::private::Bytes`, which then has to be converted back to
+        // `Box<[u8]>`.
+        Box::from(token.0)
+    }
+
+    fn tokenize(&self) -> <Self::AlloyType as AlloySolType>::Token<'_> {
+        // Direct implementation simplifies generic implementations by removing
+        // requirement for `SolValueType<Self::AlloyType>`.
+        PackedSeqToken(self.as_ref())
+    }
+}
+
+impl private::Sealed for Box<[u8]> {}
+
 mod private {
     /// Seals the implementation of `SolBytesType`.
     pub trait Sealed {}

crates/primitives/src/sol/bytes.rs

@@ -129,8 +129,29 @@ fn unsigned_int_works() {
 
 #[test]
 fn string_works() {
+    // String
     test_case!(String, String::from(""));
     test_case!(String, String::from("Hello, world!"));
+
+    // `Box<str>`
+    test_case!(
+        Box<str>,
+        Box::from(""),
+        String,
+        SolValue,
+        String::from(""),
+        [.unwrap().as_ref()],
+        [.unwrap().as_str()]
+    );
+    test_case!(
+        Box<str>,
+        Box::from("Hello, world!"),
+        String,
+        SolValue,
+        String::from("Hello, world!"),
+        [.unwrap().as_ref()],
+        [.unwrap().as_str()]
+    );
 }
 
 #[test]
@@ -180,12 +201,32 @@ fn fixed_array_works() {
 fn dynamic_array_works() {
     test_case!(Vec<bool>, vec![true, false, false, true]);
 
+    test_case!(
+        Box<[bool]>,
+        Box::from([true, false, false, true]),
+        Vec<bool>,
+        SolValue,
+        vec![true, false, false, true],
+        [.unwrap().as_ref()],
+        [.unwrap().as_slice()]
+    );
+
     test_case!(Vec<i8>, Vec::from([100i8; 8]));
     test_case!(Vec<i16>, Vec::from([-10_000i16; 16]));
     test_case!(Vec<i32>, Vec::from([1_000_000i32; 32]));
     test_case!(Vec<i64>, Vec::from([-1_000_000_000i64; 64]));
     test_case!(Vec<i128>, Vec::from([1_000_000_000_000i128; 128]));
 
+    test_case!(
+        Box<[i8]>,
+        Box::from([100i8; 8]),
+        Vec<i8>,
+        SolValue,
+        Vec::from([100i8; 8]),
+        [.unwrap().as_ref()],
+        [.unwrap().as_slice()]
+    );
+
     // `SolValue` for `Vec<u8>` maps to `bytes`.
     test_case!(
         Vec<u8>,
@@ -203,6 +244,16 @@ fn dynamic_array_works() {
         vec![String::from(""), String::from("Hello, world!")]
     );
 
+    test_case!(
+        Box<[String]>,
+        Box::from([String::from(""), String::from("Hello, world!")]),
+        Vec<String>,
+        SolValue,
+        vec![String::from(""), String::from("Hello, world!")],
+        [.unwrap().as_ref()],
+        [.unwrap().as_slice()]
+    );
+
     test_case!(
         Vec<Address>, Vec::from([Address::from([1; 20]); 4]),
         Vec<AlloyAddress>, SolValue, Vec::from([AlloyAddress::from([1; 20]); 4]),
@@ -219,16 +270,16 @@ fn fixed_bytes_works() {
     );
 
     macro_rules! fixed_bytes_test_case {
-            ($($size: literal),+ $(,)*) => {
-                $(
-                    test_case!(
-                        SolBytes<[u8; $size]>, SolBytes([100u8; $size]),
-                        AlloyFixedBytes<$size>, SolValue, AlloyFixedBytes([100u8; $size]),
-                        [.unwrap().0], [.unwrap().0]
-                    );
-                )+
-            };
-        }
+        ($($size: literal),+ $(,)*) => {
+            $(
+                test_case!(
+                    SolBytes<[u8; $size]>, SolBytes([100u8; $size]),
+                    AlloyFixedBytes<$size>, SolValue, AlloyFixedBytes([100u8; $size]),
+                    [.unwrap().0], [.unwrap().0]
+                );
+            )+
+        };
+    }
 
     fixed_bytes_test_case!(
         1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
@@ -239,23 +290,30 @@ fn fixed_bytes_works() {
 #[test]
 fn bytes_works() {
     macro_rules! bytes_test_case {
-            ($($fixture_size: literal),+ $(,)*) => {
-                $(
-                    let data = Vec::from([100u8; $fixture_size]);
-                    let bytes = SolBytes(data.clone());
-                    let sol_bytes = AlloyBytes::from(data);
-
-                    test_case!(
-                        SolBytes<Vec<u8>>, bytes,
-                        AlloyBytes, SolValue, sol_bytes,
-                        [.unwrap().as_slice()], [.unwrap().as_ref()]
-                    );
-                )+
-            };
-        }
+        ($($fixture_size: literal),+ $(,)*) => {
+            $(
+                let data = Vec::from([100u8; $fixture_size]);
+                let vec_bytes = SolBytes(data.clone());
+                let sol_bytes = AlloyBytes::from(data);
+
+                test_case!(
+                    SolBytes<Vec<u8>>, vec_bytes,
+                    AlloyBytes, SolValue, sol_bytes,
+                    [.unwrap().as_slice()], [.unwrap().as_ref()]
+                );
+
+                let box_bytes = SolBytes(Box::from([100u8; $fixture_size]));
+                test_case!(
+                    SolBytes<Box<[u8]>>, box_bytes,
+                    AlloyBytes, SolValue, sol_bytes,
+                    [.unwrap().0.as_ref()], [.unwrap().as_ref()]
+                );
+            )+
+        };
+    }
 
     // Number/size is the dynamic size of the `Vec`.
-    bytes_test_case!(0, 1, 10, 20, 30, 40, 50, 60, 70);
+    bytes_test_case!(0, 1, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100);
 }
 
 #[test]