Tck implement ScheduleCreateTransaction (#2478)

Signed-off-by: emiliyank <e.kadiyski@gmail.com>

Author: emiliyank

sdk/src/main/java/com/hedera/hashgraph/sdk/ScheduleCreateTransaction.java

@@ -101,6 +101,9 @@ public final class ScheduleCreateTransaction extends Transaction<ScheduleCreateT
     @Nullable
     private Instant expirationTime = null;
 
+    @Nullable
+    private java.time.Duration expirationTimeDuration = null;
+
     private boolean waitForExpiry = false;
 
     /**
@@ -145,7 +148,24 @@ public Instant getExpirationTime() {
      * @return {@code this}
      */
     public ScheduleCreateTransaction setExpirationTime(Instant expirationTime) {
+        Objects.requireNonNull(expirationTime);
+        requireNotFrozen();
         this.expirationTime = expirationTime;
+        this.expirationTimeDuration = null;
+        return this;
+    }
+
+    /**
+     * Overload: set the expiration time using a Duration value.
+     *
+     * @param expirationTime The duration to be used as expiration time
+     * @return {@code this}
+     */
+    public ScheduleCreateTransaction setExpirationTime(java.time.Duration expirationTime) {
+        Objects.requireNonNull(expirationTime);
+        requireNotFrozen();
+        this.expirationTime = null;
+        this.expirationTimeDuration = expirationTime;
         return this;
     }
 
@@ -312,6 +332,8 @@ ScheduleCreateTransactionBody.Builder build() {
         }
         if (expirationTime != null) {
             builder.setExpirationTime(InstantConverter.toProtobuf(expirationTime));
+        } else if (expirationTimeDuration != null) {
+            builder.setExpirationTime(InstantConverter.toProtobuf(expirationTimeDuration));
         }
         builder.setMemo(scheduleMemo).setWaitForExpiry(waitForExpiry);
         return builder;

sdk/src/test/java/com/hedera/hashgraph/sdk/ScheduleCreateTransactionTest.java

@@ -2,8 +2,10 @@
 package com.hedera.hashgraph.sdk;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import io.github.jsonSnapshot.SnapshotMatcher;
+import java.time.Duration;
 import java.time.Instant;
 import java.util.Arrays;
 import org.junit.jupiter.api.AfterAll;
@@ -61,4 +63,41 @@ void shouldBytesNoSetters() throws Exception {
         var tx2 = Transaction.fromBytes(tx.toBytes());
         assertThat(tx2.toString()).isEqualTo(tx.toString());
     }
+
+    @Test
+    void shouldSupportExpirationTimeDurationBytesRoundTrip() throws Exception {
+        var transferTransaction = new TransferTransaction()
+                .addHbarTransfer(AccountId.fromString("0.0.555"), new Hbar(-10))
+                .addHbarTransfer(AccountId.fromString("0.0.333"), new Hbar(10));
+
+        var tx = transferTransaction
+                .schedule()
+                .setNodeAccountIds(Arrays.asList(AccountId.fromString("0.0.5005"), AccountId.fromString("0.0.5006")))
+                .setTransactionId(TransactionId.withValidStart(AccountId.fromString("0.0.5006"), validStart))
+                .setAdminKey(unusedPrivateKey)
+                .setPayerAccountId(AccountId.fromString("0.0.222"))
+                .setScheduleMemo("with-duration")
+                .setMaxTransactionFee(new Hbar(1))
+                .setExpirationTime(Duration.ofSeconds(1234));
+
+        // When expiration is set via Duration, Instant getter should be null
+        assertThat(tx.getExpirationTime()).isNull();
+
+        var tx2 = (ScheduleCreateTransaction) Transaction.fromBytes(tx.toBytes());
+        assertThat(tx2.toString()).isEqualTo(tx.toString());
+        assertThat(tx2.getExpirationTime()).isEqualTo(Instant.ofEpochSecond(1234));
+    }
+
+    @Test
+    void setExpirationTimeDurationOnFrozenTransactionShouldThrow() {
+        var tx = spawnTestTransaction();
+        assertThrows(IllegalStateException.class, () -> tx.setExpirationTime(Duration.ofSeconds(1)));
+    }
+
+    @Test
+    void getSetExpirationTimeInstant() {
+        var instant = Instant.ofEpochSecond(1_234_567L);
+        var tx = new ScheduleCreateTransaction().setExpirationTime(instant);
+        assertThat(tx.getExpirationTime()).isEqualTo(instant);
+    }
 }

