feat(abi): support ABI v2 structs and nested arrays

abi/build.gradle

@@ -6,4 +6,5 @@ description 'TRON Application Binary Interface (ABI) for working with smart cont
 
 dependencies {
     implementation project(':utils')
+    testImplementation "com.fasterxml.jackson.core:jackson-databind:2.18.6"
 }

abi/src/main/java/org/tron/trident/abi/CustomErrorEncoder.java

@@ -0,0 +1,43 @@
+package org.tron.trident.abi;
+
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.tron.trident.abi.datatypes.CustomError;
+import org.tron.trident.abi.datatypes.Type;
+import org.tron.trident.crypto.Hash;
+import org.tron.trident.utils.Numeric;
+
+/**
+ * Ethereum custom error encoding. Further limited details are available <a
+ * href="https://docs.soliditylang.org/en/develop/abi-spec.html#errors">here</a>.
+ */
+public class CustomErrorEncoder {
+
+  private CustomErrorEncoder() {
+  }
+
+  public static String encode(CustomError error) {
+    return calculateSignatureHash(
+        buildErrorSignature(error.getName(), error.getParameters()));
+  }
+
+  static <T extends Type> String buildErrorSignature(
+      String errorName, List<TypeReference<T>> parameters) {
+
+    StringBuilder result = new StringBuilder();
+    result.append(errorName);
+    result.append("(");
+    String params =
+        parameters.stream().map(Utils::getTypeName).collect(Collectors.joining(","));
+    result.append(params);
+    result.append(")");
+    return result.toString();
+  }
+
+  public static String calculateSignatureHash(String errorSignature) {
+    byte[] input = errorSignature.getBytes(StandardCharsets.UTF_8);
+    byte[] hash = Hash.sha3(input);
+    return Numeric.toHexString(hash).substring(2);
+  }
+}

abi/src/main/java/org/tron/trident/abi/DefaultFunctionEncoder.java

@@ -17,6 +17,7 @@
 import java.util.List;
 import org.tron.trident.abi.datatypes.Function;
 import org.tron.trident.abi.datatypes.StaticArray;
+import org.tron.trident.abi.datatypes.StaticStruct;
 import org.tron.trident.abi.datatypes.Type;
 import org.tron.trident.abi.datatypes.Uint;
 
@@ -64,11 +65,53 @@ private static String encodeParameters(
     return result.toString();
   }
 
