small refactorings

Author: hendrikebbers

hedera-base/src/main/java/com/openelements/hedera/base/ContractParam.java

@@ -32,17 +32,30 @@ public record ContractParam<T>(@NonNull T value, @NonNull String nativeType, @No
                     "value '" + value + "' is not valid for native type '" + nativeType + "'");
         }
     }
-    
+
     private static <T> ContractParam<T> of(T value, ParamSupplier<T> paramSupplier) {
         Objects.requireNonNull(paramSupplier, "paramSupplier must not be null");
         return new ContractParam<>(value, paramSupplier.getNativeType(), paramSupplier);
     }
 
+    /**
+     * Creates a new contract parameter with the given value and native type {@code string}.
+     *
+     * @param value the value of the parameter
+     * @return the new contract parameter
+     */
     @NonNull
     public static ContractParam<String> string(String value) {
         return of(value, StringBasedDatatype.STRING);
     }
 
+    /**
+     * Creates a new contract parameter with the given value and native type {@code address}. The input must be address
+     * in solidty format.
+     *
+     * @param value the value of the parameter
+     * @return the new contract parameter
+     */
     @NonNull
     public static ContractParam<String> addressBySolidty(String value) {
         return of(value, StringBasedDatatype.ADDRESS);
@@ -70,6 +83,12 @@ public static ContractParam<Boolean> bool(boolean value) {
         return of(value, BooleanDatatype.BOOL);
     }
 
+    /**
+     * Creates a new contract parameter with the given value and native type {@code int8}.
+     *
+     * @param value the value of the parameter
+     * @return the new contract parameter
+     */
     @NonNull
     public static ContractParam<Long> int8(byte value) {
         return of((long) value, LongBasedNumericDatatypes.INT8);

hedera-base/src/main/java/com/openelements/hedera/base/implementation/ProtocolLayerClientImpl.java

@@ -466,7 +466,8 @@ private <T extends Transaction<T>> Transaction<T> sign(Transaction<T> transactio
     private ContractFunctionParameters createParameters(@NonNull final List<ContractParam<?>> params) {
         Objects.requireNonNull(params, "params must not be null");
         final ContractFunctionParameters constructorParams = new ContractFunctionParameters();
-        final Consumer<ContractParam> consumer = param -> param.supplier().addParam(param.value(), constructorParams);
+        final Consumer<ContractParam> consumer = param -> param.supplier()
+                .addParamToFunctionParameters(param.value(), constructorParams);
         params.forEach(consumer);
         return constructorParams;
     }

hedera-base/src/main/java/com/openelements/hedera/base/implementation/data/BigIntegerBasedNumericDatatypes.java

@@ -15,7 +15,8 @@ public enum BooleanDatatype implements ParamSupplier<Boolean> {
         this.addParam = (v, params) -> params.addBool(v);
     }
 
-    public void addParam(@NonNull final Boolean value, @NonNull final ContractFunctionParameters params) {
+    public void addParamToFunctionParameters(@NonNull final Boolean value,
+            @NonNull final ContractFunctionParameters params) {
         Objects.requireNonNull(value, "value must not be null");
         Objects.requireNonNull(params, "params must not be null");
         addParam.accept(value, params);

hedera-base/src/main/java/com/openelements/hedera/base/implementation/data/BooleanDatatype.java

@@ -29,22 +29,23 @@ public enum LongBasedNumericDatatypes implements ParamSupplier<Long> {
 
     private final String nativeType;
 
-    LongBasedNumericDatatypes(final String nativeType, final BiConsumer<Long, ContractFunctionParameters> addParam, long minValue, long maxValue) {
+    LongBasedNumericDatatypes(final String nativeType, final BiConsumer<Long, ContractFunctionParameters> addParam,
+            long minValue, long maxValue) {
         this.nativeType = nativeType;
         this.addParam = addParam;
         this.minValue = minValue;
         this.maxValue = maxValue;
     }
 
     @Override
-    public void addParam(@NonNull final Long value, final ContractFunctionParameters params) {
+    public void addParamToFunctionParameters(@NonNull final Long value, final ContractFunctionParameters params) {
         Objects.requireNonNull(value, "value must not be null");
         addParam.accept(value.longValue(), params);
     }
 
     @Override
     public boolean isValidParam(final Long value) {
-        if(value == null) {
+        if (value == null) {
             return false;
         }
         return value >= minValue && value <= maxValue;
@@ -57,7 +58,7 @@ public String getNativeType() {
 
     public void addParam(final long value, @NonNull final ContractFunctionParameters params) {
         Objects.requireNonNull(params, "params must not be null");
-        if(value < minValue || value > maxValue) {
+        if (value < minValue || value > maxValue) {
             throw new IllegalArgumentException("value out of range for type '" + this + "': " + value);
         }
         addParam.accept(value, params);

hedera-base/src/main/java/com/openelements/hedera/base/implementation/data/LongBasedNumericDatatypes.java

@@ -2,11 +2,38 @@
 
 import com.hedera.hashgraph.sdk.ContractFunctionParameters;
 
+/**
+ * Interface for supplying parameters to a smart contract function parameter list. An implementation can be used to add
+ * data in Java type {@code T} to a {@link ContractFunctionParameters} object. Here the data will normally be converted
+ * to a native type that can be used in a smart contract function call.
+ *
+ * @param <T>
+ */
 public interface ParamSupplier<T> {
 
-    void addParam(T value, ContractFunctionParameters params);
+    /**
+     * Add the given value of Java type {@code T} as a parameter of the native type (see {@link #getNativeType()}) to a
+     * {@link ContractFunctionParameters} object.
+     *
+     * @param value  The value to add
+     * @param params The parameters object to add the value to
+     */
+    void addParamToFunctionParameters(T value, ContractFunctionParameters params);
 
+    /**
+     * Check if the given value of Java type {@code T} is a valid parameter type for this supplier. A valid type can be
+     * converted to the native type (see {@link #getNativeType()}) and added to a {@link ContractFunctionParameters}
+     * object.
+     *
+     * @param value The value to check
+     * @return {@code true} if the value is a valid parameter type, {@code false} otherwise
+     */
     boolean isValidParam(T value);
 
+    /**
+     * Get the native type of the parameter that this supplier can add to a {@link ContractFunctionParameters} object.
+     *
+     * @return The native type
+     */
     String getNativeType();
 }

hedera-base/src/main/java/com/openelements/hedera/base/implementation/data/ParamSupplier.java

@@ -20,15 +20,15 @@ public enum StringBasedDatatype implements ParamSupplier<String> {
         this.addParam = addParam;
     }
 
-    public void addParam(final String value, @NonNull final ContractFunctionParameters params) {
+    public void addParamToFunctionParameters(final String value, @NonNull final ContractFunctionParameters params) {
         Objects.requireNonNull(params, "params must not be null");
         addParam.accept(value, params);
     }
 
     @Override
     public boolean isValidParam(@NonNull final String value) {
         Objects.requireNonNull(value, "value must not be null");
-        if(this.equals(ADDRESS)) {
+        if (this.equals(ADDRESS)) {
             try {
                 AccountId.fromString(value);
             } catch (final Exception e) {

hedera-base/src/main/java/com/openelements/hedera/base/implementation/data/StringBasedDatatype.java

@@ -8,6 +8,9 @@
 import java.util.Optional;
 import org.jspecify.annotations.NonNull;
 
+/**
+ * A client for querying the Hedera Mirror Node REST API.
+ */
 public interface MirrorNodeClient {
 
     @NonNull

hedera-base/src/main/java/com/openelements/hedera/base/mirrornode/MirrorNodeClient.java

@@ -17,9 +17,10 @@ void checkMethodsForNonNullResult(final LongBasedNumericDatatypes type) {
 
         //then
         Assertions.assertThrows(NullPointerException.class, () -> type.addParam(1L, null));
-        Assertions.assertThrows(NullPointerException.class, () -> type.addParam(null, parameters));
-        Assertions.assertThrows(NullPointerException.class, () -> type.addParam(Long.valueOf(1L), null));
-        Assertions.assertThrows(NullPointerException.class, () -> type.addParam(null, null));
+        Assertions.assertThrows(NullPointerException.class, () -> type.addParamToFunctionParameters(null, parameters));
+        Assertions.assertThrows(NullPointerException.class,
+                () -> type.addParamToFunctionParameters(Long.valueOf(1L), null));
+        Assertions.assertThrows(NullPointerException.class, () -> type.addParamToFunctionParameters(null, null));
     }
 
     @Test