Merge pull request #218 from klaytn/release/v1.6.0

[Master] release/v1.6.0 QA Sign-off

Author: kale

.github/CODEOWNERS

@@ -6,7 +6,7 @@
 # @global-owner1 and @global-owner2 will be requested for
 # review when someone opens a pull request.
 #*       @global-owner1 @global-owner2
-*       @kjhman21 @jimni1222 @sirano11
+*       @kjhman21 @jimni1222 @sirano11 @aeharvlee
 
 # Order is important; the last matching pattern takes the most
 # precedence. When someone opens a pull request that only

build.gradle

@@ -20,7 +20,7 @@ plugins {
 
 allprojects {
 
-    version '1.5.7'
+    version '1.6.0'
     group 'com.klaytn.caver'
     description 'caver-java project'
 

core/src/main/java/com/klaytn/caver/abi/ABI.java

@@ -16,11 +16,10 @@
 
 package com.klaytn.caver.abi;
 
+import com.klaytn.caver.abi.datatypes.*;
 import com.klaytn.caver.contract.ContractEvent;
 import com.klaytn.caver.contract.ContractIOType;
 import com.klaytn.caver.contract.ContractMethod;
-import org.web3j.abi.*;
-import org.web3j.abi.datatypes.*;
 import org.web3j.crypto.Hash;
 import org.web3j.utils.Numeric;
 
@@ -31,6 +30,8 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
+import static com.klaytn.caver.abi.TypeEncoder.isDynamic;
+
 /**
  * Representing a ABI type encode / decode.
  */
@@ -48,7 +49,7 @@ public static String encodeFunctionCall(ContractMethod method, List<Object> para
         List<String> solTypeList = new ArrayList();
 
         for (ContractIOType contractIOType : method.getInputs()) {
-            solTypeList.add(contractIOType.getType());
+            solTypeList.add(contractIOType.getTypeAsString());
         }
 
         return encodeFunctionCall(functionSignature, solTypeList, params);
@@ -133,12 +134,13 @@ public static String buildFunctionString(ContractMethod method) {
         result.append(method.getName());
         result.append("(");
         String params = method.getInputs().stream()
-                .map(ContractIOType::getType)
+                .map(ContractIOType::getTypeAsString)
                 .collect(Collectors.joining(","));
         result.append(params);
         result.append(")");
 
-        return result.toString();
+        //remove "tuple" string
+        return result.toString().replace("tuple", "");
     }
 
     /**
@@ -171,12 +173,13 @@ public static String buildEventString(ContractEvent event) {
         result.append(event.getName());
         result.append("(");
         String params = event.getInputs().stream()
-                .map(ContractIOType::getType)
+                .map(ContractIOType::getTypeAsString)
                 .collect(Collectors.joining(","));
         result.append(params);
         result.append(")");
 
-        return result.toString();
+        //remove "tuple" string
+        return result.toString().replace("tuple", "");
     }
 
     /**
@@ -209,7 +212,7 @@ public static String encodeParameter(String solidityType, Object value) throws C
     public static String encodeParameters(ContractMethod method, List<Object> values) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
         List<String> solTypeList = new ArrayList<>();
         for(ContractIOType type : method.getInputs()) {
-            solTypeList.add(type.getType());
+            solTypeList.add(type.getTypeAsString());
         }
 
         return encodeParameters(solTypeList, values);
@@ -251,25 +254,26 @@ public static String encodeParameter(Type parameter) {
      * @return String
      */
     public static String encodeParameters(List<Type> parameters) {
-        int dynamicDataOffset = getLength(parameters) * Type.MAX_BYTE_LENGTH;
-        StringBuilder result = new StringBuilder();
-        StringBuilder dynamicData = new StringBuilder();
-
-        for (Type parameter:parameters) {
-            String encodedValue = TypeEncoder.encode(parameter);
-
-            if (isDynamic(parameter)) {
-                String encodedDataOffset = TypeEncoder.encode(new Uint(BigInteger.valueOf(dynamicDataOffset)));
-                result.append(encodedDataOffset);
-                dynamicData.append(encodedValue);
-                dynamicDataOffset += encodedValue.length() >> 1;
-            } else {
-                result.append(encodedValue);
-            }
-        }
-        result.append(dynamicData);
-
-        return result.toString();
+        return new DefaultFunctionEncoder().encodeParameters(parameters);
+//        int dynamicDataOffset = getLength(parameters) * Type.MAX_BYTE_LENGTH;
+//        StringBuilder result = new StringBuilder();
+//        StringBuilder dynamicData = new StringBuilder();
+//
+//        for (Type parameter:parameters) {
+//            String encodedValue = TypeEncoder.encode(parameter);
+//
+//            if (isDynamic(parameter)) {
+//                String encodedDataOffset = TypeEncoder.encode(new Uint(BigInteger.valueOf(dynamicDataOffset)));
+//                result.append(encodedDataOffset);
+//                dynamicData.append(encodedValue);
+//                dynamicDataOffset += encodedValue.length() >> 1;
+//            } else {
+//                result.append(encodedValue);
+//            }
+//        }
+//        result.append(dynamicData);
+//
+//        return result.toString();
     }
 
     /**
@@ -311,7 +315,7 @@ public static List<Type> decodeParameters(ContractMethod method, String encoded)
         List<TypeReference<Type>> resultParams = new ArrayList<>();
 
         for(ContractIOType ioType: method.getOutputs()) {
-            resultParams.add(TypeReference.makeTypeReference(ioType.getType()));
+            resultParams.add(TypeReference.makeTypeReference(ioType.getTypeAsString()));
         }
 
         return FunctionReturnDecoder.decode(encoded, resultParams);
@@ -331,9 +335,9 @@ public static EventValues decodeLog(List<ContractIOType> inputs, String data, Li
 
         for(ContractIOType input: inputs) {
             if(input.isIndexed()) {
-                indexedList.add(TypeReference.makeTypeReference(input.getType()));
+                indexedList.add(TypeReference.makeTypeReference(input.getTypeAsString()));
             } else {
-                nonIndexedList.add(TypeReference.makeTypeReference(input.getType()));
+                nonIndexedList.add(TypeReference.makeTypeReference(input.getTypeAsString()));
             }
         }
 
@@ -349,21 +353,21 @@ public static EventValues decodeLog(List<ContractIOType> inputs, String data, Li
         return new EventValues(indexedValues, nonIndexedValues);
     }
 
-    private static int getLength(List<Type> parameters) {
-        int count = 0;
-        for (Type type:parameters) {
-            if (type instanceof StaticArray) {
-                count += ((StaticArray) type).getValue().size();
-            } else {
-                count++;
-            }
-        }
-        return count;
-    }
-
-    private static boolean isDynamic(Type parameter) {
-        return parameter instanceof DynamicBytes
-                || parameter instanceof Utf8String
-                || parameter instanceof DynamicArray;
-    }
+//    private static int getLength(List<Type> parameters) {
+//        int count = 0;
+//        for (Type type:parameters) {
+//            if (type instanceof StaticArray) {
+//                count += ((StaticArray) type).getValue().size();
+//            } else {
+//                count++;
+//            }
+//        }
+//        return count;
+//    }
+
+//    private static boolean isDynamic(Type parameter) {
+//        return parameter instanceof DynamicBytes
+//                || parameter instanceof Utf8String
+//                || parameter instanceof DynamicArray;
+//    }
 }

core/src/main/java/com/klaytn/caver/abi/DefaultFunctionEncoder.java

@@ -0,0 +1,90 @@
+/*
+ * Modifications copyright 2021 The caver-java Authors
+ * Copyright 2019 Web3 Labs Ltd.
+ *
+ * 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.
+ *
+ * This file is derived from web3j/abi/src/main/java/org/web3j/abi/DefaultFunctionEncoder.java (2021/04/05).
+ * Modified and improved for the caver-java development.
+ */
+
+package com.klaytn.caver.abi;
+
+import com.klaytn.caver.abi.datatypes.*;
+
+import java.math.BigInteger;
+import java.util.List;
+
+public class DefaultFunctionEncoder extends FunctionEncoder {
+
+    @Override
+    public String encodeFunction(final Function function) {
+        final List<Type> parameters = function.getInputParameters();
+
+        final String methodSignature = buildMethodSignature(function.getName(), parameters);
+        final String methodId = buildMethodId(methodSignature);
+
+        final StringBuilder result = new StringBuilder();
+        result.append(methodId);
+
+        return encodeParameters(parameters, result);
+    }
+
+    @Override
+    public String encodeParameters(final List<Type> parameters) {
+        return encodeParameters(parameters, new StringBuilder());
+    }
+
+    private static String encodeParameters(
+            final List<Type> parameters, final StringBuilder result) {
+
+        int dynamicDataOffset = getLength(parameters) * Type.MAX_BYTE_LENGTH;
+        final StringBuilder dynamicData = new StringBuilder();
+
+        for (Type parameter : parameters) {
+            final String encodedValue = TypeEncoder.encode(parameter);
+
+            if (TypeEncoder.isDynamic(parameter)) {
+                final String encodedDataOffset =
+                        TypeEncoder.encodeNumeric(new Uint(BigInteger.valueOf(dynamicDataOffset)));
+                result.append(encodedDataOffset);
+                dynamicData.append(encodedValue);
+                dynamicDataOffset += encodedValue.length() >> 1;
+            } else {
+                result.append(encodedValue);
+            }
+        }
+        result.append(dynamicData);
+
+        return result.toString();
+    }
+
+    @SuppressWarnings("unchecked")
+    private static int getLength(final List<Type> parameters) {
+        int count = 0;
+        for (final Type type : parameters) {
+            if(type instanceof StaticStruct) {
+                count += Utils.getStaticStructComponentSize((StaticStruct) type);
+            } else if (type instanceof StaticArray) {
+                if(TypeEncoder.isDynamic(type)) {
+                    count++;
+                } else {
+                    count += Utils.getStaticArrayElementSize((StaticArray)type);
+                }
+            } else {
+                count++;
+            }
+        }
+        return count;
+    }
+}