+  /**
+   * Encodes a function call including its method signature (selector) and its parameters.
+   *
+   * @param methodId   the 4-byte selector (8 hex chars)
+   * @param parameters the list of parameters to encode
+   * @return the complete ABI-encoded hex string representing the function call
+   */
+  public String encodeWithSelector(String methodId, List<Type> parameters) {
+    final StringBuilder result = new StringBuilder(methodId);
+
+    return encodeParameters(parameters, result);
+  }
+
+  /**
+   * Encodes parameters using tight packing (abi.encodePacked).
+   * This is a non-standard ABI encoding used primarily for computing hashes,
+   * where padding is omitted and dynamic types are concatenated without length prefixes.
+   *
+   * @param parameters the list of parameters to pack
+   * @return the packed ABI-encoded hex string
+   */
+  @Override
+  protected String encodePackedParameters(List<Type> parameters) {
+    final StringBuilder result = new StringBuilder();
+    for (Type parameter : parameters) {
+      result.append(TypeEncoder.encodePacked(parameter));
+    }
+    return result.toString();
+  }
+
+  /**
+   * Calculates the length of the tuple head (in 32-byte slots) required for the given parameters.
+   * Crucially, all dynamic types (including StaticArrays containing dynamic elements) always occupy exactly 
+   * 1 slot in the head (for the offset pointer). Pure static arrays and structs are flattened to calculate 
+   * their total inline slot requirement.
+   *
+   * @param parameters the list of types to be encoded.
+   * @return the total number of 32-byte slots required for the tuple head.
+   */
+  @SuppressWarnings("unchecked")
   private static int getLength(final List<Type> parameters) {
     int count = 0;
     for (final Type type : parameters) {
-      if (type instanceof StaticArray) {
-        count += ((StaticArray) type).getValue().size();
+      if (TypeEncoder.isDynamic(type)) {
+        count++;
+      } else if (type instanceof StaticArray || type instanceof StaticStruct) {
+        count += type.bytes32PaddedLength() / Type.MAX_BYTE_LENGTH;
       } else {
         count++;
       }

abi/src/main/java/org/tron/trident/abi/DefaultFunctionReturnDecoder.java

@@ -13,14 +13,16 @@
 
 package org.tron.trident.abi;
 
+import static org.tron.trident.abi.TypeDecoder.MAX_BYTE_LENGTH_FOR_HEX_STRING;
+import static org.tron.trident.abi.TypeDecoder.isDynamic;
+
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import org.tron.trident.abi.datatypes.Array;
 import org.tron.trident.abi.datatypes.Bytes;
 import org.tron.trident.abi.datatypes.BytesType;
 import org.tron.trident.abi.datatypes.DynamicArray;
-import org.tron.trident.abi.datatypes.DynamicBytes;
 import org.tron.trident.abi.datatypes.DynamicStruct;
 import org.tron.trident.abi.datatypes.StaticArray;
 import org.tron.trident.abi.datatypes.StaticStruct;
@@ -31,7 +33,7 @@
 import org.tron.trident.utils.Strings;
 
 /**
- * Ethereum Contract Application Binary Interface (ABI) encoding for functions. Further details are
+ * Ethereum Contract Application Binary Interface (ABI) decoding for functions. Further details are
  * available <a href="https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI">here</a>.
  */
 public class DefaultFunctionReturnDecoder extends FunctionReturnDecoder {
@@ -73,60 +75,63 @@ public <T extends Type> Type decodeEventParameter(
   }
 
   private static List<Type> build(String input, List<TypeReference<Type>> outputParameters) {
+    // Reject cyclic or excessively nested TypeReference graphs up front; any
+    // downstream recursion through subTypeReference / innerTypes is then bounded
+    // by what passed validation here.
+    for (TypeReference<?> typeReference : outputParameters) {
+      Utils.validateTypeReferenceDepth(typeReference);
+    }
+
     List<Type> results = new ArrayList<>(outputParameters.size());
 
     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);
-          offset += TypeDecoder.MAX_BYTE_LENGTH_FOR_HEX_STRING;
+                  TypeDecoder.decodeDynamicStruct(
+                          input, hexStringDataOffset, typeReference);
+          offset += MAX_BYTE_LENGTH_FOR_HEX_STRING;
 
         } else if (DynamicArray.class.isAssignableFrom(classType)) {
           result =
-              TypeDecoder.decodeDynamicArray(
-                  input, hexStringDataOffset, typeReference);
-          offset += TypeDecoder.MAX_BYTE_LENGTH_FOR_HEX_STRING;
-
-        } else if (typeReference instanceof TypeReference.StaticArrayTypeReference) {
-          int length = ((TypeReference.StaticArrayTypeReference) typeReference).getSize();
-          result =
-              TypeDecoder.decodeStaticArray(
-                  input, hexStringDataOffset, typeReference, length);
-          offset += length * TypeDecoder.MAX_BYTE_LENGTH_FOR_HEX_STRING;
+                  TypeDecoder.decodeDynamicArray(
+                          input, hexStringDataOffset, typeReference);
+          offset += MAX_BYTE_LENGTH_FOR_HEX_STRING;
 
         } else if (StaticStruct.class.isAssignableFrom(classType)) {
           result =
-              TypeDecoder.decodeStaticStruct(
-                  input, hexStringDataOffset, typeReference);
-          offset +=
-              classType.getDeclaredFields().length * TypeDecoder.MAX_BYTE_LENGTH_FOR_HEX_STRING;
+                  TypeDecoder.decodeStaticStruct(
+                          input, hexStringDataOffset, typeReference);
+          offset += (result.bytes32PaddedLength() / Type.MAX_BYTE_LENGTH)
+                          * MAX_BYTE_LENGTH_FOR_HEX_STRING;
+
         } else if (StaticArray.class.isAssignableFrom(classType)) {
-          int length =
-              Integer.parseInt(
-                  classType
-                      .getSimpleName()
-                      .substring(StaticArray.class.getSimpleName().length()));
+          int length;
+          if (typeReference instanceof TypeReference.StaticArrayTypeReference) {
+            length = ((TypeReference.StaticArrayTypeReference) typeReference).getSize();
+          } else {
+            length = Utils.extractStaticArraySize(classType);
+          }
           result =
-              TypeDecoder.decodeStaticArray(
-                  input, hexStringDataOffset, typeReference, length);
-          offset += length * TypeDecoder.MAX_BYTE_LENGTH_FOR_HEX_STRING;
-
+                  TypeDecoder.decodeStaticArray(
+                          input, hexStringDataOffset, typeReference, length);
+          if (isDynamic(typeReference)) {
+            offset += MAX_BYTE_LENGTH_FOR_HEX_STRING;
+          } else {
+            offset +=
+                (result.bytes32PaddedLength() / Type.MAX_BYTE_LENGTH)
+                    * MAX_BYTE_LENGTH_FOR_HEX_STRING;
+          }
         } else {
           result = TypeDecoder.decode(input, hexStringDataOffset, classType);
-          offset += TypeDecoder.MAX_BYTE_LENGTH_FOR_HEX_STRING;
+          offset += MAX_BYTE_LENGTH_FOR_HEX_STRING;
         }
         results.add(result);
 
@@ -137,10 +142,10 @@ 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) {
-    if (DynamicBytes.class.isAssignableFrom(type)
-        || Utf8String.class.isAssignableFrom(type)
-        || DynamicArray.class.isAssignableFrom(type)) {
+  public static <T extends Type> int getDataOffset(
+          String input, int offset, TypeReference<?> typeReference)
+          throws ClassNotFoundException {
+    if (isDynamic(typeReference)) {
       return TypeDecoder.decodeUintAsInt(input, offset) << 1;
     } else {
       return offset;

abi/src/main/java/org/tron/trident/abi/FunctionEncoder.java

@@ -13,6 +13,9 @@
 
 package org.tron.trident.abi;
 
+import static org.tron.trident.abi.TypeDecoder.instantiateType;
+import static org.tron.trident.abi.TypeReference.makeTypeReference;
+
 import java.lang.reflect.InvocationTargetException;
 import java.util.ArrayList;
 import java.util.Iterator;
@@ -32,36 +35,55 @@
  * @see DefaultFunctionEncoder
  * @see FunctionEncoderProvider
  */
+
 public abstract class FunctionEncoder {
 
-  private static FunctionEncoder DEFAULT_ENCODER;
+  private static final FunctionEncoder FUNCTION_ENCODER;
 
-  private static final ServiceLoader<FunctionEncoderProvider> loader =
-      ServiceLoader.load(FunctionEncoderProvider.class);
+  static {
+    ServiceLoader<FunctionEncoderProvider> loader =
+            ServiceLoader.load(FunctionEncoderProvider.class);
+    final Iterator<FunctionEncoderProvider> iterator = loader.iterator();
+
+    FUNCTION_ENCODER =
+            iterator.hasNext() ? iterator.next().get() : new DefaultFunctionEncoder();
+  }
 
   public static String encode(final Function function) {
-    return encoder().encodeFunction(function);
+    return FUNCTION_ENCODER.encodeFunction(function);
+  }
+
+  /** Encode function when we know function method Id / Selector. */
+  public static String encode(final String methodId, final List<Type> parameters) {
+    return FUNCTION_ENCODER.encodeWithSelector(methodId, parameters);
   }
 
   public static String encodeConstructor(final List<Type> parameters) {
-    return encoder().encodeParameters(parameters);
+    return FUNCTION_ENCODER.encodeParameters(parameters);
+  }
+
+  public static String encodeConstructorPacked(final List<Type> parameters) {
+    return FUNCTION_ENCODER.encodePackedParameters(parameters);
   }
 
   public static Function makeFunction(
       String fnname,
       List<String> solidityInputTypes,
       List<Object> arguments,
       List<String> solidityOutputTypes)
-      throws ClassNotFoundException, NoSuchMethodException, InstantiationException,
-      IllegalAccessException, InvocationTargetException {
+      throws ClassNotFoundException,
+            NoSuchMethodException,
+            InstantiationException,
+            IllegalAccessException,
+            InvocationTargetException {
     List<Type> encodedInput = new ArrayList<>();
     Iterator argit = arguments.iterator();
     for (String st : solidityInputTypes) {
-      encodedInput.add(TypeDecoder.instantiateType(st, argit.next()));
+      encodedInput.add(instantiateType(st, argit.next()));
     }
     List<TypeReference<?>> encodedOutput = new ArrayList<>();
     for (String st : solidityOutputTypes) {
-      encodedOutput.add(TypeReference.makeTypeReference(st));
+      encodedOutput.add(makeTypeReference(st));
     }
     return new Function(fnname, encodedInput, encodedOutput);
   }
@@ -70,6 +92,31 @@ public static Function makeFunction(
 
   protected abstract String encodeParameters(List<Type> parameters);
 
+  /**
+   * Encodes parameters prefixed with the given selector. Not part of the original
+   * subclass contract: implementations predating it inherit this throwing default,
+   * so the pre-existing entry points keep working and only the newer
+   * {@link #encode(String, List)} fails, with a clear message.
+   *
+   * @param methodId Callback selector / Abi method Id (Hex format)
+   */
+  protected String encodeWithSelector(
+          final String methodId, final List<Type> parameters) {
+    throw new UnsupportedOperationException(
+            "encodeWithSelector is not implemented by " + getClass().getName()
+                    + "; override it to support FunctionEncoder.encode(methodId, parameters)");
+  }
+
+  /**
+   * Encodes parameters using tight packing (abi.encodePacked). Not part of the
+   * original subclass contract; see {@link #encodeWithSelector(String, List)}.
+   */
+  protected String encodePackedParameters(List<Type> parameters) {
+    throw new UnsupportedOperationException(
+            "encodePackedParameters is not implemented by " + getClass().getName()
+                    + "; override it to support FunctionEncoder.encodeConstructorPacked(parameters)");
+  }
+
   protected static String buildMethodSignature(
       final String methodName, final List<Type> parameters) {
 
@@ -88,16 +135,4 @@ protected static String buildMethodId(final String methodSignature) {
     final byte[] hash = Hash.sha3(input);
     return Numeric.toHexString(hash).substring(2, 10);
   }
-
-  private static FunctionEncoder encoder() {
-    final Iterator<FunctionEncoderProvider> iterator = loader.iterator();
-    return iterator.hasNext() ? iterator.next().get() : defaultEncoder();
-  }
-
-  private static FunctionEncoder defaultEncoder() {
-    if (DEFAULT_ENCODER == null) {
-      DEFAULT_ENCODER = new DefaultFunctionEncoder();
-    }
-    return DEFAULT_ENCODER;
-  }
 }