Structs arrays support (LFDT-web3j#1321)

* adds structs arrays fixtures to AbiV2TestFixture

* Adds necessary AbiV2 functions for testing

* Adds Abi Decoder tests

* Adds Structs array + multiple structs returns decoder

* fixes String padded length size

* adds type name return for structs when getting simple name

* Adds structs encoder tests

* Adds structs encoder

* adds struct type to AbiTypes

* imports cleanup

* spotless

* Utils refactor

* fix array of structs creation by the decoder

* fix structs array encoding

* imports fix

* add support for array of structs wrapper generation

* make the convert to native function support arrays of structs

* add getTypeAsString java doc

* fix getTypeAsString to support structs arrays

* add encoder structs array tests

* add codegen structs array wrapper generation test

* cosmetics

* spotless + cosmetics

* suppress warnings + remove unnecessary sout

* suppress warnings + remove unnecessary sout

* update ComplexStorage.sol to use arrays of structs

* cosmetics

* fixes dynamic byte arrays prefixed their length encoding in structs.

* structs dynamic values tweak + add tests for dynamic struct containing dynamic bytes array

* fixes encoding of array strings + adds tests

* fixes byte types padded length

* cosmetics

* spotless

* fix isParametrizedTypeStaticStruct

* remove unnecessary function

* fixes dynamic type in static array + adds tests

* adds more encoder tests

* fixes static array with static struct decoder

* adds static/dynamic array with static struct encoder test

* suppress warnings + java docs + cosmetics

* javadocs + spotless

Author: rach-id

abi/src/main/java/org/web3j/abi/DefaultFunctionEncoder.java

@@ -15,11 +15,15 @@
 import java.math.BigInteger;
 import java.util.List;
 
+import org.web3j.abi.datatypes.DynamicStruct;
 import org.web3j.abi.datatypes.Function;
 import org.web3j.abi.datatypes.StaticArray;
+import org.web3j.abi.datatypes.StaticStruct;
 import org.web3j.abi.datatypes.Type;
 import org.web3j.abi.datatypes.Uint;
 
+import static org.web3j.abi.Utils.staticStructNestedPublicFieldsFlatList;
+
 public class DefaultFunctionEncoder extends FunctionEncoder {
 
     @Override
@@ -64,10 +68,23 @@ private static String encodeParameters(
         return result.toString();
     }
 
+    @SuppressWarnings("unchecked")
     private static int getLength(final List<Type> parameters) {
         int count = 0;
         for (final Type type : parameters) {
-            if (type instanceof StaticArray) {
+            if (type instanceof StaticArray
+                    && StaticStruct.class.isAssignableFrom(
+                            ((StaticArray) type).getComponentType())) {
+                count +=
+                        staticStructNestedPublicFieldsFlatList(
+                                                ((StaticArray) type).getComponentType())
+                                        .size()
+                                * ((StaticArray) type).getValue().size();
+            } else if (type instanceof StaticArray
+                    && DynamicStruct.class.isAssignableFrom(
+                            ((StaticArray) type).getComponentType())) {
+                count++;
+            } else if (type instanceof StaticArray) {
                 count += ((StaticArray) type).getValue().size();
             } else {
                 count++;

abi/src/main/java/org/web3j/abi/DefaultFunctionReturnDecoder.java

@@ -31,6 +31,9 @@
 import org.web3j.utils.Strings;
 
 import static org.web3j.abi.TypeDecoder.MAX_BYTE_LENGTH_FOR_HEX_STRING;
+import static org.web3j.abi.TypeDecoder.isDynamic;
+import static org.web3j.abi.Utils.getParameterizedTypeFromArray;
+import static org.web3j.abi.Utils.staticStructNestedPublicFieldsFlatList;
 
 /**
  * Ethereum Contract Application Binary Interface (ABI) encoding for functions. Further details are
@@ -80,17 +83,13 @@ private static List<Type> build(String input, List<TypeReference<Type>> outputPa
         int offset = 0;
         for (TypeReference<?> typeReference : outputParameters) {
             try {
+                int hexStringDataOffset = getDataOffset(input, offset, typeReference);
+
                 @SuppressWarnings("unchecked")
                 Class<Type> classType = (Class<Type>) typeReference.getClassType();
 
-                int hexStringDataOffset = getDataOffset(input, offset, classType);
-
                 Type result;
                 if (DynamicStruct.class.isAssignableFrom(classType)) {
-                    if (outputParameters.size() != 1) {
-                        throw new UnsupportedOperationException(
-                                "Multiple return objects containing a struct is not supported");
-                    }
                     result =
                             TypeDecoder.decodeDynamicStruct(
                                     input, hexStringDataOffset, typeReference);
@@ -113,7 +112,9 @@ private static List<Type> build(String input, List<TypeReference<Type>> outputPa
                     result =
                             TypeDecoder.decodeStaticStruct(
                                     input, hexStringDataOffset, typeReference);
-                    offset += classType.getDeclaredFields().length * MAX_BYTE_LENGTH_FOR_HEX_STRING;
+                    offset +=
+                            staticStructNestedPublicFieldsFlatList(classType).size()
+                                    * MAX_BYTE_LENGTH_FOR_HEX_STRING;
                 } else if (StaticArray.class.isAssignableFrom(classType)) {
                     int length =
                             Integer.parseInt(
@@ -123,8 +124,21 @@ private static List<Type> build(String input, List<TypeReference<Type>> outputPa
                     result =
                             TypeDecoder.decodeStaticArray(
                                     input, hexStringDataOffset, typeReference, length);
-                    offset += length * MAX_BYTE_LENGTH_FOR_HEX_STRING;
-
+                    if (DynamicStruct.class.isAssignableFrom(
+                            getParameterizedTypeFromArray(typeReference))) {
+                        offset += MAX_BYTE_LENGTH_FOR_HEX_STRING;
+                    } else if (StaticStruct.class.isAssignableFrom(
+                            getParameterizedTypeFromArray(typeReference))) {
+                        offset +=
+                                staticStructNestedPublicFieldsFlatList(
+                                                        getParameterizedTypeFromArray(
+                                                                typeReference))
+                                                .size()
+                                        * length
+                                        * MAX_BYTE_LENGTH_FOR_HEX_STRING;
+                    } else {
+                        offset += length * MAX_BYTE_LENGTH_FOR_HEX_STRING;
+                    }
                 } else {
                     result = TypeDecoder.decode(input, hexStringDataOffset, classType);
                     offset += MAX_BYTE_LENGTH_FOR_HEX_STRING;
@@ -138,13 +152,39 @@ private static List<Type> build(String input, List<TypeReference<Type>> outputPa
         return results;
     }
 
-    private static <T extends Type> int getDataOffset(String input, int offset, Class<T> type) {
+    public static <T extends Type> int getDataOffset(
+            String input, int offset, TypeReference<?> typeReference)
+            throws ClassNotFoundException {
+        @SuppressWarnings("unchecked")
+        Class<Type> type = (Class<Type>) typeReference.getClassType();
         if (DynamicBytes.class.isAssignableFrom(type)
                 || Utf8String.class.isAssignableFrom(type)
-                || DynamicArray.class.isAssignableFrom(type)) {
+                || DynamicArray.class.isAssignableFrom(type)
+                || hasDynamicOffsetInStaticArray(typeReference, offset)) {
             return TypeDecoder.decodeUintAsInt(input, offset) << 1;
         } else {
             return offset;
         }
     }
+
+    /**
+     * Checks if the parametrized type is offsetted in case of static array containing structs.
+     *
+     * @param typeReference of static array
+     * @return true, if static array elements have dynamic offsets
+     * @throws ClassNotFoundException if class type cannot be determined
+     */
+    private static boolean hasDynamicOffsetInStaticArray(TypeReference<?> typeReference, int offset)
+            throws ClassNotFoundException {
+        @SuppressWarnings("unchecked")
+        Class<Type> type = (Class<Type>) typeReference.getClassType();
+        try {
+            return StaticArray.class.isAssignableFrom(type)
+                    && (DynamicStruct.class.isAssignableFrom(
+                                    getParameterizedTypeFromArray(typeReference))
+                            || isDynamic(getParameterizedTypeFromArray(typeReference)));
+        } catch (ClassCastException e) {
+            return false;
+        }
+    }
 }

abi/src/main/java/org/web3j/abi/TypeDecoder.java

@@ -41,6 +41,7 @@
 import org.web3j.abi.datatypes.NumericType;
 import org.web3j.abi.datatypes.StaticArray;
 import org.web3j.abi.datatypes.StaticStruct;
+import org.web3j.abi.datatypes.StructType;
 import org.web3j.abi.datatypes.Type;
 import org.web3j.abi.datatypes.Ufixed;
 import org.web3j.abi.datatypes.Uint;
@@ -50,7 +51,10 @@
 import org.web3j.abi.datatypes.primitive.Float;
 import org.web3j.utils.Numeric;
 
+import static org.web3j.abi.DefaultFunctionReturnDecoder.getDataOffset;
 import static org.web3j.abi.TypeReference.makeTypeReference;
+import static org.web3j.abi.Utils.getSimpleTypeName;
+import static org.web3j.abi.Utils.staticStructNestedPublicFieldsFlatList;
 
 /**
  * Ethereum Contract Application Binary Interface (ABI) decoding for types. Decoding is not
@@ -252,13 +256,16 @@ static Type instantiateAtomicType(Class<?> referenceClass, Object value)
         return (Type) cons.newInstance(constructorArg);
     }
 
+    @SuppressWarnings("unchecked")
     static <T extends Type> int getSingleElementLength(String input, int offset, Class<T> type) {
         if (input.length() == offset) {
             return 0;
         } else if (DynamicBytes.class.isAssignableFrom(type)
                 || Utf8String.class.isAssignableFrom(type)) {
             // length field + data value
             return (decodeUintAsInt(input, offset) / Type.MAX_BYTE_LENGTH) + 2;
+        } else if (StaticStruct.class.isAssignableFrom(type)) {
+            return staticStructNestedPublicFieldsFlatList((Class<Type>) type).size();
         } else {
             return 1;
         }
@@ -331,7 +338,7 @@ static <T extends Type> T decodeStaticArray(
                         throw new UnsupportedOperationException(
                                 "Zero length fixed array is invalid type");
                     } else {
-                        return instantiateStaticArray(typeReference, elements, length);
+                        return instantiateStaticArray(elements, length);
                     }
                 };
 
@@ -353,6 +360,7 @@ public static <T extends Type> T decodeStaticStruct(
         return decodeStaticStructElement(input, offset, typeReference, function);
     }
 
+    @SuppressWarnings("unchecked")
     private static <T extends Type> T decodeStaticStructElement(
             final String input,
             final int offset,
@@ -374,11 +382,10 @@ private static <T extends Type> T decodeStaticStructElement(
             final int length = constructor.getParameterCount();
             List<T> elements = new ArrayList<>(length);
 
-            for (int i = 0, currOffset = 0; i < length; i++) {
+            for (int i = 0, currOffset = offset; i < length; i++) {
                 T value;
                 final Class<T> declaredField = (Class<T>) constructor.getParameterTypes()[i];
 
-                System.out.println(currOffset);
                 if (StaticStruct.class.isAssignableFrom(declaredField)) {
                     final int nestedStructLength =
                             classType
@@ -401,7 +408,7 @@ private static <T extends Type> T decodeStaticStructElement(
                 elements.add(value);
             }
 
-            String typeName = Utils.getSimpleTypeName(classType);
+            String typeName = getSimpleTypeName(classType);
 
             return consumer.apply(elements, typeName);
         } catch (ClassNotFoundException e) {
@@ -411,6 +418,7 @@ private static <T extends Type> T decodeStaticStructElement(
         }
     }
 
+    @SuppressWarnings("unchecked")
     private static <T extends Type> T instantiateStruct(
             final TypeReference<T> typeReference, final List<T> parameters) {
         try {
@@ -464,6 +472,7 @@ static <T extends Type> T decodeDynamicStruct(
         return decodeDynamicStructElements(input, offset, typeReference, function);
     }
 
+    @SuppressWarnings("unchecked")
     private static <T extends Type> T decodeDynamicStructElements(
             final String input,
             final int offset,
@@ -495,8 +504,9 @@ private static <T extends Type> T decodeDynamicStructElements(
                     final int parameterOffset =
                             isOnlyParameterInStruct
                                     ? offset
-                                    : decodeDynamicStructDynamicParameterOffset(
-                                            input.substring(beginIndex, beginIndex + 64));
+                                    : (decodeDynamicStructDynamicParameterOffset(
+                                                    input.substring(beginIndex, beginIndex + 64)))
+                                            + offset;
                     parameterOffsets.add(parameterOffset);
                     staticOffset += 64;
                 } else {
@@ -506,11 +516,15 @@ private static <T extends Type> T decodeDynamicStructElements(
                                         input.substring(beginIndex),
                                         0,
                                         TypeReference.create(declaredField));
+                        staticOffset +=
+                                staticStructNestedPublicFieldsFlatList((Class<Type>) classType)
+                                                .size()
+                                        * MAX_BYTE_LENGTH_FOR_HEX_STRING;
                     } else {
                         value = decode(input.substring(beginIndex), 0, declaredField);
+                        staticOffset += value.bytes32PaddedLength() * 2;
                     }
                     parameters.put(i, value);
-                    staticOffset += value.bytes32PaddedLength() * 2;
                 }
             }
             int dynamicParametersProcessed = 0;
@@ -538,7 +552,7 @@ private static <T extends Type> T decodeDynamicStructElements(
                 }
             }
 
-            String typeName = Utils.getSimpleTypeName(classType);
+            String typeName = getSimpleTypeName(classType);
 
             final List<T> elements = new ArrayList<>();
             for (int i = 0; i < length; ++i) {
@@ -579,7 +593,7 @@ private static <T extends Type> T decodeDynamicParameterFromStruct(
     }
 
     private static int decodeDynamicStructDynamicParameterOffset(final String input) {
-        return (decodeUintAsInt(input, 0) * 2) + 64;
+        return (decodeUintAsInt(input, 0) * 2);
     }
 
     static <T extends Type> boolean isDynamic(Class<T> parameter) {
@@ -618,13 +632,11 @@ static List arrayToList(Object array) {
     }
 
     @SuppressWarnings("unchecked")
-    private static <T extends Type> T instantiateStaticArray(
-            TypeReference<T> typeReference, List<T> elements, int length) {
+    private static <T extends Type> T instantiateStaticArray(List<T> elements, int length) {
         try {
             Class<? extends StaticArray> arrayClass =
                     (Class<? extends StaticArray>)
                             Class.forName("org.web3j.abi.datatypes.generated.StaticArray" + length);
-
             return (T) arrayClass.getConstructor(List.class).newInstance(elements);
         } catch (ReflectiveOperationException e) {
             throw new UnsupportedOperationException(e);
@@ -640,24 +652,55 @@ private static <T extends Type> T decodeArrayElements(
 
         try {
             Class<T> cls = Utils.getParameterizedTypeFromArray(typeReference);
-            if (Array.class.isAssignableFrom(cls)) {
-                throw new UnsupportedOperationException(
-                        "Arrays of arrays are not currently supported for external functions, see"
-                                + "http://solidity.readthedocs.io/en/develop/types.html#members");
-            } else {
+            if (StructType.class.isAssignableFrom(cls)) {
                 List<T> elements = new ArrayList<>(length);
-
                 for (int i = 0, currOffset = offset;
                         i < length;
                         i++,
                                 currOffset +=
                                         getSingleElementLength(input, currOffset, cls)
                                                 * MAX_BYTE_LENGTH_FOR_HEX_STRING) {
-                    T value = decode(input, currOffset, cls);
+                    T value;
+                    if (DynamicStruct.class.isAssignableFrom(cls)) {
+                        value =
+                                TypeDecoder.decodeDynamicStruct(
+                                        input,
+                                        offset + getDataOffset(input, currOffset, typeReference),
+                                        TypeReference.create(cls));
+                    } else {
+                        value =
+                                TypeDecoder.decodeStaticStruct(
+                                        input, currOffset, TypeReference.create(cls));
+                    }
+                    elements.add(value);
+                }
+
+                String typeName = getSimpleTypeName(cls);
+
+                return consumer.apply(elements, typeName);
+            } else if (Array.class.isAssignableFrom(cls)) {
+                throw new UnsupportedOperationException(
+                        "Arrays of arrays are not currently supported for external functions, see"
+                                + "http://solidity.readthedocs.io/en/develop/types.html#members");
+            } else {
+                List<T> elements = new ArrayList<>(length);
+                int currOffset = offset;
+                for (int i = 0; i < length; i++) {
+                    T value;
+                    if (isDynamic(cls)) {
+                        int hexStringDataOffset = getDataOffset(input, currOffset, typeReference);
+                        value = decode(input, offset + hexStringDataOffset, cls);
+                        currOffset += MAX_BYTE_LENGTH_FOR_HEX_STRING;
+                    } else {
+                        value = decode(input, currOffset, cls);
+                        currOffset +=
+                                getSingleElementLength(input, currOffset, cls)
+                                        * MAX_BYTE_LENGTH_FOR_HEX_STRING;
+                    }
                     elements.add(value);
                 }
 
-                String typeName = Utils.getSimpleTypeName(cls);
+                String typeName = getSimpleTypeName(cls);
 
                 return consumer.apply(elements, typeName);
             }