call result

OpenElements · Jul 14, 2024 · 99b46c9 · 99b46c9
1 parent 5fdaeb1
commit 99b46c9
Show file tree

Hide file tree

Showing 5 changed files with 138 additions and 19 deletions.
diff --git a/hedera-base/src/main/java/com/openelements/hedera/base/ContractCallResult.java b/hedera-base/src/main/java/com/openelements/hedera/base/ContractCallResult.java
@@ -0,0 +1,36 @@
+package com.openelements.hedera.base;
+
+import com.hedera.hashgraph.sdk.Hbar;
+import java.math.BigInteger;
+
+public interface ContractCallResult {
+
+    long gasUsed();
+
+    Hbar cost();
+
+    String getString(int index);
+
+    String getAddress(int index);
+
+    boolean getBool(int index);
+
+    byte getInt8(int index);
+
+
+    int getInt32(int index);
+
+    long getInt64(int index);
+
+    BigInteger getInt256(int index);
+
+    long getUint8(int index);
+
+
+    long getUint32(int index);
+
+    long getUint64(int index);
+
+    BigInteger getUint256(int index);
+
+}
diff --git a/hedera-base/src/main/java/com/openelements/hedera/base/SmartContractClient.java b/hedera-base/src/main/java/com/openelements/hedera/base/SmartContractClient.java
@@ -63,7 +63,7 @@ default ContractId createContract(@NonNull String fileId, @Nullable ContractPara
      * @throws HederaException if the function could not be called
      */
     @NonNull
-    default ContractFunctionResult callContractFunction(@NonNull String contractId, @NonNull String functionName, @Nullable ContractParam<?>... params) throws HederaException {
+    default ContractCallResult callContractFunction(@NonNull String contractId, @NonNull String functionName, @Nullable ContractParam<?>... params) throws HederaException {
         return callContractFunction(ContractId.fromString(contractId), functionName, params);
     }
 
@@ -76,6 +76,6 @@ default ContractFunctionResult callContractFunction(@NonNull String contractId,
      * @throws HederaException if the function could not be called
      */
     @NonNull
-    ContractFunctionResult callContractFunction(@NonNull ContractId contractId, @NonNull String functionName, @Nullable ContractParam<?>... params) throws HederaException;
+    ContractCallResult callContractFunction(@NonNull ContractId contractId, @NonNull String functionName, @Nullable ContractParam<?>... params) throws HederaException;
 
 }
diff --git a/...ase/src/main/java/com/openelements/hedera/base/implementation/ContractCallResultImpl.java b/...ase/src/main/java/com/openelements/hedera/base/implementation/ContractCallResultImpl.java
@@ -0,0 +1,82 @@
+package com.openelements.hedera.base.implementation;
+
+import com.hedera.hashgraph.sdk.ContractFunctionResult;
+import com.hedera.hashgraph.sdk.Hbar;
+import com.openelements.hedera.base.ContractCallResult;
+import edu.umd.cs.findbugs.annotations.NonNull;
+import java.math.BigInteger;
+import java.util.Objects;
+
+public class ContractCallResultImpl implements ContractCallResult {
+
+    private final ContractFunctionResult innerResult;
+
+    public ContractCallResultImpl(@NonNull final ContractFunctionResult innerResult) {
+        this.innerResult = Objects.requireNonNull(innerResult, "innerResult must not be null");
+    }
+
+    @Override
+    public long gasUsed() {
+        return innerResult.gasUsed;
+    }
+
+    @Override
+    public Hbar cost() {
+        return innerResult.hbarAmount;
+    }
+
+    @Override
+    public String getString(int index) {
+        return innerResult.getString(index);
+    }
+
+    @Override
+    public String getAddress(int index) {
+        return innerResult.getAddress(index);
+    }
+
+    @Override
+    public boolean getBool(int index) {
+        return innerResult.getBool(index);
+    }
+
+    @Override
+    public byte getInt8(int index) {
+        return innerResult.getInt8(index);
+    }
+
+    @Override
+    public int getInt32(int index) {
+        return innerResult.getInt32(index);
+    }
+
+    @Override
+    public long getInt64(int index) {
+        return innerResult.getInt64(index);
+    }
+
+    @Override
+    public BigInteger getInt256(int index) {
+        return innerResult.getInt256(index);
+    }
+
+    @Override
+    public long getUint8(int index) {
+        return innerResult.getUint8(index);
+    }
+
+    @Override
+    public long getUint32(int index) {
+        return innerResult.getUint32(index);
+    }
+
+    @Override
+    public long getUint64(int index) {
+        return innerResult.getUint64(index);
+    }
+
+    @Override
+    public BigInteger getUint256(int index) {
+        return innerResult.getUint256(index);
+    }
+}
diff --git a/...se/src/main/java/com/openelements/hedera/base/implementation/SmartContractClientImpl.java b/...se/src/main/java/com/openelements/hedera/base/implementation/SmartContractClientImpl.java
@@ -3,6 +3,7 @@
 import com.hedera.hashgraph.sdk.ContractFunctionResult;
 import com.hedera.hashgraph.sdk.ContractId;
 import com.hedera.hashgraph.sdk.FileId;
+import com.openelements.hedera.base.ContractCallResult;
 import com.openelements.hedera.base.ContractParam;
 import com.openelements.hedera.base.FileClient;
 import com.openelements.hedera.base.HederaException;
@@ -81,11 +82,12 @@ public ContractId createContract(@NonNull Path pathToBin, @Nullable ContractPara
 
     @NonNull
     @Override
-    public ContractFunctionResult callContractFunction(@NonNull ContractId contractId, @NonNull String functionName,
+    public ContractCallResult callContractFunction(@NonNull ContractId contractId, @NonNull String functionName,
             @Nullable ContractParam<?>... params) throws HederaException {
         try {
             final ContractCallRequest request = ContractCallRequest.of(contractId, functionName, params);
-            return protocolLayerClient.executeContractCallTransaction(request).contractFunctionResult();
+            ContractFunctionResult result = protocolLayerClient.executeContractCallTransaction(request).contractFunctionResult();
+            return new ContractCallResultImpl(result);
         } catch (Exception e) {
             throw new HederaException("Failed to call function '" + functionName + "' on contract with id " + contractId, e);
         }

diff --git a/spring-hedera/src/test/java/com/openelements/spring/hedera/test/DatatypesTest.java b/spring-hedera/src/test/java/com/openelements/spring/hedera/test/DatatypesTest.java
@@ -1,10 +1,9 @@
 package com.openelements.spring.hedera.test;
 
-import com.hedera.hashgraph.sdk.ContractFunctionResult;
 import com.hedera.hashgraph.sdk.ContractId;
+import com.openelements.hedera.base.ContractCallResult;
 import com.openelements.hedera.base.ContractParam;
 import com.openelements.hedera.base.SmartContractClient;
-import com.openelements.hedera.base.implementation.SmartContractClientImpl;
 import java.math.BigInteger;
 import java.nio.file.Path;
 import java.util.function.Function;
@@ -44,7 +43,7 @@ public void testString() throws Exception {
         final String expected = "Hello, World!";
 
         //when
-        final ContractFunctionResult result = smartContractClient.callContractFunction(contract, "checkString",
+        final ContractCallResult result = smartContractClient.callContractFunction(contract, "checkString",
                 ContractParam.string(expected));
 
         //then
@@ -58,7 +57,7 @@ public void testAddress() throws Exception {
         final String expected = contract.toString();
 
         //when
-        final ContractFunctionResult result = smartContractClient.callContractFunction(contract, "checkString",
+        final ContractCallResult result = smartContractClient.callContractFunction(contract, "checkString",
                 ContractParam.address(expected));
 
         //then
@@ -67,44 +66,44 @@ public void testAddress() throws Exception {
 
     @ParameterizedTest
     @MethodSource("provideIntArguments")
-    public <T> void testLongTypes(String functionName, long value, ContractParam inputParam, Function<ContractFunctionResult, Long> resultExtractor) throws Exception {
+    public <T> void testLongTypes(String functionName, long value, ContractParam inputParam, Function<ContractCallResult, Long> resultExtractor) throws Exception {
         //given
         final ContractId contract = getOrCreateContractId();
 
         //when
-        final ContractFunctionResult result = smartContractClient.callContractFunction(contract, functionName, inputParam);
+        final ContractCallResult result = smartContractClient.callContractFunction(contract, functionName, inputParam);
 
         //then
         Assertions.assertEquals(value, resultExtractor.apply(result));
     }
 
     @ParameterizedTest
     @MethodSource("provideBigIntegerArguments")
-    public <T> void testBigIntegerTypes(String functionName, BigInteger value, ContractParam inputParam, Function<ContractFunctionResult, BigInteger> resultExtractor) throws Exception {
+    public <T> void testBigIntegerTypes(String functionName, BigInteger value, ContractParam inputParam, Function<ContractCallResult, BigInteger> resultExtractor) throws Exception {
         //given
         final ContractId contract = getOrCreateContractId();
 
         //when
-        final ContractFunctionResult result = smartContractClient.callContractFunction(contract, functionName, inputParam);
+        final ContractCallResult result = smartContractClient.callContractFunction(contract, functionName, inputParam);
 
         //then
         Assertions.assertEquals(value, resultExtractor.apply(result));
     }
 
     static Stream<Arguments> provideIntArguments() {
         return Stream.of(
-                Arguments.of("checkInt8", 7, ContractParam.int8((byte)7), (Function<ContractFunctionResult, Long>) r -> (long) r.getInt8(0)),
-                Arguments.of("checkUint8", 7, ContractParam.uint8((byte)7), (Function<ContractFunctionResult, Long>) r -> (long) r.getUint8(0)),
-                Arguments.of("checkInt32", 123456789, ContractParam.int32(123456789), (Function<ContractFunctionResult, Long>) r -> (long) r.getInt32(0)),
-                Arguments.of("checkUint32", 123456789L, ContractParam.uint32(123456789L), (Function<ContractFunctionResult, Long>) r -> (long) r.getUint32(0)),
-                Arguments.of("checkInt64", 1234567890123456789L, ContractParam.int64(1234567890123456789L), (Function<ContractFunctionResult, Long>) r -> (long) r.getInt64(0))
+                Arguments.of("checkInt8", 7, ContractParam.int8((byte)7), (Function<ContractCallResult, Long>) r -> (long) r.getInt8(0)),
+                Arguments.of("checkUint8", 7, ContractParam.uint8((byte)7), (Function<ContractCallResult, Long>) r -> (long) r.getUint8(0)),
+                Arguments.of("checkInt32", 123456789, ContractParam.int32(123456789), (Function<ContractCallResult, Long>) r -> (long) r.getInt32(0)),
+                Arguments.of("checkUint32", 123456789L, ContractParam.uint32(123456789L), (Function<ContractCallResult, Long>) r -> (long) r.getUint32(0)),
+                Arguments.of("checkInt64", 1234567890123456789L, ContractParam.int64(1234567890123456789L), (Function<ContractCallResult, Long>) r -> (long) r.getInt64(0))
         );
     }
 
     static Stream<Arguments> provideBigIntegerArguments() {
         return Stream.of(
-                Arguments.of("checkInt256", new BigInteger("1234567890123456789012345678901234567890123456789012345678901234567890"), ContractParam.int256(new BigInteger("1234567890123456789012345678901234567890123456789012345678901234567890")), (Function<ContractFunctionResult, BigInteger>) r -> r.getInt256(0)),
-                Arguments.of("checkUint256", new BigInteger("1234567890123456789012345678901234567890123456789012345678901234567890"), ContractParam.uint256(new BigInteger("1234567890123456789012345678901234567890123456789012345678901234567890")), (Function<ContractFunctionResult, BigInteger>) r -> r.getUint256(0))
+                Arguments.of("checkInt256", new BigInteger("1234567890123456789012345678901234567890123456789012345678901234567890"), ContractParam.int256(new BigInteger("1234567890123456789012345678901234567890123456789012345678901234567890")), (Function<ContractCallResult, BigInteger>) r -> r.getInt256(0)),
+                Arguments.of("checkUint256", new BigInteger("1234567890123456789012345678901234567890123456789012345678901234567890"), ContractParam.uint256(new BigInteger("1234567890123456789012345678901234567890123456789012345678901234567890")), (Function<ContractCallResult, BigInteger>) r -> r.getUint256(0))
         );
     }
 }