tck/src/main/java/com/hedera/hashgraph/tck/methods/sdk/AccountService.java

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 package com.hedera.hashgraph.tck.methods.sdk;
 
-import com.google.protobuf.InvalidProtocolBufferException;
 import com.hedera.hashgraph.sdk.*;
 import com.hedera.hashgraph.tck.annotation.JSONRPC2Method;
 import com.hedera.hashgraph.tck.annotation.JSONRPC2Service;
@@ -10,10 +9,8 @@
 import com.hedera.hashgraph.tck.methods.sdk.param.transfer.*;
 import com.hedera.hashgraph.tck.methods.sdk.response.AccountAllowanceResponse;
 import com.hedera.hashgraph.tck.methods.sdk.response.AccountResponse;
-import com.hedera.hashgraph.tck.util.KeyUtils;
-import java.time.Duration;
+import com.hedera.hashgraph.tck.util.TransactionBuilders;
 import java.util.Map;
-import java.util.Optional;
 
 /**
  * AccountService for account related methods
@@ -28,41 +25,7 @@ public AccountService(SdkService sdkService) {
 
     @JSONRPC2Method("createAccount")
     public AccountResponse createAccount(final AccountCreateParams params) throws Exception {
-        AccountCreateTransaction accountCreateTransaction = new AccountCreateTransaction();
-        params.getKey().ifPresent(key -> {
-            try {
-                accountCreateTransaction.setKeyWithoutAlias(KeyUtils.getKeyFromString(key));
-            } catch (InvalidProtocolBufferException e) {
-                throw new IllegalArgumentException(e);
-            }
-        });
-
-        params.getInitialBalance()
-                .ifPresent(initialBalanceTinybars -> accountCreateTransaction.setInitialBalance(
-                        Hbar.from(Long.parseLong(initialBalanceTinybars), HbarUnit.TINYBAR)));
-
-        params.getReceiverSignatureRequired().ifPresent(accountCreateTransaction::setReceiverSignatureRequired);
-
-        params.getAutoRenewPeriod()
-                .ifPresent(autoRenewPeriodSeconds -> accountCreateTransaction.setAutoRenewPeriod(
-                        Duration.ofSeconds(Long.parseLong(autoRenewPeriodSeconds))));
-
-        params.getMemo().ifPresent(accountCreateTransaction::setAccountMemo);
-
-        params.getMaxAutoTokenAssociations()
-                .ifPresent(autoAssociations ->
-                        accountCreateTransaction.setMaxAutomaticTokenAssociations(autoAssociations.intValue()));
-
-        params.getStakedAccountId()
-                .ifPresent(stakedAccountId ->
-                        accountCreateTransaction.setStakedAccountId(AccountId.fromString(stakedAccountId)));
-
-        params.getStakedNodeId()
-                .ifPresent(stakedNodeId -> accountCreateTransaction.setStakedNodeId(Long.parseLong(stakedNodeId)));
-
-        params.getDeclineStakingReward().ifPresent(accountCreateTransaction::setDeclineStakingReward);
-
-        params.getAlias().ifPresent(accountCreateTransaction::setAlias);
+        AccountCreateTransaction accountCreateTransaction = TransactionBuilders.AccountBuilder.buildCreate(params);
 
         params.getCommonTransactionParams()
                 .ifPresent(commonTransactionParams ->
@@ -81,43 +44,7 @@ public AccountResponse createAccount(final AccountCreateParams params) throws Ex
 
     @JSONRPC2Method("updateAccount")
     public AccountResponse updateAccount(final AccountUpdateParams params) throws Exception {
-        AccountUpdateTransaction accountUpdateTransaction = new AccountUpdateTransaction();
-
-        params.getAccountId()
-                .ifPresent(accountId -> accountUpdateTransaction.setAccountId(AccountId.fromString(accountId)));
-
-        params.getKey().ifPresent(key -> {
-            try {
-                accountUpdateTransaction.setKey(KeyUtils.getKeyFromString(key));
-            } catch (InvalidProtocolBufferException e) {
-                throw new IllegalArgumentException(e);
-            }
-        });
-
-        params.getReceiverSignatureRequired().ifPresent(accountUpdateTransaction::setReceiverSignatureRequired);
-
-        params.getAutoRenewPeriod()
-                .ifPresent(autoRenewPeriodSeconds -> accountUpdateTransaction.setAutoRenewPeriod(
-                        Duration.ofSeconds(Long.parseLong(autoRenewPeriodSeconds))));
-
-        params.getMemo().ifPresent(accountUpdateTransaction::setAccountMemo);
-
-        params.getExpirationTime()
-                .ifPresent(expirationTime ->
-                        accountUpdateTransaction.setExpirationTime(Duration.ofSeconds(Long.parseLong(expirationTime))));
-
-        params.getMaxAutoTokenAssociations()
-                .ifPresent(autoAssociations ->
-                        accountUpdateTransaction.setMaxAutomaticTokenAssociations(autoAssociations.intValue()));
-
-        params.getStakedAccountId()
-                .ifPresent(stakedAccountId ->
-                        accountUpdateTransaction.setStakedAccountId(AccountId.fromString(stakedAccountId)));
-
-        params.getStakedNodeId()
-                .ifPresent(stakedNodeId -> accountUpdateTransaction.setStakedNodeId(Long.parseLong(stakedNodeId)));
-
-        params.getDeclineStakingReward().ifPresent(accountUpdateTransaction::setDeclineStakingReward);
+        AccountUpdateTransaction accountUpdateTransaction = TransactionBuilders.AccountBuilder.buildUpdate(params);
 
         params.getCommonTransactionParams()
                 .ifPresent(commonTransactionParams ->
@@ -131,13 +58,7 @@ public AccountResponse updateAccount(final AccountUpdateParams params) throws Ex
 
     @JSONRPC2Method("deleteAccount")
     public AccountResponse deleteAccount(final AccountDeleteParams params) throws Exception {
-        AccountDeleteTransaction accountDeleteTransaction = new AccountDeleteTransaction();
-
-        params.getDeleteAccountId()
-                .ifPresent(accountId -> accountDeleteTransaction.setAccountId(AccountId.fromString(accountId)));
-
-        params.getTransferAccountId()
-                .ifPresent(accountId -> accountDeleteTransaction.setTransferAccountId(AccountId.fromString(accountId)));
+        AccountDeleteTransaction accountDeleteTransaction = TransactionBuilders.AccountBuilder.buildDelete(params);
 
         params.getCommonTransactionParams()
                 .ifPresent(commonTransactionParams ->
@@ -151,9 +72,7 @@ public AccountResponse deleteAccount(final AccountDeleteParams params) throws Ex
 
     @JSONRPC2Method("approveAllowance")
     public AccountAllowanceResponse approveAllowance(final AccountAllowanceParams params) throws Exception {
-        AccountAllowanceApproveTransaction tx = new AccountAllowanceApproveTransaction();
-
-        params.getAllowances().ifPresent(allowances -> allowances.forEach(allowance -> approve(tx, allowance)));
+        AccountAllowanceApproveTransaction tx = TransactionBuilders.AccountBuilder.buildApproveAllowance(params);
 
         params.getCommonTransactionParams()
                 .ifPresent(commonParams -> commonParams.fillOutTransaction(tx, sdkService.getClient()));
@@ -165,9 +84,7 @@ public AccountAllowanceResponse approveAllowance(final AccountAllowanceParams pa
 
     @JSONRPC2Method("deleteAllowance")
     public AccountAllowanceResponse deleteAllowance(final AccountAllowanceParams params) throws Exception {
-        AccountAllowanceDeleteTransaction tx = new AccountAllowanceDeleteTransaction();
-
-        params.getAllowances().ifPresent(allowances -> allowances.forEach(allowance -> delete(tx, allowance)));
+        AccountAllowanceDeleteTransaction tx = TransactionBuilders.AccountBuilder.buildDeleteAllowance(params);
 
         params.getCommonTransactionParams()
                 .ifPresent(commonParams -> commonParams.fillOutTransaction(tx, sdkService.getClient()));
@@ -186,10 +103,7 @@ public AccountAllowanceResponse deleteAllowance(final AccountAllowanceParams par
      */
     @JSONRPC2Method("transferCrypto")
     public Map<String, String> transferCrypto(final TransferCryptoParams params) throws Exception {
-        TransferTransaction transferTransaction = new TransferTransaction();
-
-        params.getTransfers()
-                .ifPresent(transfers -> transfers.forEach(txParams -> processTransfer(transferTransaction, txParams)));
+        TransferTransaction transferTransaction = TransactionBuilders.TransferBuilder.buildTransfer(params);
 
         params.getCommonTransactionParams()
                 .ifPresent(
@@ -204,7 +118,7 @@ public Map<String, String> transferCrypto(final TransferCryptoParams params) thr
     /**
      * Process an individual transfer based on its type (Hbar, Token, or NFT)
      */
-    private void processTransfer(TransferTransaction tx, TransferParams txParams) {
+    public static void processTransfer(TransferTransaction tx, TransferParams txParams) {
         boolean approved = txParams.getApproved().orElse(false);
 
         txParams.getHbar().ifPresent(hbarParams -> processHbarTransfer(tx, hbarParams, approved));
@@ -215,7 +129,7 @@ private void processTransfer(TransferTransaction tx, TransferParams txParams) {
     /**
      * Process an Hbar transfer
      */
-    private void processHbarTransfer(TransferTransaction tx, HbarTransferParams hbarParams, boolean approved) {
+    private static void processHbarTransfer(TransferTransaction tx, HbarTransferParams hbarParams, boolean approved) {
         hbarParams.getAmount().ifPresent(amountStr -> {
             Hbar amount = Hbar.fromTinybars(Long.parseLong(amountStr));
 
@@ -242,7 +156,8 @@ private void processHbarTransfer(TransferTransaction tx, HbarTransferParams hbar
     /**
      * Process a token transfer
      */
-    private void processTokenTransfer(TransferTransaction tx, TokenTransferParams tokenParams, boolean approved) {
+    private static void processTokenTransfer(
+            TransferTransaction tx, TokenTransferParams tokenParams, boolean approved) {
         tokenParams.getAccountId().ifPresent(accountIdStr -> {
             tokenParams.getTokenId().ifPresent(tokenIdStr -> {
                 tokenParams.getAmount().ifPresent(amountStr -> {
@@ -272,7 +187,7 @@ private void processTokenTransfer(TransferTransaction tx, TokenTransferParams to
     /**
      * Process an NFT transfer
      */
-    private void processNftTransfer(TransferTransaction tx, NftTransferParams nftParams, boolean approved) {
+    private static void processNftTransfer(TransferTransaction tx, NftTransferParams nftParams, boolean approved) {
         nftParams.getSenderAccountId().ifPresent(senderIdStr -> {
             nftParams.getReceiverAccountId().ifPresent(receiverIdStr -> {
                 nftParams.getTokenId().ifPresent(tokenIdStr -> {
@@ -293,55 +208,4 @@ private void processNftTransfer(TransferTransaction tx, NftTransferParams nftPar
             });
         });
     }
-
-    private void approve(AccountAllowanceApproveTransaction tx, AllowanceParams allowance) {
-        AccountId owner = AccountId.fromString(allowance.getOwnerAccountId().orElseThrow());
-        AccountId spender = AccountId.fromString(allowance.getSpenderAccountId().orElseThrow());
-
-        allowance
-                .getHbar()
-                .ifPresent(hbar ->
-                        tx.approveHbarAllowance(owner, spender, Hbar.fromTinybars(Long.parseLong(hbar.getAmount()))));
-
-        allowance
-                .getToken()
-                .ifPresent(token -> tx.approveTokenAllowance(
-                        TokenId.fromString(token.getTokenId()), owner, spender, token.getAmount()));
-
-        allowance.getNft().ifPresent(nft -> approveNFT(tx, owner, spender, nft));
-    }
-
-    private void delete(AccountAllowanceDeleteTransaction tx, AllowanceParams allowance) {
-        var owner = AccountId.fromString(allowance.getOwnerAccountId().orElseThrow());
-        var tokenId = allowance.getTokenId().orElseThrow();
-
-        if (allowance.getSerialNumbers().isPresent()) {
-            allowance.getSerialNumbers().get().forEach(serialNumber -> {
-                var nftId = new NftId(TokenId.fromString(tokenId), Long.parseLong(serialNumber));
-                tx.deleteAllTokenNftAllowances(nftId, owner);
-            });
-        }
-    }
-
-    private void approveNFT(
-            AccountAllowanceApproveTransaction tx,
-            AccountId owner,
-            AccountId spender,
-            AllowanceParams.TokenNftAllowance nft) {
-        TokenId tokenId = TokenId.fromString(nft.getTokenId());
-        Optional<String> delegateSpender = Optional.ofNullable(nft.getDelegatingSpender());
-
-        if (!nft.getSerialNumbers().isEmpty()) {
-            nft.getSerialNumbers().forEach(serial -> {
-                NftId nftId = new NftId(tokenId, serial);
-                delegateSpender.ifPresentOrElse(
-                        ds -> tx.approveTokenNftAllowance(nftId, owner, spender, AccountId.fromString(ds)),
-                        () -> tx.approveTokenNftAllowance(nftId, owner, spender));
-            });
-        } else if (nft.getAllSerials()) {
-            tx.approveTokenNftAllowanceAllSerials(tokenId, owner, spender);
-        } else {
-            tx.deleteTokenNftAllowanceAllSerials(tokenId, owner, spender);
-        }
-    }
 }