diff --git a/src/main/java/com/openelements/spring/hedera/api/ContractVerificationClient.java b/src/main/java/com/openelements/spring/hedera/api/ContractVerificationClient.java new file mode 100644 index 00000000..dcaba629 --- /dev/null +++ b/src/main/java/com/openelements/spring/hedera/api/ContractVerificationClient.java @@ -0,0 +1,12 @@ +package com.openelements.spring.hedera.api; + +import com.hedera.hashgraph.sdk.ContractId; +import com.openelements.spring.hedera.api.data.ContractVerificationState; + +public interface ContractVerificationClient { + + ContractVerificationState checkVerification(String contractId, String contractSource, String contractMetadata); + + ContractVerificationState checkVerification(ContractId contractId, String contractSource, String contractMetadata); + +} diff --git a/src/main/java/com/openelements/spring/hedera/api/FileServiceClient.java b/src/main/java/com/openelements/spring/hedera/api/FileServiceClient.java new file mode 100644 index 00000000..8e8b9b2f --- /dev/null +++ b/src/main/java/com/openelements/spring/hedera/api/FileServiceClient.java @@ -0,0 +1,20 @@ +package com.openelements.spring.hedera.api; + +import com.hedera.hashgraph.sdk.FileId; + +public interface FileServiceClient { + + FileId createFile(byte[] contents) throws HederaException; + + default byte[] readFile(String fileId) throws HederaException { + return readFile(FileId.fromString(fileId)); + } + + byte[] readFile(FileId fileId) throws HederaException; + + default void deleteFile(String fileId) throws HederaException { + deleteFile(FileId.fromString(fileId)); + } + + void deleteFile(FileId fileId) throws HederaException; +} diff --git a/src/main/java/com/openelements/spring/hedera/api/HederaClient.java b/src/main/java/com/openelements/spring/hedera/api/HederaClient.java index 0b7fdb08..80470c02 100644 --- a/src/main/java/com/openelements/spring/hedera/api/HederaClient.java +++ b/src/main/java/com/openelements/spring/hedera/api/HederaClient.java @@ -1,6 +1,7 @@ package com.openelements.spring.hedera.api; import com.hedera.hashgraph.sdk.Client; +import com.hedera.hashgraph.sdk.ContractFunctionResult; import com.hedera.hashgraph.sdk.ContractId; import com.hedera.hashgraph.sdk.FileId; import com.openelements.spring.hedera.api.data.ContractParam; @@ -24,31 +25,7 @@ /** * Interface for interacting with the Hedera network. */ -public interface HederaClient { - - FileId createFile(byte[] contents) throws HederaException; - - default byte[] readFile(String fileId) throws HederaException { - return readFile(FileId.fromString(fileId)); - } - - byte[] readFile(FileId fileId) throws HederaException; - - default void deleteFile(String fileId) throws HederaException { - deleteFile(FileId.fromString(fileId)); - } - - void deleteFile(FileId fileId) throws HederaException; - - default ContractId createContract(String fileId, ContractParam... constructorParams) throws HederaException { - return createContract(FileId.fromString(fileId), constructorParams); - } - - ContractId createContract(FileId fileId, ContractParam... constructorParams) throws HederaException; - - ContractId createContract(byte[] contents, ContractParam... constructorParams) throws HederaException; - - ContractId createContract(Path pathToBin, ContractParam... constructorParams) throws HederaException; +public interface HederaClient extends FileServiceClient, SmartContractServiceClient { AccountBalanceResponse executeAccountBalanceQuery(AccountBalanceRequest request) throws HederaException; diff --git a/src/main/java/com/openelements/spring/hedera/api/SmartContractServiceClient.java b/src/main/java/com/openelements/spring/hedera/api/SmartContractServiceClient.java new file mode 100644 index 00000000..75501ef9 --- /dev/null +++ b/src/main/java/com/openelements/spring/hedera/api/SmartContractServiceClient.java @@ -0,0 +1,27 @@ +package com.openelements.spring.hedera.api; + +import com.hedera.hashgraph.sdk.ContractFunctionResult; +import com.hedera.hashgraph.sdk.ContractId; +import com.hedera.hashgraph.sdk.FileId; +import com.openelements.spring.hedera.api.data.ContractParam; +import java.nio.file.Path; + +public interface SmartContractServiceClient { + + default ContractId createContract(String fileId, ContractParam... constructorParams) throws HederaException { + return createContract(FileId.fromString(fileId), constructorParams); + } + + ContractId createContract(FileId fileId, ContractParam... constructorParams) throws HederaException; + + ContractId createContract(byte[] contents, ContractParam... constructorParams) throws HederaException; + + ContractId createContract(Path pathToBin, ContractParam... constructorParams) throws HederaException; + + default ContractFunctionResult callContractFunction(String contractId, String functionName, ContractParam... params) throws HederaException { + return callContractFunction(ContractId.fromString(contractId), functionName, params); + } + + ContractFunctionResult callContractFunction(ContractId contractId, String functionName, ContractParam... params) throws HederaException; + +} diff --git a/src/main/java/com/openelements/spring/hedera/api/data/ContractParam.java b/src/main/java/com/openelements/spring/hedera/api/data/ContractParam.java index e9a77118..28884762 100644 --- a/src/main/java/com/openelements/spring/hedera/api/data/ContractParam.java +++ b/src/main/java/com/openelements/spring/hedera/api/data/ContractParam.java @@ -1,40 +1,603 @@ package com.openelements.spring.hedera.api.data; +import com.hedera.hashgraph.sdk.AccountId; +import com.hedera.hashgraph.sdk.ContractId; import com.openelements.spring.hedera.implementation.data.BigIntegerBasedNumericDatatypes; +import com.openelements.spring.hedera.implementation.data.BooleanDatatype; import com.openelements.spring.hedera.implementation.data.LongBasedNumericDatatypes; import com.openelements.spring.hedera.implementation.data.ParamSupplier; -import com.openelements.spring.hedera.implementation.data.StringDatatype; +import com.openelements.spring.hedera.implementation.data.StringBasedDatatype; import jakarta.annotation.Nonnull; import java.math.BigInteger; import java.util.Objects; -public record ContractParam(@Nonnull T value, @Nonnull ParamSupplier supplier) { +public record ContractParam(@Nonnull T value, @Nonnull String nativeType, @Nonnull ParamSupplier supplier) { public ContractParam { Objects.requireNonNull(value, "value must not be null"); + Objects.requireNonNull(nativeType, "nativeType must not be null"); Objects.requireNonNull(supplier, "supplier must not be null"); + if(!supplier.isValidParam(value)) { + throw new IllegalArgumentException("value '" + value + "' is not valid for native type '" + nativeType + "'"); + } + } + + private static ContractParam of(T value, ParamSupplier paramSupplier) { + Objects.requireNonNull(paramSupplier, "paramSupplier must not be null"); + return new ContractParam<>(value, paramSupplier.getNativeType(), paramSupplier); + } + + @Nonnull + public static ContractParam string(String value) { + return of(value, StringBasedDatatype.STRING); + } + + @Nonnull + public static ContractParam address(String value) { + return of(value, StringBasedDatatype.ADDRESS); + } + + @Nonnull + public static ContractParam address(@Nonnull AccountId value) { + Objects.requireNonNull(value, "value must not be null"); + return of(value.toString(), StringBasedDatatype.ADDRESS); + } + + @Nonnull + public static ContractParam address(@Nonnull ContractId value) { + Objects.requireNonNull(value, "value must not be null"); + return of(value.toString(), StringBasedDatatype.ADDRESS); + } + + @Nonnull + public static ContractParam bool(boolean value) { + return of(value, BooleanDatatype.BOOL); + } + + @Nonnull + public static ContractParam int8(byte value) { + return of((long) value, LongBasedNumericDatatypes.INT8); + } + + @Nonnull + public static ContractParam uint8(short value) { + return of((long) value, LongBasedNumericDatatypes.UINT8); + } + + @Nonnull + public static ContractParam int16(short value) { + return of((long) value, LongBasedNumericDatatypes.INT8); + } + + @Nonnull + public static ContractParam uint16(int value) { + return of((long) value, LongBasedNumericDatatypes.UINT8); + } + + @Nonnull + public static ContractParam int32(int value) { + return of((long) value, LongBasedNumericDatatypes.INT32); + } + + @Nonnull + public static ContractParam uint32(long value) { + return of(value, LongBasedNumericDatatypes.UINT32); + } + + @Nonnull + public static ContractParam int40(long value) { + return of(value, LongBasedNumericDatatypes.INT40); + } + + @Nonnull + public static ContractParam uint40(long value) { + return of(value, LongBasedNumericDatatypes.UINT40); + } + + @Nonnull + public static ContractParam int48(long value) { + return of(value, LongBasedNumericDatatypes.INT48); + } + + @Nonnull + public static ContractParam uint48(long value) { + return of(value, LongBasedNumericDatatypes.UINT48); + } + + @Nonnull + public static ContractParam int56(long value) { + return of(value, LongBasedNumericDatatypes.INT56); + } + + @Nonnull + public static ContractParam uint56(long value) { + return of(value, LongBasedNumericDatatypes.UINT56); + } + + @Nonnull + public static ContractParam int64(long value) { + return of(value, LongBasedNumericDatatypes.INT64); + } + + @Nonnull + public static ContractParam int72(long value) { + return int72(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam int72(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.INT72); + } + + public static ContractParam uint72(long value) { + return uint72(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam uint72(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.UINT72); + } + + @Nonnull + public static ContractParam int80(long value) { + return int80(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam int80(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.INT80); + } + + @Nonnull + public static ContractParam uint80(long value) { + return uint80(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam uint80(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.UINT80); + } + + @Nonnull + public static ContractParam int88(long value) { + return int88(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam int88(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.INT88); + } + + @Nonnull + public static ContractParam uint88(long value) { + return uint88(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam uint88(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.UINT88); + } + + + @Nonnull + public static ContractParam int96(long value) { + return int96(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam int96(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.INT96); + } + + @Nonnull + public static ContractParam uint96(long value) { + return uint96(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam uint96(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.UINT96); + } + + @Nonnull + public static ContractParam int104(long value) { + return int104(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam int104(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.INT104); + } + + @Nonnull + public static ContractParam uint104(long value) { + return uint104(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam uint104(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.UINT104); + } + + @Nonnull + public static ContractParam int112(long value) { + return int112(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam int112(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.INT112); + } + + @Nonnull + public static ContractParam uint112(long value) { + return uint112(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam uint112(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.UINT112); + } + + @Nonnull + public static ContractParam int120(long value) { + return int120(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam int120(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.INT120); + } + + @Nonnull + public static ContractParam uint120(long value) { + return uint120(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam uint120(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.UINT120); + } + + @Nonnull + public static ContractParam int128(long value) { + return int128(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam int128(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.INT128); + } + + @Nonnull + public static ContractParam uint128(long value) { + return uint128(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam uint128(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.UINT128); + } + + @Nonnull + public static ContractParam int136(long value) { + return int136(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam int136(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.INT136); + } + + @Nonnull + public static ContractParam uint136(long value) { + return uint136(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam uint136(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.UINT136); + } + + @Nonnull + public static ContractParam int144(long value) { + return int144(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam int144(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.INT144); + } + + @Nonnull + public static ContractParam uint144(long value) { + return uint144(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam uint144(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.UINT144); + } + + @Nonnull + public static ContractParam int152(long value) { + return int152(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam int152(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.INT152); + } + + @Nonnull + public static ContractParam uint152(long value) { + return uint152(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam uint152(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.UINT152); + } + + @Nonnull + public static ContractParam int160(long value) { + return int160(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam int160(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.INT160); + } + + @Nonnull + public static ContractParam uint160(long value) { + return uint160(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam uint160(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.UINT160); + } + + @Nonnull + public static ContractParam int168(long value) { + return int168(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam int168(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.INT168); + } + + @Nonnull + public static ContractParam uint168(long value) { + return uint168(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam uint168(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.UINT168); + } + + @Nonnull + public static ContractParam int176(long value) { + return int176(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam int176(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.INT176); + } + + @Nonnull + public static ContractParam uint176(long value) { + return uint176(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam uint176(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.UINT176); + } + + @Nonnull + public static ContractParam int184(long value) { + return int184(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam int184(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.INT184); + } + + @Nonnull + public static ContractParam uint184(long value) { + return uint184(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam uint184(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.UINT184); + } + + @Nonnull + public static ContractParam int192(long value) { + return int192(BigInteger.valueOf(value)); } @Nonnull - public static ContractParam string(String value) { - return new ContractParam(value, StringDatatype.STRING); + public static ContractParam int192(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.INT192); } @Nonnull - public static ContractParam int64(long value) { - return new ContractParam(value, LongBasedNumericDatatypes.INT64); + public static ContractParam uint192(long value) { + return uint192(BigInteger.valueOf(value)); } @Nonnull - public static ContractParam int256(@Nonnull BigInteger value) { + public static ContractParam uint192(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.UINT192); + } + + @Nonnull + public static ContractParam int200(long value) { + return int200(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam int200(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.INT200); + } + + @Nonnull + public static ContractParam uint200(long value) { + return uint200(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam uint200(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.UINT200); + } + + @Nonnull + public static ContractParam int208(long value) { + return int208(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam int208(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.INT208); + } + + @Nonnull + public static ContractParam uint208(long value) { + return uint208(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam uint208(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.UINT208); + } + + @Nonnull + public static ContractParam int216(long value) { + return int216(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam int216(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.INT216); + } + + @Nonnull + public static ContractParam uint216(long value) { + return uint216(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam uint216(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.UINT216); + } + + @Nonnull + public static ContractParam int224(long value) { + return int224(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam int224(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.INT224); + } + + @Nonnull + public static ContractParam uint224(long value) { + return uint224(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam uint224(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.UINT224); + } + + @Nonnull + public static ContractParam int232(long value) { + return int232(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam int232(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.INT232); + } + + @Nonnull + public static ContractParam uint232(long value) { + return uint232(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam uint232(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.UINT232); + } + + @Nonnull + public static ContractParam int240(long value) { + return int240(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam int240(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.INT240); + } + + @Nonnull + public static ContractParam uint240(long value) { + return uint240(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam uint240(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.UINT240); + } + + @Nonnull + public static ContractParam int248(long value) { + return int248(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam int248(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.INT248); + } + + @Nonnull + public static ContractParam uint248(long value) { + return uint248(BigInteger.valueOf(value)); + } + + @Nonnull + public static ContractParam uint248(@Nonnull BigInteger value) { + return of(value, BigIntegerBasedNumericDatatypes.UINT248); + } + + @Nonnull + public static ContractParam int256(@Nonnull BigInteger value) { Objects.requireNonNull(value, "value must not be null"); - return new ContractParam(value, BigIntegerBasedNumericDatatypes.INT256); + return of(value, BigIntegerBasedNumericDatatypes.INT256); + } + + @Nonnull + public static ContractParam int256(long value) { + return int256(BigInteger.valueOf(value)); } @Nonnull - public static ContractParam int256(long value) { - final BigInteger valueAsBigInteger = BigInteger.valueOf(value); - return int256(valueAsBigInteger); + public static ContractParam uint256(@Nonnull BigInteger value) { + Objects.requireNonNull(value, "value must not be null"); + return of(value, BigIntegerBasedNumericDatatypes.UINT256); } + @Nonnull + public static ContractParam uint256(long value) { + return uint256(BigInteger.valueOf(value)); + } } diff --git a/src/main/java/com/openelements/spring/hedera/api/data/ContractVerificationState.java b/src/main/java/com/openelements/spring/hedera/api/data/ContractVerificationState.java new file mode 100644 index 00000000..b69c83b9 --- /dev/null +++ b/src/main/java/com/openelements/spring/hedera/api/data/ContractVerificationState.java @@ -0,0 +1,7 @@ +package com.openelements.spring.hedera.api.data; + +public enum ContractVerificationState { + PARTIAL, + FULL, + NONE; +} diff --git a/src/main/java/com/openelements/spring/hedera/implementation/HederaClientImpl.java b/src/main/java/com/openelements/spring/hedera/implementation/HederaClientImpl.java index 36c21662..c575b6a2 100644 --- a/src/main/java/com/openelements/spring/hedera/implementation/HederaClientImpl.java +++ b/src/main/java/com/openelements/spring/hedera/implementation/HederaClientImpl.java @@ -7,6 +7,7 @@ import com.hedera.hashgraph.sdk.ContractCreateTransaction; import com.hedera.hashgraph.sdk.ContractExecuteTransaction; import com.hedera.hashgraph.sdk.ContractFunctionParameters; +import com.hedera.hashgraph.sdk.ContractFunctionResult; import com.hedera.hashgraph.sdk.ContractId; import com.hedera.hashgraph.sdk.FileAppendTransaction; import com.hedera.hashgraph.sdk.FileContentsQuery; @@ -209,6 +210,13 @@ public ContractCallResult executeContractCallTransaction(ContractCallRequest req return new ContractCallResult(record.transactionId, record.receipt.status, record.transactionHash, record.consensusTimestamp, record.transactionFee, record.contractFunctionResult); } + @Override + public ContractFunctionResult callContractFunction(ContractId contractId, String functionName, + ContractParam... params) throws HederaException { + final ContractCallRequest request = ContractCallRequest.of(contractId, functionName, params); + return executeContractCallTransaction(request).contractFunctionResult(); + } + private ContractFunctionParameters createParameters(List> params) { Objects.requireNonNull(params, "params must not be null"); final ContractFunctionParameters constructorParams = new ContractFunctionParameters(); diff --git a/src/main/java/com/openelements/spring/hedera/implementation/data/BigIntegerBasedNumericDatatypes.java b/src/main/java/com/openelements/spring/hedera/implementation/data/BigIntegerBasedNumericDatatypes.java index 8d3f5355..090c3243 100644 --- a/src/main/java/com/openelements/spring/hedera/implementation/data/BigIntegerBasedNumericDatatypes.java +++ b/src/main/java/com/openelements/spring/hedera/implementation/data/BigIntegerBasedNumericDatatypes.java @@ -6,16 +6,64 @@ public enum BigIntegerBasedNumericDatatypes implements ParamSupplier { - INT256((v, params) -> params.addInt256(v), new BigInteger("-2").pow(255), new BigInteger("2").pow(255).subtract(BigInteger.ONE)), - UINT256((v, params) -> params.addUint256(v), BigInteger.ZERO, new BigInteger("2").pow(256).subtract(BigInteger.ONE)); - + INT72("int72", (v, params) -> params.addInt72(v), new BigInteger("-2361183241434822606848"), new BigInteger("2361183241434822606847")), + INT80("int80", (v, params) -> params.addInt80(v), new BigInteger("-1208925819614629174706176"), new BigInteger("1208925819614629174706175")), + INT88("int88", (v, params) -> params.addInt88(v), new BigInteger("-309485009821345068724781056"), new BigInteger("309485009821345068724781055")), + INT96("int96", (v, params) -> params.addInt96(v), new BigInteger("-79228162514264337593543950336"), new BigInteger("79228162514264337593543950335")), + INT104("int104", (v, params) -> params.addInt104(v), new BigInteger("-20282409603651670423947251286016"), new BigInteger("20282409603651670423947251286015")), + INT112("int112", (v, params) -> params.addInt112(v), new BigInteger("-5192296858534827628530496329220096"), new BigInteger("5192296858534827628530496329220095")), + INT120("int120", (v, params) -> params.addInt120(v), new BigInteger("-1329227995784915872903807060280344576"), new BigInteger("1329227995784915872903807060280344575")), + INT128("int128", (v, params) -> params.addInt128(v), new BigInteger("-340282366920938463463374607431768211456"), new BigInteger("340282366920938463463374607431768211455")), + INT136("int136", (v, params) -> params.addInt136(v), new BigInteger("-87112285931760246646623899502532662132736"), new BigInteger("87112285931760246646623899502532662132735")), + INT144("int144", (v, params) -> params.addInt144(v), new BigInteger("-22300745198530623141535718272648361505980416"), new BigInteger("22300745198530623141535718272648361505980415")), + INT152("int152", (v, params) -> params.addInt152(v), new BigInteger("-5708990770823839524233143877797980545530986496"), new BigInteger("5708990770823839524233143877797980545530986495")), + INT160("int160", (v, params) -> params.addInt160(v), new BigInteger("-1461501637330902918203684832716283019655932542976"), new BigInteger("1461501637330902918203684832716283019655932542975")), + INT168("int168", (v, params) -> params.addInt168(v), new BigInteger("-374144419156711147060143317175368453031918731001856"), new BigInteger("374144419156711147060143317175368453031918731001855")), + INT176("int176", (v, params) -> params.addInt176(v), new BigInteger("-95780971304118053647396689196894323976171195136475136"), new BigInteger("95780971304118053647396689196894323976171195136475135")), + INT184("int184", (v, params) -> params.addInt184(v), new BigInteger("-24519928653854221733733552434404946937899825954937634816"), new BigInteger("24519928653854221733733552434404946937899825954937634815")), + INT192("int192", (v, params) -> params.addInt192(v), new BigInteger("-6277101735386680763835789423207666416102355444464034512896"), new BigInteger("6277101735386680763835789423207666416102355444464034512895")), + INT200("int200", (v, params) -> params.addInt200(v), new BigInteger("-1606938044258990275541962092341162602522202993782792835301376"), new BigInteger("1606938044258990275541962092341162602522202993782792835301375")), + INT208("int208", (v, params) -> params.addInt208(v), new BigInteger("-411376139330301510538742295639337626245683966408394965837152256"), new BigInteger("411376139330301510538742295639337626245683966408394965837152255")), + INT216("int216", (v, params) -> params.addInt216(v), new BigInteger("-105312291668557186697918027683670432318895095400549111254310977536"), new BigInteger("105312291668557186697918027683670432318895095400549111254310977535")), + INT224("int224", (v, params) -> params.addInt224(v), new BigInteger("-26959946667150639794667015087019630673637144422540572481103610249216"), new BigInteger("26959946667150639794667015087019630673637144422540572481103610249215")), + INT232("int232", (v, params) -> params.addInt232(v), new BigInteger("-6901746346790563787434755862277025452451108972170386555162524223799296"), new BigInteger("6901746346790563787434755862277025452451108972170386555162524223799295")), + INT240("int240", (v, params) -> params.addInt240(v), new BigInteger("-1766847064778384329583297500742918515827483896875618958121606201292619776"), new BigInteger("1766847064778384329583297500742918515827483896875618958121606201292619775")), + INT248("int248", (v, params) -> params.addInt248(v), new BigInteger("-452312848583266388373324160190187140051835877600158453279131187530910662656"), new BigInteger("452312848583266388373324160190187140051835877600158453279131187530910662655")), + INT256("int256", (v, params) -> params.addInt256(v), new BigInteger("-115792089237316195423570985008687907853269984665640564039457584007913129639936"), new BigInteger("115792089237316195423570985008687907853269984665640564039457584007913129639935")), + UINT72("uint72", (v, params) -> params.addUint72(v), BigInteger.ZERO, new BigInteger("4722366482869645213695")), + UINT80("uint80", (v, params) -> params.addUint80(v), BigInteger.ZERO, new BigInteger("1208925819614629174706175")), + UINT88("uint88", (v, params) -> params.addUint88(v), BigInteger.ZERO, new BigInteger("309485009821345068724781055")), + UINT96("uint96", (v, params) -> params.addUint96(v), BigInteger.ZERO, new BigInteger("79228162514264337593543950335")), + UINT104("uint104", (v, params) -> params.addUint104(v), BigInteger.ZERO, new BigInteger("20282409603651670423947251286015")), + UINT112("uint112", (v, params) -> params.addUint112(v), BigInteger.ZERO, new BigInteger("5192296858534827628530496329220095")), + UINT120("uint120", (v, params) -> params.addUint120(v), BigInteger.ZERO, new BigInteger("1329227995784915872903807060280344575")), + UINT128("uint128", (v, params) -> params.addUint128(v), BigInteger.ZERO, new BigInteger("340282366920938463463374607431768211455")), + UINT136("uint136", (v, params) -> params.addUint136(v), BigInteger.ZERO, new BigInteger("87112285931760246646623899502532662132735")), + UINT144("uint144", (v, params) -> params.addUint144(v), BigInteger.ZERO, new BigInteger("22300745198530623141535718272648361505980415")), + UINT152("uint152", (v, params) -> params.addUint152(v), BigInteger.ZERO, new BigInteger("5708990770823839524233143877797980545530986495")), + UINT160("uint160", (v, params) -> params.addUint160(v), BigInteger.ZERO, new BigInteger("1461501637330902918203684832716283019655932542975")), + UINT168("uint168", (v, params) -> params.addUint168(v), BigInteger.ZERO, new BigInteger("374144419156711147060143317175368453031918731001855")), + UINT176("uint176", (v, params) -> params.addUint176(v), BigInteger.ZERO, new BigInteger("95780971304118053647396689196894323976171195136475135")), + UINT184("uint184", (v, params) -> params.addUint184(v), BigInteger.ZERO, new BigInteger("24519928653854221733733552434404946937899825954937634815")), + UINT192("uint192", (v, params) -> params.addUint192(v), BigInteger.ZERO, new BigInteger("6277101735386680763835789423207666416102355444464034512895")), + UINT200("uint200", (v, params) -> params.addUint200(v), BigInteger.ZERO, new BigInteger("1606938044258990275541962092341162602522202993782792835301375")), + UINT208("uint208", (v, params) -> params.addUint208(v), BigInteger.ZERO, new BigInteger("411376139330301510538742295639337626245683966408394965837152255")), + UINT216("uint216", (v, params) -> params.addUint216(v), BigInteger.ZERO, new BigInteger("105312291668557186697918027683670432318895095400549111254310977535")), + UINT224("uint224", (v, params) -> params.addUint224(v), BigInteger.ZERO, new BigInteger("26959946667150639794667015087019630673637144422540572481103610249215")), + UINT232("uint232", (v, params) -> params.addUint232(v), BigInteger.ZERO, new BigInteger("6901746346790563787434755862277025452451108972170386555162524223799295")), + UINT240("uint240", (v, params) -> params.addUint240(v), BigInteger.ZERO, new BigInteger("1766847064778384329583297500742918515827483896875618958121606201292619775")), + UINT248("uint248", (v, params) -> params.addUint248(v), BigInteger.ZERO, new BigInteger("452312848583266388373324160190187140051835877600158453279131187530910662655")), + UINT256("uint256", (v, params) -> params.addUint256(v), BigInteger.ZERO, new BigInteger("115792089237316195423570985008687907853269984665640564039457584007913129639935")); private final BiConsumer addParam; private final BigInteger minValue; private final BigInteger maxValue; - BigIntegerBasedNumericDatatypes(BiConsumer addParam, BigInteger minValue, BigInteger maxValue) { + private final String nativeType; + + BigIntegerBasedNumericDatatypes(final String nativeType, BiConsumer addParam, BigInteger minValue, BigInteger maxValue) { + this.nativeType = nativeType; this.addParam = addParam; this.minValue = minValue; this.maxValue = maxValue; @@ -28,4 +76,19 @@ public void addParam(BigInteger value, ContractFunctionParameters params) { } addParam.accept(value, params); } + + @Override + public boolean isValidParam(BigInteger value) { + if(value == null) { + return false; + } + return value.compareTo(minValue) >= 0 && value.compareTo(maxValue) <= 0; + } + + @Override + public String getNativeType() { + return nativeType; + } + + } diff --git a/src/main/java/com/openelements/spring/hedera/implementation/data/BooleanDatatype.java b/src/main/java/com/openelements/spring/hedera/implementation/data/BooleanDatatype.java new file mode 100644 index 00000000..775a3717 --- /dev/null +++ b/src/main/java/com/openelements/spring/hedera/implementation/data/BooleanDatatype.java @@ -0,0 +1,39 @@ +package com.openelements.spring.hedera.implementation.data; + +import com.hedera.hashgraph.sdk.ContractFunctionParameters; +import java.util.Objects; +import java.util.function.BiConsumer; + +public enum BooleanDatatype implements ParamSupplier { + + BOOL; + + private final BiConsumer addParam; + + BooleanDatatype() { + this.addParam = (v, params) -> params.addBool(v); + } + + public void addParam(Boolean value, ContractFunctionParameters params) { + Objects.requireNonNull(value, "value must not be null"); + Objects.requireNonNull(params, "params must not be null"); + addParam.accept(value, params); + } + + public void addParam(boolean value, ContractFunctionParameters params) { + Objects.requireNonNull(params, "params must not be null"); + addParam.accept(value, params); + } + + @Override + public boolean isValidParam(Boolean value) { + return true; + } + + @Override + public String getNativeType() { + return "bool"; + } + + +} diff --git a/src/main/java/com/openelements/spring/hedera/implementation/data/LongBasedNumericDatatypes.java b/src/main/java/com/openelements/spring/hedera/implementation/data/LongBasedNumericDatatypes.java index aedadc6c..e0f4d94b 100644 --- a/src/main/java/com/openelements/spring/hedera/implementation/data/LongBasedNumericDatatypes.java +++ b/src/main/java/com/openelements/spring/hedera/implementation/data/LongBasedNumericDatatypes.java @@ -5,8 +5,20 @@ import java.util.function.BiConsumer; public enum LongBasedNumericDatatypes implements ParamSupplier { - - INT64((v, params) -> params.addInt64(v), Long.MIN_VALUE, Long.MAX_VALUE); + INT8("int8", (v, params) -> params.addInt8(v.byteValue()), Byte.MIN_VALUE, Byte.MAX_VALUE), + UINT8("uint8", (v, params) -> params.addUint8(v.byteValue()), 0L, 255L), + INT16("int16", (v, params) -> params.addInt16(v.shortValue()), Short.MIN_VALUE, Short.MAX_VALUE), + UINT16("uint16", (v, params) -> params.addUint16(v.shortValue()), 0L, 65535L), + INT32("int32", (v, params) -> params.addInt32(v.intValue()), Integer.MIN_VALUE, Integer.MAX_VALUE), + UINT32("uint32", (v, params) -> params.addUint32(v.intValue()), 0L, 4294967295L), + INT40("int40", (v, params) -> params.addInt40(v), -549755813888L, 549755813887L), + UINT40("uint40", (v, params) -> params.addUint40(v), 0L, 1099511627775L), + INT48("int48", (v, params) -> params.addInt48(v), -140737488355328L, 140737488355327L), + UINT48("uint48", (v, params) -> params.addUint48(v), 0L, 281474976710655L), + INT56("int56", (v, params) -> params.addInt56(v), -72057594037927936L, 72057594037927935L), + UINT56("uint56", (v, params) -> params.addUint56(v), 0L, 144115188075855871L), + INT64("int64", (v, params) -> params.addInt64(v), Long.MIN_VALUE, Long.MAX_VALUE); + //TODO; UINT64 but max value is > long max value private final BiConsumer addParam; @@ -14,7 +26,10 @@ public enum LongBasedNumericDatatypes implements ParamSupplier { private final long maxValue; - LongBasedNumericDatatypes(final BiConsumer addParam, long minValue, long maxValue) { + private final String nativeType; + + LongBasedNumericDatatypes(final String nativeType, final BiConsumer addParam, long minValue, long maxValue) { + this.nativeType = nativeType; this.addParam = addParam; this.minValue = minValue; this.maxValue = maxValue; @@ -26,6 +41,19 @@ public void addParam(Long value, ContractFunctionParameters params) { addParam.accept(value.longValue(), params); } + @Override + public boolean isValidParam(Long value) { + if(value == null) { + return false; + } + return value >= minValue && value <= maxValue; + } + + @Override + public String getNativeType() { + return nativeType; + } + public void addParam(long value, ContractFunctionParameters params) { Objects.requireNonNull(params, "params must not be null"); if(value < minValue || value > maxValue) { diff --git a/src/main/java/com/openelements/spring/hedera/implementation/data/ParamSupplier.java b/src/main/java/com/openelements/spring/hedera/implementation/data/ParamSupplier.java index 5bb40ccd..6ffcef83 100644 --- a/src/main/java/com/openelements/spring/hedera/implementation/data/ParamSupplier.java +++ b/src/main/java/com/openelements/spring/hedera/implementation/data/ParamSupplier.java @@ -5,4 +5,8 @@ public interface ParamSupplier { void addParam(T value, ContractFunctionParameters params); + + boolean isValidParam(T value); + + String getNativeType(); } diff --git a/src/main/java/com/openelements/spring/hedera/implementation/data/StringBasedDatatype.java b/src/main/java/com/openelements/spring/hedera/implementation/data/StringBasedDatatype.java new file mode 100644 index 00000000..185457d9 --- /dev/null +++ b/src/main/java/com/openelements/spring/hedera/implementation/data/StringBasedDatatype.java @@ -0,0 +1,44 @@ +package com.openelements.spring.hedera.implementation.data; + +import com.hedera.hashgraph.sdk.AccountId; +import com.hedera.hashgraph.sdk.ContractFunctionParameters; +import java.util.Objects; +import java.util.function.BiConsumer; + +public enum StringBasedDatatype implements ParamSupplier { + + STRING("string", (v, params) -> params.addString(v)), + ADDRESS("address", (v, params) -> params.addAddress(v)); + + private final String nativeType; + + private final BiConsumer addParam; + + StringBasedDatatype(final String nativeType, final BiConsumer addParam) { + this.nativeType = nativeType; + this.addParam = addParam; + } + + public void addParam(String value, ContractFunctionParameters params) { + Objects.requireNonNull(params, "params must not be null"); + addParam.accept(value, params); + } + + @Override + public boolean isValidParam(String value) { + if(this.equals(ADDRESS)) { + try { + AccountId.fromString(value); + } catch (final Exception e) { + throw new IllegalArgumentException("Invalid address", e); + } + } + return true; + } + + @Override + public String getNativeType() { + return nativeType; + } + +} diff --git a/src/main/java/com/openelements/spring/hedera/implementation/data/StringDatatype.java b/src/main/java/com/openelements/spring/hedera/implementation/data/StringDatatype.java deleted file mode 100644 index 79411ae0..00000000 --- a/src/main/java/com/openelements/spring/hedera/implementation/data/StringDatatype.java +++ /dev/null @@ -1,24 +0,0 @@ -package com.openelements.spring.hedera.implementation.data; - -import com.hedera.hashgraph.sdk.ContractFunctionParameters; -import java.util.Objects; -import java.util.function.BiConsumer; - -public enum StringDatatype implements ParamSupplier { - - STRING("string"); - - private final String name; - - private final BiConsumer addParam; - - StringDatatype(final String name) { - this.name = name; - this.addParam = (v, params) -> params.addString(v); - } - - public void addParam(String value, ContractFunctionParameters params) { - Objects.requireNonNull(params, "params must not be null"); - addParam.accept(value, params); - } -} diff --git a/src/test/java/com/openelements/spring/hedera/test/ContractServiceTest.java b/src/test/java/com/openelements/spring/hedera/test/ContractServiceTest.java index 15f2d889..55cef86f 100644 --- a/src/test/java/com/openelements/spring/hedera/test/ContractServiceTest.java +++ b/src/test/java/com/openelements/spring/hedera/test/ContractServiceTest.java @@ -139,7 +139,14 @@ void testCallFunctionResult() throws Exception { //given final Path path = Path.of(ContractServiceTest.class.getResource("/uint_getter_setter_contract.bin").getPath()); final ContractId contract = hederaClient.createContract(path); + + final ContractCallRequest setRequest = ContractCallRequest.of(contract, "set", int256(123)); + + + + + final ContractCallResult setResult = hederaClient.executeContractCallTransaction(setRequest); final ContractCallRequest getRequest = ContractCallRequest.of(contract, "get"); diff --git a/src/test/java/com/openelements/spring/hedera/test/DatatypesTest.java b/src/test/java/com/openelements/spring/hedera/test/DatatypesTest.java new file mode 100644 index 00000000..ae0991c0 --- /dev/null +++ b/src/test/java/com/openelements/spring/hedera/test/DatatypesTest.java @@ -0,0 +1,33 @@ +package com.openelements.spring.hedera.test; + +import com.hedera.hashgraph.sdk.ContractFunctionResult; +import com.hedera.hashgraph.sdk.ContractId; +import com.openelements.spring.hedera.api.HederaClient; +import com.openelements.spring.hedera.api.data.ContractParam; +import java.nio.file.Path; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; + +@SpringBootTest(classes = TestConfig.class) +public class DatatypesTest { + + @Autowired + private HederaClient hederaClient; + + @Test + public void testString() throws Exception { + //given + final Path path = Path.of(ContractServiceTest.class.getResource("/small_contract.bin").getPath()); + final ContractId contract = hederaClient.createContract(path); + final String expected = "Hello, World!"; + + //when + final ContractFunctionResult result = hederaClient.callContractFunction(contract, "checkString", + ContractParam.string(expected)); + + //then + Assertions.assertEquals(expected, result.getString(0)); + } +} diff --git a/src/test/java/com/openelements/spring/hedera/test/LongBasedNumericDatatypesTest.java b/src/test/java/com/openelements/spring/hedera/test/LongBasedNumericDatatypesTest.java new file mode 100644 index 00000000..ecd6960e --- /dev/null +++ b/src/test/java/com/openelements/spring/hedera/test/LongBasedNumericDatatypesTest.java @@ -0,0 +1,53 @@ +package com.openelements.spring.hedera.test; + +import com.hedera.hashgraph.sdk.ContractFunctionParameters; +import com.openelements.spring.hedera.implementation.data.LongBasedNumericDatatypes; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; + +public class LongBasedNumericDatatypesTest { + + @ParameterizedTest + @EnumSource(LongBasedNumericDatatypes.class) + void checkMethodsForNonNullResult(final LongBasedNumericDatatypes type) { + //given + final ContractFunctionParameters parameters = new ContractFunctionParameters(); + + //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)); + } + + @Test + void checkIsValidParamInt8() { + + //given + final LongBasedNumericDatatypes type = LongBasedNumericDatatypes.INT8; + + //then + Assertions.assertTrue(type.isValidParam(1L)); + Assertions.assertTrue(type.isValidParam(0L)); + Assertions.assertTrue(type.isValidParam(-1L)); + Assertions.assertFalse(type.isValidParam(128L)); + Assertions.assertFalse(type.isValidParam(-129L)); + } + + @Test + void checkIsValidParamUint8() { + + //given + final LongBasedNumericDatatypes type = LongBasedNumericDatatypes.UINT8; + + //then + Assertions.assertTrue(type.isValidParam(1L)); + Assertions.assertTrue(type.isValidParam(0L)); + Assertions.assertTrue(type.isValidParam(255L)); + Assertions.assertFalse(type.isValidParam(256L)); + Assertions.assertFalse(type.isValidParam(-1L)); + } + +} diff --git a/src/test/resources/datatypes.bin b/src/test/resources/datatypes.bin new file mode 100644 index 00000000..969009f8 --- /dev/null +++ b/src/test/resources/datatypes.bin @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/src/test/resources/datatypes.sol b/src/test/resources/datatypes.sol new file mode 100644 index 00000000..c9182fa6 --- /dev/null +++ b/src/test/resources/datatypes.sol @@ -0,0 +1,22 @@ +// SPDX-License-Identifier: GPL-3.0 + +pragma solidity >=0.7.0 <0.9.0; +contract Datatypes { + + function checkString(string memory data) public pure returns (string memory) { + return data; + } + + function checkAddress(address data) public pure returns (address) { + return data; + } + + function checkInt8(int8 data) public pure returns (int8) { + return data; + } + + function checkUint8(uint8 data) public pure returns (uint8) { + return data; + } + +} \ No newline at end of file