From 905c1876db5008a3915f8c00897db314d70a48be Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Wed, 2 Oct 2024 12:07:13 -0500 Subject: [PATCH 1/8] chore(deps): bump codecov/codecov-action from 4.5.0 to 4.6.0 (#2022) Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Signed-off-by: Jeffery Orazulike --- .github/workflows/build.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index c3d99c37c..375cd9303 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -111,7 +111,7 @@ jobs: - name: Upload coverage to Codecov if: ${{ github.event_name == 'push' || (github.event.pull_request.head.repo.full_name == github.repository && github.actor != 'dependabot[bot]') }} - uses: codecov/codecov-action@e28ff129e5465c2c0dcc6f003fc735cb6ae0c673 # v4.5.0 + uses: codecov/codecov-action@b9fd7d16f6d7d1b5d2bec1a2887e65ceed900238 # v4.6.0 - name: Stop the local node run: npx @hashgraph/hedera-local stop From 267b6afbab735a9c92edac390681b2bcde5bb9ca Mon Sep 17 00:00:00 2001 From: Jeffery Orazulike Date: Sat, 5 Oct 2024 11:54:58 +0100 Subject: [PATCH 2/8] feat(ContractFunctionParameters): added addBytes4 and addBytes4Array Signed-off-by: Jeffery Orazulike --- .../sdk/ContractFunctionParameters.java | 41 +++++++++++- .../sdk/ContractFunctionParametersTest.java | 62 ++++++++++++++++++- ...ractFunctionParametersIntegrationTest.java | 33 ++++++++++ 3 files changed, 132 insertions(+), 4 deletions(-) diff --git a/sdk/src/main/java/com/hedera/hashgraph/sdk/ContractFunctionParameters.java b/sdk/src/main/java/com/hedera/hashgraph/sdk/ContractFunctionParameters.java index d86a0e589..611b1a984 100644 --- a/sdk/src/main/java/com/hedera/hashgraph/sdk/ContractFunctionParameters.java +++ b/sdk/src/main/java/com/hedera/hashgraph/sdk/ContractFunctionParameters.java @@ -21,6 +21,7 @@ import com.google.errorprone.annotations.Var; import com.google.protobuf.ByteString; + import java.math.BigInteger; import java.util.ArrayList; import java.util.Arrays; @@ -29,6 +30,7 @@ import java.util.stream.IntStream; import java.util.stream.Stream; import javax.annotation.Nullable; + import org.bouncycastle.util.encoders.DecoderException; import org.bouncycastle.util.encoders.Hex; @@ -86,6 +88,14 @@ private static ByteString encodeBytes(byte[] bytes) { .concat(rightPad32(ByteString.copyFrom(bytes))); } + private static ByteString encodeBytes4(byte[] bytes) { + if (bytes.length > 4) { + throw new IllegalArgumentException("bytes4 encoding forbids byte array length greater than 4"); + } + return rightPad32(ByteString.copyFrom(bytes)); + } + + private static ByteString encodeBytes32(byte[] bytes) { if (bytes.length > 32) { throw new IllegalArgumentException("byte32 encoding forbids byte array length greater than 32"); @@ -187,7 +197,7 @@ static ByteString leftPad32(ByteString input, boolean negative) { return rem == 32 ? input : (negative ? negativePadding : padding).substring(0, rem) - .concat(input); + .concat(input); } static ByteString leftPad32(byte[] input, boolean negative) { @@ -275,6 +285,35 @@ public ContractFunctionParameters addBytesArray(byte[][] param) { return this; } + /** + * Add a parameter of type {@code bytes4}, a 4-byte fixed-length byte-string. + * + * @param param The 4-byte array to be added + * @return {@code this} + * @throws IllegalArgumentException if the length of the byte array is not 4. + */ + public ContractFunctionParameters addBytes4(byte[] param) { + args.add(new Argument("bytes4", encodeBytes4(param), false)); + + return this; + } + + /** + * Add a parameter of type {@code bytes4[]}, an array of 4-byte fixed-length byte-strings. + * + * @param param The array of 4-byte arrays to be added + * @return {@code this} + * @throws IllegalArgumentException if the length of any byte array is not 4. + */ + public ContractFunctionParameters addBytes4Array(byte[][] param) { + Stream byteArrays = Arrays.stream(param) + .map(ContractFunctionParameters::encodeBytes4); + + args.add(new Argument("bytes4[]", encodeArray(byteArrays), true)); + + return this; + } + /** * Add a parameter of type {@code bytes32}, a 32-byte byte-string. *

diff --git a/sdk/src/test/java/com/hedera/hashgraph/sdk/ContractFunctionParametersTest.java b/sdk/src/test/java/com/hedera/hashgraph/sdk/ContractFunctionParametersTest.java index aa2a72d33..a48bc48cd 100644 --- a/sdk/src/test/java/com/hedera/hashgraph/sdk/ContractFunctionParametersTest.java +++ b/sdk/src/test/java/com/hedera/hashgraph/sdk/ContractFunctionParametersTest.java @@ -254,6 +254,44 @@ void functionsError() { }); } + @Test + @DisplayName("encodes bytes4 correctly") + void bytes4Encoding() { + var params = new ContractFunctionParameters() + .addBytes4(new byte[]{1, 2, 3, 4}); + assertThat( + "580526ee" + + "0102030400000000000000000000000000000000000000000000000000000000" + ).isEqualTo(Hex.toHexString(params.toBytes("foo").toByteArray())); + } + + @Test + @DisplayName("fails to encode bytes4 if length too long") + void bytes4EncodingError() { + assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> { + new ContractFunctionParameters().addBytes4(new byte[]{1, 2, 3, 4, 5}); + }); + } + + @Test + @DisplayName("encodes UTF-8 string as bytes4 correctly") + void bytes4UTF8Encoding() { + var params = new ContractFunctionParameters() + .addBytes4("ABCD".getBytes(StandardCharsets.UTF_8)); + assertThat( + "580526ee" + + "4142434400000000000000000000000000000000000000000000000000000000" + ).isEqualTo(Hex.toHexString(params.toBytes("foo").toByteArray())); + } + + @Test + @DisplayName("fails to encode UTF-8 string as bytes4 if length is bigger than 4 bytes") + void bytes4UTF8EncodingError() { + assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> { + new ContractFunctionParameters().addBytes4("ABCDE".getBytes(StandardCharsets.UTF_8)); + }); + } + @Test @DisplayName("encodes bytes32 correctly") void bytes() { @@ -410,6 +448,24 @@ void arrayTypesEncoding() { ).isEqualTo(Hex.toHexString(params.toBytes("foo").toByteArray())); } + @Test + @DisplayName("bytes4[] encodes correctly") + void fixedBytes4ArrayEncoding() { + ContractFunctionParameters params = new ContractFunctionParameters() + .addBytes4Array(new byte[][]{ + {1, 2, 3, 4}, + {5, 6, 7, 8}, + {9, 10, 11, 12} + }); + assertThat( + "0000000000000000000000000000000000000000000000000000000000000020" + // offset of array + "0000000000000000000000000000000000000000000000000000000000000003" + // length of array + "0102030400000000000000000000000000000000000000000000000000000000" + // first bytes4 + "0506070800000000000000000000000000000000000000000000000000000000" + // second bytes4 + "090a0b0c00000000000000000000000000000000000000000000000000000000" // third bytes4 + ).isEqualTo(Hex.toHexString(params.toBytes(null).toByteArray())); + } + @Test @DisplayName("bytes32[] encodes correctly") void fixedBytesArrayEncoding() { @@ -544,10 +600,10 @@ void uInt256EncodesCorrectly(long val, String hexString, int bitWidth) { @Test void intSizesEncodeCorrectly() throws Exception { List snapshotStrings = new ArrayList<>(); - for (int n = 8; n <= 256; n+= 8) { + for (int n = 8; n <= 256; n += 8) { var bitWidth = n; - var argType = ((Supplier>)() -> { + var argType = ((Supplier>) () -> { if (bitWidth == 8) { return byte.class; } else if (bitWidth <= 32) { @@ -559,7 +615,7 @@ void intSizesEncodeCorrectly() throws Exception { } }).get(); - var argVal = ((Supplier)() -> { + var argVal = ((Supplier) () -> { if (bitWidth == 8) { return (byte) (1 << (bitWidth - 1)); } else if (bitWidth <= 32) { diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractFunctionParametersIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractFunctionParametersIntegrationTest.java index 6c9d45569..ed02edada 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractFunctionParametersIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractFunctionParametersIntegrationTest.java @@ -2788,6 +2788,39 @@ void canCallContractFunctionBytesArrayType() throws Exception { assertThat(responseResult).isEqualTo(testBytes); } + + @Test + @DisplayName("Can receive bytes4 value from contract call") + void canCallContractFunctionBytes4Type() throws Exception { + byte[] testBytes = "Test".getBytes(); + byte[] testBytesLen4 = new byte[4]; + System.arraycopy(testBytes, 0, testBytesLen4, 0, testBytes.length); + + var response = new ContractCallQuery().setContractId(contractId).setGas(1500000) + .setFunction("returnBytes4", new ContractFunctionParameters().addBytes4(testBytesLen4)) + .setQueryPayment(new Hbar(10)).execute(testEnv.client); + + assertThat(response.getBytes(0)).isEqualTo(testBytesLen4); + } + + @Test + @DisplayName("Can receive bytes4 array value from contract call") + void canCallContractFunctionBytes4ArrayType() throws Exception { + byte[] testBytes = "Test".getBytes(); + byte[] testBytes2 = "Test2".getBytes(); + byte[][] testBytesLen4 = new byte[2][4]; + System.arraycopy(testBytes, 0, testBytesLen4[0], 0, testBytes.length); + System.arraycopy(testBytes2, 0, testBytesLen4[1], 0, testBytes2.length); + + var response = new ContractCallQuery().setContractId(contractId).setGas(1500000) + .setFunction("returnBytes4Arr", new ContractFunctionParameters().addBytes4Array(testBytesLen4)) + .setQueryPayment(new Hbar(10)).execute(testEnv.client); + + var responseResult = (byte[][]) response.getResult("(bytes4[])").get(0); + + assertThat(responseResult).isEqualTo(testBytesLen4); + } + @Test @DisplayName("Can receive bytes32 value from contract call") void canCallContractFunctionBytes32Type() throws Exception { From cae64a21c5420a993188a42d0d3d0dc461224f5d Mon Sep 17 00:00:00 2001 From: Jeffery Orazulike Date: Mon, 7 Oct 2024 08:30:35 +0100 Subject: [PATCH 3/8] chore(ContractFunctionParameters): removed integration tests Signed-off-by: Jeffery Orazulike --- ...ractFunctionParametersIntegrationTest.java | 33 ------------------- 1 file changed, 33 deletions(-) diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractFunctionParametersIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractFunctionParametersIntegrationTest.java index ed02edada..6c9d45569 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractFunctionParametersIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractFunctionParametersIntegrationTest.java @@ -2788,39 +2788,6 @@ void canCallContractFunctionBytesArrayType() throws Exception { assertThat(responseResult).isEqualTo(testBytes); } - - @Test - @DisplayName("Can receive bytes4 value from contract call") - void canCallContractFunctionBytes4Type() throws Exception { - byte[] testBytes = "Test".getBytes(); - byte[] testBytesLen4 = new byte[4]; - System.arraycopy(testBytes, 0, testBytesLen4, 0, testBytes.length); - - var response = new ContractCallQuery().setContractId(contractId).setGas(1500000) - .setFunction("returnBytes4", new ContractFunctionParameters().addBytes4(testBytesLen4)) - .setQueryPayment(new Hbar(10)).execute(testEnv.client); - - assertThat(response.getBytes(0)).isEqualTo(testBytesLen4); - } - - @Test - @DisplayName("Can receive bytes4 array value from contract call") - void canCallContractFunctionBytes4ArrayType() throws Exception { - byte[] testBytes = "Test".getBytes(); - byte[] testBytes2 = "Test2".getBytes(); - byte[][] testBytesLen4 = new byte[2][4]; - System.arraycopy(testBytes, 0, testBytesLen4[0], 0, testBytes.length); - System.arraycopy(testBytes2, 0, testBytesLen4[1], 0, testBytes2.length); - - var response = new ContractCallQuery().setContractId(contractId).setGas(1500000) - .setFunction("returnBytes4Arr", new ContractFunctionParameters().addBytes4Array(testBytesLen4)) - .setQueryPayment(new Hbar(10)).execute(testEnv.client); - - var responseResult = (byte[][]) response.getResult("(bytes4[])").get(0); - - assertThat(responseResult).isEqualTo(testBytesLen4); - } - @Test @DisplayName("Can receive bytes32 value from contract call") void canCallContractFunctionBytes32Type() throws Exception { From 96eaae24f929addfe8236c4c544bf51b10016349 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 8 Oct 2024 17:43:56 +0300 Subject: [PATCH 4/8] chore(deps): bump gradle/actions from 4.0.1 to 4.1.0 (#1996) Signed-off-by: dependabot[bot] Signed-off-by: Ivan Ivanov Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: Roger Barker Co-authored-by: Ivan Ivanov Signed-off-by: Jeffery Orazulike --- .github/workflows/build.yml | 8 ++++---- .github/workflows/pages.yml | 2 +- .github/workflows/release-artifacts.yml | 4 ++-- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 375cd9303..832094d1e 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -45,7 +45,7 @@ jobs: java-version: 17 - name: Setup Gradle - uses: gradle/actions/setup-gradle@16bf8bc8fe830fa669c3c9f914d3eb147c629707 # v4 + uses: gradle/actions/setup-gradle@d156388eb19639ec20ade50009f3d199ce1e2808 # v4.1.0 with: cache-read-only: false @@ -80,7 +80,7 @@ jobs: java-version: 17 - name: Setup Gradle - uses: gradle/actions/setup-gradle@16bf8bc8fe830fa669c3c9f914d3eb147c629707 # v4 + uses: gradle/actions/setup-gradle@d156388eb19639ec20ade50009f3d199ce1e2808 # v4.1.0 - name: Install Local Node run: npm install @hashgraph/hedera-local @@ -145,7 +145,7 @@ jobs: uses: android-actions/setup-android@00854ea68c109d98c75d956347303bf7c45b0277 # v3.2.1 - name: Setup Gradle - uses: gradle/actions/setup-gradle@16bf8bc8fe830fa669c3c9f914d3eb147c629707 # v4 + uses: gradle/actions/setup-gradle@d156388eb19639ec20ade50009f3d199ce1e2808 # v4.1.0 - name: Install Local Node run: npm install @hashgraph/hedera-local @@ -194,7 +194,7 @@ jobs: java-version: 17 - name: Setup Gradle - uses: gradle/actions/setup-gradle@16bf8bc8fe830fa669c3c9f914d3eb147c629707 # v4 + uses: gradle/actions/setup-gradle@d156388eb19639ec20ade50009f3d199ce1e2808 # v4.1.0 - name: Install Local Node run: npm install @hashgraph/hedera-local diff --git a/.github/workflows/pages.yml b/.github/workflows/pages.yml index e77dbf83e..2c36e1b5e 100644 --- a/.github/workflows/pages.yml +++ b/.github/workflows/pages.yml @@ -38,7 +38,7 @@ jobs: java-version: 17 - name: Setup Gradle - uses: gradle/actions/setup-gradle@16bf8bc8fe830fa669c3c9f914d3eb147c629707 # v4 + uses: gradle/actions/setup-gradle@d156388eb19639ec20ade50009f3d199ce1e2808 # v4.1.0 - name: Compile SDK run: ./gradlew compileJava --scan diff --git a/.github/workflows/release-artifacts.yml b/.github/workflows/release-artifacts.yml index 436391374..a892413c2 100644 --- a/.github/workflows/release-artifacts.yml +++ b/.github/workflows/release-artifacts.yml @@ -54,7 +54,7 @@ jobs: java-version: 17 - name: Setup Gradle - uses: gradle/actions/setup-gradle@16bf8bc8fe830fa669c3c9f914d3eb147c629707 # v4 + uses: gradle/actions/setup-gradle@d156388eb19639ec20ade50009f3d199ce1e2808 # v4.1.0 with: cache-read-only: false @@ -116,7 +116,7 @@ jobs: java-version: 17 - name: Setup Gradle - uses: gradle/actions/setup-gradle@16bf8bc8fe830fa669c3c9f914d3eb147c629707 # v4 + uses: gradle/actions/setup-gradle@d156388eb19639ec20ade50009f3d199ce1e2808 # v4.1.0 with: cache-read-only: false From cc42c40c96969ea793dda30976ec7360baa738bc Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 8 Oct 2024 17:46:11 +0300 Subject: [PATCH 5/8] chore(deps): bump com.autonomousapps:dependency-analysis-gradle-plugin from 2.0.2 to 2.1.4 in /gradle/plugins (#2028) Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Signed-off-by: Jeffery Orazulike --- gradle/plugins/build.gradle.kts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gradle/plugins/build.gradle.kts b/gradle/plugins/build.gradle.kts index 3056c03d6..5c98630fd 100644 --- a/gradle/plugins/build.gradle.kts +++ b/gradle/plugins/build.gradle.kts @@ -25,7 +25,7 @@ plugins { repositories.gradlePluginPortal() dependencies { - implementation("com.autonomousapps:dependency-analysis-gradle-plugin:2.0.2") + implementation("com.autonomousapps:dependency-analysis-gradle-plugin:2.1.4") implementation("com.github.spotbugs.snom:spotbugs-gradle-plugin:6.0.12") implementation("com.google.protobuf:protobuf-gradle-plugin:0.9.4") implementation("io.github.gradle-nexus:publish-plugin:1.3.0") From 2be02d0d791750cf9785c5b7f66bd2c746527c75 Mon Sep 17 00:00:00 2001 From: matteriben Date: Wed, 9 Oct 2024 04:47:45 -0500 Subject: [PATCH 6/8] feat: support ports that are not well known for use with port forwarding (#1930) Signed-off-by: Matt Riben Signed-off-by: Ivan Ivanov Co-authored-by: Ivan Ivanov Signed-off-by: Jeffery Orazulike --- .../hedera/hashgraph/sdk/BaseNodeAddress.java | 20 +++++++++++++--- .../java/com/hedera/hashgraph/sdk/Client.java | 8 +------ .../com/hedera/hashgraph/sdk/Network.java | 23 ++++++------------- 3 files changed, 25 insertions(+), 26 deletions(-) diff --git a/sdk/src/main/java/com/hedera/hashgraph/sdk/BaseNodeAddress.java b/sdk/src/main/java/com/hedera/hashgraph/sdk/BaseNodeAddress.java index 4bf02a845..b3b929969 100644 --- a/sdk/src/main/java/com/hedera/hashgraph/sdk/BaseNodeAddress.java +++ b/sdk/src/main/java/com/hedera/hashgraph/sdk/BaseNodeAddress.java @@ -40,6 +40,7 @@ class BaseNodeAddress { @Nullable private final String address; private final int port; + private final boolean secure; /** * Constructor. @@ -49,9 +50,22 @@ class BaseNodeAddress { * @param port the port part */ public BaseNodeAddress(@Nullable String name, @Nullable String address, int port) { + this(name, address, port, false); + } + + /** + * Constructor. + * + * @param name the name part + * @param address the address part + * @param port the port part + * @param secure secure transport + */ + public BaseNodeAddress(@Nullable String name, @Nullable String address, int port, boolean secure) { this.name = name; this.address = address; this.port = port; + this.secure = secure; } /** @@ -118,7 +132,7 @@ public boolean isInProcess() { * @return are we secure */ public boolean isTransportSecurity() { - return port == PORT_NODE_TLS || port == PORT_MIRROR_TLS; + return port == PORT_NODE_TLS || port == PORT_MIRROR_TLS || secure; } /** @@ -128,7 +142,7 @@ public boolean isTransportSecurity() { */ public BaseNodeAddress toInsecure() { var newPort = (this.port == PORT_NODE_TLS) ? PORT_NODE_PLAIN : this.port; - return new BaseNodeAddress(name, address, newPort); + return new BaseNodeAddress(name, address, newPort, false); } /** @@ -138,7 +152,7 @@ public BaseNodeAddress toInsecure() { */ public BaseNodeAddress toSecure() { var newPort = (this.port == PORT_NODE_PLAIN) ? PORT_NODE_TLS : this.port; - return new BaseNodeAddress(name, address, newPort); + return new BaseNodeAddress(name, address, newPort, true); } @Override diff --git a/sdk/src/main/java/com/hedera/hashgraph/sdk/Client.java b/sdk/src/main/java/com/hedera/hashgraph/sdk/Client.java index deceec552..79a93d62f 100644 --- a/sdk/src/main/java/com/hedera/hashgraph/sdk/Client.java +++ b/sdk/src/main/java/com/hedera/hashgraph/sdk/Client.java @@ -19,9 +19,6 @@ */ package com.hedera.hashgraph.sdk; -import static com.hedera.hashgraph.sdk.BaseNodeAddress.PORT_NODE_PLAIN; -import static com.hedera.hashgraph.sdk.BaseNodeAddress.PORT_NODE_TLS; - import com.google.common.annotations.VisibleForTesting; import com.google.common.util.concurrent.ThreadFactoryBuilder; import com.google.gson.Gson; @@ -469,10 +466,7 @@ void untrackSubscription(SubscriptionHandle subscriptionHandle) { */ public synchronized Client setNetworkFromAddressBook(NodeAddressBook addressBook, boolean updateAddressBook) throws InterruptedException, TimeoutException { - network.setNetwork(Network.addressBookToNetwork( - addressBook.nodeAddresses, - isTransportSecurity() ? PORT_NODE_TLS : PORT_NODE_PLAIN - )); + network.setNetwork(Network.addressBookToNetwork(addressBook.nodeAddresses)); if (updateAddressBook) { network.setAddressBook(addressBook); } diff --git a/sdk/src/main/java/com/hedera/hashgraph/sdk/Network.java b/sdk/src/main/java/com/hedera/hashgraph/sdk/Network.java index d787e2184..c6bb1b707 100644 --- a/sdk/src/main/java/com/hedera/hashgraph/sdk/Network.java +++ b/sdk/src/main/java/com/hedera/hashgraph/sdk/Network.java @@ -22,10 +22,6 @@ import com.google.common.io.ByteStreams; import com.google.errorprone.annotations.Var; import com.google.protobuf.ByteString; - -import java.util.function.Function; -import java.util.stream.Collectors; -import javax.annotation.Nullable; import java.io.IOException; import java.util.ArrayList; import java.util.Collection; @@ -35,6 +31,9 @@ import java.util.Objects; import java.util.concurrent.ExecutorService; import java.util.concurrent.TimeoutException; +import java.util.function.Function; +import java.util.stream.Collectors; +import javax.annotation.Nullable; /** * Internal utility class. @@ -83,9 +82,7 @@ static Network forNetwork(ExecutorService executor, Map netwo static Network forMainnet(ExecutorService executor) { var addressBook = getAddressBookForLedger(LedgerId.MAINNET); HashMap network = addressBookToNetwork( - Objects.requireNonNull(addressBook).values(), - BaseNodeAddress.PORT_NODE_PLAIN - ); + Objects.requireNonNull(addressBook).values()); return new Network(executor, network).setLedgerIdInternal(LedgerId.MAINNET, addressBook); } @@ -98,9 +95,7 @@ static Network forMainnet(ExecutorService executor) { static Network forTestnet(ExecutorService executor) { var addressBook = getAddressBookForLedger(LedgerId.TESTNET); HashMap network = addressBookToNetwork( - Objects.requireNonNull(addressBook).values(), - BaseNodeAddress.PORT_NODE_PLAIN - ); + Objects.requireNonNull(addressBook).values()); return new Network(executor, network).setLedgerIdInternal(LedgerId.TESTNET, addressBook); } @@ -113,9 +108,7 @@ static Network forTestnet(ExecutorService executor) { static Network forPreviewnet(ExecutorService executor) { var addressBook = getAddressBookForLedger(LedgerId.PREVIEWNET); HashMap network = addressBookToNetwork( - Objects.requireNonNull(addressBook).values(), - BaseNodeAddress.PORT_NODE_PLAIN - ); + Objects.requireNonNull(addressBook).values()); return new Network(executor, network).setLedgerIdInternal(LedgerId.PREVIEWNET, addressBook); } @@ -205,13 +198,11 @@ private static Map getAddressBookForLedger(@Nullable Led readAddressBookResource("addressbook/" + ledgerId + ".pb"); } - static HashMap addressBookToNetwork(Collection addressBook, int desiredPort) { + static HashMap addressBookToNetwork(Collection addressBook) { var network = new HashMap(); for (var nodeAddress : addressBook) { for (var endpoint : nodeAddress.addresses) { - if (endpoint.port == desiredPort) { network.put(endpoint.toString(), nodeAddress.accountId); - } } } return network; From 06cefb0621fa6d7268e7d5e25eb84cb0b37d33e2 Mon Sep 17 00:00:00 2001 From: steffenboe Date: Thu, 10 Oct 2024 08:42:47 +0200 Subject: [PATCH 7/8] Make testEnv implement Autoclosable Interface, replace occurrences (#2023) Signed-off-by: steffenboe Co-authored-by: Ivan Ivanov Signed-off-by: Jeffery Orazulike --- .../AccountAllowanceIntegrationTest.java | 92 +- .../AccountBalanceIntegrationTest.java | 116 +- .../AccountCreateIntegrationTest.java | 469 +- .../AccountDeleteIntegrationTest.java | 82 +- .../AccountIdPopulationIntegrationTest.java | 113 +- .../AccountInfoIntegrationTest.java | 118 +- .../AccountRecordsIntegrationTest.java | 48 +- .../AccountStakersIntegrationTest.java | 16 +- .../AccountUpdateIntegrationTest.java | 104 +- .../integration/ClientIntegrationTest.java | 190 +- .../ContractBytecodeIntegrationTest.java | 368 +- .../ContractCallIntegrationTest.java | 497 +- .../ContractCreateFlowIntegrationTest.java | 222 +- .../ContractCreateIntegrationTest.java | 248 +- .../ContractDeleteIntegrationTest.java | 178 +- .../ContractExecuteIntegrationTest.java | 234 +- .../ContractIdPopulationIntegrationTest.java | 99 +- .../ContractInfoIntegrationTest.java | 348 +- .../ContractNonceInfoIntegrationTest.java | 74 +- .../ContractUpdateIntegrationTest.java | 192 +- .../EthereumTransactionIntegrationTest.java | 176 +- .../test/integration/FeeSchedulesTest.java | 20 +- .../FileAppendIntegrationTest.java | 282 +- .../FileContentsIntegrationTest.java | 170 +- .../FileCreateIntegrationTest.java | 102 +- .../FileDeleteIntegrationTest.java | 79 +- .../integration/FileInfoIntegrationTest.java | 164 +- .../FileUpdateIntegrationTest.java | 168 +- .../test/integration/IntegrationTestEnv.java | 38 +- .../LiveHashAddIntegrationTest.java | 34 +- .../LiveHashDeleteIntegrationTest.java | 30 +- .../test/integration/LoadIntegrationTest.java | 90 +- .../NetworkVersionInfoIntegrationTest.java | 8 +- .../NftAllowancesIntegrationTest.java | 692 +-- .../ReceiptQueryIntegrationTest.java | 157 +- .../ScheduleCreateIntegrationTest.java | 516 +- .../integration/SystemIntegrationTest.java | 83 +- .../TokenAirdropCancelIntegrationTest.java | 697 ++- .../TokenAirdropClaimIntegrationTest.java | 753 ++- ...okenAirdropTransactionIntegrationTest.java | 768 +-- ...enAutomaticAssociationIntegrationTest.java | 887 ++-- .../integration/TokenBurnIntegrationTest.java | 344 +- .../TokenCreateIntegrationTest.java | 454 +- .../TokenDeleteIntegrationTest.java | 122 +- .../TokenDissociateIntegrationTest.java | 304 +- ...TokenFeeScheduleUpdateIntegrationTest.java | 292 +- .../TokenFreezeIntegrationTest.java | 238 +- .../TokenGrantKycIntegrationTest.java | 238 +- .../integration/TokenInfoIntegrationTest.java | 415 +- ...TokenManualAssociationIntegrationTest.java | 332 +- .../integration/TokenMintIntegrationTest.java | 354 +- .../TokenNftInfoIntegrationTest.java | 380 +- .../TokenNftTransferIntegrationTest.java | 232 +- .../TokenPauseIntegrationTest.java | 56 +- .../TokenRejectFlowIntegrationTest.java | 356 +- .../TokenRejectIntegrationTest.java | 1732 +++---- .../TokenRevokeKycIntegrationTest.java | 238 +- .../TokenTransferIntegrationTest.java | 230 +- .../TokenUnfreezeIntegrationTest.java | 238 +- .../TokenUnpauseIntegrationTest.java | 55 +- .../TokenUpdateIntegrationTest.java | 4334 +++++++++-------- .../TokenUpdateNftsIntegrationTest.java | 574 +-- .../integration/TokenWipeIntegrationTest.java | 672 +-- .../TopicCreateIntegrationTest.java | 32 +- .../TopicDeleteIntegrationTest.java | 44 +- .../integration/TopicInfoIntegrationTest.java | 171 +- .../TopicMessageIntegrationTest.java | 160 +- .../TopicMessageSubmitIntegrationTest.java | 194 +- .../TopicUpdateIntegrationTest.java | 46 +- .../TransactionIntegrationTest.java | 1051 ++-- .../integration/TransactionResponseTest.java | 20 +- 71 files changed, 11815 insertions(+), 11815 deletions(-) diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountAllowanceIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountAllowanceIntegrationTest.java index 5a7d1bf5f..8f4fb7eae 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountAllowanceIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountAllowanceIntegrationTest.java @@ -37,60 +37,60 @@ public class AccountAllowanceIntegrationTest { @Test @DisplayName("Can spend hbar allowance") void canSpendHbarAllowance() throws Throwable { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var aliceKey = PrivateKey.generateED25519(); - var aliceId = new AccountCreateTransaction() - .setKey(aliceKey) - .setInitialBalance(new Hbar(10)) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .accountId; + var aliceKey = PrivateKey.generateED25519(); + var aliceId = new AccountCreateTransaction() + .setKey(aliceKey) + .setInitialBalance(new Hbar(10)) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .accountId; - var bobKey = PrivateKey.generateED25519(); - var bobId = new AccountCreateTransaction() - .setKey(bobKey) - .setInitialBalance(new Hbar(10)) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .accountId; + var bobKey = PrivateKey.generateED25519(); + var bobId = new AccountCreateTransaction() + .setKey(bobKey) + .setInitialBalance(new Hbar(10)) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .accountId; - Objects.requireNonNull(aliceId); - Objects.requireNonNull(bobId); + Objects.requireNonNull(aliceId); + Objects.requireNonNull(bobId); - new AccountAllowanceApproveTransaction() - .approveHbarAllowance(bobId, aliceId, new Hbar(10)) - .freezeWith(testEnv.client) - .sign(bobKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new AccountAllowanceApproveTransaction() + .approveHbarAllowance(bobId, aliceId, new Hbar(10)) + .freezeWith(testEnv.client) + .sign(bobKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); - var transferRecord = new TransferTransaction() - .addHbarTransfer(testEnv.operatorId, new Hbar(5)) - .addApprovedHbarTransfer(bobId, new Hbar(5).negated()) - .setTransactionId(TransactionId.generate(aliceId)) - .freezeWith(testEnv.client) - .sign(aliceKey) - .execute(testEnv.client) - .getRecord(testEnv.client); + var transferRecord = new TransferTransaction() + .addHbarTransfer(testEnv.operatorId, new Hbar(5)) + .addApprovedHbarTransfer(bobId, new Hbar(5).negated()) + .setTransactionId(TransactionId.generate(aliceId)) + .freezeWith(testEnv.client) + .sign(aliceKey) + .execute(testEnv.client) + .getRecord(testEnv.client); - var transferFound = false; - for (var transfer : transferRecord.transfers) { - if (transfer.accountId.equals(testEnv.operatorId) && transfer.amount.equals(new Hbar(5))) { - transferFound = true; - break; + var transferFound = false; + for (var transfer : transferRecord.transfers) { + if (transfer.accountId.equals(testEnv.operatorId) && transfer.amount.equals(new Hbar(5))) { + transferFound = true; + break; + } } - } - assertThat(transferFound).isTrue(); + assertThat(transferFound).isTrue(); - new AccountDeleteTransaction() - .setAccountId(bobId) - .setTransferAccountId(testEnv.operatorId) - .freezeWith(testEnv.client) - .sign(bobKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new AccountDeleteTransaction() + .setAccountId(bobId) + .setTransferAccountId(testEnv.operatorId) + .freezeWith(testEnv.client) + .sign(bobKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(aliceId, aliceKey); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountBalanceIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountBalanceIntegrationTest.java index bf80fafd8..0669f2a57 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountBalanceIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountBalanceIntegrationTest.java @@ -149,114 +149,114 @@ void cannotConnectToPreviewnetWhenNetworkNameIsNullAndCertificateVerificationIsE @Test @DisplayName("Can fetch balance for client operator") void canFetchBalanceForClientOperator() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (IntegrationTestEnv testEnv = new IntegrationTestEnv(1)) { - var balance = new AccountBalanceQuery() + var balance = new AccountBalanceQuery() .setAccountId(testEnv.operatorId) .execute(testEnv.client); - assertThat(balance.hbars.toTinybars() > 0).isTrue(); + assertThat(balance.hbars.toTinybars() > 0).isTrue(); - testEnv.close(); + } } @Test @DisplayName("Can fetch cost for the query") void getCostBalanceForClientOperator() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (IntegrationTestEnv testEnv = new IntegrationTestEnv(1)) { - var balance = new AccountBalanceQuery() - .setAccountId(testEnv.operatorId) - .setMaxQueryPayment(new Hbar(1)); + var balance = new AccountBalanceQuery() + .setAccountId(testEnv.operatorId) + .setMaxQueryPayment(new Hbar(1)); - var cost = balance.getCost(testEnv.client); + var cost = balance.getCost(testEnv.client); - var accBalance = balance.setQueryPayment(cost).execute(testEnv.client); + var accBalance = balance.setQueryPayment(cost).execute(testEnv.client); - assertThat(accBalance.hbars.toTinybars() > 0).isTrue(); - assertThat(cost.toTinybars()).isEqualTo(0); + assertThat(accBalance.hbars.toTinybars() > 0).isTrue(); + assertThat(cost.toTinybars()).isEqualTo(0); - testEnv.close(); + } } @Test @DisplayName("Can fetch cost for the query, big max set") void getCostBigMaxBalanceForClientOperator() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (IntegrationTestEnv testEnv = new IntegrationTestEnv(1)) { - var balance = new AccountBalanceQuery() - .setAccountId(testEnv.operatorId) - .setMaxQueryPayment(new Hbar(1000000)); + var balance = new AccountBalanceQuery() + .setAccountId(testEnv.operatorId) + .setMaxQueryPayment(new Hbar(1000000)); - var cost = balance.getCost(testEnv.client); + var cost = balance.getCost(testEnv.client); - var accBalance = balance.setQueryPayment(cost).execute(testEnv.client); + var accBalance = balance.setQueryPayment(cost).execute(testEnv.client); - assertThat(accBalance.hbars.toTinybars() > 0).isTrue(); + assertThat(accBalance.hbars.toTinybars() > 0).isTrue(); - testEnv.close(); + } } @Test @DisplayName("Can fetch cost for the query, very small max set") void getCostSmallMaxBalanceForClientOperator() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (IntegrationTestEnv testEnv = new IntegrationTestEnv(1)) { - var balance = new AccountBalanceQuery() - .setAccountId(testEnv.operatorId) - .setMaxQueryPayment(Hbar.fromTinybars(1)); + var balance = new AccountBalanceQuery() + .setAccountId(testEnv.operatorId) + .setMaxQueryPayment(Hbar.fromTinybars(1)); - var cost = balance.getCost(testEnv.client); + var cost = balance.getCost(testEnv.client); - var accBalance = balance.setQueryPayment(cost).execute(testEnv.client); + var accBalance = balance.setQueryPayment(cost).execute(testEnv.client); - assertThat(accBalance.hbars.toTinybars() > 0).isTrue(); + assertThat(accBalance.hbars.toTinybars() > 0).isTrue(); - testEnv.close(); + } } @Test @DisplayName("Cannot fetch balance for invalid account ID") void canNotFetchBalanceForInvalidAccountId() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (IntegrationTestEnv testEnv = new IntegrationTestEnv(1)) { - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new AccountBalanceQuery() - .setAccountId(AccountId.fromString("1.0.3")) - .execute(testEnv.client); - }).withMessageContaining(Status.INVALID_ACCOUNT_ID.toString()); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new AccountBalanceQuery() + .setAccountId(AccountId.fromString("1.0.3")) + .execute(testEnv.client); + }).withMessageContaining(Status.INVALID_ACCOUNT_ID.toString()); - testEnv.close(); + } } @Test @DisplayName("Can fetch token balances for client operator") void canFetchTokenBalancesForClientOperator() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var response = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setInitialSupply(10000) - .setDecimals(50) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var response = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setInitialSupply(10000) + .setDecimals(50) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client); - var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); + var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); - var query = new AccountBalanceQuery(); - var balance = query - .setAccountId(testEnv.operatorId) - .execute(testEnv.client); + var query = new AccountBalanceQuery(); + var balance = query + .setAccountId(testEnv.operatorId) + .execute(testEnv.client); - assertThat(balance.tokens.get(tokenId)).isEqualTo(10000); - assertThat(balance.tokenDecimals.get(tokenId)).isEqualTo(50); - assertThat(query.toString()).isNotEmpty(); - assertThat(query.getPaymentTransactionId()).isNull(); + assertThat(balance.tokens.get(tokenId)).isEqualTo(10000); + assertThat(balance.tokenDecimals.get(tokenId)).isEqualTo(50); + assertThat(query.toString()).isNotEmpty(); + assertThat(query.getPaymentTransactionId()).isNull(); - testEnv.close(tokenId); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountCreateIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountCreateIntegrationTest.java index fe60d54b1..4dcd7886d 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountCreateIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountCreateIntegrationTest.java @@ -34,126 +34,126 @@ class AccountCreateIntegrationTest { @Test @DisplayName("Can create account with only initial balance and key") void canCreateAccountWithOnlyInitialBalanceAndKey() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var key = PrivateKey.generateED25519(); + var key = PrivateKey.generateED25519(); - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - var info = new AccountInfoQuery() - .setAccountId(accountId) - .execute(testEnv.client); + var info = new AccountInfoQuery() + .setAccountId(accountId) + .execute(testEnv.client); - assertThat(info.accountId).isEqualTo(accountId); - assertThat(info.isDeleted).isFalse(); - assertThat(info.key.toString()).isEqualTo(key.getPublicKey().toString()); - assertThat(info.balance).isEqualTo(new Hbar(1)); - assertThat(info.autoRenewPeriod).isEqualTo(Duration.ofDays(90)); - assertThat(info.proxyAccountId).isNull(); - assertThat(info.proxyReceived).isEqualTo(Hbar.ZERO); + assertThat(info.accountId).isEqualTo(accountId); + assertThat(info.isDeleted).isFalse(); + assertThat(info.key.toString()).isEqualTo(key.getPublicKey().toString()); + assertThat(info.balance).isEqualTo(new Hbar(1)); + assertThat(info.autoRenewPeriod).isEqualTo(Duration.ofDays(90)); + assertThat(info.proxyAccountId).isNull(); + assertThat(info.proxyReceived).isEqualTo(Hbar.ZERO); - testEnv.close(accountId, key); + } } @Test @DisplayName("Can create account with no initial balance") void canCreateAccountWithNoInitialBalance() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var key = PrivateKey.generateED25519(); + var key = PrivateKey.generateED25519(); - var response = new AccountCreateTransaction() - .setKey(key) - .execute(testEnv.client); + var response = new AccountCreateTransaction() + .setKey(key) + .execute(testEnv.client); - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - var info = new AccountInfoQuery() - .setAccountId(accountId) - .execute(testEnv.client); + var info = new AccountInfoQuery() + .setAccountId(accountId) + .execute(testEnv.client); - assertThat(info.accountId).isEqualTo(accountId); - assertThat(info.isDeleted).isFalse(); - assertThat(info.key.toString()).isEqualTo(key.getPublicKey().toString()); - assertThat(info.balance).isEqualTo(new Hbar(0)); - assertThat(info.autoRenewPeriod).isEqualTo(Duration.ofDays(90)); - assertThat(info.proxyAccountId).isNull(); - assertThat(info.proxyReceived).isEqualTo(Hbar.ZERO); + assertThat(info.accountId).isEqualTo(accountId); + assertThat(info.isDeleted).isFalse(); + assertThat(info.key.toString()).isEqualTo(key.getPublicKey().toString()); + assertThat(info.balance).isEqualTo(new Hbar(0)); + assertThat(info.autoRenewPeriod).isEqualTo(Duration.ofDays(90)); + assertThat(info.proxyAccountId).isNull(); + assertThat(info.proxyReceived).isEqualTo(Hbar.ZERO); - testEnv.close(accountId, key); + } } @Test @DisplayName("Cannot create account with no key") void canNotCreateAccountWithNoKey() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> new AccountCreateTransaction() - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client) - .getReceipt(testEnv.client)).withMessageContaining(Status.KEY_REQUIRED.toString()); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> new AccountCreateTransaction() + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client) + .getReceipt(testEnv.client)).withMessageContaining(Status.KEY_REQUIRED.toString()); - testEnv.close(); + } } @Test @DisplayName("Can create account using aliasKey") void canCreateWithAliasKey() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var key = PrivateKey.generateED25519(); + var key = PrivateKey.generateED25519(); - var aliasId = key.toAccountId(0, 0); + var aliasId = key.toAccountId(0, 0); - new TransferTransaction() - .addHbarTransfer(testEnv.operatorId, new Hbar(10).negated()) - .addHbarTransfer(aliasId, new Hbar(10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TransferTransaction() + .addHbarTransfer(testEnv.operatorId, new Hbar(10).negated()) + .addHbarTransfer(aliasId, new Hbar(10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); - var info = new AccountInfoQuery() - .setAccountId(aliasId) - .execute(testEnv.client); + var info = new AccountInfoQuery() + .setAccountId(aliasId) + .execute(testEnv.client); - assertThat(key.getPublicKey()).isEqualTo(info.aliasKey); + assertThat(key.getPublicKey()).isEqualTo(info.aliasKey); - testEnv.close(info.accountId, key); + } } @Test @DisplayName("Regenerates TransactionIds in response to expiration") void managesExpiration() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var key = PrivateKey.generateED25519(); + var key = PrivateKey.generateED25519(); - var response = new AccountCreateTransaction() - .setKey(key) - .setTransactionId(new TransactionId(testEnv.operatorId, Instant.now().minusSeconds(40))) - .setTransactionValidDuration(Duration.ofSeconds(30)) - .freezeWith(testEnv.client) - .execute(testEnv.client); + var response = new AccountCreateTransaction() + .setKey(key) + .setTransactionId(new TransactionId(testEnv.operatorId, Instant.now().minusSeconds(40))) + .setTransactionValidDuration(Duration.ofSeconds(30)) + .freezeWith(testEnv.client) + .execute(testEnv.client); - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - var info = new AccountInfoQuery() - .setAccountId(accountId) - .execute(testEnv.client); + var info = new AccountInfoQuery() + .setAccountId(accountId) + .execute(testEnv.client); - assertThat(info.accountId).isEqualTo(accountId); - assertThat(info.isDeleted).isFalse(); - assertThat(info.key.toString()).isEqualTo(key.getPublicKey().toString()); - assertThat(info.balance).isEqualTo(new Hbar(0)); - assertThat(info.autoRenewPeriod).isEqualTo(Duration.ofDays(90)); - assertThat(info.proxyAccountId).isNull(); - assertThat(info.proxyReceived).isEqualTo(Hbar.ZERO); + assertThat(info.accountId).isEqualTo(accountId); + assertThat(info.isDeleted).isFalse(); + assertThat(info.key.toString()).isEqualTo(key.getPublicKey().toString()); + assertThat(info.balance).isEqualTo(new Hbar(0)); + assertThat(info.autoRenewPeriod).isEqualTo(Duration.ofDays(90)); + assertThat(info.proxyAccountId).isNull(); + assertThat(info.proxyReceived).isEqualTo(Hbar.ZERO); - testEnv.close(accountId, key); + } } @Test @@ -161,36 +161,36 @@ void managesExpiration() throws Exception { void createAccountWithAliasFromAdminKey() throws Exception { // Tests the third row of this table // https://github.com/hashgraph/hedera-improvement-proposal/blob/d39f740021d7da592524cffeaf1d749803798e9a/HIP/hip-583.md#signatures - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var adminKey = PrivateKey.generateECDSA(); - var evmAddress = adminKey.getPublicKey().toEvmAddress(); + var adminKey = PrivateKey.generateECDSA(); + var evmAddress = adminKey.getPublicKey().toEvmAddress(); - // Create the admin account - new AccountCreateTransaction() - .setKey(adminKey) - .freezeWith(testEnv.client) - .execute(testEnv.client); + // Create the admin account + new AccountCreateTransaction() + .setKey(adminKey) + .freezeWith(testEnv.client) + .execute(testEnv.client); - var accountId = new AccountCreateTransaction() - .setKey(adminKey) - .setAlias(evmAddress) - .freezeWith(testEnv.client) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .accountId; + var accountId = new AccountCreateTransaction() + .setKey(adminKey) + .setAlias(evmAddress) + .freezeWith(testEnv.client) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .accountId; - assertThat(accountId).isNotNull(); + assertThat(accountId).isNotNull(); - var info = new AccountInfoQuery() - .setAccountId(accountId) - .execute(testEnv.client); + var info = new AccountInfoQuery() + .setAccountId(accountId) + .execute(testEnv.client); - assertThat(info.accountId).isNotNull(); - assertThat(info.contractAccountId).hasToString(evmAddress.toString()); - assertThat(info.key).isEqualTo(adminKey.getPublicKey()); + assertThat(info.accountId).isNotNull(); + assertThat(info.contractAccountId).hasToString(evmAddress.toString()); + assertThat(info.key).isEqualTo(adminKey.getPublicKey()); - testEnv.close(); + } } @Test @@ -198,63 +198,62 @@ void createAccountWithAliasFromAdminKey() throws Exception { void createAccountWithAliasFromAdminKeyWithReceiverSigRequired() throws Exception { // Tests the fourth row of this table // https://github.com/hashgraph/hedera-improvement-proposal/blob/d39f740021d7da592524cffeaf1d749803798e9a/HIP/hip-583.md#signatures - var testEnv = new IntegrationTestEnv(1); - - var adminKey = PrivateKey.generateECDSA(); - var evmAddress = adminKey.getPublicKey().toEvmAddress(); - - // Create the admin account - new AccountCreateTransaction() - .setKey(adminKey) - .freezeWith(testEnv.client) - .execute(testEnv.client); - - var accountId = new AccountCreateTransaction() - .setReceiverSignatureRequired(true) - .setKey(adminKey) - .setAlias(evmAddress) - .freezeWith(testEnv.client) - .sign(adminKey) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .accountId; - - assertThat(accountId).isNotNull(); - - var info = new AccountInfoQuery() - .setAccountId(accountId) - .execute(testEnv.client); - - assertThat(info.accountId).isNotNull(); - assertThat(info.contractAccountId).hasToString(evmAddress.toString()); - assertThat(info.key).isEqualTo(adminKey.getPublicKey()); - - testEnv.close(); + try (var testEnv = new IntegrationTestEnv(1)) { + + var adminKey = PrivateKey.generateECDSA(); + var evmAddress = adminKey.getPublicKey().toEvmAddress(); + + // Create the admin account + new AccountCreateTransaction() + .setKey(adminKey) + .freezeWith(testEnv.client) + .execute(testEnv.client); + + var accountId = new AccountCreateTransaction() + .setReceiverSignatureRequired(true) + .setKey(adminKey) + .setAlias(evmAddress) + .freezeWith(testEnv.client) + .sign(adminKey) + .execute(testEnv.client) + .getReceipt(testEnv.client).accountId; + + assertThat(accountId).isNotNull(); + + var info = new AccountInfoQuery() + .setAccountId(accountId) + .execute(testEnv.client); + + assertThat(info.accountId).isNotNull(); + assertThat(info.contractAccountId).hasToString(evmAddress.toString()); + assertThat(info.key).isEqualTo(adminKey.getPublicKey()); + + } } @Test @DisplayName("Cannot create account with alias from admin key with receiver sig required without signature") void cannotCreateAccountWithAliasFromAdminKeyWithReceiverSigRequiredAndNoSignature() throws Exception { - var testEnv = new IntegrationTestEnv(1); - - var adminKey = PrivateKey.generateECDSA(); - var evmAddress = adminKey.getPublicKey().toEvmAddress(); - - // Create the admin account - new AccountCreateTransaction() - .setKey(adminKey) - .freezeWith(testEnv.client) - .execute(testEnv.client); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> new AccountCreateTransaction() - .setReceiverSignatureRequired(true) - .setKey(adminKey) - .setAlias(evmAddress) - .freezeWith(testEnv.client) - .execute(testEnv.client) - .getReceipt(testEnv.client)).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - testEnv.close(); + try (var testEnv = new IntegrationTestEnv(1)) { + + var adminKey = PrivateKey.generateECDSA(); + var evmAddress = adminKey.getPublicKey().toEvmAddress(); + + // Create the admin account + new AccountCreateTransaction() + .setKey(adminKey) + .freezeWith(testEnv.client) + .execute(testEnv.client); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> new AccountCreateTransaction() + .setReceiverSignatureRequired(true) + .setKey(adminKey) + .setAlias(evmAddress) + .freezeWith(testEnv.client) + .execute(testEnv.client) + .getReceipt(testEnv.client)).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + } } @Test @@ -262,66 +261,65 @@ void cannotCreateAccountWithAliasFromAdminKeyWithReceiverSigRequiredAndNoSignatu void createAccountWithAlias() throws Exception { // Tests the fifth row of this table // https://github.com/hashgraph/hedera-improvement-proposal/blob/d39f740021d7da592524cffeaf1d749803798e9a/HIP/hip-583.md#signatures - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var adminKey = PrivateKey.generateED25519(); + var adminKey = PrivateKey.generateED25519(); - // Create the admin account - new AccountCreateTransaction() - .setKey(adminKey) - .freezeWith(testEnv.client) - .execute(testEnv.client); + // Create the admin account + new AccountCreateTransaction() + .setKey(adminKey) + .freezeWith(testEnv.client) + .execute(testEnv.client); - var key = PrivateKey.generateECDSA(); - var evmAddress = key.getPublicKey().toEvmAddress(); + var key = PrivateKey.generateECDSA(); + var evmAddress = key.getPublicKey().toEvmAddress(); - var accountId = new AccountCreateTransaction() - .setKey(adminKey) - .setAlias(evmAddress) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .accountId; + var accountId = new AccountCreateTransaction() + .setKey(adminKey) + .setAlias(evmAddress) + .freezeWith(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client).accountId; - assertThat(accountId).isNotNull(); + assertThat(accountId).isNotNull(); - var info = new AccountInfoQuery() - .setAccountId(accountId) - .execute(testEnv.client); + var info = new AccountInfoQuery() + .setAccountId(accountId) + .execute(testEnv.client); - assertThat(info.accountId).isNotNull(); - assertThat(info.contractAccountId).hasToString(evmAddress.toString()); - assertThat(info.key).isEqualTo(adminKey.getPublicKey()); + assertThat(info.accountId).isNotNull(); + assertThat(info.contractAccountId).hasToString(evmAddress.toString()); + assertThat(info.key).isEqualTo(adminKey.getPublicKey()); - testEnv.close(); + } } @Test @DisplayName("Cannot create account with alias different from admin key without signature") void cannotCreateAccountWithAliasWithoutSignature() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var adminKey = PrivateKey.generateED25519(); + var adminKey = PrivateKey.generateED25519(); - // Create the admin account - new AccountCreateTransaction() - .setKey(adminKey) - .freezeWith(testEnv.client) - .execute(testEnv.client); + // Create the admin account + new AccountCreateTransaction() + .setKey(adminKey) + .freezeWith(testEnv.client) + .execute(testEnv.client); - var key = PrivateKey.generateECDSA(); - var evmAddress = key.getPublicKey().toEvmAddress(); + var key = PrivateKey.generateECDSA(); + var evmAddress = key.getPublicKey().toEvmAddress(); - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> new AccountCreateTransaction() - .setReceiverSignatureRequired(true) - .setKey(adminKey) - .setAlias(evmAddress) - .freezeWith(testEnv.client) - .execute(testEnv.client) - .getReceipt(testEnv.client)).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> new AccountCreateTransaction() + .setReceiverSignatureRequired(true) + .setKey(adminKey) + .setAlias(evmAddress) + .freezeWith(testEnv.client) + .execute(testEnv.client) + .getReceipt(testEnv.client)).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - testEnv.close(); + } } @Test @@ -329,68 +327,67 @@ void cannotCreateAccountWithAliasWithoutSignature() throws Exception { void createAccountWithAliasWithReceiverSigRequired() throws Exception { // Tests the sixth row of this table // https://github.com/hashgraph/hedera-improvement-proposal/blob/d39f740021d7da592524cffeaf1d749803798e9a/HIP/hip-583.md#signatures - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var adminKey = PrivateKey.generateED25519(); + var adminKey = PrivateKey.generateED25519(); - // Create the admin account - new AccountCreateTransaction() - .setKey(adminKey) - .freezeWith(testEnv.client) - .execute(testEnv.client); + // Create the admin account + new AccountCreateTransaction() + .setKey(adminKey) + .freezeWith(testEnv.client) + .execute(testEnv.client); - var key = PrivateKey.generateECDSA(); - var evmAddress = key.getPublicKey().toEvmAddress(); + var key = PrivateKey.generateECDSA(); + var evmAddress = key.getPublicKey().toEvmAddress(); - var accountId = new AccountCreateTransaction() - .setReceiverSignatureRequired(true) - .setKey(adminKey) - .setAlias(evmAddress) - .freezeWith(testEnv.client) - .sign(key) - .sign(adminKey) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .accountId; + var accountId = new AccountCreateTransaction() + .setReceiverSignatureRequired(true) + .setKey(adminKey) + .setAlias(evmAddress) + .freezeWith(testEnv.client) + .sign(key) + .sign(adminKey) + .execute(testEnv.client) + .getReceipt(testEnv.client).accountId; - assertThat(accountId).isNotNull(); + assertThat(accountId).isNotNull(); - var info = new AccountInfoQuery() - .setAccountId(accountId) - .execute(testEnv.client); + var info = new AccountInfoQuery() + .setAccountId(accountId) + .execute(testEnv.client); - assertThat(info.accountId).isNotNull(); - assertThat(info.contractAccountId).hasToString(evmAddress.toString()); - assertThat(info.key).isEqualTo(adminKey.getPublicKey()); + assertThat(info.accountId).isNotNull(); + assertThat(info.contractAccountId).hasToString(evmAddress.toString()); + assertThat(info.key).isEqualTo(adminKey.getPublicKey()); - testEnv.close(); + } } @Test @DisplayName("Cannot create account with alias different from admin key and receiver sig required without signature") void cannotCreateAccountWithAliasWithReceiverSigRequiredWithoutSignature() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var adminKey = PrivateKey.generateED25519(); + var adminKey = PrivateKey.generateED25519(); - // Create the admin account - new AccountCreateTransaction() - .setKey(adminKey) - .freezeWith(testEnv.client) - .execute(testEnv.client); + // Create the admin account + new AccountCreateTransaction() + .setKey(adminKey) + .freezeWith(testEnv.client) + .execute(testEnv.client); - var key = PrivateKey.generateECDSA(); - var evmAddress = key.getPublicKey().toEvmAddress(); + var key = PrivateKey.generateECDSA(); + var evmAddress = key.getPublicKey().toEvmAddress(); - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> new AccountCreateTransaction() - .setReceiverSignatureRequired(true) - .setKey(adminKey) - .setAlias(evmAddress) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client)).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> new AccountCreateTransaction() + .setReceiverSignatureRequired(true) + .setKey(adminKey) + .setAlias(evmAddress) + .freezeWith(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client)).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - testEnv.close(); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountDeleteIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountDeleteIntegrationTest.java index db6abad0a..a3ed86879 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountDeleteIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountDeleteIntegrationTest.java @@ -40,69 +40,69 @@ class AccountDeleteIntegrationTest { @Test @DisplayName("Can delete account") void canDeleteAccount() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var key = PrivateKey.generateED25519(); + var key = PrivateKey.generateED25519(); - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - var info = new AccountInfoQuery() - .setAccountId(accountId) - .execute(testEnv.client); + var info = new AccountInfoQuery() + .setAccountId(accountId) + .execute(testEnv.client); - assertThat(info.accountId).isEqualTo(accountId); - assertThat(info.isDeleted).isFalse(); - assertThat(info.key.toString()).isEqualTo(key.getPublicKey().toString()); - assertThat(info.balance).isEqualTo(new Hbar(1)); - assertThat(info.autoRenewPeriod).isEqualTo(Duration.ofDays(90)); - assertThat(info.proxyAccountId).isNull(); - assertThat(info.proxyReceived).isEqualTo(Hbar.ZERO); + assertThat(info.accountId).isEqualTo(accountId); + assertThat(info.isDeleted).isFalse(); + assertThat(info.key.toString()).isEqualTo(key.getPublicKey().toString()); + assertThat(info.balance).isEqualTo(new Hbar(1)); + assertThat(info.autoRenewPeriod).isEqualTo(Duration.ofDays(90)); + assertThat(info.proxyAccountId).isNull(); + assertThat(info.proxyReceived).isEqualTo(Hbar.ZERO); - testEnv.close(accountId, key); + } } @Test @DisplayName("Cannot delete invalid account ID") void cannotCreateAccountWithNoKey() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new AccountDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.ACCOUNT_ID_DOES_NOT_EXIST.toString()); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new AccountDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.ACCOUNT_ID_DOES_NOT_EXIST.toString()); - testEnv.close(); + } } @Test @DisplayName("Cannot delete account that has not signed transaction") void cannotDeleteAccountThatHasNotSignedTransaction() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var key = PrivateKey.generateED25519(); + var key = PrivateKey.generateED25519(); - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new AccountDeleteTransaction() - .setAccountId(accountId) - .setTransferAccountId(testEnv.operatorId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new AccountDeleteTransaction() + .setAccountId(accountId) + .setTransferAccountId(testEnv.operatorId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - testEnv.close(accountId, key); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountIdPopulationIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountIdPopulationIntegrationTest.java index 713f1014f..cff313103 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountIdPopulationIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountIdPopulationIntegrationTest.java @@ -33,103 +33,108 @@ class AccountIdPopulationIntegrationTest { @Test @DisplayName("Can populate AccountId num from mirror node (using sync method)") void canPopulateAccountIdNumSync() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var privateKey = PrivateKey.generateECDSA(); - var publicKey = privateKey.getPublicKey(); + var privateKey = PrivateKey.generateECDSA(); + var publicKey = privateKey.getPublicKey(); - var evmAddress = publicKey.toEvmAddress(); - var evmAddressAccount = AccountId.fromEvmAddress(evmAddress); + var evmAddress = publicKey.toEvmAddress(); + var evmAddressAccount = AccountId.fromEvmAddress(evmAddress); - var tx = new TransferTransaction().addHbarTransfer(evmAddressAccount, new Hbar(1)) - .addHbarTransfer(testEnv.operatorId, new Hbar(-1)).execute(testEnv.client); + var tx = new TransferTransaction().addHbarTransfer(evmAddressAccount, new Hbar(1)) + .addHbarTransfer(testEnv.operatorId, new Hbar(-1)).execute(testEnv.client); - var receipt = new TransactionReceiptQuery().setTransactionId(tx.transactionId).setIncludeChildren(true) - .execute(testEnv.client); + var receipt = new TransactionReceiptQuery().setTransactionId(tx.transactionId).setIncludeChildren(true) + .execute(testEnv.client); - var newAccountId = receipt.children.get(0).accountId; + var newAccountId = receipt.children.get(0).accountId; - var idMirror = AccountId.fromEvmAddress(evmAddress); - Thread.sleep(5000); - var accountId = idMirror.populateAccountNum(testEnv.client); + var idMirror = AccountId.fromEvmAddress(evmAddress); + Thread.sleep(5000); + var accountId = idMirror.populateAccountNum(testEnv.client); - assertThat(newAccountId.num).isEqualTo(accountId.num); + assertThat(newAccountId.num).isEqualTo(accountId.num); + } } @Test @DisplayName("Can populate AccountId num from mirror node (using async method)") void canPopulateAccountIdNumAsync() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var privateKey = PrivateKey.generateECDSA(); - var publicKey = privateKey.getPublicKey(); + var privateKey = PrivateKey.generateECDSA(); + var publicKey = privateKey.getPublicKey(); - var evmAddress = publicKey.toEvmAddress(); - var evmAddressAccount = AccountId.fromEvmAddress(evmAddress); + var evmAddress = publicKey.toEvmAddress(); + var evmAddressAccount = AccountId.fromEvmAddress(evmAddress); - var tx = new TransferTransaction().addHbarTransfer(evmAddressAccount, new Hbar(1)) - .addHbarTransfer(testEnv.operatorId, new Hbar(-1)).execute(testEnv.client); + var tx = new TransferTransaction().addHbarTransfer(evmAddressAccount, new Hbar(1)) + .addHbarTransfer(testEnv.operatorId, new Hbar(-1)).execute(testEnv.client); - var receipt = new TransactionReceiptQuery().setTransactionId(tx.transactionId).setIncludeChildren(true) - .execute(testEnv.client); + var receipt = new TransactionReceiptQuery().setTransactionId(tx.transactionId).setIncludeChildren(true) + .execute(testEnv.client); - var newAccountId = receipt.children.get(0).accountId; + var newAccountId = receipt.children.get(0).accountId; - var idMirror = AccountId.fromEvmAddress(evmAddress); - Thread.sleep(5000); - var accountId = idMirror.populateAccountNumAsync(testEnv.client).get(); + var idMirror = AccountId.fromEvmAddress(evmAddress); + Thread.sleep(5000); + var accountId = idMirror.populateAccountNumAsync(testEnv.client).get(); - assertThat(newAccountId.num).isEqualTo(accountId.num); + assertThat(newAccountId.num).isEqualTo(accountId.num); + + } } @Test @DisplayName("Can populate AccountId evm address from mirror node (using sync method)") void canPopulateAccountIdEvmAddressSync() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var privateKey = PrivateKey.generateECDSA(); - var publicKey = privateKey.getPublicKey(); + var privateKey = PrivateKey.generateECDSA(); + var publicKey = privateKey.getPublicKey(); - var evmAddress = publicKey.toEvmAddress(); - var evmAddressAccount = AccountId.fromEvmAddress(evmAddress); + var evmAddress = publicKey.toEvmAddress(); + var evmAddressAccount = AccountId.fromEvmAddress(evmAddress); - var tx = new TransferTransaction().addHbarTransfer(evmAddressAccount, new Hbar(1)) - .addHbarTransfer(testEnv.operatorId, new Hbar(-1)).execute(testEnv.client); + var tx = new TransferTransaction().addHbarTransfer(evmAddressAccount, new Hbar(1)) + .addHbarTransfer(testEnv.operatorId, new Hbar(-1)).execute(testEnv.client); - var receipt = new TransactionReceiptQuery().setTransactionId(tx.transactionId).setIncludeChildren(true) - .execute(testEnv.client); + var receipt = new TransactionReceiptQuery().setTransactionId(tx.transactionId).setIncludeChildren(true) + .execute(testEnv.client); - var newAccountId = receipt.children.get(0).accountId; + var newAccountId = receipt.children.get(0).accountId; - Thread.sleep(5000); - var accountId = newAccountId.populateAccountEvmAddress(testEnv.client); + Thread.sleep(5000); + var accountId = newAccountId.populateAccountEvmAddress(testEnv.client); - assertThat(evmAddressAccount.evmAddress).isEqualTo(accountId.evmAddress); + assertThat(evmAddressAccount.evmAddress).isEqualTo(accountId.evmAddress); + } } @Test @DisplayName("Can populate AccountId evm address from mirror node (using async method)") void canPopulateAccountIdEvmAddressAsync() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var privateKey = PrivateKey.generateECDSA(); - var publicKey = privateKey.getPublicKey(); + var privateKey = PrivateKey.generateECDSA(); + var publicKey = privateKey.getPublicKey(); - var evmAddress = publicKey.toEvmAddress(); - var evmAddressAccount = AccountId.fromEvmAddress(evmAddress); + var evmAddress = publicKey.toEvmAddress(); + var evmAddressAccount = AccountId.fromEvmAddress(evmAddress); - var tx = new TransferTransaction().addHbarTransfer(evmAddressAccount, new Hbar(1)) - .addHbarTransfer(testEnv.operatorId, new Hbar(-1)).execute(testEnv.client); + var tx = new TransferTransaction().addHbarTransfer(evmAddressAccount, new Hbar(1)) + .addHbarTransfer(testEnv.operatorId, new Hbar(-1)).execute(testEnv.client); - var receipt = new TransactionReceiptQuery().setTransactionId(tx.transactionId).setIncludeChildren(true) - .execute(testEnv.client); + var receipt = new TransactionReceiptQuery().setTransactionId(tx.transactionId).setIncludeChildren(true) + .execute(testEnv.client); - var newAccountId = receipt.children.get(0).accountId; + var newAccountId = receipt.children.get(0).accountId; - Thread.sleep(5000); - var accountId = newAccountId.populateAccountEvmAddressAsync(testEnv.client).get(); + Thread.sleep(5000); + var accountId = newAccountId.populateAccountEvmAddressAsync(testEnv.client).get(); - assertThat(evmAddressAccount.evmAddress).isEqualTo(accountId.evmAddress); + assertThat(evmAddressAccount.evmAddress).isEqualTo(accountId.evmAddress); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountInfoIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountInfoIntegrationTest.java index 3703a8a86..45d47016c 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountInfoIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountInfoIntegrationTest.java @@ -39,115 +39,115 @@ class AccountInfoIntegrationTest { @Test @DisplayName("Can query account info for client operator") void canQueryAccountInfoForClientOperator() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var info = new AccountInfoQuery() - .setAccountId(testEnv.operatorId) - .execute(testEnv.client); + var info = new AccountInfoQuery() + .setAccountId(testEnv.operatorId) + .execute(testEnv.client); - assertThat(info.accountId).isEqualTo(testEnv.operatorId); - assertThat(info.isDeleted).isFalse(); - assertThat(info.key).isEqualTo(testEnv.operatorKey); - assertThat(info.balance.toTinybars()).isGreaterThan(0); - assertThat(info.proxyAccountId).isNull(); - assertThat(info.proxyReceived).isEqualTo(Hbar.ZERO); + assertThat(info.accountId).isEqualTo(testEnv.operatorId); + assertThat(info.isDeleted).isFalse(); + assertThat(info.key).isEqualTo(testEnv.operatorKey); + assertThat(info.balance.toTinybars()).isGreaterThan(0); + assertThat(info.proxyAccountId).isNull(); + assertThat(info.proxyReceived).isEqualTo(Hbar.ZERO); - testEnv.close(); + } } @Test @DisplayName("Can get cost for account info query") void getCostAccountInfoForClientOperator() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var info = new AccountInfoQuery() - .setAccountId(testEnv.operatorId) - .setMaxQueryPayment(new Hbar(1)); + var info = new AccountInfoQuery() + .setAccountId(testEnv.operatorId) + .setMaxQueryPayment(new Hbar(1)); - var cost = info.getCost(testEnv.client); + var cost = info.getCost(testEnv.client); - var accInfo = info.setQueryPayment(cost).execute(testEnv.client); + var accInfo = info.setQueryPayment(cost).execute(testEnv.client); - assertThat(accInfo.accountId).isEqualTo(testEnv.operatorId); + assertThat(accInfo.accountId).isEqualTo(testEnv.operatorId); - testEnv.close(); + } } @Test @DisplayName("Can get cost for account info query, with a bix max") void getCostBigMaxAccountInfoForClientOperator() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var info = new AccountInfoQuery() - .setAccountId(testEnv.operatorId) - .setMaxQueryPayment(Hbar.MAX); + var info = new AccountInfoQuery() + .setAccountId(testEnv.operatorId) + .setMaxQueryPayment(Hbar.MAX); - var cost = info.getCost(testEnv.client); + var cost = info.getCost(testEnv.client); - var accInfo = info.setQueryPayment(cost).execute(testEnv.client); + var accInfo = info.setQueryPayment(cost).execute(testEnv.client); - assertThat(accInfo.accountId).isEqualTo(testEnv.operatorId); + assertThat(accInfo.accountId).isEqualTo(testEnv.operatorId); - testEnv.close(); + } } @Test @Disabled @DisplayName("Can get cost for account info query, with a small max") void getCostSmallMaxAccountInfoForClientOperator() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var info = new AccountInfoQuery() - .setAccountId(testEnv.operatorId) - .setMaxQueryPayment(Hbar.fromTinybars(1)); + var info = new AccountInfoQuery() + .setAccountId(testEnv.operatorId) + .setMaxQueryPayment(Hbar.fromTinybars(1)); - var cost = info.getCost(testEnv.client); + var cost = info.getCost(testEnv.client); - assertThatExceptionOfType(RuntimeException.class).isThrownBy(() -> { - info.execute(testEnv.client); - }).withMessage("com.hedera.hashgraph.sdk.MaxQueryPaymentExceededException: cost for AccountInfoQuery, of " + cost.toString() + ", without explicit payment is greater than the maximum allowed payment of 1 tℏ"); + assertThatExceptionOfType(RuntimeException.class).isThrownBy(() -> { + info.execute(testEnv.client); + }).withMessage("com.hedera.hashgraph.sdk.MaxQueryPaymentExceededException: cost for AccountInfoQuery, of " + cost.toString() + ", without explicit payment is greater than the maximum allowed payment of 1 tℏ"); - testEnv.close(); + } } @Test @DisplayName("Insufficient tx fee error.") void getCostInsufficientTxFeeAccountInfoForClientOperator() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var info = new AccountInfoQuery() - .setAccountId(testEnv.operatorId) - .setMaxQueryPayment(Hbar.fromTinybars(10000)); + var info = new AccountInfoQuery() + .setAccountId(testEnv.operatorId) + .setMaxQueryPayment(Hbar.fromTinybars(10000)); - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - info.setQueryPayment(Hbar.fromTinybars(1)).execute(testEnv.client); - }).satisfies(error -> assertThat(error.status.toString()).isEqualTo("INSUFFICIENT_TX_FEE")); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + info.setQueryPayment(Hbar.fromTinybars(1)).execute(testEnv.client); + }).satisfies(error -> assertThat(error.status.toString()).isEqualTo("INSUFFICIENT_TX_FEE")); - testEnv.close(); + } } @Test @DisplayName("AccountInfoFlow.verify functions") void accountInfoFlowVerifyFunctions() throws Throwable { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var newKey = PrivateKey.generateED25519(); - var newPublicKey = newKey.getPublicKey(); + var newKey = PrivateKey.generateED25519(); + var newPublicKey = newKey.getPublicKey(); - Transaction signedTx = new AccountCreateTransaction() - .setKey(newPublicKey) - .setInitialBalance(Hbar.fromTinybars(1000)) - .freezeWith(testEnv.client) - .signWithOperator(testEnv.client); + Transaction signedTx = new AccountCreateTransaction() + .setKey(newPublicKey) + .setInitialBalance(Hbar.fromTinybars(1000)) + .freezeWith(testEnv.client) + .signWithOperator(testEnv.client); - Transaction unsignedTx = new AccountCreateTransaction() - .setKey(newPublicKey) - .setInitialBalance(Hbar.fromTinybars(1000)) - .freezeWith(testEnv.client); + Transaction unsignedTx = new AccountCreateTransaction() + .setKey(newPublicKey) + .setInitialBalance(Hbar.fromTinybars(1000)) + .freezeWith(testEnv.client); - assertThat(AccountInfoFlow.verifyTransactionSignature(testEnv.client, testEnv.operatorId, signedTx)).isTrue(); - assertThat(AccountInfoFlow.verifyTransactionSignature(testEnv.client, testEnv.operatorId, unsignedTx)).isFalse(); + assertThat(AccountInfoFlow.verifyTransactionSignature(testEnv.client, testEnv.operatorId, signedTx)).isTrue(); + assertThat(AccountInfoFlow.verifyTransactionSignature(testEnv.client, testEnv.operatorId, unsignedTx)).isFalse(); - testEnv.close(); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountRecordsIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountRecordsIntegrationTest.java index 16cd27d6d..9dc2a4697 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountRecordsIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountRecordsIntegrationTest.java @@ -35,36 +35,36 @@ class AccountRecordsIntegrationTest { @Test @DisplayName("Can query account records") void canQueryAccountRecords() throws Exception { - var testEnv = new IntegrationTestEnv(1); - var key = PrivateKey.generateED25519(); + try(var testEnv = new IntegrationTestEnv(1)){ + var key = PrivateKey.generateED25519(); - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - new TransferTransaction() - .addHbarTransfer(testEnv.operatorId, new Hbar(1).negated()) - .addHbarTransfer(accountId, new Hbar(1)) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TransferTransaction() + .addHbarTransfer(testEnv.operatorId, new Hbar(1).negated()) + .addHbarTransfer(accountId, new Hbar(1)) + .execute(testEnv.client) + .getReceipt(testEnv.client); - new TransferTransaction() - .addHbarTransfer(testEnv.operatorId, new Hbar(1)) - .addHbarTransfer(accountId, new Hbar(1).negated()) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TransferTransaction() + .addHbarTransfer(testEnv.operatorId, new Hbar(1)) + .addHbarTransfer(accountId, new Hbar(1).negated()) + .freezeWith(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); - var records = new AccountRecordsQuery() - .setAccountId(testEnv.operatorId) - .execute(testEnv.client); + var records = new AccountRecordsQuery() + .setAccountId(testEnv.operatorId) + .execute(testEnv.client); - assertThat(records.isEmpty()).isFalse(); + assertThat(records.isEmpty()).isFalse(); - testEnv.close(accountId, key); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountStakersIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountStakersIntegrationTest.java index c400f5504..222b6b5a7 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountStakersIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountStakersIntegrationTest.java @@ -32,15 +32,15 @@ class AccountStakersIntegrationTest { @Test @DisplayName("Cannot query account stakers since it is not supported") void cannotQueryAccountStakersSinceItIsNotSupported() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new AccountStakersQuery() - .setAccountId(testEnv.operatorId) - .setMaxQueryPayment(new Hbar(1)) - .execute(testEnv.client); - }).withMessageContaining(Status.NOT_SUPPORTED.toString()); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new AccountStakersQuery() + .setAccountId(testEnv.operatorId) + .setMaxQueryPayment(new Hbar(1)) + .execute(testEnv.client); + }).withMessageContaining(Status.NOT_SUPPORTED.toString()); - testEnv.close(); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountUpdateIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountUpdateIntegrationTest.java index 5db7a50a8..ad0a96b10 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountUpdateIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/AccountUpdateIntegrationTest.java @@ -40,64 +40,64 @@ class AccountUpdateIntegrationTest { @Test @DisplayName("Can update account with a new key") void canUpdateAccountWithNewKey() throws Exception { - var testEnv = new IntegrationTestEnv(1); - - var key1 = PrivateKey.generateED25519(); - var key2 = PrivateKey.generateED25519(); - - var response = new AccountCreateTransaction() - .setKey(key1) - .execute(testEnv.client); - - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - - @Var var info = new AccountInfoQuery() - .setAccountId(accountId) - .execute(testEnv.client); - - assertThat(info.accountId).isEqualTo(accountId); - assertThat(info.isDeleted).isFalse(); - assertThat(info.key.toString()).isEqualTo(key1.getPublicKey().toString()); - assertThat(info.balance).isEqualTo(new Hbar(0)); - assertThat(info.autoRenewPeriod).isEqualTo(Duration.ofDays(90)); - assertThat(info.proxyAccountId).isNull(); - assertThat(info.proxyReceived).isEqualTo(Hbar.ZERO); - - new AccountUpdateTransaction() - .setAccountId(accountId) - .setKey(key2.getPublicKey()) - .freezeWith(testEnv.client) - .sign(key1) - .sign(key2) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - info = new AccountInfoQuery() - .setAccountId(accountId) - .execute(testEnv.client); - - assertThat(info.accountId).isEqualTo(accountId); - assertThat(info.isDeleted).isFalse(); - assertThat(info.key.toString()).isEqualTo(key2.getPublicKey().toString()); - assertThat(info.balance).isEqualTo(new Hbar(0)); - assertThat(info.autoRenewPeriod).isEqualTo(Duration.ofDays(90)); - assertThat(info.proxyAccountId).isNull(); - assertThat(info.proxyReceived).isEqualTo(Hbar.ZERO); - - testEnv.close(accountId, key2); + try(var testEnv = new IntegrationTestEnv(1)){ + + var key1 = PrivateKey.generateED25519(); + var key2 = PrivateKey.generateED25519(); + + var response = new AccountCreateTransaction() + .setKey(key1) + .execute(testEnv.client); + + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + + @Var var info = new AccountInfoQuery() + .setAccountId(accountId) + .execute(testEnv.client); + + assertThat(info.accountId).isEqualTo(accountId); + assertThat(info.isDeleted).isFalse(); + assertThat(info.key.toString()).isEqualTo(key1.getPublicKey().toString()); + assertThat(info.balance).isEqualTo(new Hbar(0)); + assertThat(info.autoRenewPeriod).isEqualTo(Duration.ofDays(90)); + assertThat(info.proxyAccountId).isNull(); + assertThat(info.proxyReceived).isEqualTo(Hbar.ZERO); + + new AccountUpdateTransaction() + .setAccountId(accountId) + .setKey(key2.getPublicKey()) + .freezeWith(testEnv.client) + .sign(key1) + .sign(key2) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + info = new AccountInfoQuery() + .setAccountId(accountId) + .execute(testEnv.client); + + assertThat(info.accountId).isEqualTo(accountId); + assertThat(info.isDeleted).isFalse(); + assertThat(info.key.toString()).isEqualTo(key2.getPublicKey().toString()); + assertThat(info.balance).isEqualTo(new Hbar(0)); + assertThat(info.autoRenewPeriod).isEqualTo(Duration.ofDays(90)); + assertThat(info.proxyAccountId).isNull(); + assertThat(info.proxyReceived).isEqualTo(Hbar.ZERO); + + } } @Test @DisplayName("Cannot update account when account ID is not set") void cannotUpdateAccountWhenAccountIdIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new AccountUpdateTransaction() - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.ACCOUNT_ID_DOES_NOT_EXIST.toString()); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new AccountUpdateTransaction() + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.ACCOUNT_ID_DOES_NOT_EXIST.toString()); - testEnv.close(); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ClientIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ClientIntegrationTest.java index 8cb6bc14e..aeb5c1b6f 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ClientIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ClientIntegrationTest.java @@ -40,37 +40,37 @@ void testReplaceNodes() throws Exception { network.put("0.testnet.hedera.com:50211", new AccountId(3)); network.put("1.testnet.hedera.com:50211", new AccountId(4)); - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - testEnv.client - .setMaxQueryPayment(new Hbar(2)) - .setRequestTimeout(Duration.ofMinutes(2)) - .setNetwork(network); + testEnv.client + .setMaxQueryPayment(new Hbar(2)) + .setRequestTimeout(Duration.ofMinutes(2)) + .setNetwork(network); - assertThat(testEnv.operatorId).isNotNull(); + assertThat(testEnv.operatorId).isNotNull(); - // Execute two simple queries so we create a channel for each network node. - new AccountBalanceQuery() - .setAccountId(new AccountId(3)) - .execute(testEnv.client); + // Execute two simple queries so we create a channel for each network node. + new AccountBalanceQuery() + .setAccountId(new AccountId(3)) + .execute(testEnv.client); - new AccountBalanceQuery() - .setAccountId(new AccountId(3)) - .execute(testEnv.client); + new AccountBalanceQuery() + .setAccountId(new AccountId(3)) + .execute(testEnv.client); - network = new HashMap<>(); - network.put("1.testnet.hedera.com:50211", new AccountId(4)); - network.put("2.testnet.hedera.com:50211", new AccountId(5)); + network = new HashMap<>(); + network.put("1.testnet.hedera.com:50211", new AccountId(4)); + network.put("2.testnet.hedera.com:50211", new AccountId(5)); - testEnv.client.setNetwork(network); + testEnv.client.setNetwork(network); - network = new HashMap<>(); - network.put("35.186.191.247:50211", new AccountId(4)); - network.put("35.192.2.25:50211", new AccountId(5)); + network = new HashMap<>(); + network.put("35.186.191.247:50211", new AccountId(4)); + network.put("35.192.2.25:50211", new AccountId(5)); - testEnv.client.setNetwork(network); + testEnv.client.setNetwork(network); - testEnv.close(); + } } @Test @@ -89,131 +89,131 @@ void transactionIdNetworkIsVerified() { @Test @DisplayName("`setMaxNodesPerTransaction()`") void testMaxNodesPerTransaction() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - testEnv.client.setMaxNodesPerTransaction(1); + testEnv.client.setMaxNodesPerTransaction(1); - var transaction = new AccountDeleteTransaction() - .setAccountId(testEnv.operatorId) - .freezeWith(testEnv.client); + var transaction = new AccountDeleteTransaction() + .setAccountId(testEnv.operatorId) + .freezeWith(testEnv.client); - assertThat(transaction.getNodeAccountIds()).isNotNull(); - assertThat(transaction.getNodeAccountIds().size()).isEqualTo(1); + assertThat(transaction.getNodeAccountIds()).isNotNull(); + assertThat(transaction.getNodeAccountIds().size()).isEqualTo(1); - testEnv.close(); + } } @Test void ping() throws Exception { - var testEnv = new IntegrationTestEnv(1); - var network = testEnv.client.getNetwork(); - var nodes = new ArrayList<>(network.values()); + try(var testEnv = new IntegrationTestEnv(1)){ + var network = testEnv.client.getNetwork(); + var nodes = new ArrayList<>(network.values()); - assertThat(nodes.isEmpty()).isFalse(); + assertThat(nodes.isEmpty()).isFalse(); - var node = nodes.get(0); + var node = nodes.get(0); - testEnv.client.setMaxNodeAttempts(1); - testEnv.client.ping(node); - testEnv.close(); + testEnv.client.setMaxNodeAttempts(1); + testEnv.client.ping(node); + } } @Test void pingAll() throws Exception { - var testEnv = new IntegrationTestEnv(); + try(var testEnv = new IntegrationTestEnv()){ - testEnv.client.setMaxNodeAttempts(1); - testEnv.client.pingAll(); + testEnv.client.setMaxNodeAttempts(1); + testEnv.client.pingAll(); - var network = testEnv.client.getNetwork(); - var nodes = new ArrayList<>(network.values()); + var network = testEnv.client.getNetwork(); + var nodes = new ArrayList<>(network.values()); - assertThat(nodes.isEmpty()).isFalse(); + assertThat(nodes.isEmpty()).isFalse(); - var node = nodes.get(0); + var node = nodes.get(0); - new AccountBalanceQuery() - .setAccountId(node) - .execute(testEnv.client); + new AccountBalanceQuery() + .setAccountId(node) + .execute(testEnv.client); - testEnv.close(); + } } @Test void pingAllBadNetwork() throws Exception { - var testEnv = new IntegrationTestEnv(3); + try(var testEnv = new IntegrationTestEnv(3)){ - // Skip if using local node. - // Note: this check should be removed once the local node is supporting multiple nodes. - testEnv.assumeNotLocalNode(); + // Skip if using local node. + // Note: this check should be removed once the local node is supporting multiple nodes. + testEnv.assumeNotLocalNode(); - testEnv.client.setMaxNodeAttempts(1); - testEnv.client.setMaxAttempts(1); - testEnv.client.setMaxNodesPerTransaction(2); + testEnv.client.setMaxNodeAttempts(1); + testEnv.client.setMaxAttempts(1); + testEnv.client.setMaxNodesPerTransaction(2); - var network = testEnv.client.getNetwork(); + var network = testEnv.client.getNetwork(); - var entries = new ArrayList<>(network.entrySet()); - assertThat(entries.size()).isGreaterThan(1); + var entries = new ArrayList<>(network.entrySet()); + assertThat(entries.size()).isGreaterThan(1); - network.clear(); - network.put("in-process:name", entries.get(0).getValue()); - network.put(entries.get(1).getKey(), entries.get(1).getValue()); + network.clear(); + network.put("in-process:name", entries.get(0).getValue()); + network.put(entries.get(1).getKey(), entries.get(1).getValue()); - testEnv.client.setNetwork(network); + testEnv.client.setNetwork(network); - assertThatExceptionOfType(MaxAttemptsExceededException.class).isThrownBy(() -> { - testEnv.client.pingAll(); - }).withMessageContaining("exceeded maximum attempts"); + assertThatExceptionOfType(MaxAttemptsExceededException.class).isThrownBy(() -> { + testEnv.client.pingAll(); + }).withMessageContaining("exceeded maximum attempts"); - var nodes = new ArrayList<>(testEnv.client.getNetwork().values()); - assertThat(nodes.isEmpty()).isFalse(); + var nodes = new ArrayList<>(testEnv.client.getNetwork().values()); + assertThat(nodes.isEmpty()).isFalse(); - var node = nodes.get(0); + var node = nodes.get(0); - new AccountBalanceQuery() - .setAccountId(node) - .execute(testEnv.client); + new AccountBalanceQuery() + .setAccountId(node) + .execute(testEnv.client); - assertThat(testEnv.client.getNetwork().values().size()).isEqualTo(1); - - testEnv.close(); + assertThat(testEnv.client.getNetwork().values().size()).isEqualTo(1); + } + } @Test void pingAsync() throws Exception { - var testEnv = new IntegrationTestEnv(1); - var network = testEnv.client.getNetwork(); - var nodes = new ArrayList<>(network.values()); + try(var testEnv = new IntegrationTestEnv(1)){ + var network = testEnv.client.getNetwork(); + var nodes = new ArrayList<>(network.values()); - assertThat(nodes.isEmpty()).isFalse(); + assertThat(nodes.isEmpty()).isFalse(); - var node = nodes.get(0); + var node = nodes.get(0); - testEnv.client.setMaxNodeAttempts(1); - testEnv.client.pingAsync(node).get(); - testEnv.close(); + testEnv.client.setMaxNodeAttempts(1); + testEnv.client.pingAsync(node).get(); + } } @Test void pingAllAsync() throws Exception { - var testEnv = new IntegrationTestEnv(); - - testEnv.client.setMaxNodeAttempts(1); - testEnv.client.pingAllAsync().get(); + try(var testEnv = new IntegrationTestEnv()){ - var network = testEnv.client.getNetwork(); - var nodes = new ArrayList<>(network.values()); + testEnv.client.setMaxNodeAttempts(1); + testEnv.client.pingAllAsync().get(); - assertThat(nodes.isEmpty()).isFalse(); + var network = testEnv.client.getNetwork(); + var nodes = new ArrayList<>(network.values()); - var node = nodes.get(0); + assertThat(nodes.isEmpty()).isFalse(); - new AccountBalanceQuery() - .setAccountId(node) - .execute(testEnv.client); + var node = nodes.get(0); - testEnv.close(); + new AccountBalanceQuery() + .setAccountId(node) + .execute(testEnv.client); + + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractBytecodeIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractBytecodeIntegrationTest.java index 0ea101e7d..3877f264a 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractBytecodeIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractBytecodeIntegrationTest.java @@ -40,194 +40,194 @@ import static org.assertj.core.api.Assertions.assertThatExceptionOfType; public class ContractBytecodeIntegrationTest { - private static final String SMART_CONTRACT_BYTECODE = "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"; + private static final String SMART_CONTRACT_BYTECODE = "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"; - @Test - @DisplayName("Can query contract bytecode") - void canQueryContractBytecode() throws Exception { - var testEnv = new IntegrationTestEnv(1); + @Test + @DisplayName("Can query contract bytecode") + void canQueryContractBytecode() throws Exception { + try (var testEnv = new IntegrationTestEnv(1)) { - @Var var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); + @Var var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - response = new ContractCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setGas(200000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setBytecodeFileId(fileId) - .setContractMemo("[e2e::ContractCreateTransaction]") - .execute(testEnv.client); + response = new ContractCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setGas(200000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setBytecodeFileId(fileId) + .setContractMemo("[e2e::ContractCreateTransaction]") + .execute(testEnv.client); - var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); - - var bytecode = new ContractByteCodeQuery() - .setContractId(contractId) - .execute(testEnv.client); - - assertThat(bytecode.size()).isEqualTo(798); - - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(); - } - - @Test - @DisplayName("Can get cost, even with a big max") - void getCostBigMaxQueryContractBytecode() throws Exception { - var testEnv = new IntegrationTestEnv(1); - - @Var var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); - - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - - response = new ContractCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setGas(200000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setBytecodeFileId(fileId) - .setContractMemo("[e2e::ContractCreateTransaction]") - .execute(testEnv.client); - - var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); - - var bytecodeQuery = new ContractByteCodeQuery() - .setContractId(contractId) - .setMaxQueryPayment(new Hbar(1000)); - - var cost = bytecodeQuery.getCost(testEnv.client); - - var bytecode = bytecodeQuery.setQueryPayment(cost).execute(testEnv.client); - - assertThat(bytecode.size()).isEqualTo(798); - - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(); - } - - @Test - @DisplayName("Error, max is smaller than set payment.") - void getCostSmallMaxQueryContractBytecode() throws Exception { - var testEnv = new IntegrationTestEnv(1); - - @Var var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); - - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - - response = new ContractCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setGas(200000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setBytecodeFileId(fileId) - .setContractMemo("[e2e::ContractCreateTransaction]") - .execute(testEnv.client); - - var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); - - var bytecodeQuery = new ContractByteCodeQuery() - .setContractId(contractId) - .setMaxQueryPayment(Hbar.fromTinybars(1)); - - assertThatExceptionOfType(MaxQueryPaymentExceededException.class).isThrownBy(() -> { - bytecodeQuery.execute(testEnv.client); - }); - - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(); - } - - @Test - @DisplayName("Insufficient tx fee error.") - void getCostInsufficientTxFeeQueryContractBytecode() throws Exception { - var testEnv = new IntegrationTestEnv(1); - - @Var var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); - - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - - response = new ContractCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setGas(200000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setBytecodeFileId(fileId) - .setContractMemo("[e2e::ContractCreateTransaction]") - .execute(testEnv.client); - - var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); - - var bytecodeQuery = new ContractByteCodeQuery() - .setContractId(contractId) - .setMaxQueryPayment(new Hbar(100)); - - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - bytecodeQuery.setQueryPayment(Hbar.fromTinybars(1)).execute(testEnv.client); - }).satisfies(error -> assertThat(error.status.toString()).isEqualTo("INSUFFICIENT_TX_FEE")); + var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); + + var bytecode = new ContractByteCodeQuery() + .setContractId(contractId) + .execute(testEnv.client); + + assertThat(bytecode.size()).isEqualTo(798); + + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .setContractId(contractId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } + } + + @Test + @DisplayName("Can get cost, even with a big max") + void getCostBigMaxQueryContractBytecode() throws Exception { + try (var testEnv = new IntegrationTestEnv(1)) { + + @Var var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); + + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + + response = new ContractCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setGas(200000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setBytecodeFileId(fileId) + .setContractMemo("[e2e::ContractCreateTransaction]") + .execute(testEnv.client); + + var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); + + var bytecodeQuery = new ContractByteCodeQuery() + .setContractId(contractId) + .setMaxQueryPayment(new Hbar(1000)); + + var cost = bytecodeQuery.getCost(testEnv.client); + + var bytecode = bytecodeQuery.setQueryPayment(cost).execute(testEnv.client); + + assertThat(bytecode.size()).isEqualTo(798); + + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .setContractId(contractId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } + } + + @Test + @DisplayName("Error, max is smaller than set payment.") + void getCostSmallMaxQueryContractBytecode() throws Exception { + try (var testEnv = new IntegrationTestEnv(1)) { + + @Var var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); + + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + + response = new ContractCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setGas(200000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setBytecodeFileId(fileId) + .setContractMemo("[e2e::ContractCreateTransaction]") + .execute(testEnv.client); + + var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); + + var bytecodeQuery = new ContractByteCodeQuery() + .setContractId(contractId) + .setMaxQueryPayment(Hbar.fromTinybars(1)); + + assertThatExceptionOfType(MaxQueryPaymentExceededException.class).isThrownBy(() -> { + bytecodeQuery.execute(testEnv.client); + }); + + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .setContractId(contractId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } + } + + @Test + @DisplayName("Insufficient tx fee error.") + void getCostInsufficientTxFeeQueryContractBytecode() throws Exception { + try (var testEnv = new IntegrationTestEnv(1)) { + + @Var var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); + + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + + response = new ContractCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setGas(200000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setBytecodeFileId(fileId) + .setContractMemo("[e2e::ContractCreateTransaction]") + .execute(testEnv.client); + + var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); + + var bytecodeQuery = new ContractByteCodeQuery() + .setContractId(contractId) + .setMaxQueryPayment(new Hbar(100)); + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + bytecodeQuery.setQueryPayment(Hbar.fromTinybars(1)).execute(testEnv.client); + }).satisfies(error -> assertThat(error.status.toString()).isEqualTo("INSUFFICIENT_TX_FEE")); - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(); - } - - @Test - @DisplayName("Cannot query contract bytecode when contract ID is not set") - void cannotQueryContractBytecodeWhenContractIDIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1); - - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new ContractByteCodeQuery() - .execute(testEnv.client); - }).withMessageContaining(Status.INVALID_CONTRACT_ID.toString()); - - testEnv.close(); - } + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .setContractId(contractId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } + } + + @Test + @DisplayName("Cannot query contract bytecode when contract ID is not set") + void cannotQueryContractBytecodeWhenContractIDIsNotSet() throws Exception { + try (var testEnv = new IntegrationTestEnv(1)) { + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new ContractByteCodeQuery() + .execute(testEnv.client); + }).withMessageContaining(Status.INVALID_CONTRACT_ID.toString()); + + } + } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractCallIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractCallIntegrationTest.java index 757c3584b..a9bc43d95 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractCallIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractCallIntegrationTest.java @@ -44,321 +44,322 @@ public class ContractCallIntegrationTest { @Test @DisplayName("Can call contract function") void canCallContractFunction() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - @Var var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); + @Var + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - response = new ContractCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setGas(200000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setBytecodeFileId(fileId) - .setContractMemo("[e2e::ContractCreateTransaction]") - .execute(testEnv.client); + response = new ContractCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setGas(200000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setBytecodeFileId(fileId) + .setContractMemo("[e2e::ContractCreateTransaction]") + .execute(testEnv.client); - var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); + var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); - var callQuery = new ContractCallQuery() - .setContractId(contractId) - .setGas(200000) - .setFunction("getMessage") - .setQueryPayment(new Hbar(1)); + var callQuery = new ContractCallQuery() + .setContractId(contractId) + .setGas(200000) + .setFunction("getMessage") + .setQueryPayment(new Hbar(1)); - var result = callQuery - .execute(testEnv.client); + var result = callQuery + .execute(testEnv.client); - assertThat(result.getString(0)).isEqualTo("Hello from Hedera."); + assertThat(result.getString(0)).isEqualTo("Hello from Hedera."); - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .setContractId(contractId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } @Test @DisplayName("Cannot call contract function when contract function is not set") void cannotCallContractFunctionWhenContractFunctionIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + + var contractId = Objects.requireNonNull( + new ContractCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setGas(200000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setBytecodeFileId(fileId) + .setContractMemo("[e2e::ContractCreateTransaction]") + .execute(testEnv.client) + .getReceipt(testEnv.client) + .contractId + ); + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new ContractCallQuery() + .setContractId(contractId) + .setGas(100000) + .execute(testEnv.client); + }).withMessageContaining(Status.CONTRACT_REVERT_EXECUTED.toString()); + + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .setContractId(contractId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - var contractId = Objects.requireNonNull( - new ContractCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setGas(200000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setBytecodeFileId(fileId) - .setContractMemo("[e2e::ContractCreateTransaction]") + new FileDeleteTransaction() + .setFileId(fileId) .execute(testEnv.client) - .getReceipt(testEnv.client) - .contractId - ); + .getReceipt(testEnv.client); + + } + } + + @Test + @DisplayName("Cannot call contract function when gas is not set") + void cannotCallContractFunctionWhenGasIsNotSet() throws Exception { + try (var testEnv = new IntegrationTestEnv(1)) { - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new ContractCallQuery() + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); + + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + + var contractId = Objects.requireNonNull( + new ContractCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setGas(200000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setBytecodeFileId(fileId) + .setContractMemo("[e2e::ContractCreateTransaction]") + .execute(testEnv.client) + .getReceipt(testEnv.client) + .contractId + ); + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new ContractCallQuery() + .setContractId(contractId) + .setFunction("getMessage") + .execute(testEnv.client); + }).withMessageContaining(Status.INSUFFICIENT_GAS.toString()); + + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) .setContractId(contractId) - .setGas(100000) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } + } + + @Test + @DisplayName("Cannot call contract function when contract ID is not set") + void cannotCallContractFunctionWhenContractIDIsNotSet() throws Exception { + try (var testEnv = new IntegrationTestEnv(1)) { + + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) .execute(testEnv.client); - }).withMessageContaining(Status.CONTRACT_REVERT_EXECUTED.toString()); - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + + var contractId = Objects.requireNonNull( + new ContractCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setGas(200000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setBytecodeFileId(fileId) + .setContractMemo("[e2e::ContractCreateTransaction]") + .execute(testEnv.client) + .getReceipt(testEnv.client) + .contractId + ); + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new ContractCallQuery() + .setGas(100000) + .setFunction("getMessage") + .execute(testEnv.client); + }).withMessageContaining(Status.INVALID_CONTRACT_ID.toString()); + + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .setContractId(contractId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } @Test - @DisplayName("Cannot call contract function when gas is not set") - void cannotCallContractFunctionWhenGasIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1); + @DisplayName("Can get cost, even with a big max") + void getCostBigMaxContractCallFunction() throws Exception { + try (var testEnv = new IntegrationTestEnv(1)) { - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); + @Var var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - var contractId = Objects.requireNonNull( - new ContractCreateTransaction() + response = new ContractCreateTransaction() .setAdminKey(testEnv.operatorKey) .setGas(200000) .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) .setBytecodeFileId(fileId) .setContractMemo("[e2e::ContractCreateTransaction]") - .execute(testEnv.client) - .getReceipt(testEnv.client) - .contractId - ); - - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new ContractCallQuery() - .setContractId(contractId) - .setFunction("getMessage") .execute(testEnv.client); - }).withMessageContaining(Status.INSUFFICIENT_GAS.toString()); - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); + + var callQuery = new ContractCallQuery() + .setContractId(contractId) + .setGas(100000) + .setFunction("getMessage") + .setQueryPayment(new Hbar(1)); + + var result = callQuery + .execute(testEnv.client); + + assertThat(result.getString(0)).isEqualTo("Hello from Hedera."); - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .setContractId(contractId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } @Test - @DisplayName("Cannot call contract function when contract ID is not set") - void cannotCallContractFunctionWhenContractIDIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1); + @DisplayName("Error, max is smaller than set payment.") + void getCostSmallMaxContractCallFunction() throws Exception { + try (var testEnv = new IntegrationTestEnv(1)) { - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); + @Var var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - var contractId = Objects.requireNonNull( - new ContractCreateTransaction() + response = new ContractCreateTransaction() .setAdminKey(testEnv.operatorKey) .setGas(200000) .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) .setBytecodeFileId(fileId) .setContractMemo("[e2e::ContractCreateTransaction]") - .execute(testEnv.client) - .getReceipt(testEnv.client) - .contractId - ); - - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new ContractCallQuery() - .setGas(100000) - .setFunction("getMessage") .execute(testEnv.client); - }).withMessageContaining(Status.INVALID_CONTRACT_ID.toString()); - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + var callQuery = new ContractCallQuery() + .setContractId(contractId) + .setGas(100000) + .setFunction("getMessage") + .setMaxQueryPayment(Hbar.fromTinybars(1)); - testEnv.close(); - } + assertThatExceptionOfType(MaxQueryPaymentExceededException.class).isThrownBy(() -> { + callQuery.execute(testEnv.client); + }); - @Test - @DisplayName("Can get cost, even with a big max") - void getCostBigMaxContractCallFunction() throws Exception { - var testEnv = new IntegrationTestEnv(1); + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .setContractId(contractId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - @Var var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + } + } - response = new ContractCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setGas(200000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setBytecodeFileId(fileId) - .setContractMemo("[e2e::ContractCreateTransaction]") - .execute(testEnv.client); + @Test + @DisplayName("Insufficient tx fee error.") + void getCostInsufficientTxFeeContractCallFunction() throws Exception { + try (var testEnv = new IntegrationTestEnv(1)) { - var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); + @Var var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); - var callQuery = new ContractCallQuery() - .setContractId(contractId) - .setGas(100000) - .setFunction("getMessage") - .setQueryPayment(new Hbar(1)); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - var result = callQuery - .execute(testEnv.client); + response = new ContractCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setGas(200000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setBytecodeFileId(fileId) + .setContractMemo("[e2e::ContractCreateTransaction]") + .execute(testEnv.client); - assertThat(result.getString(0)).isEqualTo("Hello from Hedera."); + var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + var callQuery = new ContractCallQuery() + .setContractId(contractId) + .setGas(100000) + .setFunction("getMessage") + .setMaxQueryPayment(new Hbar(100)); - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + callQuery.setQueryPayment(Hbar.fromTinybars(1)).execute(testEnv.client); + }).satisfies(error -> assertThat(error.status.toString()).isEqualTo("INSUFFICIENT_TX_FEE")); - testEnv.close(); - } + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .setContractId(contractId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - @Test - @DisplayName("Error, max is smaller than set payment.") - void getCostSmallMaxContractCallFunction() throws Exception { - var testEnv = new IntegrationTestEnv(1); - - @Var var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); - - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - - response = new ContractCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setGas(200000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setBytecodeFileId(fileId) - .setContractMemo("[e2e::ContractCreateTransaction]") - .execute(testEnv.client); - - var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); - - var callQuery = new ContractCallQuery() - .setContractId(contractId) - .setGas(100000) - .setFunction("getMessage") - .setMaxQueryPayment(Hbar.fromTinybars(1)); - - assertThatExceptionOfType(MaxQueryPaymentExceededException.class).isThrownBy(() -> { - callQuery.execute(testEnv.client); - }); - - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(); - } + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - @Test - @DisplayName("Insufficient tx fee error.") - void getCostInsufficientTxFeeContractCallFunction() throws Exception { - var testEnv = new IntegrationTestEnv(1); - - @Var var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); - - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - - response = new ContractCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setGas(200000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setBytecodeFileId(fileId) - .setContractMemo("[e2e::ContractCreateTransaction]") - .execute(testEnv.client); - - var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); - - var callQuery = new ContractCallQuery() - .setContractId(contractId) - .setGas(100000) - .setFunction("getMessage") - .setMaxQueryPayment(new Hbar(100)); - - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - callQuery.setQueryPayment(Hbar.fromTinybars(1)).execute(testEnv.client); - }).satisfies(error -> assertThat(error.status.toString()).isEqualTo("INSUFFICIENT_TX_FEE")); - - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractCreateFlowIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractCreateFlowIntegrationTest.java index 50580f7a3..14cf3231d 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractCreateFlowIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractCreateFlowIntegrationTest.java @@ -34,131 +34,131 @@ public class ContractCreateFlowIntegrationTest { @Test @DisplayName("Create contract with flow") void createContractWithFlow() throws Throwable { - var testEnv = new IntegrationTestEnv(1); - - var response = new ContractCreateFlow() - .setBytecode(SMART_CONTRACT_BYTECODE) - .setAdminKey(testEnv.operatorKey) - .setGas(200000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setContractMemo("[e2e::ContractCreateFlow]") - .execute(testEnv.client); - - var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); - - var receipt = new ContractExecuteTransaction() - .setContractId(contractId) - .setGas(100000) - .setFunction("setMessage", new ContractFunctionParameters().addString("new message")) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - assertThat(receipt.status).isEqualTo(Status.SUCCESS); - - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .setTransferAccountId(testEnv.operatorId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(); + try(var testEnv = new IntegrationTestEnv(1)){ + + var response = new ContractCreateFlow() + .setBytecode(SMART_CONTRACT_BYTECODE) + .setAdminKey(testEnv.operatorKey) + .setGas(200000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setContractMemo("[e2e::ContractCreateFlow]") + .execute(testEnv.client); + + var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); + + var receipt = new ContractExecuteTransaction() + .setContractId(contractId) + .setGas(100000) + .setFunction("setMessage", new ContractFunctionParameters().addString("new message")) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + assertThat(receipt.status).isEqualTo(Status.SUCCESS); + + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .setContractId(contractId) + .setTransferAccountId(testEnv.operatorId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } @Test @DisplayName("Create contract with flow without signing") void createContractWithFlowWithoutSigning() throws Throwable { - var testEnv = new IntegrationTestEnv(1); - var adminKey = PrivateKey.generateED25519(); - - assertThatThrownBy(() -> new ContractCreateFlow() - .setBytecode(SMART_CONTRACT_BYTECODE) - .setAdminKey(adminKey) - .setGas(100000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setContractMemo("[e2e::ContractCreateFlow]") - .execute(testEnv.client)) - .isInstanceOf(RuntimeException.class) - .hasMessageEndingWith("raised status INVALID_SIGNATURE"); - - testEnv.close(); + try(var testEnv = new IntegrationTestEnv(1)){ + var adminKey = PrivateKey.generateED25519(); + + assertThatThrownBy(() -> new ContractCreateFlow() + .setBytecode(SMART_CONTRACT_BYTECODE) + .setAdminKey(adminKey) + .setGas(100000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setContractMemo("[e2e::ContractCreateFlow]") + .execute(testEnv.client)) + .isInstanceOf(RuntimeException.class) + .hasMessageEndingWith("raised status INVALID_SIGNATURE"); + + } } @Test @DisplayName("Create contract with flow and sign with private key") void createContractWithFlowPrivateKeySign() throws Throwable { - var testEnv = new IntegrationTestEnv(1); - var adminKey = PrivateKey.generateED25519(); - - var response = new ContractCreateFlow() - .setBytecode(SMART_CONTRACT_BYTECODE) - .setAdminKey(testEnv.operatorKey) - .setGas(200000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setContractMemo("[e2e::ContractCreateFlow]") - .freezeWith(testEnv.client) - .sign(adminKey) - .execute(testEnv.client); - - var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); - - var receipt = new ContractExecuteTransaction() - .setContractId(contractId) - .setGas(100000) - .setFunction("setMessage", new ContractFunctionParameters().addString("new message")) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - assertThat(receipt.status).isEqualTo(Status.SUCCESS); - - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .setTransferAccountId(testEnv.operatorId) - .freezeWith(testEnv.client) - .sign(adminKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(); + try(var testEnv = new IntegrationTestEnv(1)){ + var adminKey = PrivateKey.generateED25519(); + + var response = new ContractCreateFlow() + .setBytecode(SMART_CONTRACT_BYTECODE) + .setAdminKey(testEnv.operatorKey) + .setGas(200000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setContractMemo("[e2e::ContractCreateFlow]") + .freezeWith(testEnv.client) + .sign(adminKey) + .execute(testEnv.client); + + var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); + + var receipt = new ContractExecuteTransaction() + .setContractId(contractId) + .setGas(100000) + .setFunction("setMessage", new ContractFunctionParameters().addString("new message")) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + assertThat(receipt.status).isEqualTo(Status.SUCCESS); + + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .setContractId(contractId) + .setTransferAccountId(testEnv.operatorId) + .freezeWith(testEnv.client) + .sign(adminKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } @Test @DisplayName("Create contract with flow and sign with public key and transaction signer") void createContractWithFlowPublicKeySign() throws Throwable { - var testEnv = new IntegrationTestEnv(1); - var adminKey = PrivateKey.generateED25519(); - - var response = new ContractCreateFlow() - .setBytecode(SMART_CONTRACT_BYTECODE) - .setAdminKey(testEnv.operatorKey) - .setGas(200000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setContractMemo("[e2e::ContractCreateFlow]") - .freezeWith(testEnv.client) - .signWith(adminKey.getPublicKey(), adminKey::sign) - .execute(testEnv.client); - - var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); - - var receipt = new ContractExecuteTransaction() - .setContractId(contractId) - .setGas(100000) - .setFunction("setMessage", new ContractFunctionParameters().addString("new message")) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - assertThat(receipt.status).isEqualTo(Status.SUCCESS); - - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .setTransferAccountId(testEnv.operatorId) - .freezeWith(testEnv.client) - .sign(adminKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(); + try(var testEnv = new IntegrationTestEnv(1)){ + var adminKey = PrivateKey.generateED25519(); + + var response = new ContractCreateFlow() + .setBytecode(SMART_CONTRACT_BYTECODE) + .setAdminKey(testEnv.operatorKey) + .setGas(200000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setContractMemo("[e2e::ContractCreateFlow]") + .freezeWith(testEnv.client) + .signWith(adminKey.getPublicKey(), adminKey::sign) + .execute(testEnv.client); + + var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); + + var receipt = new ContractExecuteTransaction() + .setContractId(contractId) + .setGas(100000) + .setFunction("setMessage", new ContractFunctionParameters().addString("new message")) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + assertThat(receipt.status).isEqualTo(Status.SUCCESS); + + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .setContractId(contractId) + .setTransferAccountId(testEnv.operatorId) + .freezeWith(testEnv.client) + .sign(adminKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractCreateIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractCreateIntegrationTest.java index d667264fa..f255e381f 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractCreateIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractCreateIntegrationTest.java @@ -44,163 +44,163 @@ public class ContractCreateIntegrationTest { @Test @DisplayName("Can create contract") void canCreateContract() throws Exception { - var testEnv = new IntegrationTestEnv(1); - - @Var var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); - - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - - response = new ContractCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setGas(200000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setBytecodeFileId(fileId) - .setContractMemo("[e2e::ContractCreateTransaction]") - .execute(testEnv.client); - - var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); - - var info = new ContractInfoQuery() - .setContractId(contractId) - .execute(testEnv.client); - - assertThat(info.contractId).isEqualTo(contractId); - assertThat(info.accountId).isNotNull(); - assertThat(Objects.requireNonNull(info.accountId).toString()).isEqualTo(Objects.requireNonNull(contractId).toString()); - assertThat(info.adminKey).isNotNull(); - assertThat(Objects.requireNonNull(info.adminKey).toString()).isEqualTo(Objects.requireNonNull(testEnv.operatorKey).toString()); - assertThat(info.storage).isEqualTo(128); - assertThat(info.contractMemo).isEqualTo("[e2e::ContractCreateTransaction]"); - - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(); - } + try (var testEnv = new IntegrationTestEnv(1)) { - @Test - @DisplayName("Can create contract with no admin key") - void canCreateContractWithNoAdminKey() throws Exception { - var testEnv = new IntegrationTestEnv(1); + @Var var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); - @Var var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + response = new ContractCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setGas(200000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setBytecodeFileId(fileId) + .setContractMemo("[e2e::ContractCreateTransaction]") + .execute(testEnv.client); - response = new ContractCreateTransaction() - .setGas(200000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setBytecodeFileId(fileId) - .setContractMemo("[e2e::ContractCreateTransaction]") - .execute(testEnv.client); + var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); - var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); + var info = new ContractInfoQuery() + .setContractId(contractId) + .execute(testEnv.client); - var info = new ContractInfoQuery() - .setContractId(contractId) - .execute(testEnv.client); + assertThat(info.contractId).isEqualTo(contractId); + assertThat(info.accountId).isNotNull(); + assertThat(Objects.requireNonNull(info.accountId).toString()).isEqualTo(Objects.requireNonNull(contractId).toString()); + assertThat(info.adminKey).isNotNull(); + assertThat(Objects.requireNonNull(info.adminKey).toString()).isEqualTo(Objects.requireNonNull(testEnv.operatorKey).toString()); + assertThat(info.storage).isEqualTo(128); + assertThat(info.contractMemo).isEqualTo("[e2e::ContractCreateTransaction]"); - assertThat(info.contractId).isEqualTo(contractId); - assertThat(info.accountId).isNotNull(); - assertThat(Objects.requireNonNull(info.accountId).toString()).isEqualTo(Objects.requireNonNull(contractId).toString()); - assertThat(info.adminKey).isNotNull(); - // assertEquals(info.adminKey, contractId); - assertThat(info.storage).isEqualTo(128); - assertThat(info.contractMemo).isEqualTo("[e2e::ContractCreateTransaction]"); + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .setContractId(contractId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } @Test - @DisplayName("Cannot create contract when gas is not set") - void cannotCreateContractWhenGasIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1); + @DisplayName("Can create contract with no admin key") + void canCreateContractWithNoAdminKey() throws Exception { + try (var testEnv = new IntegrationTestEnv(1)) { - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); + @Var var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new ContractCreateTransaction() - .setAdminKey(testEnv.operatorKey) + response = new ContractCreateTransaction() + .setGas(200000) .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) .setBytecodeFileId(fileId) .setContractMemo("[e2e::ContractCreateTransaction]") - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INSUFFICIENT_GAS.toString()); + .execute(testEnv.client); + + var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + var info = new ContractInfoQuery() + .setContractId(contractId) + .execute(testEnv.client); - testEnv.close(); + assertThat(info.contractId).isEqualTo(contractId); + assertThat(info.accountId).isNotNull(); + assertThat(Objects.requireNonNull(info.accountId).toString()).isEqualTo(Objects.requireNonNull(contractId).toString()); + assertThat(info.adminKey).isNotNull(); + // assertEquals(info.adminKey, contractId); + assertThat(info.storage).isEqualTo(128); + assertThat(info.contractMemo).isEqualTo("[e2e::ContractCreateTransaction]"); + } } @Test - @DisplayName("Cannot create contract when constructor parameters are not set") - void cannotCreateContractWhenConstructorParametersAreNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1); + @DisplayName("Cannot create contract when gas is not set") + void cannotCreateContractWhenGasIsNotSet() throws Exception { + try (var testEnv = new IntegrationTestEnv(1)) { + + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); + + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new ContractCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setBytecodeFileId(fileId) + .setContractMemo("[e2e::ContractCreateTransaction]") + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INSUFFICIENT_GAS.toString()); + + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); + } - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + } - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new ContractCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setGas(100000) - .setBytecodeFileId(fileId) - .setContractMemo("[e2e::ContractCreateTransaction]") + @Test + @DisplayName("Cannot create contract when constructor parameters are not set") + void cannotCreateContractWhenConstructorParametersAreNotSet() throws Exception { + try (var testEnv = new IntegrationTestEnv(1)) { + + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); + + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new ContractCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setGas(100000) + .setBytecodeFileId(fileId) + .setContractMemo("[e2e::ContractCreateTransaction]") + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.CONTRACT_REVERT_EXECUTED.toString()); + + new FileDeleteTransaction() + .setFileId(fileId) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.CONTRACT_REVERT_EXECUTED.toString()); - - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - testEnv.close(); + } } @Test @DisplayName("Cannot create contract when bytecode file ID is not set") void cannotCreateContractWhenBytecodeFileIdIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new ContractCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setGas(100000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setContractMemo("[e2e::ContractCreateTransaction]") - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_FILE_ID.toString()); - - testEnv.close(); + try (var testEnv = new IntegrationTestEnv(1)) { + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new ContractCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setGas(100000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setContractMemo("[e2e::ContractCreateTransaction]") + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_FILE_ID.toString()); + + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractDeleteIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractDeleteIntegrationTest.java index 2573ef137..6f09db559 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractDeleteIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractDeleteIntegrationTest.java @@ -44,107 +44,109 @@ public class ContractDeleteIntegrationTest { @Test @DisplayName("Can delete contract with admin key") void canDeleteContractWithAdminKey() throws Exception { - var testEnv = new IntegrationTestEnv(1); - - @Var var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); - - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - - response = new ContractCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setGas(200000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setBytecodeFileId(fileId) - .setContractMemo("[e2e::ContractCreateTransaction]") - .execute(testEnv.client); - - var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); - - var info = new ContractInfoQuery() - .setContractId(contractId) - .execute(testEnv.client); - - assertThat(info.contractId).isEqualTo(contractId); - assertThat(info.accountId).isNotNull(); - assertThat(Objects.requireNonNull(info.accountId).toString()).isEqualTo(contractId.toString()); - assertThat(info.adminKey).isNotNull(); - assertThat(Objects.requireNonNull(info.adminKey).toString()).isEqualTo(Objects.requireNonNull(testEnv.operatorKey).toString()); - assertThat(info.storage).isEqualTo(128); - assertThat(info.contractMemo).isEqualTo("[e2e::ContractCreateTransaction]"); - - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(); + try (var testEnv = new IntegrationTestEnv(1)) { + + @Var + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); + + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + + response = new ContractCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setGas(200000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setBytecodeFileId(fileId) + .setContractMemo("[e2e::ContractCreateTransaction]") + .execute(testEnv.client); + + var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); + + var info = new ContractInfoQuery() + .setContractId(contractId) + .execute(testEnv.client); + + assertThat(info.contractId).isEqualTo(contractId); + assertThat(info.accountId).isNotNull(); + assertThat(Objects.requireNonNull(info.accountId).toString()).isEqualTo(contractId.toString()); + assertThat(info.adminKey).isNotNull(); + assertThat(Objects.requireNonNull(info.adminKey).toString()) + .isEqualTo(Objects.requireNonNull(testEnv.operatorKey).toString()); + assertThat(info.storage).isEqualTo(128); + assertThat(info.contractMemo).isEqualTo("[e2e::ContractCreateTransaction]"); + + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .setContractId(contractId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } @Test @DisplayName("Cannot delete contract which has no admin key") void cannotDeleteContractWhichHasNoAdminKey() throws Exception { - var testEnv = new IntegrationTestEnv(1); - - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); - - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - - var contractId = Objects.requireNonNull(new ContractCreateTransaction() - .setGas(200000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setBytecodeFileId(fileId) - .setContractMemo("[e2e::ContractCreateTransaction]") - .execute(testEnv.client) - .getReceipt(testEnv.client) - .contractId - ); - - var info = new ContractInfoQuery() - .setContractId(contractId) - .execute(testEnv.client); - - assertThat(info.contractId).isEqualTo(contractId); - assertThat(info.accountId).isNotNull(); - assertThat(Objects.requireNonNull(info.accountId).toString()).isEqualTo(contractId.toString()); - assertThat(info.adminKey).isNotNull(); - // assertEquals(info.adminKey, contractId); - assertThat(info.storage).isEqualTo(128); - assertThat(info.contractMemo).isEqualTo("[e2e::ContractCreateTransaction]"); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new ContractDeleteTransaction() - .setContractId(contractId) - .setTransferAccountId(testEnv.client.getOperatorAccountId()) + try (var testEnv = new IntegrationTestEnv(1)) { + + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); + + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + + var contractId = Objects.requireNonNull(new ContractCreateTransaction() + .setGas(200000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setBytecodeFileId(fileId) + .setContractMemo("[e2e::ContractCreateTransaction]") .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.MODIFYING_IMMUTABLE_CONTRACT.toString()); + .getReceipt(testEnv.client) + .contractId + ); - testEnv.close(); + var info = new ContractInfoQuery() + .setContractId(contractId) + .execute(testEnv.client); + + assertThat(info.contractId).isEqualTo(contractId); + assertThat(info.accountId).isNotNull(); + assertThat(Objects.requireNonNull(info.accountId).toString()).isEqualTo(contractId.toString()); + assertThat(info.adminKey).isNotNull(); + // assertEquals(info.adminKey, contractId); + assertThat(info.storage).isEqualTo(128); + assertThat(info.contractMemo).isEqualTo("[e2e::ContractCreateTransaction]"); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new ContractDeleteTransaction() + .setContractId(contractId) + .setTransferAccountId(testEnv.client.getOperatorAccountId()) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.MODIFYING_IMMUTABLE_CONTRACT.toString()); + + } } @Test @DisplayName("Cannot delete contract when contract ID is not set") void cannotDeleteContractWhenContractIDIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new ContractDeleteTransaction() - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_CONTRACT_ID.toString()); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new ContractDeleteTransaction() + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_CONTRACT_ID.toString()); - testEnv.close(); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractExecuteIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractExecuteIntegrationTest.java index 6939ab49a..af2b5d365 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractExecuteIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractExecuteIntegrationTest.java @@ -42,153 +42,149 @@ public class ContractExecuteIntegrationTest { @Test @DisplayName("Can execute contract methods") void canExecuteContractMethods() throws Exception { - var testEnv = new IntegrationTestEnv(1); - - @Var var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); - - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - - response = new ContractCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setGas(200000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setBytecodeFileId(fileId) - .setContractMemo("[e2e::ContractCreateTransaction]") - .execute(testEnv.client); - - var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); - - var receipt = new ContractExecuteTransaction() - .setContractId(contractId) - .setGas(100000) - .setFunction("setMessage", new ContractFunctionParameters().addString("new message")) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - assertThat(receipt.status).isEqualTo(Status.SUCCESS); - - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(); - } - - @Test - @DisplayName("Cannot execute contract when contract ID is not set") - void cannotExecuteContractWhenContractIDIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1); - - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new ContractExecuteTransaction() - .setGas(100000) - .setFunction("setMessage", new ContractFunctionParameters().addString("new message")) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_CONTRACT_ID.toString()); - - testEnv.close(); - } - - @Test - @DisplayName("Cannot execute contract when contract function parameters are not set") - void cannotExecuteContractWhenContractFunctionParametersAreNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); + @Var var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - var contractId = Objects.requireNonNull( - new ContractCreateTransaction() + response = new ContractCreateTransaction() .setAdminKey(testEnv.operatorKey) .setGas(200000) .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) .setBytecodeFileId(fileId) .setContractMemo("[e2e::ContractCreateTransaction]") - .execute(testEnv.client) - .getReceipt(testEnv.client) - .contractId - ); + .execute(testEnv.client); - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new ContractExecuteTransaction() + var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); + + var receipt = new ContractExecuteTransaction() .setContractId(contractId) .setGas(100000) + .setFunction("setMessage", new ContractFunctionParameters().addString("new message")) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.CONTRACT_REVERT_EXECUTED.toString()); - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + assertThat(receipt.status).isEqualTo(Status.SUCCESS); - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .setContractId(contractId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } @Test - @DisplayName("Cannot execute contract when gas is not set") - void cannotExecuteContractWhenGasIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1); + @DisplayName("Cannot execute contract when contract ID is not set") + void cannotExecuteContractWhenContractIDIsNotSet() throws Exception { + try (var testEnv = new IntegrationTestEnv(1)) { - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new ContractExecuteTransaction() + .setGas(100000) + .setFunction("setMessage", new ContractFunctionParameters().addString("new message")) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_CONTRACT_ID.toString()); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + } + } - var contractId = Objects.requireNonNull( - new ContractCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setGas(200000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setBytecodeFileId(fileId) - .setContractMemo("[e2e::ContractCreateTransaction]") + @Test + @DisplayName("Cannot execute contract when contract function parameters are not set") + void cannotExecuteContractWhenContractFunctionParametersAreNotSet() throws Exception { + try (var testEnv = new IntegrationTestEnv(1)) { + + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); + + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + + var contractId = Objects.requireNonNull( + new ContractCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setGas(200000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setBytecodeFileId(fileId) + .setContractMemo("[e2e::ContractCreateTransaction]") + .execute(testEnv.client) + .getReceipt(testEnv.client).contractId); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new ContractExecuteTransaction() + .setContractId(contractId) + .setGas(100000) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.CONTRACT_REVERT_EXECUTED.toString()); + + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .setContractId(contractId) .execute(testEnv.client) - .getReceipt(testEnv.client) - .contractId - ); + .getReceipt(testEnv.client); - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new ContractExecuteTransaction() - .setContractId(contractId) - .setFunction("setMessage", new ContractFunctionParameters().addString("new message")) + new FileDeleteTransaction() + .setFileId(fileId) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.INSUFFICIENT_GAS.toString()); - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + } + } - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + @Test + @DisplayName("Cannot execute contract when gas is not set") + void cannotExecuteContractWhenGasIsNotSet() throws Exception { + try (var testEnv = new IntegrationTestEnv(1)) { + + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); + + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + + var contractId = Objects.requireNonNull( + new ContractCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setGas(200000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setBytecodeFileId(fileId) + .setContractMemo("[e2e::ContractCreateTransaction]") + .execute(testEnv.client) + .getReceipt(testEnv.client).contractId); + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new ContractExecuteTransaction() + .setContractId(contractId) + .setFunction("setMessage", new ContractFunctionParameters().addString("new message")) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INSUFFICIENT_GAS.toString()); + + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .setContractId(contractId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractIdPopulationIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractIdPopulationIntegrationTest.java index 9b45f0dad..74e3f5f9a 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractIdPopulationIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractIdPopulationIntegrationTest.java @@ -34,78 +34,81 @@ class ContractIdPopulationIntegrationTest { @Test @DisplayName("Can populate ContractId num from mirror node (using sync method)") void canPopulateContractIdNumSync() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var testContractByteCode = "608060405234801561001057600080fd5b50336000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506101cb806100606000396000f3fe608060405260043610610046576000357c01000000000000000000000000000000000000000000000000000000009004806341c0e1b51461004b578063cfae321714610062575b600080fd5b34801561005757600080fd5b506100606100f2565b005b34801561006e57600080fd5b50610077610162565b6040518080602001828103825283818151815260200191508051906020019080838360005b838110156100b757808201518184015260208101905061009c565b50505050905090810190601f1680156100e45780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161415610160573373ffffffffffffffffffffffffffffffffffffffff16ff5b565b60606040805190810160405280600d81526020017f48656c6c6f2c20776f726c64210000000000000000000000000000000000000081525090509056fea165627a7a72305820ae96fb3af7cde9c0abfe365272441894ab717f816f07f41f07b1cbede54e256e0029"; + var testContractByteCode = "608060405234801561001057600080fd5b50336000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506101cb806100606000396000f3fe608060405260043610610046576000357c01000000000000000000000000000000000000000000000000000000009004806341c0e1b51461004b578063cfae321714610062575b600080fd5b34801561005757600080fd5b506100606100f2565b005b34801561006e57600080fd5b50610077610162565b6040518080602001828103825283818151815260200191508051906020019080838360005b838110156100b757808201518184015260208101905061009c565b50505050905090810190601f1680156100e45780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161415610160573373ffffffffffffffffffffffffffffffffffffffff16ff5b565b60606040805190810160405280600d81526020017f48656c6c6f2c20776f726c64210000000000000000000000000000000000000081525090509056fea165627a7a72305820ae96fb3af7cde9c0abfe365272441894ab717f816f07f41f07b1cbede54e256e0029"; - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(testContractByteCode) - .execute(testEnv.client); + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(testContractByteCode) + .execute(testEnv.client); - var receipt = response.setValidateStatus(true).getReceipt(testEnv.client); - var fileId = Objects.requireNonNull(receipt.fileId); + var receipt = response.setValidateStatus(true).getReceipt(testEnv.client); + var fileId = Objects.requireNonNull(receipt.fileId); - response = new ContractCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setGas(100000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setBytecodeFileId(fileId) - .setContractMemo("[e2e::canPopulateContractIdNum]") - .execute(testEnv.client); + response = new ContractCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setGas(100000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setBytecodeFileId(fileId) + .setContractMemo("[e2e::canPopulateContractIdNum]") + .execute(testEnv.client); - receipt = response.setValidateStatus(true).getReceipt(testEnv.client); + receipt = response.setValidateStatus(true).getReceipt(testEnv.client); - var contractId = Objects.requireNonNull(receipt.contractId); + var contractId = Objects.requireNonNull(receipt.contractId); - var info = new ContractInfoQuery() - .setContractId(contractId) - .execute(testEnv.client); + var info = new ContractInfoQuery() + .setContractId(contractId) + .execute(testEnv.client); - var idMirror = ContractId.fromEvmAddress(0, 0, info.contractAccountId); - Thread.sleep(5000); + var idMirror = ContractId.fromEvmAddress(0, 0, info.contractAccountId); + Thread.sleep(5000); - var newContractId = idMirror.populateContractNum(testEnv.client); + var newContractId = idMirror.populateContractNum(testEnv.client); - assertThat(contractId.num).isEqualTo(newContractId.num); + assertThat(contractId.num).isEqualTo(newContractId.num); + } } @Test @DisplayName("Can populate ContractId num from mirror node (using async method)") void canPopulateContractIdNumAsync() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var testContractByteCode = "608060405234801561001057600080fd5b50336000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506101cb806100606000396000f3fe608060405260043610610046576000357c01000000000000000000000000000000000000000000000000000000009004806341c0e1b51461004b578063cfae321714610062575b600080fd5b34801561005757600080fd5b506100606100f2565b005b34801561006e57600080fd5b50610077610162565b6040518080602001828103825283818151815260200191508051906020019080838360005b838110156100b757808201518184015260208101905061009c565b50505050905090810190601f1680156100e45780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161415610160573373ffffffffffffffffffffffffffffffffffffffff16ff5b565b60606040805190810160405280600d81526020017f48656c6c6f2c20776f726c64210000000000000000000000000000000000000081525090509056fea165627a7a72305820ae96fb3af7cde9c0abfe365272441894ab717f816f07f41f07b1cbede54e256e0029"; + var testContractByteCode = "608060405234801561001057600080fd5b50336000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506101cb806100606000396000f3fe608060405260043610610046576000357c01000000000000000000000000000000000000000000000000000000009004806341c0e1b51461004b578063cfae321714610062575b600080fd5b34801561005757600080fd5b506100606100f2565b005b34801561006e57600080fd5b50610077610162565b6040518080602001828103825283818151815260200191508051906020019080838360005b838110156100b757808201518184015260208101905061009c565b50505050905090810190601f1680156100e45780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161415610160573373ffffffffffffffffffffffffffffffffffffffff16ff5b565b60606040805190810160405280600d81526020017f48656c6c6f2c20776f726c64210000000000000000000000000000000000000081525090509056fea165627a7a72305820ae96fb3af7cde9c0abfe365272441894ab717f816f07f41f07b1cbede54e256e0029"; - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(testContractByteCode) - .execute(testEnv.client); + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(testContractByteCode) + .execute(testEnv.client); - var receipt = response.setValidateStatus(true).getReceipt(testEnv.client); - var fileId = Objects.requireNonNull(receipt.fileId); + var receipt = response.setValidateStatus(true).getReceipt(testEnv.client); + var fileId = Objects.requireNonNull(receipt.fileId); - response = new ContractCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setGas(100000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setBytecodeFileId(fileId) - .setContractMemo("[e2e::canPopulateContractIdNum]") - .execute(testEnv.client); + response = new ContractCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setGas(100000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setBytecodeFileId(fileId) + .setContractMemo("[e2e::canPopulateContractIdNum]") + .execute(testEnv.client); - receipt = response.setValidateStatus(true).getReceipt(testEnv.client); + receipt = response.setValidateStatus(true).getReceipt(testEnv.client); - var contractId = Objects.requireNonNull(receipt.contractId); + var contractId = Objects.requireNonNull(receipt.contractId); - var info = new ContractInfoQuery() - .setContractId(contractId) - .execute(testEnv.client); + var info = new ContractInfoQuery() + .setContractId(contractId) + .execute(testEnv.client); - var idMirror = ContractId.fromEvmAddress(0, 0, info.contractAccountId); - Thread.sleep(5000); + var idMirror = ContractId.fromEvmAddress(0, 0, info.contractAccountId); + Thread.sleep(5000); - var newContractId = idMirror.populateContractNumAsync(testEnv.client).get(); + var newContractId = idMirror.populateContractNumAsync(testEnv.client).get(); - assertThat(contractId.num).isEqualTo(newContractId.num); + assertThat(contractId.num).isEqualTo(newContractId.num); + + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractInfoIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractInfoIntegrationTest.java index f4d9d0b7c..f81eab6ad 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractInfoIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractInfoIntegrationTest.java @@ -34,235 +34,235 @@ public class ContractInfoIntegrationTest { @Test @DisplayName("Can query contract info") void canQueryContractInfo() throws Exception { - var testEnv = new IntegrationTestEnv(1); - - @Var var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); - - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - - response = new ContractCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setGas(200000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setBytecodeFileId(fileId) - .setContractMemo("[e2e::ContractCreateTransaction]") - .execute(testEnv.client); - - var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); - - assertThat(contractId.hashCode()).isGreaterThan(0); - assertThat(contractId.compareTo(ContractId.fromBytes(contractId.toBytes()))).isZero(); - - var info = new ContractInfoQuery() - .setContractId(contractId) - .execute(testEnv.client); - - assertThat(info.contractId).isEqualTo(contractId); - assertThat(info.accountId).isNotNull(); - assertThat(Objects.requireNonNull(info.accountId).toString()).isEqualTo(contractId.toString()); - assertThat(info.adminKey).isNotNull(); - assertThat(Objects.requireNonNull(info.adminKey).toString()).isEqualTo(Objects.requireNonNull(testEnv.operatorKey).toString()); - assertThat(info.storage).isEqualTo(128); - assertThat(info.contractMemo).isEqualTo("[e2e::ContractCreateTransaction]"); - - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(); + try (var testEnv = new IntegrationTestEnv(1)) { + + @Var var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); + + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + + response = new ContractCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setGas(200000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setBytecodeFileId(fileId) + .setContractMemo("[e2e::ContractCreateTransaction]") + .execute(testEnv.client); + + var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); + + assertThat(contractId.hashCode()).isGreaterThan(0); + assertThat(contractId.compareTo(ContractId.fromBytes(contractId.toBytes()))).isZero(); + + var info = new ContractInfoQuery() + .setContractId(contractId) + .execute(testEnv.client); + + assertThat(info.contractId).isEqualTo(contractId); + assertThat(info.accountId).isNotNull(); + assertThat(Objects.requireNonNull(info.accountId).toString()).isEqualTo(contractId.toString()); + assertThat(info.adminKey).isNotNull(); + assertThat(Objects.requireNonNull(info.adminKey).toString()).isEqualTo(Objects.requireNonNull(testEnv.operatorKey).toString()); + assertThat(info.storage).isEqualTo(128); + assertThat(info.contractMemo).isEqualTo("[e2e::ContractCreateTransaction]"); + + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .setContractId(contractId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } @Test @DisplayName("Can query contract info when admin key is null") void canQueryContractInfoWhenAdminKeyIsNull() throws Exception { - var testEnv = new IntegrationTestEnv(1); - - @Var var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); - - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - - response = new ContractCreateTransaction() - .setGas(200000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setBytecodeFileId(fileId) - .setContractMemo("[e2e::ContractCreateTransaction]") - .execute(testEnv.client); - - var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); - - var info = new ContractInfoQuery() - .setContractId(contractId) - .execute(testEnv.client); - - assertThat(info.contractId).isEqualTo(contractId); - assertThat(info.accountId).isNotNull(); - assertThat(Objects.requireNonNull(info.accountId).toString()).isEqualTo(contractId.toString()); - assertThat(info.adminKey).isNotNull(); - // TODO: Fix this when we know it's correct - // assertEquals(info.adminKey, contractId); - assertThat(info.storage).isEqualTo(128); - assertThat(info.contractMemo).isEqualTo("[e2e::ContractCreateTransaction]"); - - testEnv.close(); + try (var testEnv = new IntegrationTestEnv(1)) { + + @Var var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); + + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + + response = new ContractCreateTransaction() + .setGas(200000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setBytecodeFileId(fileId) + .setContractMemo("[e2e::ContractCreateTransaction]") + .execute(testEnv.client); + + var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); + + var info = new ContractInfoQuery() + .setContractId(contractId) + .execute(testEnv.client); + + assertThat(info.contractId).isEqualTo(contractId); + assertThat(info.accountId).isNotNull(); + assertThat(Objects.requireNonNull(info.accountId).toString()).isEqualTo(contractId.toString()); + assertThat(info.adminKey).isNotNull(); + // TODO: Fix this when we know it's correct + // assertEquals(info.adminKey, contractId); + assertThat(info.storage).isEqualTo(128); + assertThat(info.contractMemo).isEqualTo("[e2e::ContractCreateTransaction]"); + + } } @Test @DisplayName("Cannot query contract info when contract ID is not set") void cannotQueryContractInfoWhenContractIDIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new ContractInfoQuery() - .execute(testEnv.client); - }).withMessageContaining(Status.INVALID_CONTRACT_ID.toString()); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new ContractInfoQuery() + .execute(testEnv.client); + }).withMessageContaining(Status.INVALID_CONTRACT_ID.toString()); - testEnv.close(); + } } @Test @DisplayName("Can get cost, even with a big max") @SuppressWarnings("UnusedVariable") void getCostBigMaxContractInfoFunction() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - @Var var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); + @Var var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - response = new ContractCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setGas(200000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setBytecodeFileId(fileId) - .setContractMemo("[e2e::ContractCreateTransaction]") - .execute(testEnv.client); + response = new ContractCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setGas(200000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setBytecodeFileId(fileId) + .setContractMemo("[e2e::ContractCreateTransaction]") + .execute(testEnv.client); - var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); + var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); - var infoQuery = new ContractInfoQuery() - .setContractId(contractId) - .setMaxQueryPayment(new Hbar(10000)); + var infoQuery = new ContractInfoQuery() + .setContractId(contractId) + .setMaxQueryPayment(new Hbar(10000)); - var cost = infoQuery.getCost(testEnv.client); + var cost = infoQuery.getCost(testEnv.client); - var result = infoQuery - .execute(testEnv.client); + var result = infoQuery + .execute(testEnv.client); - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .setContractId(contractId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } @Test @DisplayName("Error, max is smaller than set payment.") void getCostSmallMaxContractInfoFunction() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - @Var var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); + @Var var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - response = new ContractCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setGas(200000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setBytecodeFileId(fileId) - .setContractMemo("[e2e::ContractCreateTransaction]") - .execute(testEnv.client); + response = new ContractCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setGas(200000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setBytecodeFileId(fileId) + .setContractMemo("[e2e::ContractCreateTransaction]") + .execute(testEnv.client); - var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); + var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); - var infoQuery = new ContractInfoQuery() - .setContractId(contractId) - .setMaxQueryPayment(Hbar.fromTinybars(1)); + var infoQuery = new ContractInfoQuery() + .setContractId(contractId) + .setMaxQueryPayment(Hbar.fromTinybars(1)); - assertThatExceptionOfType(MaxQueryPaymentExceededException.class).isThrownBy(() -> { - infoQuery.execute(testEnv.client); - }); + assertThatExceptionOfType(MaxQueryPaymentExceededException.class).isThrownBy(() -> { + infoQuery.execute(testEnv.client); + }); - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .setContractId(contractId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } @Test @DisplayName("Insufficient tx fee error.") void getCostInsufficientTxFeeContractInfoFunction() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - @Var var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); + @Var var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - response = new ContractCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setGas(200000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setBytecodeFileId(fileId) - .setContractMemo("[e2e::ContractCreateTransaction]") - .execute(testEnv.client); + response = new ContractCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setGas(200000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setBytecodeFileId(fileId) + .setContractMemo("[e2e::ContractCreateTransaction]") + .execute(testEnv.client); - var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); + var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); - var infoQuery = new ContractInfoQuery() - .setContractId(contractId) - .setMaxQueryPayment(new Hbar(100)); + var infoQuery = new ContractInfoQuery() + .setContractId(contractId) + .setMaxQueryPayment(new Hbar(100)); - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - infoQuery.setQueryPayment(Hbar.fromTinybars(1)).execute(testEnv.client); - }).satisfies(error -> assertThat(error.status.toString()).isEqualTo("INSUFFICIENT_TX_FEE")); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + infoQuery.setQueryPayment(Hbar.fromTinybars(1)).execute(testEnv.client); + }).satisfies(error -> assertThat(error.status.toString()).isEqualTo("INSUFFICIENT_TX_FEE")); - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .setContractId(contractId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractNonceInfoIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractNonceInfoIntegrationTest.java index c69656b71..a40c3a732 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractNonceInfoIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractNonceInfoIntegrationTest.java @@ -38,53 +38,53 @@ public class ContractNonceInfoIntegrationTest { @Test @DisplayName("Contract Create of A nonce, which deploys contract B in CONSTRUCTOR") void canIncrementNonceThroughContractConstructor() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - @Var var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); + @Var var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - response = new ContractCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setGas(100000) - .setBytecodeFileId(fileId) - .setContractMemo("[e2e::ContractADeploysContractBInConstructor]") - .execute(testEnv.client); + response = new ContractCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setGas(100000) + .setBytecodeFileId(fileId) + .setContractMemo("[e2e::ContractADeploysContractBInConstructor]") + .execute(testEnv.client); - var contractFunctionResult = response.getRecord(testEnv.client).contractFunctionResult; + var contractFunctionResult = response.getRecord(testEnv.client).contractFunctionResult; - ContractId contractA = contractFunctionResult.contractId; - ContractId contractB = contractFunctionResult.contractNonces.stream() - .filter(contractNonce -> !contractNonce.contractId.equals(contractA)).findFirst().get().contractId; + ContractId contractA = contractFunctionResult.contractId; + ContractId contractB = contractFunctionResult.contractNonces.stream() + .filter(contractNonce -> !contractNonce.contractId.equals(contractA)).findFirst().get().contractId; - ContractNonceInfo contractANonceInfo = contractFunctionResult.contractNonces.stream() - .filter(contractNonce -> contractNonce.contractId.equals(contractA)).findFirst().get(); - ContractNonceInfo contractBNonceInfo = contractFunctionResult.contractNonces.stream() - .filter(contractNonce -> contractNonce.contractId.equals(contractB)).findFirst().get(); + ContractNonceInfo contractANonceInfo = contractFunctionResult.contractNonces.stream() + .filter(contractNonce -> contractNonce.contractId.equals(contractA)).findFirst().get(); + ContractNonceInfo contractBNonceInfo = contractFunctionResult.contractNonces.stream() + .filter(contractNonce -> contractNonce.contractId.equals(contractB)).findFirst().get(); - // A.nonce = 2 - assertThat(contractANonceInfo.nonce).isEqualTo(2); - // B.nonce = 1 - assertThat(contractBNonceInfo.nonce).isEqualTo(1); - // validate HIP-844 case - signer nonce should be set only for Ethereum transactions - assertThat(contractFunctionResult.signerNonce).isEqualTo(0); + // A.nonce = 2 + assertThat(contractANonceInfo.nonce).isEqualTo(2); + // B.nonce = 1 + assertThat(contractBNonceInfo.nonce).isEqualTo(1); + // validate HIP-844 case - signer nonce should be set only for Ethereum transactions + assertThat(contractFunctionResult.signerNonce).isEqualTo(0); - var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); + var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .setContractId(contractId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractUpdateIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractUpdateIntegrationTest.java index ffc75f422..445eb8b39 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractUpdateIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ContractUpdateIntegrationTest.java @@ -44,115 +44,115 @@ class ContractUpdateIntegrationTest { @Test @DisplayName("Can update contract") void canUpdateContract() throws Exception { - var testEnv = new IntegrationTestEnv(1); - - @Var var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); - - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - - response = new ContractCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setGas(200000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setBytecodeFileId(fileId) - .setContractMemo("[e2e::ContractCreateTransaction]") - .execute(testEnv.client); - - var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); - - @Var var info = new ContractInfoQuery() - .setContractId(contractId) - .execute(testEnv.client); - - assertThat(info.contractId).isEqualTo(contractId); - assertThat(info.accountId).isNotNull(); - assertThat(Objects.requireNonNull(info.accountId).toString()).isEqualTo(contractId.toString()); - assertThat(info.adminKey).isNotNull(); - assertThat(Objects.requireNonNull(info.adminKey).toString()).isEqualTo(Objects.requireNonNull(testEnv.operatorKey).toString()); - assertThat(info.storage).isEqualTo(128); - assertThat(info.contractMemo).isEqualTo("[e2e::ContractCreateTransaction]"); - - new ContractUpdateTransaction() - .setContractId(contractId) - .setContractMemo("[e2e::ContractUpdateTransaction]") - .execute(testEnv.client) - .getReceipt(testEnv.client); - - info = new ContractInfoQuery() - .setContractId(contractId) - .execute(testEnv.client); - - assertThat(info.contractId).isEqualTo(contractId); - assertThat(info.accountId).isNotNull(); - assertThat(Objects.requireNonNull(info.accountId).toString()).isEqualTo(contractId.toString()); - assertThat(info.adminKey).isNotNull(); - assertThat(Objects.requireNonNull(info.adminKey).toString()).isEqualTo(Objects.requireNonNull(testEnv.operatorKey).toString()); - assertThat(info.storage).isEqualTo(128); - assertThat(info.contractMemo).isEqualTo("[e2e::ContractUpdateTransaction]"); - - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(); - } + try (var testEnv = new IntegrationTestEnv(1)) { - @Test - @DisplayName("Cannot update contract when contract ID is not set") - void cannotUpdateContractWhenContractIDIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1); + @Var var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new ContractUpdateTransaction() - .setContractMemo("[e2e::ContractUpdateTransaction]") - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_CONTRACT_ID.toString()); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - testEnv.close(); - } - - @Test - @DisplayName("Cannot update contract that is immutable") - void cannotUpdateContractThatIsImmutable() throws Exception { - var testEnv = new IntegrationTestEnv(1); - - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); - - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - - var contractId = Objects.requireNonNull( - new ContractCreateTransaction() + response = new ContractCreateTransaction() + .setAdminKey(testEnv.operatorKey) .setGas(200000) .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) .setBytecodeFileId(fileId) .setContractMemo("[e2e::ContractCreateTransaction]") - .execute(testEnv.client) - .getReceipt(testEnv.client) - .contractId - ); + .execute(testEnv.client); + + var contractId = Objects.requireNonNull(response.getReceipt(testEnv.client).contractId); + + @Var var info = new ContractInfoQuery() + .setContractId(contractId) + .execute(testEnv.client); + + assertThat(info.contractId).isEqualTo(contractId); + assertThat(info.accountId).isNotNull(); + assertThat(Objects.requireNonNull(info.accountId).toString()).isEqualTo(contractId.toString()); + assertThat(info.adminKey).isNotNull(); + assertThat(Objects.requireNonNull(info.adminKey).toString()).isEqualTo(Objects.requireNonNull(testEnv.operatorKey).toString()); + assertThat(info.storage).isEqualTo(128); + assertThat(info.contractMemo).isEqualTo("[e2e::ContractCreateTransaction]"); - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { new ContractUpdateTransaction() .setContractId(contractId) .setContractMemo("[e2e::ContractUpdateTransaction]") .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.MODIFYING_IMMUTABLE_CONTRACT.toString()); - testEnv.close(); + info = new ContractInfoQuery() + .setContractId(contractId) + .execute(testEnv.client); + + assertThat(info.contractId).isEqualTo(contractId); + assertThat(info.accountId).isNotNull(); + assertThat(Objects.requireNonNull(info.accountId).toString()).isEqualTo(contractId.toString()); + assertThat(info.adminKey).isNotNull(); + assertThat(Objects.requireNonNull(info.adminKey).toString()).isEqualTo(Objects.requireNonNull(testEnv.operatorKey).toString()); + assertThat(info.storage).isEqualTo(128); + assertThat(info.contractMemo).isEqualTo("[e2e::ContractUpdateTransaction]"); + + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .setContractId(contractId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } + } + + @Test + @DisplayName("Cannot update contract when contract ID is not set") + void cannotUpdateContractWhenContractIDIsNotSet() throws Exception { + try (var testEnv = new IntegrationTestEnv(1)) { + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new ContractUpdateTransaction() + .setContractMemo("[e2e::ContractUpdateTransaction]") + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_CONTRACT_ID.toString()); + + } + } + + @Test + @DisplayName("Cannot update contract that is immutable") + void cannotUpdateContractThatIsImmutable() throws Exception { + try (var testEnv = new IntegrationTestEnv(1)) { + + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); + + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + + var contractId = Objects.requireNonNull( + new ContractCreateTransaction() + .setGas(200000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setBytecodeFileId(fileId) + .setContractMemo("[e2e::ContractCreateTransaction]") + .execute(testEnv.client) + .getReceipt(testEnv.client) + .contractId + ); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new ContractUpdateTransaction() + .setContractId(contractId) + .setContractMemo("[e2e::ContractUpdateTransaction]") + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.MODIFYING_IMMUTABLE_CONTRACT.toString()); + + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/EthereumTransactionIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/EthereumTransactionIntegrationTest.java index 1a40cb158..80c7c6849 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/EthereumTransactionIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/EthereumTransactionIntegrationTest.java @@ -53,70 +53,46 @@ public class EthereumTransactionIntegrationTest { @Test @DisplayName("Signer nonce changed on Ethereum transaction") void signerNonceChangedOnEthereumTransaction() throws Exception { - var testEnv = new IntegrationTestEnv(1); - - var privateKey = PrivateKey.generateECDSA(); - var newAccountAliasId = privateKey.toAccountId(0, 0); - - new TransferTransaction() - .addHbarTransfer(testEnv.operatorId, new Hbar(1).negated()) - .addHbarTransfer(newAccountAliasId, new Hbar(1)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var fileCreateTransactionResponse = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client); - - var fileId = Objects.requireNonNull(fileCreateTransactionResponse.getReceipt(testEnv.client).fileId); - - var contractCreateTransactionResponse = new ContractCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setGas(200000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setBytecodeFileId(fileId) - .setContractMemo("[e2e::ContractCreateTransaction]") - .execute(testEnv.client); - - var contractId = Objects.requireNonNull( - contractCreateTransactionResponse.getReceipt(testEnv.client).contractId); - - int nonce = 0; - byte[] chainId = Hex.decode("012a"); - byte[] maxPriorityGas = Hex.decode("00"); - byte[] maxGas = Hex.decode("d1385c7bf0"); - byte[] to = Hex.decode(contractId.toSolidityAddress()); - byte[] callData = new ContractExecuteTransaction() - .setFunction("setMessage", new ContractFunctionParameters().addString("new message")) - .getFunctionParameters() - .toByteArray(); - - var sequence = RLPEncoder.sequence(Integers.toBytes(2), new Object[]{ - chainId, - Integers.toBytes(nonce), // nonce - maxPriorityGas, - maxGas, - Integers.toBytes(150000), // gasLimit - to, - Integers.toBytesUnsigned(BigInteger.ZERO), // value - callData, - new Object[0] - }); - - byte[] signedBytes = privateKey.sign(sequence); - - // wrap in signature object - final byte[] r = new byte[32]; - System.arraycopy(signedBytes, 0, r, 0, 32); - final byte[] s = new byte[32]; - System.arraycopy(signedBytes, 32, s, 0, 32); - - final int recId = ((PrivateKeyECDSA) privateKey).getRecoveryId(r, s, sequence); - - byte[] ethereumData = RLPEncoder.sequence( - Integers.toBytes(0x02), - List.of( + try (var testEnv = new IntegrationTestEnv(1)) { + + var privateKey = PrivateKey.generateECDSA(); + var newAccountAliasId = privateKey.toAccountId(0, 0); + + new TransferTransaction() + .addHbarTransfer(testEnv.operatorId, new Hbar(1).negated()) + .addHbarTransfer(newAccountAliasId, new Hbar(1)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var fileCreateTransactionResponse = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client); + + var fileId = Objects.requireNonNull(fileCreateTransactionResponse.getReceipt(testEnv.client).fileId); + + var contractCreateTransactionResponse = new ContractCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setGas(200000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setBytecodeFileId(fileId) + .setContractMemo("[e2e::ContractCreateTransaction]") + .execute(testEnv.client); + + var contractId = Objects.requireNonNull( + contractCreateTransactionResponse.getReceipt(testEnv.client).contractId); + + int nonce = 0; + byte[] chainId = Hex.decode("012a"); + byte[] maxPriorityGas = Hex.decode("00"); + byte[] maxGas = Hex.decode("d1385c7bf0"); + byte[] to = Hex.decode(contractId.toSolidityAddress()); + byte[] callData = new ContractExecuteTransaction() + .setFunction("setMessage", new ContractFunctionParameters().addString("new message")) + .getFunctionParameters() + .toByteArray(); + + var sequence = RLPEncoder.sequence(Integers.toBytes(2), new Object[]{ chainId, Integers.toBytes(nonce), // nonce maxPriorityGas, @@ -125,29 +101,53 @@ void signerNonceChangedOnEthereumTransaction() throws Exception { to, Integers.toBytesUnsigned(BigInteger.ZERO), // value callData, - List.of(/*accessList*/), - Integers.toBytes(recId), // recId - r, - s)); - - EthereumTransaction ethereumTransaction = new EthereumTransaction() - .setEthereumData(ethereumData); - var ethereumTransactionResponse = ethereumTransaction.execute(testEnv.client); - var ethereumTransactionRecord = ethereumTransactionResponse.getRecord(testEnv.client); - - assertThat(ethereumTransactionRecord.contractFunctionResult.signerNonce).isEqualTo(1); - - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(); + new Object[0] + }); + + byte[] signedBytes = privateKey.sign(sequence); + + // wrap in signature object + final byte[] r = new byte[32]; + System.arraycopy(signedBytes, 0, r, 0, 32); + final byte[] s = new byte[32]; + System.arraycopy(signedBytes, 32, s, 0, 32); + + final int recId = ((PrivateKeyECDSA) privateKey).getRecoveryId(r, s, sequence); + + byte[] ethereumData = RLPEncoder.sequence( + Integers.toBytes(0x02), + List.of( + chainId, + Integers.toBytes(nonce), // nonce + maxPriorityGas, + maxGas, + Integers.toBytes(150000), // gasLimit + to, + Integers.toBytesUnsigned(BigInteger.ZERO), // value + callData, + List.of(/*accessList*/), + Integers.toBytes(recId), // recId + r, + s)); + + EthereumTransaction ethereumTransaction = new EthereumTransaction() + .setEthereumData(ethereumData); + var ethereumTransactionResponse = ethereumTransaction.execute(testEnv.client); + var ethereumTransactionRecord = ethereumTransactionResponse.getRecord(testEnv.client); + + assertThat(ethereumTransactionRecord.contractFunctionResult.signerNonce).isEqualTo(1); + + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .setContractId(contractId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FeeSchedulesTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FeeSchedulesTest.java index dbab2b0a2..08f408ed8 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FeeSchedulesTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FeeSchedulesTest.java @@ -32,19 +32,19 @@ public class FeeSchedulesTest { @Test @DisplayName("FeeSchedules (CurrentAndNextFeeSchedule) is fetched and parsed from file 0.0.111") void canFetchFeeSchedules() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - ByteString feeSchedulesBytes = new FileContentsQuery() - .setFileId(new FileId(0, 0, 111)) - .execute(testEnv.client); + ByteString feeSchedulesBytes = new FileContentsQuery() + .setFileId(new FileId(0, 0, 111)) + .execute(testEnv.client); - FeeSchedules feeSchedules = FeeSchedules.fromBytes(feeSchedulesBytes.toByteArray()); + FeeSchedules feeSchedules = FeeSchedules.fromBytes(feeSchedulesBytes.toByteArray()); - /* - * Test whether the file 0.0.111 actually contains stuff - */ - assertThat(feeSchedules.getCurrent()).isNotNull(); + /* + * Test whether the file 0.0.111 actually contains stuff + */ + assertThat(feeSchedules.getCurrent()).isNotNull(); - testEnv.close(); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FileAppendIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FileAppendIntegrationTest.java index ebec99a47..e512dbc41 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FileAppendIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FileAppendIntegrationTest.java @@ -39,171 +39,171 @@ public class FileAppendIntegrationTest { @DisplayName("Can append to file") void canAppendToFile() throws Exception { // There are potential bugs in FileAppendTransaction which require more than one node to trigger. - var testEnv = new IntegrationTestEnv(1); - - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents("[e2e::FileCreateTransaction]") - .execute(testEnv.client); - - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - - @Var var info = new FileInfoQuery() - .setFileId(fileId) - .execute(testEnv.client); - - assertThat(info.fileId).isEqualTo(fileId); - assertThat(info.size).isEqualTo(28); - assertThat(info.isDeleted).isFalse(); - assertThat(info.keys).isNotNull(); - assertThat(info.keys.getThreshold()).isNull(); - assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); - - new FileAppendTransaction() - .setFileId(fileId) - .setContents("[e2e::FileAppendTransaction]") - .execute(testEnv.client) - .getReceipt(testEnv.client); - - info = new FileInfoQuery() - .setFileId(fileId) - .execute(testEnv.client); - - assertThat(info.fileId).isEqualTo(fileId); - assertThat(info.size).isEqualTo(56); - assertThat(info.isDeleted).isFalse(); - assertThat(info.keys).isNotNull(); - assertThat(info.keys.getThreshold()).isNull(); - assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); - - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(); + try(var testEnv = new IntegrationTestEnv(1)){ + + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents("[e2e::FileCreateTransaction]") + .execute(testEnv.client); + + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + + @Var var info = new FileInfoQuery() + .setFileId(fileId) + .execute(testEnv.client); + + assertThat(info.fileId).isEqualTo(fileId); + assertThat(info.size).isEqualTo(28); + assertThat(info.isDeleted).isFalse(); + assertThat(info.keys).isNotNull(); + assertThat(info.keys.getThreshold()).isNull(); + assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); + + new FileAppendTransaction() + .setFileId(fileId) + .setContents("[e2e::FileAppendTransaction]") + .execute(testEnv.client) + .getReceipt(testEnv.client); + + info = new FileInfoQuery() + .setFileId(fileId) + .execute(testEnv.client); + + assertThat(info.fileId).isEqualTo(fileId); + assertThat(info.size).isEqualTo(56); + assertThat(info.isDeleted).isFalse(); + assertThat(info.keys).isNotNull(); + assertThat(info.keys.getThreshold()).isNull(); + assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); + + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } @Test @DisplayName("Can append large contents to file") void canAppendLargeContentsToFile() throws Exception { // There are potential bugs in FileAppendTransaction which require more than one node to trigger. - var testEnv = new IntegrationTestEnv(2); + try(var testEnv = new IntegrationTestEnv(2)){ - // Skip if using local node. - // Note: this check should be removed once the local node is supporting multiple nodes. - testEnv.assumeNotLocalNode(); + // Skip if using local node. + // Note: this check should be removed once the local node is supporting multiple nodes. + testEnv.assumeNotLocalNode(); - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents("[e2e::FileCreateTransaction]") - .execute(testEnv.client); + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents("[e2e::FileCreateTransaction]") + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - Thread.sleep(5000); + Thread.sleep(5000); - @Var var info = new FileInfoQuery() - .setFileId(fileId) - .execute(testEnv.client); + @Var var info = new FileInfoQuery() + .setFileId(fileId) + .execute(testEnv.client); - assertThat(info.fileId).isEqualTo(fileId); - assertThat(info.size).isEqualTo(28); - assertThat(info.isDeleted).isFalse(); - assertThat(info.keys).isNotNull(); - assertThat(info.keys.getThreshold()).isNull(); - assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); + assertThat(info.fileId).isEqualTo(fileId); + assertThat(info.size).isEqualTo(28); + assertThat(info.isDeleted).isFalse(); + assertThat(info.keys).isNotNull(); + assertThat(info.keys.getThreshold()).isNull(); + assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); - new FileAppendTransaction() - .setFileId(fileId) - .setContents(Contents.BIG_CONTENTS) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new FileAppendTransaction() + .setFileId(fileId) + .setContents(Contents.BIG_CONTENTS) + .execute(testEnv.client) + .getReceipt(testEnv.client); - var contents = new FileContentsQuery() - .setFileId(fileId) - .execute(testEnv.client); + var contents = new FileContentsQuery() + .setFileId(fileId) + .execute(testEnv.client); - assertThat(contents.toStringUtf8()).isEqualTo("[e2e::FileCreateTransaction]" + Contents.BIG_CONTENTS); + assertThat(contents.toStringUtf8()).isEqualTo("[e2e::FileCreateTransaction]" + Contents.BIG_CONTENTS); - info = new FileInfoQuery() - .setFileId(fileId) - .execute(testEnv.client); + info = new FileInfoQuery() + .setFileId(fileId) + .execute(testEnv.client); - assertThat(info.fileId).isEqualTo(fileId); - assertThat(info.size).isEqualTo(13522); - assertThat(info.isDeleted).isFalse(); - assertThat(info.keys).isNotNull(); - assertThat(info.keys.getThreshold()).isNull(); - assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); + assertThat(info.fileId).isEqualTo(fileId); + assertThat(info.size).isEqualTo(13522); + assertThat(info.isDeleted).isFalse(); + assertThat(info.keys).isNotNull(); + assertThat(info.keys.getThreshold()).isNull(); + assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } @Test @DisplayName("Can append large contents to file despite TRANSACTION_EXPIRATION response codes") void canAppendLargeContentsToFileDespiteExpiration() throws Exception { // There are potential bugs in FileAppendTransaction which require more than one node to trigger. - var testEnv = new IntegrationTestEnv(2); - - // Skip if using local node. - // Note: this check should be removed once the local node is supporting multiple nodes. - testEnv.assumeNotLocalNode(); - - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents("[e2e::FileCreateTransaction]") - .execute(testEnv.client); - - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - - Thread.sleep(5000); - - @Var var info = new FileInfoQuery() - .setFileId(fileId) - .execute(testEnv.client); - - assertThat(info.fileId).isEqualTo(fileId); - assertThat(info.size).isEqualTo(28); - assertThat(info.isDeleted).isFalse(); - assertThat(info.keys).isNotNull(); - assertThat(info.keys.getThreshold()).isNull(); - assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); - - var appendTx = new FileAppendTransaction() - .setFileId(fileId) - .setContents(Contents.BIG_CONTENTS) - .setTransactionValidDuration(Duration.ofSeconds(25)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var contents = new FileContentsQuery() - .setFileId(fileId) - .execute(testEnv.client); - - assertThat(contents.toStringUtf8()).isEqualTo("[e2e::FileCreateTransaction]" + Contents.BIG_CONTENTS); - - info = new FileInfoQuery() - .setFileId(fileId) - .execute(testEnv.client); - - assertThat(info.fileId).isEqualTo(fileId); - assertThat(info.size).isEqualTo(13522); - assertThat(info.isDeleted).isFalse(); - assertThat(info.keys).isNotNull(); - assertThat(info.keys.getThreshold()).isNull(); - assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); - - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(); + try(var testEnv = new IntegrationTestEnv(2)){ + + // Skip if using local node. + // Note: this check should be removed once the local node is supporting multiple nodes. + testEnv.assumeNotLocalNode(); + + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents("[e2e::FileCreateTransaction]") + .execute(testEnv.client); + + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + + Thread.sleep(5000); + + @Var var info = new FileInfoQuery() + .setFileId(fileId) + .execute(testEnv.client); + + assertThat(info.fileId).isEqualTo(fileId); + assertThat(info.size).isEqualTo(28); + assertThat(info.isDeleted).isFalse(); + assertThat(info.keys).isNotNull(); + assertThat(info.keys.getThreshold()).isNull(); + assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); + + var appendTx = new FileAppendTransaction() + .setFileId(fileId) + .setContents(Contents.BIG_CONTENTS) + .setTransactionValidDuration(Duration.ofSeconds(25)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var contents = new FileContentsQuery() + .setFileId(fileId) + .execute(testEnv.client); + + assertThat(contents.toStringUtf8()).isEqualTo("[e2e::FileCreateTransaction]" + Contents.BIG_CONTENTS); + + info = new FileInfoQuery() + .setFileId(fileId) + .execute(testEnv.client); + + assertThat(info.fileId).isEqualTo(fileId); + assertThat(info.size).isEqualTo(13522); + assertThat(info.isDeleted).isFalse(); + assertThat(info.keys).isNotNull(); + assertThat(info.keys.getThreshold()).isNull(); + assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); + + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FileContentsIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FileContentsIntegrationTest.java index f5697097d..929ff8f8d 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FileContentsIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FileContentsIntegrationTest.java @@ -39,148 +39,148 @@ public class FileContentsIntegrationTest { @Test @DisplayName("Can query file contents") void canQueryFileContents() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents("[e2e::FileCreateTransaction]") - .execute(testEnv.client); + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents("[e2e::FileCreateTransaction]") + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - var contents = new FileContentsQuery() - .setFileId(fileId) - .execute(testEnv.client); + var contents = new FileContentsQuery() + .setFileId(fileId) + .execute(testEnv.client); - assertThat(contents.toStringUtf8()).isEqualTo("[e2e::FileCreateTransaction]"); + assertThat(contents.toStringUtf8()).isEqualTo("[e2e::FileCreateTransaction]"); - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } @Test @DisplayName("Can query empty file contents") void canQueryEmptyFileContents() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .execute(testEnv.client); + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - var contents = new FileContentsQuery() - .setFileId(fileId) - .execute(testEnv.client); + var contents = new FileContentsQuery() + .setFileId(fileId) + .execute(testEnv.client); - assertThat(contents.size()).isEqualTo(0); + assertThat(contents.size()).isEqualTo(0); - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } @Test @DisplayName("Cannot query file contents when file ID is not set") void cannotQueryFileContentsWhenFileIDIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new FileContentsQuery() - .execute(testEnv.client); - }).withMessageContaining(Status.INVALID_FILE_ID.toString()); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new FileContentsQuery() + .execute(testEnv.client); + }).withMessageContaining(Status.INVALID_FILE_ID.toString()); - testEnv.close(); + } } @Test @DisplayName("Can get cost, even with a big max") void getCostBigMaxQueryFileContents() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents("[e2e::FileCreateTransaction]") - .execute(testEnv.client); + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents("[e2e::FileCreateTransaction]") + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - var contentsQuery = new FileContentsQuery() - .setFileId(fileId) - .setMaxQueryPayment(new Hbar(1000)); + var contentsQuery = new FileContentsQuery() + .setFileId(fileId) + .setMaxQueryPayment(new Hbar(1000)); - var contents = contentsQuery.execute(testEnv.client); + var contents = contentsQuery.execute(testEnv.client); - assertThat(contents.toStringUtf8()).isEqualTo("[e2e::FileCreateTransaction]"); + assertThat(contents.toStringUtf8()).isEqualTo("[e2e::FileCreateTransaction]"); - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } @Test @DisplayName("Error, max is smaller than set payment.") void getCostSmallMaxQueryFileContents() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents("[e2e::FileCreateTransaction]") - .execute(testEnv.client); + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents("[e2e::FileCreateTransaction]") + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - var contentsQuery = new FileContentsQuery() - .setFileId(fileId) - .setMaxQueryPayment(Hbar.fromTinybars(1)); + var contentsQuery = new FileContentsQuery() + .setFileId(fileId) + .setMaxQueryPayment(Hbar.fromTinybars(1)); - assertThatExceptionOfType(MaxQueryPaymentExceededException.class).isThrownBy(() -> { - contentsQuery.execute(testEnv.client); - }); + assertThatExceptionOfType(MaxQueryPaymentExceededException.class).isThrownBy(() -> { + contentsQuery.execute(testEnv.client); + }); - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } @Test @DisplayName("Insufficient tx fee error.") void getCostInsufficientTxFeeQueryFileContents() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents("[e2e::FileCreateTransaction]") - .execute(testEnv.client); + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents("[e2e::FileCreateTransaction]") + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - var contentsQuery = new FileContentsQuery() - .setFileId(fileId) - .setMaxQueryPayment(new Hbar(100)); + var contentsQuery = new FileContentsQuery() + .setFileId(fileId) + .setMaxQueryPayment(new Hbar(100)); - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - contentsQuery.setQueryPayment(Hbar.fromTinybars(1)).execute(testEnv.client); - }).satisfies(error -> assertThat(error.status.toString()).isEqualTo("INSUFFICIENT_TX_FEE")); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + contentsQuery.setQueryPayment(Hbar.fromTinybars(1)).execute(testEnv.client); + }).satisfies(error -> assertThat(error.status.toString()).isEqualTo("INSUFFICIENT_TX_FEE")); - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FileCreateIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FileCreateIntegrationTest.java index 97e9f6568..92a93c198 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FileCreateIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FileCreateIntegrationTest.java @@ -34,83 +34,83 @@ public class FileCreateIntegrationTest { @Test @DisplayName("Can create file") void canCreateFile() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents("[e2e::FileCreateTransaction]") - .execute(testEnv.client); + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents("[e2e::FileCreateTransaction]") + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - var info = new FileInfoQuery() - .setFileId(fileId) - .execute(testEnv.client); + var info = new FileInfoQuery() + .setFileId(fileId) + .execute(testEnv.client); - assertThat(info.fileId).isEqualTo(fileId); - assertThat(info.size).isEqualTo(28); - assertThat(info.isDeleted).isFalse(); - assertThat(info.keys).isNotNull(); - assertThat(info.keys.getThreshold()).isNull(); - assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); + assertThat(info.fileId).isEqualTo(fileId); + assertThat(info.size).isEqualTo(28); + assertThat(info.isDeleted).isFalse(); + assertThat(info.keys).isNotNull(); + assertThat(info.keys.getThreshold()).isNull(); + assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } @Test @DisplayName("Can create file with no contents") void canCreateFileWithNoContents() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .execute(testEnv.client); + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - var info = new FileInfoQuery() - .setFileId(fileId) - .execute(testEnv.client); + var info = new FileInfoQuery() + .setFileId(fileId) + .execute(testEnv.client); - assertThat(info.fileId).isEqualTo(fileId); - assertThat(info.size).isEqualTo(0); - assertThat(info.isDeleted).isFalse(); - assertThat(info.keys).isNotNull(); - assertThat(info.keys.getThreshold()).isNull(); - assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); + assertThat(info.fileId).isEqualTo(fileId); + assertThat(info.size).isEqualTo(0); + assertThat(info.isDeleted).isFalse(); + assertThat(info.keys).isNotNull(); + assertThat(info.keys.getThreshold()).isNull(); + assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } @Test @DisplayName("Can create file with no keys") void canCreateFileWithNoKeys() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var response = new FileCreateTransaction() - .execute(testEnv.client); + var response = new FileCreateTransaction() + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - var info = new FileInfoQuery() - .setFileId(fileId) - .execute(testEnv.client); + var info = new FileInfoQuery() + .setFileId(fileId) + .execute(testEnv.client); - assertThat(info.fileId).isEqualTo(fileId); - assertThat(info.size).isEqualTo(0); - assertThat(info.isDeleted).isFalse(); - assertThat(info.keys).isNull(); + assertThat(info.fileId).isEqualTo(fileId); + assertThat(info.size).isEqualTo(0); + assertThat(info.isDeleted).isFalse(); + assertThat(info.keys).isNull(); - testEnv.close(); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FileDeleteIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FileDeleteIntegrationTest.java index 31adb0964..04bc27eb2 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FileDeleteIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FileDeleteIntegrationTest.java @@ -30,7 +30,6 @@ import java.util.Objects; -import static org.assertj.core.api.Assertions.as; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatExceptionOfType; @@ -38,61 +37,61 @@ public class FileDeleteIntegrationTest { @Test @DisplayName("Can delete file") void canDeleteFile() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents("[e2e::FileCreateTransaction]") - .execute(testEnv.client); + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents("[e2e::FileCreateTransaction]") + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - var info = new FileInfoQuery() - .setFileId(fileId) - .execute(testEnv.client); + var info = new FileInfoQuery() + .setFileId(fileId) + .execute(testEnv.client); - assertThat(info.fileId).isEqualTo(fileId); - assertThat(info.size).isEqualTo(28); - assertThat(info.isDeleted).isFalse(); - assertThat(info.keys).isNotNull(); - assertThat(info.keys.getThreshold()).isNull(); - assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); + assertThat(info.fileId).isEqualTo(fileId); + assertThat(info.size).isEqualTo(28); + assertThat(info.isDeleted).isFalse(); + assertThat(info.keys).isNotNull(); + assertThat(info.keys.getThreshold()).isNull(); + assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } @Test @DisplayName("Cannot delete immutable file") void cannotDeleteImmutableFile() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var response = new FileCreateTransaction() - .setContents("[e2e::FileCreateTransaction]") - .execute(testEnv.client); + var response = new FileCreateTransaction() + .setContents("[e2e::FileCreateTransaction]") + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - var info = new FileInfoQuery() - .setFileId(fileId) - .execute(testEnv.client); + var info = new FileInfoQuery() + .setFileId(fileId) + .execute(testEnv.client); - assertThat(info.fileId).isEqualTo(fileId); - assertThat(info.size).isEqualTo(28); - assertThat(info.isDeleted).isFalse(); - assertThat(info.keys).isNull(); + assertThat(info.fileId).isEqualTo(fileId); + assertThat(info.size).isEqualTo(28); + assertThat(info.isDeleted).isFalse(); + assertThat(info.keys).isNull(); - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.UNAUTHORIZED.toString()); + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.UNAUTHORIZED.toString()); - testEnv.close(); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FileInfoIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FileInfoIntegrationTest.java index 6cb0f4c75..8eef3c92a 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FileInfoIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FileInfoIntegrationTest.java @@ -38,138 +38,138 @@ public class FileInfoIntegrationTest { @Test @DisplayName("Can query file info") void canQueryFileInfo() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents("[e2e::FileCreateTransaction]") - .execute(testEnv.client); + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents("[e2e::FileCreateTransaction]") + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - var info = new FileInfoQuery() - .setFileId(fileId) - .execute(testEnv.client); + var info = new FileInfoQuery() + .setFileId(fileId) + .execute(testEnv.client); - assertThat(info.fileId).isEqualTo(fileId); - assertThat(info.size).isEqualTo(28); - assertThat(info.isDeleted).isFalse(); - assertThat(info.keys).isNotNull(); - assertThat(info.keys.getThreshold()).isNull(); - assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); + assertThat(info.fileId).isEqualTo(fileId); + assertThat(info.size).isEqualTo(28); + assertThat(info.isDeleted).isFalse(); + assertThat(info.keys).isNotNull(); + assertThat(info.keys.getThreshold()).isNull(); + assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } @Test @DisplayName("Can query file info with no admin key or contents") void canQueryFileInfoWithNoAdminKeyOrContents() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var response = new FileCreateTransaction() - .execute(testEnv.client); + var response = new FileCreateTransaction() + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - var info = new FileInfoQuery() - .setFileId(fileId) - .execute(testEnv.client); + var info = new FileInfoQuery() + .setFileId(fileId) + .execute(testEnv.client); - assertThat(info.fileId).isEqualTo(fileId); - assertThat(info.size).isEqualTo(0); - assertThat(info.isDeleted).isFalse(); - assertThat(info.keys).isNull(); + assertThat(info.fileId).isEqualTo(fileId); + assertThat(info.size).isEqualTo(0); + assertThat(info.isDeleted).isFalse(); + assertThat(info.keys).isNull(); - testEnv.close(); + } } @Test @DisplayName("Can get cost, even with a big max") @SuppressWarnings("UnusedVariable") void getCostBigMaxQueryFileInfo() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents("[e2e::FileCreateTransaction]") - .execute(testEnv.client); + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents("[e2e::FileCreateTransaction]") + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - var infoQuery = new FileInfoQuery() - .setFileId(fileId) - .setMaxQueryPayment(new Hbar(1000)); + var infoQuery = new FileInfoQuery() + .setFileId(fileId) + .setMaxQueryPayment(new Hbar(1000)); - var cost = infoQuery.getCost(testEnv.client); + var cost = infoQuery.getCost(testEnv.client); - var info = infoQuery.setQueryPayment(cost).execute(testEnv.client); + var info = infoQuery.setQueryPayment(cost).execute(testEnv.client); - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } @Test @DisplayName("Error, max is smaller than set payment.") void getCostSmallMaxQueryFileInfo() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents("[e2e::FileCreateTransaction]") - .execute(testEnv.client); + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents("[e2e::FileCreateTransaction]") + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - var infoQuery = new FileInfoQuery() - .setFileId(fileId) - .setMaxQueryPayment(Hbar.fromTinybars(1)); + var infoQuery = new FileInfoQuery() + .setFileId(fileId) + .setMaxQueryPayment(Hbar.fromTinybars(1)); - assertThatExceptionOfType(MaxQueryPaymentExceededException.class).isThrownBy(() -> { - infoQuery.execute(testEnv.client); - }); + assertThatExceptionOfType(MaxQueryPaymentExceededException.class).isThrownBy(() -> { + infoQuery.execute(testEnv.client); + }); - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } @Test @DisplayName("Insufficient tx fee error.") void getCostInsufficientTxFeeQueryFileInfo() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents("[e2e::FileCreateTransaction]") - .execute(testEnv.client); + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents("[e2e::FileCreateTransaction]") + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - var infoQuery = new FileInfoQuery() - .setFileId(fileId) - .setMaxQueryPayment(Hbar.fromTinybars(1)); + var infoQuery = new FileInfoQuery() + .setFileId(fileId) + .setMaxQueryPayment(Hbar.fromTinybars(1)); - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - infoQuery.setQueryPayment(Hbar.fromTinybars(1)).execute(testEnv.client); - }).satisfies(error -> assertThat(error.status.toString()).isEqualTo("INSUFFICIENT_TX_FEE")); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + infoQuery.setQueryPayment(Hbar.fromTinybars(1)).execute(testEnv.client); + }).satisfies(error -> assertThat(error.status.toString()).isEqualTo("INSUFFICIENT_TX_FEE")); - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FileUpdateIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FileUpdateIntegrationTest.java index 6ccd8ec5f..23b852d7b 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FileUpdateIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/FileUpdateIntegrationTest.java @@ -43,112 +43,112 @@ public class FileUpdateIntegrationTest { @Test @DisplayName("Can update file") void canUpdateFile() throws Exception { - var testEnv = new IntegrationTestEnv(1); - - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents("[e2e::FileCreateTransaction]") - .execute(testEnv.client); - - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - - @Var var info = new FileInfoQuery() - .setFileId(fileId) - .execute(testEnv.client); - - assertThat(info.fileId).isEqualTo(fileId); - assertThat(info.size).isEqualTo(28); - assertThat(info.isDeleted).isFalse(); - assertThat(info.keys).isNotNull(); - assertThat(info.keys.getThreshold()).isNull(); - assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); - - new FileUpdateTransaction() - .setFileId(fileId) - .setContents("[e2e::FileUpdateTransaction]") - .execute(testEnv.client) - .getReceipt(testEnv.client); - - info = new FileInfoQuery() - .setFileId(fileId) - .execute(testEnv.client); - - assertThat(info.fileId).isEqualTo(fileId); - assertThat(info.size).isEqualTo(28); - assertThat(info.isDeleted).isFalse(); - assertThat(info.keys).isNotNull(); - assertThat(info.keys.getThreshold()).isNull(); - assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); - - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(); - } - - @Test - @DisplayName("Cannot update immutable file") - void cannotUpdateImmutableFile() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var response = new FileCreateTransaction() - .setContents("[e2e::FileCreateTransaction]") - .execute(testEnv.client); + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents("[e2e::FileCreateTransaction]") + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - var info = new FileInfoQuery() - .setFileId(fileId) - .execute(testEnv.client); + @Var var info = new FileInfoQuery() + .setFileId(fileId) + .execute(testEnv.client); - assertThat(info.fileId).isEqualTo(fileId); - assertThat(info.size).isEqualTo(28); - assertThat(info.isDeleted).isFalse(); - assertThat(info.keys).isNull(); + assertThat(info.fileId).isEqualTo(fileId); + assertThat(info.size).isEqualTo(28); + assertThat(info.isDeleted).isFalse(); + assertThat(info.keys).isNotNull(); + assertThat(info.keys.getThreshold()).isNull(); + assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { new FileUpdateTransaction() .setFileId(fileId) .setContents("[e2e::FileUpdateTransaction]") .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.UNAUTHORIZED.toString()); - testEnv.close(); + info = new FileInfoQuery() + .setFileId(fileId) + .execute(testEnv.client); + + assertThat(info.fileId).isEqualTo(fileId); + assertThat(info.size).isEqualTo(28); + assertThat(info.isDeleted).isFalse(); + assertThat(info.keys).isNotNull(); + assertThat(info.keys.getThreshold()).isNull(); + assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); + + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } + } + + @Test + @DisplayName("Cannot update immutable file") + void cannotUpdateImmutableFile() throws Exception { + try(var testEnv = new IntegrationTestEnv(1)){ + + var response = new FileCreateTransaction() + .setContents("[e2e::FileCreateTransaction]") + .execute(testEnv.client); + + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + + var info = new FileInfoQuery() + .setFileId(fileId) + .execute(testEnv.client); + + assertThat(info.fileId).isEqualTo(fileId); + assertThat(info.size).isEqualTo(28); + assertThat(info.isDeleted).isFalse(); + assertThat(info.keys).isNull(); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new FileUpdateTransaction() + .setFileId(fileId) + .setContents("[e2e::FileUpdateTransaction]") + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.UNAUTHORIZED.toString()); + + } } @Test @DisplayName("Cannot update file when file ID is not set") void cannotUpdateFileWhenFileIDIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new FileUpdateTransaction() - .setContents("[e2e::FileUpdateTransaction]") - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_FILE_ID.toString()); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new FileUpdateTransaction() + .setContents("[e2e::FileUpdateTransaction]") + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_FILE_ID.toString()); - testEnv.close(); + } } @Test @DisplayName("Can update fee schedule file") void canUpdateFeeScheduleFile() throws Exception { - var testEnv = new IntegrationTestEnv(1); - testEnv.client.setOperator(new AccountId(0, 0, 2), PrivateKey.fromString( - "302e020100300506032b65700422042091132178e72057a1d7528025956fe39b0b847f200ab59b2fdd367017f3087137")); - - var fileId = new FileId(0, 0, 111); - var receipt = new FileUpdateTransaction() - .setFileId(fileId) - .setContents("[e2e::FileUpdateTransaction]") - .execute(testEnv.client) - .getReceipt(testEnv.client); - - assertThat(receipt.status).isEqualTo(Status.FEE_SCHEDULE_FILE_PART_UPLOADED); - testEnv.close(); + try(var testEnv = new IntegrationTestEnv(1)){ + testEnv.client.setOperator(new AccountId(0, 0, 2), PrivateKey.fromString( + "302e020100300506032b65700422042091132178e72057a1d7528025956fe39b0b847f200ab59b2fdd367017f3087137")); + + var fileId = new FileId(0, 0, 111); + var receipt = new FileUpdateTransaction() + .setFileId(fileId) + .setContents("[e2e::FileUpdateTransaction]") + .execute(testEnv.client) + .getReceipt(testEnv.client); + + assertThat(receipt.status).isEqualTo(Status.FEE_SCHEDULE_FILE_PART_UPLOADED); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/IntegrationTestEnv.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/IntegrationTestEnv.java index 0f30899db..6eb2f28dc 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/IntegrationTestEnv.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/IntegrationTestEnv.java @@ -40,7 +40,7 @@ import javax.annotation.Nullable; import org.junit.jupiter.api.Assumptions; -public class IntegrationTestEnv { +public class IntegrationTestEnv implements AutoCloseable { static final String LOCAL_CONSENSUS_NODE_ENDPOINT = "127.0.0.1:50211"; static final String LOCAL_MIRROR_NODE_GRPC_ENDPOINT = "127.0.0.1:5600"; static final AccountId LOCAL_CONSENSUS_NODE_ACCOUNT_ID = new AccountId(3); @@ -150,15 +150,8 @@ public void assumeNotLocalNode() throws Exception { Assumptions.assumeFalse(isLocalNode); } - public void close( - @Nullable TokenId newTokenId, - @Nullable AccountId newAccountId, - @Nullable PrivateKey newAccountKey - ) throws Exception { - if (newAccountId != null) { - wipeAccountHbars(newAccountId, newAccountKey); - } - + @Override + public void close() throws Exception { if (!operatorId.equals(originalClient.getOperatorAccountId())) { var hbarsBalance = new AccountBalanceQuery() .setAccountId(operatorId) @@ -176,31 +169,6 @@ public void close( originalClient.close(); } - public void wipeAccountHbars(AccountId newAccountId, PrivateKey newAccountKey) throws Exception { - var hbarsBalance = new AccountBalanceQuery() - .setAccountId(newAccountId) - .execute(originalClient) - .hbars; - new TransferTransaction() - .addHbarTransfer(newAccountId, hbarsBalance.negated()) - .addHbarTransfer(Objects.requireNonNull(originalClient.getOperatorAccountId()), hbarsBalance) - .freezeWith(originalClient) - .sign(Objects.requireNonNull(newAccountKey)) - .execute(originalClient); - } - - public void close() throws Exception { - close(null, null, null); - } - - public void close(AccountId newAccountId, PrivateKey newAccountKey) throws Exception { - close(null, newAccountId, newAccountKey); - } - - public void close(TokenId newTokenId) throws Exception { - close(newTokenId, null, null); - } - private static class TestEnvNodeGetter { private final Client client; private final List> nodes; diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/LiveHashAddIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/LiveHashAddIntegrationTest.java index 19b034972..8d590d749 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/LiveHashAddIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/LiveHashAddIntegrationTest.java @@ -40,27 +40,27 @@ class LiveHashAddIntegrationTest { @Test @DisplayName("Cannot create live hash because it's not supported") void cannotCreateLiveHashBecauseItsNotSupported() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var key = PrivateKey.generateED25519(); + var key = PrivateKey.generateED25519(); - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new LiveHashAddTransaction() - .setAccountId(accountId) - .setDuration(Duration.ofDays(30)) - .setHash(HASH) - .setKeys(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.NOT_SUPPORTED.toString()); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new LiveHashAddTransaction() + .setAccountId(accountId) + .setDuration(Duration.ofDays(30)) + .setHash(HASH) + .setKeys(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.NOT_SUPPORTED.toString()); - testEnv.close(accountId, key); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/LiveHashDeleteIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/LiveHashDeleteIntegrationTest.java index cd3bc7f89..4c313c074 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/LiveHashDeleteIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/LiveHashDeleteIntegrationTest.java @@ -39,25 +39,25 @@ class LiveHashDeleteIntegrationTest { @Test @DisplayName("Cannot delete live hash because it's not supported") void cannotDeleteLiveHashBecauseItsNotSupported() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var key = PrivateKey.generateED25519(); + var key = PrivateKey.generateED25519(); - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new LiveHashDeleteTransaction() - .setAccountId(accountId) - .setHash(HASH) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.NOT_SUPPORTED.toString()); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new LiveHashDeleteTransaction() + .setAccountId(accountId) + .setHash(HASH) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.NOT_SUPPORTED.toString()); - testEnv.close(accountId, key); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/LoadIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/LoadIntegrationTest.java index 8225d23cb..50a307fda 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/LoadIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/LoadIntegrationTest.java @@ -38,60 +38,62 @@ class LoadIntegrationTest { @Test @DisplayName("Load test with multiple clients and single executor") void loadTest() throws Exception { - var testEnv = new IntegrationTestEnv(1); - var operatorPrivateKey = PrivateKey.fromString(System.getProperty("OPERATOR_KEY")); - var operatorId = AccountId.fromString(System.getProperty("OPERATOR_ID")); + try (var testEnv = new IntegrationTestEnv(1)) { - int nThreads = 10; - var clientExecutor = Executors.newFixedThreadPool(16); + var operatorPrivateKey = PrivateKey.fromString(System.getProperty("OPERATOR_KEY")); + var operatorId = AccountId.fromString(System.getProperty("OPERATOR_ID")); - var threadPoolExecutor = (ThreadPoolExecutor) Executors.newFixedThreadPool(nThreads); + int nThreads = 10; + var clientExecutor = Executors.newFixedThreadPool(16); - long startTime = System.currentTimeMillis(); + var threadPoolExecutor = (ThreadPoolExecutor) Executors.newFixedThreadPool(nThreads); - System.out.println("Finished executing tasks:"); - for (int i = 0; i < nThreads; i++) { - int finalI = i; - threadPoolExecutor.submit(() -> { - var client = Client.forNetwork(testEnv.client.getNetwork(), clientExecutor); - client.setOperator(operatorId, operatorPrivateKey); - client.setMaxAttempts(10); - try { - new AccountCreateTransaction() - .setKey(PrivateKey.generateED25519()) - .execute(client) - .getReceipt(client); - System.out.println(finalI); - } catch (Exception e) { - fail("AccountCreateTransaction failed, " + e); - } finally { + long startTime = System.currentTimeMillis(); + + System.out.println("Finished executing tasks:"); + for (int i = 0; i < nThreads; i++) { + int finalI = i; + threadPoolExecutor.submit(() -> { + var client = Client.forNetwork(testEnv.client.getNetwork(), clientExecutor); + client.setOperator(operatorId, operatorPrivateKey); + client.setMaxAttempts(10); try { - client.closeChannels(); - } catch (TimeoutException e) { - throw new RuntimeException(e); + new AccountCreateTransaction() + .setKey(PrivateKey.generateED25519()) + .execute(client) + .getReceipt(client); + System.out.println(finalI); + } catch (Exception e) { + fail("AccountCreateTransaction failed, " + e); + } finally { + try { + client.closeChannels(); + } catch (TimeoutException e) { + throw new RuntimeException(e); + } } - } - }); - } + }); + } - threadPoolExecutor.shutdown(); + threadPoolExecutor.shutdown(); - // Wait for all tasks to finish - try { - if (!threadPoolExecutor.awaitTermination(60, TimeUnit.SECONDS)) { - System.out.println(); - System.out.println("Forcing shutdown"); + // Wait for all tasks to finish + try { + if (!threadPoolExecutor.awaitTermination(60, TimeUnit.SECONDS)) { + System.out.println(); + System.out.println("Forcing shutdown"); + threadPoolExecutor.shutdownNow(); + } + } catch (InterruptedException e) { threadPoolExecutor.shutdownNow(); } - } catch (InterruptedException e) { - threadPoolExecutor.shutdownNow(); - } - long endTime = System.currentTimeMillis(); - long executionTime = endTime - startTime; - System.out.println(); - System.out.println("All tasks have finished execution in " + executionTime + "ms"); - clientExecutor.shutdownNow(); - testEnv.close(); + long endTime = System.currentTimeMillis(); + long executionTime = endTime - startTime; + System.out.println(); + System.out.println("All tasks have finished execution in " + executionTime + "ms"); + clientExecutor.shutdownNow(); + + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/NetworkVersionInfoIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/NetworkVersionInfoIntegrationTest.java index b6b90b857..e006fb5f7 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/NetworkVersionInfoIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/NetworkVersionInfoIntegrationTest.java @@ -27,11 +27,11 @@ public class NetworkVersionInfoIntegrationTest { @Test @DisplayName("Cannot query network version info") void cannotQueryNetworkVersionInfo() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - new NetworkVersionInfoQuery() - .execute(testEnv.client); + new NetworkVersionInfoQuery() + .execute(testEnv.client); - testEnv.close(); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/NftAllowancesIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/NftAllowancesIntegrationTest.java index ac078ff94..a10dfcd24 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/NftAllowancesIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/NftAllowancesIntegrationTest.java @@ -47,366 +47,366 @@ public class NftAllowancesIntegrationTest { @Test @DisplayName("Cannot transfer on behalf of `spender` account without allowance approval") void cannotTransferWithoutAllowanceApproval() throws Exception { - var testEnv = new IntegrationTestEnv(1); - - var spenderKey = PrivateKey.generateED25519(); - var spenderAccountId = new AccountCreateTransaction() - .setKey(spenderKey) - .setInitialBalance(new Hbar(2)) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .accountId; - - var receiverKey = PrivateKey.generateED25519(); - var receiverAccountId = new AccountCreateTransaction() - .setKey(receiverKey) - .setMaxAutomaticTokenAssociations(10) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .accountId; - - TokenId nftTokenId = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .freezeWith(testEnv.client) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId; - - new TokenAssociateTransaction() - .setAccountId(spenderAccountId) - .setTokenIds(List.of(nftTokenId)) - .freezeWith(testEnv.client) - .sign(spenderKey) - .execute(testEnv.client); - - var serials = new TokenMintTransaction() - .setTokenId(nftTokenId) - .addMetadata("asd".getBytes(StandardCharsets.UTF_8)) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .serials; - - var nft1 = new NftId(nftTokenId, serials.get(0)); - - var onBehalfOfTransactionId = TransactionId.generate(spenderAccountId); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> new TransferTransaction() - .addApprovedNftTransfer(nft1, testEnv.operatorId, receiverAccountId) - .setTransactionId(onBehalfOfTransactionId) - .freezeWith(testEnv.client) - .sign(spenderKey) - .execute(testEnv.client) - .getReceipt(testEnv.client)).withMessageContaining(Status.SPENDER_DOES_NOT_HAVE_ALLOWANCE.toString()); - - testEnv.close(spenderAccountId, spenderKey); + try(var testEnv = new IntegrationTestEnv(1)){ + + var spenderKey = PrivateKey.generateED25519(); + var spenderAccountId = new AccountCreateTransaction() + .setKey(spenderKey) + .setInitialBalance(new Hbar(2)) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .accountId; + + var receiverKey = PrivateKey.generateED25519(); + var receiverAccountId = new AccountCreateTransaction() + .setKey(receiverKey) + .setMaxAutomaticTokenAssociations(10) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .accountId; + + TokenId nftTokenId = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .freezeWith(testEnv.client) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId; + + new TokenAssociateTransaction() + .setAccountId(spenderAccountId) + .setTokenIds(List.of(nftTokenId)) + .freezeWith(testEnv.client) + .sign(spenderKey) + .execute(testEnv.client); + + var serials = new TokenMintTransaction() + .setTokenId(nftTokenId) + .addMetadata("asd".getBytes(StandardCharsets.UTF_8)) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .serials; + + var nft1 = new NftId(nftTokenId, serials.get(0)); + + var onBehalfOfTransactionId = TransactionId.generate(spenderAccountId); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> new TransferTransaction() + .addApprovedNftTransfer(nft1, testEnv.operatorId, receiverAccountId) + .setTransactionId(onBehalfOfTransactionId) + .freezeWith(testEnv.client) + .sign(spenderKey) + .execute(testEnv.client) + .getReceipt(testEnv.client)).withMessageContaining(Status.SPENDER_DOES_NOT_HAVE_ALLOWANCE.toString()); + + } } @Test @DisplayName("Cannot transfer on behalf of `spender` account after removing the allowance approval") void cannotTransferAfterAllowanceRemove() throws Exception { - var testEnv = new IntegrationTestEnv(1); - - var spenderKey = PrivateKey.generateED25519(); - var spenderAccountId = new AccountCreateTransaction() - .setKey(spenderKey) - .setInitialBalance(new Hbar(2)) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .accountId; - - var receiverKey = PrivateKey.generateED25519(); - var receiverAccountId = new AccountCreateTransaction() - .setKey(receiverKey) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .accountId; - - TokenId nftTokenId = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .freezeWith(testEnv.client) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId; - - new TokenAssociateTransaction() - .setAccountId(spenderAccountId) - .setTokenIds(List.of(nftTokenId)) - .freezeWith(testEnv.client) - .sign(spenderKey) - .execute(testEnv.client); - - new TokenAssociateTransaction() - .setAccountId(receiverAccountId) - .setTokenIds(List.of(nftTokenId)) - .freezeWith(testEnv.client) - .sign(receiverKey) - .execute(testEnv.client); - - var serials = new TokenMintTransaction() - .setTokenId(nftTokenId) - .addMetadata("asd1".getBytes(StandardCharsets.UTF_8)) - .addMetadata("asd2".getBytes(StandardCharsets.UTF_8)) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .serials; - - var nft1 = new NftId(nftTokenId, serials.get(0)); - var nft2 = new NftId(nftTokenId, serials.get(1)); - - new AccountAllowanceApproveTransaction() - .approveTokenNftAllowance(nft1, testEnv.operatorId, spenderAccountId) - .approveTokenNftAllowance(nft2, testEnv.operatorId, spenderAccountId) - .execute(testEnv.client); - - new AccountAllowanceDeleteTransaction() - .deleteAllTokenNftAllowances(nft2, testEnv.operatorId) - .execute(testEnv.client); - - var onBehalfOfTransactionId = TransactionId.generate(spenderAccountId); - - new TransferTransaction() - .addApprovedNftTransfer(nft1, testEnv.operatorId, receiverAccountId) - .setTransactionId(onBehalfOfTransactionId) - .freezeWith(testEnv.client) - .sign(spenderKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var info = new TokenNftInfoQuery() - .setNftId(nft1) - .execute(testEnv.client); - assertThat(info.get(0).accountId).isEqualTo(receiverAccountId); - - var onBehalfOfTransactionId2 = TransactionId.generate(spenderAccountId); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> new TransferTransaction() - .addApprovedNftTransfer(nft2, testEnv.operatorId, receiverAccountId) - .setTransactionId(onBehalfOfTransactionId2) - .freezeWith(testEnv.client) - .sign(spenderKey) - .execute(testEnv.client) - .getReceipt(testEnv.client)).withMessageContaining(Status.SPENDER_DOES_NOT_HAVE_ALLOWANCE.toString()); - - testEnv.close(spenderAccountId, spenderKey); + try(var testEnv = new IntegrationTestEnv(1)){ + + var spenderKey = PrivateKey.generateED25519(); + var spenderAccountId = new AccountCreateTransaction() + .setKey(spenderKey) + .setInitialBalance(new Hbar(2)) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .accountId; + + var receiverKey = PrivateKey.generateED25519(); + var receiverAccountId = new AccountCreateTransaction() + .setKey(receiverKey) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .accountId; + + TokenId nftTokenId = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .freezeWith(testEnv.client) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId; + + new TokenAssociateTransaction() + .setAccountId(spenderAccountId) + .setTokenIds(List.of(nftTokenId)) + .freezeWith(testEnv.client) + .sign(spenderKey) + .execute(testEnv.client); + + new TokenAssociateTransaction() + .setAccountId(receiverAccountId) + .setTokenIds(List.of(nftTokenId)) + .freezeWith(testEnv.client) + .sign(receiverKey) + .execute(testEnv.client); + + var serials = new TokenMintTransaction() + .setTokenId(nftTokenId) + .addMetadata("asd1".getBytes(StandardCharsets.UTF_8)) + .addMetadata("asd2".getBytes(StandardCharsets.UTF_8)) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .serials; + + var nft1 = new NftId(nftTokenId, serials.get(0)); + var nft2 = new NftId(nftTokenId, serials.get(1)); + + new AccountAllowanceApproveTransaction() + .approveTokenNftAllowance(nft1, testEnv.operatorId, spenderAccountId) + .approveTokenNftAllowance(nft2, testEnv.operatorId, spenderAccountId) + .execute(testEnv.client); + + new AccountAllowanceDeleteTransaction() + .deleteAllTokenNftAllowances(nft2, testEnv.operatorId) + .execute(testEnv.client); + + var onBehalfOfTransactionId = TransactionId.generate(spenderAccountId); + + new TransferTransaction() + .addApprovedNftTransfer(nft1, testEnv.operatorId, receiverAccountId) + .setTransactionId(onBehalfOfTransactionId) + .freezeWith(testEnv.client) + .sign(spenderKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var info = new TokenNftInfoQuery() + .setNftId(nft1) + .execute(testEnv.client); + assertThat(info.get(0).accountId).isEqualTo(receiverAccountId); + + var onBehalfOfTransactionId2 = TransactionId.generate(spenderAccountId); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> new TransferTransaction() + .addApprovedNftTransfer(nft2, testEnv.operatorId, receiverAccountId) + .setTransactionId(onBehalfOfTransactionId2) + .freezeWith(testEnv.client) + .sign(spenderKey) + .execute(testEnv.client) + .getReceipt(testEnv.client)).withMessageContaining(Status.SPENDER_DOES_NOT_HAVE_ALLOWANCE.toString()); + + } } @Test @DisplayName("Cannot remove single serial number allowance when the allowance is given for all serials at once") void cannotRemoveSingleSerialWhenAllowanceIsGivenForAll() throws Exception { - var testEnv = new IntegrationTestEnv(1); - - var spenderKey = PrivateKey.generateED25519(); - var spenderAccountId = new AccountCreateTransaction() - .setKey(spenderKey) - .setInitialBalance(new Hbar(2)) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .accountId; - - var receiverKey = PrivateKey.generateED25519(); - var receiverAccountId = new AccountCreateTransaction() - .setKey(receiverKey) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .accountId; - - TokenId nftTokenId = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .freezeWith(testEnv.client) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId; - - new TokenAssociateTransaction() - .setAccountId(spenderAccountId) - .setTokenIds(List.of(nftTokenId)) - .freezeWith(testEnv.client) - .sign(spenderKey) - .execute(testEnv.client); - - new TokenAssociateTransaction() - .setAccountId(receiverAccountId) - .setTokenIds(List.of(nftTokenId)) - .freezeWith(testEnv.client) - .sign(receiverKey) - .execute(testEnv.client); - - var serials = new TokenMintTransaction() - .setTokenId(nftTokenId) - .addMetadata("asd1".getBytes(StandardCharsets.UTF_8)) - .addMetadata("asd2".getBytes(StandardCharsets.UTF_8)) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .serials; - - var nft1 = new NftId(nftTokenId, serials.get(0)); - var nft2 = new NftId(nftTokenId, serials.get(1)); - - new AccountAllowanceApproveTransaction() - .approveTokenNftAllowanceAllSerials(nftTokenId, testEnv.operatorId, spenderAccountId) - .execute(testEnv.client); - - var onBehalfOfTransactionId = TransactionId.generate(spenderAccountId); - - new TransferTransaction() - .addApprovedNftTransfer(nft1, testEnv.operatorId, receiverAccountId) - .setTransactionId(onBehalfOfTransactionId) - .freezeWith(testEnv.client) - .sign(spenderKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // hopefully in the future this should end up with a precheck error provided from services - new AccountAllowanceDeleteTransaction() - .deleteAllTokenNftAllowances(nft2, testEnv.operatorId) - .execute(testEnv.client); - - var onBehalfOfTransactionId2 = TransactionId.generate(spenderAccountId); - - new TransferTransaction() - .addApprovedNftTransfer(nft2, testEnv.operatorId, receiverAccountId) - .setTransactionId(onBehalfOfTransactionId2) - .freezeWith(testEnv.client) - .sign(spenderKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var infoNft1 = new TokenNftInfoQuery() - .setNftId(nft1) - .execute(testEnv.client); - - var infoNft2 = new TokenNftInfoQuery() - .setNftId(nft2) - .execute(testEnv.client); - - assertThat(infoNft1.get(0).accountId).isEqualTo(receiverAccountId); - assertThat(infoNft2.get(0).accountId).isEqualTo(receiverAccountId); - testEnv.close(spenderAccountId, spenderKey); + try(var testEnv = new IntegrationTestEnv(1)){ + + var spenderKey = PrivateKey.generateED25519(); + var spenderAccountId = new AccountCreateTransaction() + .setKey(spenderKey) + .setInitialBalance(new Hbar(2)) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .accountId; + + var receiverKey = PrivateKey.generateED25519(); + var receiverAccountId = new AccountCreateTransaction() + .setKey(receiverKey) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .accountId; + + TokenId nftTokenId = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .freezeWith(testEnv.client) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId; + + new TokenAssociateTransaction() + .setAccountId(spenderAccountId) + .setTokenIds(List.of(nftTokenId)) + .freezeWith(testEnv.client) + .sign(spenderKey) + .execute(testEnv.client); + + new TokenAssociateTransaction() + .setAccountId(receiverAccountId) + .setTokenIds(List.of(nftTokenId)) + .freezeWith(testEnv.client) + .sign(receiverKey) + .execute(testEnv.client); + + var serials = new TokenMintTransaction() + .setTokenId(nftTokenId) + .addMetadata("asd1".getBytes(StandardCharsets.UTF_8)) + .addMetadata("asd2".getBytes(StandardCharsets.UTF_8)) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .serials; + + var nft1 = new NftId(nftTokenId, serials.get(0)); + var nft2 = new NftId(nftTokenId, serials.get(1)); + + new AccountAllowanceApproveTransaction() + .approveTokenNftAllowanceAllSerials(nftTokenId, testEnv.operatorId, spenderAccountId) + .execute(testEnv.client); + + var onBehalfOfTransactionId = TransactionId.generate(spenderAccountId); + + new TransferTransaction() + .addApprovedNftTransfer(nft1, testEnv.operatorId, receiverAccountId) + .setTransactionId(onBehalfOfTransactionId) + .freezeWith(testEnv.client) + .sign(spenderKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // hopefully in the future this should end up with a precheck error provided from services + new AccountAllowanceDeleteTransaction() + .deleteAllTokenNftAllowances(nft2, testEnv.operatorId) + .execute(testEnv.client); + + var onBehalfOfTransactionId2 = TransactionId.generate(spenderAccountId); + + new TransferTransaction() + .addApprovedNftTransfer(nft2, testEnv.operatorId, receiverAccountId) + .setTransactionId(onBehalfOfTransactionId2) + .freezeWith(testEnv.client) + .sign(spenderKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var infoNft1 = new TokenNftInfoQuery() + .setNftId(nft1) + .execute(testEnv.client); + + var infoNft2 = new TokenNftInfoQuery() + .setNftId(nft2) + .execute(testEnv.client); + + assertThat(infoNft1.get(0).accountId).isEqualTo(receiverAccountId); + assertThat(infoNft2.get(0).accountId).isEqualTo(receiverAccountId); + } } @Test @DisplayName("Account, which given the allowance for all serials at once, should be able to give allowances for single serial numbers to other accounts") void accountGivenAllowanceForAllShouldBeAbleToGiveAllowanceForSingle() throws Exception { - var testEnv = new IntegrationTestEnv(1); - - var delegatingSpenderKey = PrivateKey.generateED25519(); - var delegatingSpenderAccountId = new AccountCreateTransaction() - .setKey(delegatingSpenderKey) - .setInitialBalance(new Hbar(2)) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .accountId; - - var spenderKey = PrivateKey.generateED25519(); - var spenderAccountId = new AccountCreateTransaction() - .setKey(spenderKey) - .setInitialBalance(new Hbar(2)) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .accountId; - - var receiverKey = PrivateKey.generateED25519(); - var receiverAccountId = new AccountCreateTransaction() - .setKey(receiverKey) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .accountId; - - TokenId nftTokenId = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .freezeWith(testEnv.client) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId; - - new TokenAssociateTransaction() - .setAccountId(delegatingSpenderAccountId) - .setTokenIds(List.of(nftTokenId)) - .freezeWith(testEnv.client) - .sign(spenderKey) - .execute(testEnv.client); - - new TokenAssociateTransaction() - .setAccountId(receiverAccountId) - .setTokenIds(List.of(nftTokenId)) - .freezeWith(testEnv.client) - .sign(receiverKey) - .execute(testEnv.client); - - var serials = new TokenMintTransaction() - .setTokenId(nftTokenId) - .addMetadata("asd1".getBytes(StandardCharsets.UTF_8)) - .addMetadata("asd2".getBytes(StandardCharsets.UTF_8)) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .serials; - - var nft1 = new NftId(nftTokenId, serials.get(0)); - var nft2 = new NftId(nftTokenId, serials.get(1)); - - new AccountAllowanceApproveTransaction() - .approveTokenNftAllowanceAllSerials(nftTokenId, testEnv.operatorId, delegatingSpenderAccountId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new AccountAllowanceApproveTransaction() - .approveTokenNftAllowance(nft1, testEnv.operatorId, spenderAccountId, delegatingSpenderAccountId) - .freezeWith(testEnv.client) - .sign(delegatingSpenderKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var onBehalfOfTransactionId = TransactionId.generate(spenderAccountId); - - new TransferTransaction() - .addApprovedNftTransfer(nft1, testEnv.operatorId, receiverAccountId) - .setTransactionId(onBehalfOfTransactionId) - .freezeWith(testEnv.client) - .sign(spenderKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var onBehalfOfTransactionId2 = TransactionId.generate(spenderAccountId); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> new TransferTransaction() - .addApprovedNftTransfer(nft2, testEnv.operatorId, receiverAccountId) - .setTransactionId(onBehalfOfTransactionId2) - .freezeWith(testEnv.client) - .sign(spenderKey) - .execute(testEnv.client) - .getReceipt(testEnv.client)).withMessageContaining(Status.SPENDER_DOES_NOT_HAVE_ALLOWANCE.toString()); - - var infoNft1 = new TokenNftInfoQuery() - .setNftId(nft1) - .execute(testEnv.client); - - var infoNft2 = new TokenNftInfoQuery() - .setNftId(nft2) - .execute(testEnv.client); - - assertThat(infoNft1.get(0).accountId).isEqualTo(receiverAccountId); - assertThat(infoNft2.get(0).accountId).isEqualTo(testEnv.operatorId); - - testEnv.close(spenderAccountId, spenderKey); + try(var testEnv = new IntegrationTestEnv(1)){ + + var delegatingSpenderKey = PrivateKey.generateED25519(); + var delegatingSpenderAccountId = new AccountCreateTransaction() + .setKey(delegatingSpenderKey) + .setInitialBalance(new Hbar(2)) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .accountId; + + var spenderKey = PrivateKey.generateED25519(); + var spenderAccountId = new AccountCreateTransaction() + .setKey(spenderKey) + .setInitialBalance(new Hbar(2)) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .accountId; + + var receiverKey = PrivateKey.generateED25519(); + var receiverAccountId = new AccountCreateTransaction() + .setKey(receiverKey) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .accountId; + + TokenId nftTokenId = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .freezeWith(testEnv.client) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId; + + new TokenAssociateTransaction() + .setAccountId(delegatingSpenderAccountId) + .setTokenIds(List.of(nftTokenId)) + .freezeWith(testEnv.client) + .sign(spenderKey) + .execute(testEnv.client); + + new TokenAssociateTransaction() + .setAccountId(receiverAccountId) + .setTokenIds(List.of(nftTokenId)) + .freezeWith(testEnv.client) + .sign(receiverKey) + .execute(testEnv.client); + + var serials = new TokenMintTransaction() + .setTokenId(nftTokenId) + .addMetadata("asd1".getBytes(StandardCharsets.UTF_8)) + .addMetadata("asd2".getBytes(StandardCharsets.UTF_8)) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .serials; + + var nft1 = new NftId(nftTokenId, serials.get(0)); + var nft2 = new NftId(nftTokenId, serials.get(1)); + + new AccountAllowanceApproveTransaction() + .approveTokenNftAllowanceAllSerials(nftTokenId, testEnv.operatorId, delegatingSpenderAccountId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new AccountAllowanceApproveTransaction() + .approveTokenNftAllowance(nft1, testEnv.operatorId, spenderAccountId, delegatingSpenderAccountId) + .freezeWith(testEnv.client) + .sign(delegatingSpenderKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var onBehalfOfTransactionId = TransactionId.generate(spenderAccountId); + + new TransferTransaction() + .addApprovedNftTransfer(nft1, testEnv.operatorId, receiverAccountId) + .setTransactionId(onBehalfOfTransactionId) + .freezeWith(testEnv.client) + .sign(spenderKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var onBehalfOfTransactionId2 = TransactionId.generate(spenderAccountId); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> new TransferTransaction() + .addApprovedNftTransfer(nft2, testEnv.operatorId, receiverAccountId) + .setTransactionId(onBehalfOfTransactionId2) + .freezeWith(testEnv.client) + .sign(spenderKey) + .execute(testEnv.client) + .getReceipt(testEnv.client)).withMessageContaining(Status.SPENDER_DOES_NOT_HAVE_ALLOWANCE.toString()); + + var infoNft1 = new TokenNftInfoQuery() + .setNftId(nft1) + .execute(testEnv.client); + + var infoNft2 = new TokenNftInfoQuery() + .setNftId(nft2) + .execute(testEnv.client); + + assertThat(infoNft1.get(0).accountId).isEqualTo(receiverAccountId); + assertThat(infoNft2.get(0).accountId).isEqualTo(testEnv.operatorId); + + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ReceiptQueryIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ReceiptQueryIntegrationTest.java index d1941e941..e2e160110 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ReceiptQueryIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ReceiptQueryIntegrationTest.java @@ -35,141 +35,140 @@ public class ReceiptQueryIntegrationTest { @Test @DisplayName("Can get Receipt") void canGetTransactionReceipt() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var key = PrivateKey.generateED25519(); + var key = PrivateKey.generateED25519(); - var response = new AccountCreateTransaction() - .setKey(key) - .execute(testEnv.client); + var response = new AccountCreateTransaction() + .setKey(key) + .execute(testEnv.client); - var receipt = new TransactionReceiptQuery() - .setTransactionId(response.transactionId) - .execute(testEnv.client); + var receipt = new TransactionReceiptQuery() + .setTransactionId(response.transactionId) + .execute(testEnv.client); - testEnv.close(receipt.accountId, key); + } } @Test @DisplayName("Can get Record") void canGetTransactionRecord() throws Exception { - var testEnv = new IntegrationTestEnv(1); - var key = PrivateKey.generateED25519(); + try(var testEnv = new IntegrationTestEnv(1)){ + var key = PrivateKey.generateED25519(); - var response = new AccountCreateTransaction() - .setKey(key) - .execute(testEnv.client); + var response = new AccountCreateTransaction() + .setKey(key) + .execute(testEnv.client); - new TransactionReceiptQuery() - .setTransactionId(response.transactionId) - .execute(testEnv.client); + new TransactionReceiptQuery() + .setTransactionId(response.transactionId) + .execute(testEnv.client); - var record = new TransactionRecordQuery() - .setTransactionId(response.transactionId) - .execute(testEnv.client); + new TransactionRecordQuery() + .setTransactionId(response.transactionId) + .execute(testEnv.client); - testEnv.close(record.receipt.accountId, key); + } } @Test @DisplayName("Can get Record cost") @SuppressWarnings("UnusedVariable") void getCostTransactionRecord() throws Exception { - var testEnv = new IntegrationTestEnv(1); - var key = PrivateKey.generateED25519(); + try(var testEnv = new IntegrationTestEnv(1)){ + var key = PrivateKey.generateED25519(); - var response = new AccountCreateTransaction() - .setKey(key) - .execute(testEnv.client); + var response = new AccountCreateTransaction() + .setKey(key) + .execute(testEnv.client); - new TransactionReceiptQuery() - .setTransactionId(response.transactionId) - .execute(testEnv.client); + new TransactionReceiptQuery() + .setTransactionId(response.transactionId) + .execute(testEnv.client); - var recordQuery = new TransactionRecordQuery() - .setTransactionId(response.transactionId); + var recordQuery = new TransactionRecordQuery() + .setTransactionId(response.transactionId); - var cost = recordQuery.getCost(testEnv.client); - - var record = recordQuery.execute(testEnv.client); + recordQuery.getCost(testEnv.client); + recordQuery.execute(testEnv.client); - testEnv.close(record.receipt.accountId, key); + } } @Test @DisplayName("Can get Record cost with big max set") @SuppressWarnings("UnusedVariable") void getCostBigMaxTransactionRecord() throws Exception { - var testEnv = new IntegrationTestEnv(1); - var key = PrivateKey.generateED25519(); + try(var testEnv = new IntegrationTestEnv(1)){ + var key = PrivateKey.generateED25519(); - var response = new AccountCreateTransaction() - .setKey(key) - .execute(testEnv.client); + var response = new AccountCreateTransaction() + .setKey(key) + .execute(testEnv.client); - new TransactionReceiptQuery() - .setTransactionId(response.transactionId) - .execute(testEnv.client); + new TransactionReceiptQuery() + .setTransactionId(response.transactionId) + .execute(testEnv.client); - var recordQuery = new TransactionRecordQuery() - .setTransactionId(response.transactionId) - .setMaxQueryPayment(new Hbar(1000)); + var recordQuery = new TransactionRecordQuery() + .setTransactionId(response.transactionId) + .setMaxQueryPayment(new Hbar(1000)); - var cost = recordQuery.getCost(testEnv.client); + recordQuery.getCost(testEnv.client); - var record = recordQuery.execute(testEnv.client); + recordQuery.execute(testEnv.client); - testEnv.close(record.receipt.accountId, key); + } } @Test @DisplayName("Error at very small max, getRecord") void getCostSmallMaxTransactionRecord() throws Exception { - var testEnv = new IntegrationTestEnv(1); - var key = PrivateKey.generateED25519(); + try(var testEnv = new IntegrationTestEnv(1)){ + var key = PrivateKey.generateED25519(); - var response = new AccountCreateTransaction() - .setKey(key) - .execute(testEnv.client); + var response = new AccountCreateTransaction() + .setKey(key) + .execute(testEnv.client); - var receipt = new TransactionReceiptQuery() - .setTransactionId(response.transactionId) - .execute(testEnv.client); + var receipt = new TransactionReceiptQuery() + .setTransactionId(response.transactionId) + .execute(testEnv.client); - var recordQuery = new TransactionRecordQuery() - .setTransactionId(response.transactionId) - .setMaxQueryPayment(Hbar.fromTinybars(1)); + var recordQuery = new TransactionRecordQuery() + .setTransactionId(response.transactionId) + .setMaxQueryPayment(Hbar.fromTinybars(1)); - var cost = recordQuery.getCost(testEnv.client); + var cost = recordQuery.getCost(testEnv.client); - assertThatExceptionOfType(RuntimeException.class).isThrownBy(() -> { - recordQuery.execute(testEnv.client); - }).withMessage("cost for TransactionRecordQuery, of " + cost.toString() + ", without explicit payment is greater than the maximum allowed payment of 1 tℏ"); + assertThatExceptionOfType(RuntimeException.class).isThrownBy(() -> { + recordQuery.execute(testEnv.client); + }).withMessage("cost for TransactionRecordQuery, of " + cost.toString() + ", without explicit payment is greater than the maximum allowed payment of 1 tℏ"); - testEnv.close(receipt.accountId, key); + } } @Test @DisplayName("Insufficient transaction fee error for transaction record query") void getCostInsufficientTxFeeTransactionRecord() throws Exception { - var testEnv = new IntegrationTestEnv(1); - var key = PrivateKey.generateED25519(); + try(var testEnv = new IntegrationTestEnv(1)){ + var key = PrivateKey.generateED25519(); - var response = new AccountCreateTransaction() - .setKey(key) - .execute(testEnv.client); + var response = new AccountCreateTransaction() + .setKey(key) + .execute(testEnv.client); - var receipt = new TransactionReceiptQuery() - .setTransactionId(response.transactionId) - .execute(testEnv.client); + var receipt = new TransactionReceiptQuery() + .setTransactionId(response.transactionId) + .execute(testEnv.client); - var recordQuery = new TransactionRecordQuery() - .setTransactionId(response.transactionId); + var recordQuery = new TransactionRecordQuery() + .setTransactionId(response.transactionId); - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - recordQuery.setQueryPayment(Hbar.fromTinybars(1)).execute(testEnv.client); - }).satisfies(error -> assertThat(error.status.toString()).isEqualTo("INSUFFICIENT_TX_FEE")); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + recordQuery.setQueryPayment(Hbar.fromTinybars(1)).execute(testEnv.client); + }).satisfies(error -> assertThat(error.status.toString()).isEqualTo("INSUFFICIENT_TX_FEE")); - testEnv.close(receipt.accountId, key); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ScheduleCreateIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ScheduleCreateIntegrationTest.java index 0cc7fffd1..690452e0f 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ScheduleCreateIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/ScheduleCreateIntegrationTest.java @@ -58,369 +58,367 @@ public class ScheduleCreateIntegrationTest { @Disabled @DisplayName("Can create schedule") void canCreateSchedule() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var key = PrivateKey.generateED25519(); + var key = PrivateKey.generateED25519(); - var transaction = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(10)); + var transaction = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(10)); - var response = new ScheduleCreateTransaction() - .setScheduledTransaction(transaction) - .setAdminKey(testEnv.operatorKey) - .setPayerAccountId(testEnv.operatorId) - .execute(testEnv.client); + var response = new ScheduleCreateTransaction() + .setScheduledTransaction(transaction) + .setAdminKey(testEnv.operatorKey) + .setPayerAccountId(testEnv.operatorId) + .execute(testEnv.client); - var scheduleId = Objects.requireNonNull(response.getReceipt(testEnv.client).scheduleId); + var scheduleId = Objects.requireNonNull(response.getReceipt(testEnv.client).scheduleId); - var info = new ScheduleInfoQuery() - .setScheduleId(scheduleId) - .execute(testEnv.client); + var info = new ScheduleInfoQuery() + .setScheduleId(scheduleId) + .execute(testEnv.client); - assertThat(info.executedAt).isNotNull(); + assertThat(info.executedAt).isNotNull(); - testEnv.close(); + } } @Test @Disabled @DisplayName("Can get Transaction") void canGetTransactionSchedule() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var key = PrivateKey.generateED25519(); + var key = PrivateKey.generateED25519(); - var transaction = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(10)); + var transaction = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(10)); - var response = new ScheduleCreateTransaction() - .setScheduledTransaction(transaction) - .setAdminKey(testEnv.operatorKey) - .setPayerAccountId(testEnv.operatorId) - .execute(testEnv.client); + var response = new ScheduleCreateTransaction() + .setScheduledTransaction(transaction) + .setAdminKey(testEnv.operatorKey) + .setPayerAccountId(testEnv.operatorId) + .execute(testEnv.client); - var scheduleId = Objects.requireNonNull(response.getReceipt(testEnv.client).scheduleId); + var scheduleId = Objects.requireNonNull(response.getReceipt(testEnv.client).scheduleId); - var info = new ScheduleInfoQuery() - .setScheduleId(scheduleId) - .execute(testEnv.client); + var info = new ScheduleInfoQuery() + .setScheduleId(scheduleId) + .execute(testEnv.client); - assertThat(info.executedAt).isNotNull(); - assertThat(info.getScheduledTransaction()).isNotNull(); + assertThat(info.executedAt).isNotNull(); + assertThat(info.getScheduledTransaction()).isNotNull(); - testEnv.close(); + } } @Test @Disabled @DisplayName("Can create schedule with schedule()") void canCreateWithSchedule() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var key = PrivateKey.generateED25519(); + var key = PrivateKey.generateED25519(); - var transaction = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(10)); + var transaction = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(10)); - var tx = transaction.schedule(); + var tx = transaction.schedule(); - var response = tx - .setAdminKey(testEnv.operatorKey) - .setPayerAccountId(testEnv.operatorId) - .execute(testEnv.client); + var response = tx + .setAdminKey(testEnv.operatorKey) + .setPayerAccountId(testEnv.operatorId) + .execute(testEnv.client); - var scheduleId = Objects.requireNonNull(response.getReceipt(testEnv.client).scheduleId); + var scheduleId = Objects.requireNonNull(response.getReceipt(testEnv.client).scheduleId); - var info = new ScheduleInfoQuery() - .setScheduleId(scheduleId) - .execute(testEnv.client); + var info = new ScheduleInfoQuery() + .setScheduleId(scheduleId) + .execute(testEnv.client); - assertThat(info.executedAt).isNotNull(); - assertThat(info.getScheduledTransaction()).isNotNull(); + assertThat(info.executedAt).isNotNull(); + assertThat(info.getScheduledTransaction()).isNotNull(); - testEnv.close(); + } } @Test @DisplayName("Can sign schedule") void canSignSchedule2() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - PrivateKey key1 = PrivateKey.generateED25519(); - PrivateKey key2 = PrivateKey.generateED25519(); - PrivateKey key3 = PrivateKey.generateED25519(); + PrivateKey key1 = PrivateKey.generateED25519(); + PrivateKey key2 = PrivateKey.generateED25519(); + PrivateKey key3 = PrivateKey.generateED25519(); - KeyList keyList = new KeyList(); + KeyList keyList = new KeyList(); - keyList.add(key1.getPublicKey()); - keyList.add(key2.getPublicKey()); - keyList.add(key3.getPublicKey()); + keyList.add(key1.getPublicKey()); + keyList.add(key2.getPublicKey()); + keyList.add(key3.getPublicKey()); - // Creat the account with the `KeyList` - TransactionResponse response = new AccountCreateTransaction() - .setKey(keyList) - .setInitialBalance(new Hbar(10)) - .execute(testEnv.client); + // Creat the account with the `KeyList` + TransactionResponse response = new AccountCreateTransaction() + .setKey(keyList) + .setInitialBalance(new Hbar(10)) + .execute(testEnv.client); - // This will wait for the receipt to become available - @Var TransactionReceipt receipt = response.getReceipt(testEnv.client); + // This will wait for the receipt to become available + @Var TransactionReceipt receipt = response.getReceipt(testEnv.client); - AccountId accountId = Objects.requireNonNull(receipt.accountId); + AccountId accountId = Objects.requireNonNull(receipt.accountId); - // Generate a `TransactionId`. This id is used to query the inner scheduled transaction - // after we expect it to have been executed - TransactionId transactionId = TransactionId.generate(testEnv.operatorId); + // Generate a `TransactionId`. This id is used to query the inner scheduled transaction + // after we expect it to have been executed + TransactionId transactionId = TransactionId.generate(testEnv.operatorId); - // Create a transfer transaction with 2/3 signatures. - TransferTransaction transfer = new TransferTransaction() - .setTransactionId(transactionId) - .addHbarTransfer(accountId, new Hbar(1).negated()) - .addHbarTransfer(testEnv.operatorId, new Hbar(1)); + // Create a transfer transaction with 2/3 signatures. + TransferTransaction transfer = new TransferTransaction() + .setTransactionId(transactionId) + .addHbarTransfer(accountId, new Hbar(1).negated()) + .addHbarTransfer(testEnv.operatorId, new Hbar(1)); - // Schedule the transactoin - ScheduleCreateTransaction scheduled = transfer.schedule(); + // Schedule the transactoin + ScheduleCreateTransaction scheduled = transfer.schedule(); - receipt = scheduled.execute(testEnv.client).getReceipt(testEnv.client); + receipt = scheduled.execute(testEnv.client).getReceipt(testEnv.client); - // Get the schedule ID from the receipt - ScheduleId scheduleId = Objects.requireNonNull(receipt.scheduleId); + // Get the schedule ID from the receipt + ScheduleId scheduleId = Objects.requireNonNull(receipt.scheduleId); - // Get the schedule info to see if `signatories` is populated with 2/3 signatures - @Var ScheduleInfo info = new ScheduleInfoQuery() - .setScheduleId(scheduleId) - .execute(testEnv.client); + // Get the schedule info to see if `signatories` is populated with 2/3 signatures + @Var ScheduleInfo info = new ScheduleInfoQuery() + .setScheduleId(scheduleId) + .execute(testEnv.client); - assertThat(info.executedAt).isNull(); + assertThat(info.executedAt).isNull(); - // Finally send this last signature to Hedera. This last signature _should_ mean the transaction executes - // since all 3 signatures have been provided. - ScheduleSignTransaction signTransaction = new ScheduleSignTransaction() - .setScheduleId(scheduleId) - .freezeWith(testEnv.client); + // Finally send this last signature to Hedera. This last signature _should_ mean the transaction executes + // since all 3 signatures have been provided. + ScheduleSignTransaction signTransaction = new ScheduleSignTransaction() + .setScheduleId(scheduleId) + .freezeWith(testEnv.client); - signTransaction.sign(key1).sign(key2).sign(key3).execute(testEnv.client).getReceipt(testEnv.client); + signTransaction.sign(key1).sign(key2).sign(key3).execute(testEnv.client).getReceipt(testEnv.client); - info = new ScheduleInfoQuery() - .setScheduleId(scheduleId) - .execute(testEnv.client); + info = new ScheduleInfoQuery() + .setScheduleId(scheduleId) + .execute(testEnv.client); - assertThat(info.executedAt).isNotNull(); + assertThat(info.executedAt).isNotNull(); - assertThat(scheduleId.getChecksum()).isNull(); - assertThat(scheduleId.hashCode()).isNotZero(); - assertThat(scheduleId.compareTo(ScheduleId.fromBytes(scheduleId.toBytes()))).isZero(); + assertThat(scheduleId.getChecksum()).isNull(); + assertThat(scheduleId.hashCode()).isNotZero(); + assertThat(scheduleId.compareTo(ScheduleId.fromBytes(scheduleId.toBytes()))).isZero(); - new AccountDeleteTransaction() - .setAccountId(accountId) - .setTransferAccountId(testEnv.operatorId) - .freezeWith(testEnv.client) - .sign(key1).sign(key2).sign(key3) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new AccountDeleteTransaction() + .setAccountId(accountId) + .setTransferAccountId(testEnv.operatorId) + .freezeWith(testEnv.client) + .sign(key1).sign(key2).sign(key3) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } @Test @DisplayName("Can schedule token transfer") void canScheduleTokenTransfer() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - PrivateKey key = PrivateKey.generateED25519(); - - var accountId = new AccountCreateTransaction() - .setReceiverSignatureRequired(true) - .setKey(key) - .setInitialBalance(new Hbar(10)) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .accountId; - - Objects.requireNonNull(accountId); - - var tokenId = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setInitialSupply(100) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId; - - Objects.requireNonNull(tokenId); - - new TokenAssociateTransaction() - .setAccountId(accountId) - .setTokenIds(Collections.singletonList(tokenId)) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var scheduleId = new TransferTransaction() - .addTokenTransfer(tokenId, testEnv.operatorId, -10) - .addTokenTransfer(tokenId, accountId, 10) - .schedule() - .execute(testEnv.client) - .getReceipt(testEnv.client) - .scheduleId; - - Objects.requireNonNull(scheduleId); - - var balanceQuery1 = new AccountBalanceQuery() - .setAccountId(accountId) - .execute(testEnv.client); - - assertThat(balanceQuery1.tokens.get(tokenId)).isEqualTo(0); - - new ScheduleSignTransaction() - .setScheduleId(scheduleId) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var balanceQuery2 = new AccountBalanceQuery() - .setAccountId(accountId) - .execute(testEnv.client); - - assertThat(balanceQuery2.tokens.get(tokenId)).isEqualTo(10); - - testEnv.close(tokenId, accountId, key); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + PrivateKey key = PrivateKey.generateED25519(); + + var accountId = new AccountCreateTransaction() + .setReceiverSignatureRequired(true) + .setKey(key) + .setInitialBalance(new Hbar(10)) + .freezeWith(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .accountId; + + Objects.requireNonNull(accountId); + + var tokenId = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setInitialSupply(100) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId; + + Objects.requireNonNull(tokenId); + + new TokenAssociateTransaction() + .setAccountId(accountId) + .setTokenIds(Collections.singletonList(tokenId)) + .freezeWith(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var scheduleId = new TransferTransaction() + .addTokenTransfer(tokenId, testEnv.operatorId, -10) + .addTokenTransfer(tokenId, accountId, 10) + .schedule() + .execute(testEnv.client) + .getReceipt(testEnv.client) + .scheduleId; + + Objects.requireNonNull(scheduleId); + + var balanceQuery1 = new AccountBalanceQuery() + .setAccountId(accountId) + .execute(testEnv.client); + + assertThat(balanceQuery1.tokens.get(tokenId)).isEqualTo(0); + + new ScheduleSignTransaction() + .setScheduleId(scheduleId) + .freezeWith(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var balanceQuery2 = new AccountBalanceQuery() + .setAccountId(accountId) + .execute(testEnv.client); + + assertThat(balanceQuery2.tokens.get(tokenId)).isEqualTo(10); + + } } @Test @DisplayName("Cannot schedule two identical transactions") void cannotScheduleTwoTransactions() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try(var testEnv = new IntegrationTestEnv(1)){ - var key = PrivateKey.generateED25519(); - var accountId = new AccountCreateTransaction() - .setInitialBalance(new Hbar(10)) - .setKey(key) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .accountId; + var key = PrivateKey.generateED25519(); + var accountId = new AccountCreateTransaction() + .setInitialBalance(new Hbar(10)) + .setKey(key) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .accountId; - var transferTx = new TransferTransaction() - .addHbarTransfer(testEnv.operatorId, new Hbar(-10)) - .addHbarTransfer(accountId, new Hbar(10)); + var transferTx = new TransferTransaction() + .addHbarTransfer(testEnv.operatorId, new Hbar(-10)) + .addHbarTransfer(accountId, new Hbar(10)); - var scheduleId1 = transferTx.schedule() - .execute(testEnv.client) - .getReceipt(testEnv.client) - .scheduleId; + var scheduleId1 = transferTx.schedule() + .execute(testEnv.client) + .getReceipt(testEnv.client) + .scheduleId; - var info1 = new ScheduleInfoQuery() - .setScheduleId(scheduleId1) - .execute(testEnv.client); + var info1 = new ScheduleInfoQuery() + .setScheduleId(scheduleId1) + .execute(testEnv.client); - assertThat(info1.executedAt).isNotNull(); + assertThat(info1.executedAt).isNotNull(); - var transferTxFromInfo = info1.getScheduledTransaction(); + var transferTxFromInfo = info1.getScheduledTransaction(); - var scheduleCreateTx1 = transferTx.schedule(); - var scheduleCreateTx2 = transferTxFromInfo.schedule(); + var scheduleCreateTx1 = transferTx.schedule(); + var scheduleCreateTx2 = transferTxFromInfo.schedule(); - assertThat(scheduleCreateTx2.toString()).isEqualTo(scheduleCreateTx1.toString()); + assertThat(scheduleCreateTx2.toString()).isEqualTo(scheduleCreateTx1.toString()); - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - transferTxFromInfo.schedule() - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining("IDENTICAL_SCHEDULE_ALREADY_CREATED"); + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + transferTxFromInfo.schedule() + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining("IDENTICAL_SCHEDULE_ALREADY_CREATED"); - testEnv.close(accountId, key); + } } @Test @DisplayName("Can schedule topic message") void canScheduleTopicMessage() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - // Generate 3 random keys - var key1 = PrivateKey.generateED25519(); + // Generate 3 random keys + var key1 = PrivateKey.generateED25519(); - // This is the submit key - var key2 = PrivateKey.generateED25519(); + // This is the submit key + var key2 = PrivateKey.generateED25519(); - var key3 = PrivateKey.generateED25519(); + var key3 = PrivateKey.generateED25519(); - var keyList = new KeyList(); + var keyList = new KeyList(); - keyList.add(key1.getPublicKey()); - keyList.add(key2.getPublicKey()); - keyList.add(key3.getPublicKey()); + keyList.add(key1.getPublicKey()); + keyList.add(key2.getPublicKey()); + keyList.add(key3.getPublicKey()); - var response = new AccountCreateTransaction() - .setInitialBalance(new Hbar(100)) - .setKey(keyList) - .execute(testEnv.client); + var response = new AccountCreateTransaction() + .setInitialBalance(new Hbar(100)) + .setKey(keyList) + .execute(testEnv.client); - assertThat(response.getReceipt(testEnv.client).accountId).isNotNull(); + assertThat(response.getReceipt(testEnv.client).accountId).isNotNull(); - var topicId = Objects.requireNonNull(new TopicCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setAutoRenewAccountId(testEnv.operatorId) - .setTopicMemo("HCS Topic_") - .setSubmitKey(key2.getPublicKey()) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .topicId - ); + var topicId = Objects.requireNonNull(new TopicCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setAutoRenewAccountId(testEnv.operatorId) + .setTopicMemo("HCS Topic_") + .setSubmitKey(key2.getPublicKey()) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .topicId + ); - var transaction = new TopicMessageSubmitTransaction() - .setTopicId(topicId) - .setMessage("scheduled hcs message".getBytes(StandardCharsets.UTF_8)); + var transaction = new TopicMessageSubmitTransaction() + .setTopicId(topicId) + .setMessage("scheduled hcs message".getBytes(StandardCharsets.UTF_8)); - // create schedule - var scheduledTx = transaction.schedule() - .setAdminKey(testEnv.operatorKey) - .setPayerAccountId(testEnv.operatorId) - .setScheduleMemo("mirror scheduled E2E signature on create and sign_" + Instant.now()); + // create schedule + var scheduledTx = transaction.schedule() + .setAdminKey(testEnv.operatorKey) + .setPayerAccountId(testEnv.operatorId) + .setScheduleMemo("mirror scheduled E2E signature on create and sign_" + Instant.now()); - var scheduled = scheduledTx.freezeWith(testEnv.client); + var scheduled = scheduledTx.freezeWith(testEnv.client); - var scheduleId = Objects.requireNonNull(scheduled - .execute(testEnv.client) - .getReceipt(testEnv.client) - .scheduleId - ); + var scheduleId = Objects.requireNonNull(scheduled + .execute(testEnv.client) + .getReceipt(testEnv.client).scheduleId); - // verify schedule has been created and has 1 of 2 signatures - @Var var info = new ScheduleInfoQuery() - .setScheduleId(scheduleId) - .execute(testEnv.client); + // verify schedule has been created and has 1 of 2 signatures + @Var var info = new ScheduleInfoQuery() + .setScheduleId(scheduleId) + .execute(testEnv.client); - assertThat(info).isNotNull(); - assertThat(info.scheduleId).isEqualTo(scheduleId); + assertThat(info).isNotNull(); + assertThat(info.scheduleId).isEqualTo(scheduleId); - var infoTransaction = (TopicMessageSubmitTransaction) info.getScheduledTransaction(); + var infoTransaction = (TopicMessageSubmitTransaction) info.getScheduledTransaction(); - assertThat(transaction.getTopicId()).isEqualTo(infoTransaction.getTopicId()); - assertThat(transaction.getNodeAccountIds()).isEqualTo(infoTransaction.getNodeAccountIds()); + assertThat(transaction.getTopicId()).isEqualTo(infoTransaction.getTopicId()); + assertThat(transaction.getNodeAccountIds()).isEqualTo(infoTransaction.getNodeAccountIds()); - var scheduleSign = new ScheduleSignTransaction() - .setScheduleId(scheduleId) - .freezeWith(testEnv.client); + var scheduleSign = new ScheduleSignTransaction() + .setScheduleId(scheduleId) + .freezeWith(testEnv.client); - scheduleSign - .sign(key2) - .execute(testEnv.client) - .getReceipt(testEnv.client); + scheduleSign + .sign(key2) + .execute(testEnv.client) + .getReceipt(testEnv.client); - info = new ScheduleInfoQuery() - .setScheduleId(scheduleId) - .execute(testEnv.client); + info = new ScheduleInfoQuery() + .setScheduleId(scheduleId) + .execute(testEnv.client); - assertThat(info.executedAt).isNotNull(); + assertThat(info.executedAt).isNotNull(); - testEnv.close(); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/SystemIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/SystemIntegrationTest.java index f55f65ae3..3eeaecb2f 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/SystemIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/SystemIntegrationTest.java @@ -41,54 +41,53 @@ public class SystemIntegrationTest { @Test @DisplayName("All system transactions are not supported") void allSystemTransactionsAreNotSupported() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var fileId = Objects.requireNonNull( - new FileCreateTransaction() - .setContents(SMART_CONTRACT_BYTECODE) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .fileId - ); + var fileId = Objects.requireNonNull( + new FileCreateTransaction() + .setContents(SMART_CONTRACT_BYTECODE) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .fileId); - var contractId = Objects.requireNonNull( - new ContractCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setGas(200000) - .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) - .setBytecodeFileId(fileId) - .setContractMemo("[e2e::ContractCreateTransaction]") - .execute(testEnv.client) - .getReceipt(testEnv.client) - .contractId - ); + var contractId = Objects.requireNonNull( + new ContractCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setGas(200000) + .setConstructorParameters(new ContractFunctionParameters().addString("Hello from Hedera.")) + .setBytecodeFileId(fileId) + .setContractMemo("[e2e::ContractCreateTransaction]") + .execute(testEnv.client) + .getReceipt(testEnv.client) + .contractId + ); - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new SystemDeleteTransaction() - .setContractId(contractId) - .setExpirationTime(Instant.now()) - .execute(testEnv.client); - }).withMessageContaining(Status.NOT_SUPPORTED.toString()); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new SystemDeleteTransaction() + .setContractId(contractId) + .setExpirationTime(Instant.now()) + .execute(testEnv.client); + }).withMessageContaining(Status.NOT_SUPPORTED.toString()); - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new SystemDeleteTransaction() - .setFileId(fileId) - .setExpirationTime(Instant.now()) - .execute(testEnv.client); - }).withMessageContaining(Status.NOT_SUPPORTED.toString()); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new SystemDeleteTransaction() + .setFileId(fileId) + .setExpirationTime(Instant.now()) + .execute(testEnv.client); + }).withMessageContaining(Status.NOT_SUPPORTED.toString()); - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new SystemUndeleteTransaction() - .setContractId(contractId) - .execute(testEnv.client); - }).withMessageContaining(Status.NOT_SUPPORTED.toString()); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new SystemUndeleteTransaction() + .setContractId(contractId) + .execute(testEnv.client); + }).withMessageContaining(Status.NOT_SUPPORTED.toString()); - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new SystemUndeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client); - }).withMessageContaining(Status.NOT_SUPPORTED.toString()); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new SystemUndeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client); + }).withMessageContaining(Status.NOT_SUPPORTED.toString()); - testEnv.close(); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenAirdropCancelIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenAirdropCancelIntegrationTest.java index 81983cd9b..3d15da8e2 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenAirdropCancelIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenAirdropCancelIntegrationTest.java @@ -52,431 +52,428 @@ class TokenAirdropCancelIntegrationTest { @Test @DisplayName("Cancels the tokens when they are in pending state") void canCancelTokens() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // create fungible and nf token - var tokenID = EntityHelper.createFungibleToken(testEnv, 3); - var nftID = EntityHelper.createNft(testEnv); - // mint some NFTs - var mintReceipt = new TokenMintTransaction() - .setTokenId(nftID) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - var nftSerials = mintReceipt.serials; - - // create receiver with 0 auto associations - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); - - // airdrop the tokens - var record = new TokenAirdropTransaction() - .addNftTransfer(nftID.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(nftID.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) - .addTokenTransfer(tokenID, receiverAccountId, amount) - .addTokenTransfer(tokenID, testEnv.operatorId, -amount) - .execute(testEnv.client) - .getRecord(testEnv.client); - - // sender cancels the tokens - record = new TokenCancelAirdropTransaction() - .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) - .addPendingAirdrop(record.pendingAirdropRecords.get(1).getPendingAirdropId()) - .addPendingAirdrop(record.pendingAirdropRecords.get(2).getPendingAirdropId()) - .execute(testEnv.client) - .getRecord(testEnv.client); - - // verify in the transaction record the pending airdrop ids for nft and ft - should no longer exist - assertEquals(0, record.pendingAirdropRecords.size()); - - // verify the receiver does not hold the tokens via query - var receiverAccountBalance = new AccountBalanceQuery() - .setAccountId(receiverAccountId) - .execute(testEnv.client); - assertNull(receiverAccountBalance.tokens.get(tokenID)); - assertNull(receiverAccountBalance.tokens.get(nftID)); - - // verify the operator does hold the tokens - var operatorBalance = new AccountBalanceQuery() - .setAccountId(testEnv.operatorId) - .execute(testEnv.client); - assertEquals(fungibleInitialBalance, operatorBalance.tokens.get(tokenID)); - assertEquals(mitedNfts, operatorBalance.tokens.get(nftID)); - - testEnv.close(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + // create fungible and nf token + var tokenID = EntityHelper.createFungibleToken(testEnv, 3); + var nftID = EntityHelper.createNft(testEnv); + // mint some NFTs + var mintReceipt = new TokenMintTransaction() + .setTokenId(nftID) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + var nftSerials = mintReceipt.serials; + + // create receiver with 0 auto associations + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); + + // airdrop the tokens + var record = new TokenAirdropTransaction() + .addNftTransfer(nftID.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(nftID.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) + .addTokenTransfer(tokenID, receiverAccountId, amount) + .addTokenTransfer(tokenID, testEnv.operatorId, -amount) + .execute(testEnv.client) + .getRecord(testEnv.client); + + // sender cancels the tokens + record = new TokenCancelAirdropTransaction() + .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) + .addPendingAirdrop(record.pendingAirdropRecords.get(1).getPendingAirdropId()) + .addPendingAirdrop(record.pendingAirdropRecords.get(2).getPendingAirdropId()) + .execute(testEnv.client) + .getRecord(testEnv.client); + + // verify in the transaction record the pending airdrop ids for nft and ft - should no longer exist + assertEquals(0, record.pendingAirdropRecords.size()); + + // verify the receiver does not hold the tokens via query + var receiverAccountBalance = new AccountBalanceQuery() + .setAccountId(receiverAccountId) + .execute(testEnv.client); + assertNull(receiverAccountBalance.tokens.get(tokenID)); + assertNull(receiverAccountBalance.tokens.get(nftID)); + + // verify the operator does hold the tokens + var operatorBalance = new AccountBalanceQuery() + .setAccountId(testEnv.operatorId) + .execute(testEnv.client); + assertEquals(fungibleInitialBalance, operatorBalance.tokens.get(tokenID)); + assertEquals(mitedNfts, operatorBalance.tokens.get(nftID)); + + } } @Test @DisplayName("Cancels the tokens when token is frozen") void canCancelTokensWhenTokenIsFrozen() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // create fungible token - var tokenID = EntityHelper.createFungibleToken(testEnv, 3); - - // create receiver with 0 auto associations - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); - - // airdrop the tokens - var record = new TokenAirdropTransaction() - .addTokenTransfer(tokenID, receiverAccountId, amount) - .addTokenTransfer(tokenID, testEnv.operatorId, -amount) - .execute(testEnv.client) - .getRecord(testEnv.client); - - // associate - new TokenAssociateTransaction() - .setAccountId(receiverAccountId) - .setTokenIds(Collections.singletonList(tokenID)) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // freeze the token - new TokenFreezeTransaction() - .setAccountId(receiverAccountId) - .setTokenId(tokenID) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // cancel - new TokenCancelAirdropTransaction() - .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) - .execute(testEnv.client) - .getRecord(testEnv.client); - - testEnv.close(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + // create fungible token + var tokenID = EntityHelper.createFungibleToken(testEnv, 3); + + // create receiver with 0 auto associations + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); + + // airdrop the tokens + var record = new TokenAirdropTransaction() + .addTokenTransfer(tokenID, receiverAccountId, amount) + .addTokenTransfer(tokenID, testEnv.operatorId, -amount) + .execute(testEnv.client) + .getRecord(testEnv.client); + + // associate + new TokenAssociateTransaction() + .setAccountId(receiverAccountId) + .setTokenIds(Collections.singletonList(tokenID)) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // freeze the token + new TokenFreezeTransaction() + .setAccountId(receiverAccountId) + .setTokenId(tokenID) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // cancel + new TokenCancelAirdropTransaction() + .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) + .execute(testEnv.client) + .getRecord(testEnv.client); + + } } @Test @DisplayName("Cancels the tokens when token is paused") void canCancelTokensWhenTokenIsPaused() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { - // create fungible token - var tokenID = EntityHelper.createFungibleToken(testEnv, 3); + // create fungible token + var tokenID = EntityHelper.createFungibleToken(testEnv, 3); - // create receiver with 0 auto associations - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); + // create receiver with 0 auto associations + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); - // airdrop the tokens - var record = new TokenAirdropTransaction() - .addTokenTransfer(tokenID, receiverAccountId, amount) - .addTokenTransfer(tokenID, testEnv.operatorId, -amount) - .execute(testEnv.client) - .getRecord(testEnv.client); + // airdrop the tokens + var record = new TokenAirdropTransaction() + .addTokenTransfer(tokenID, receiverAccountId, amount) + .addTokenTransfer(tokenID, testEnv.operatorId, -amount) + .execute(testEnv.client) + .getRecord(testEnv.client); - // pause the token - new TokenPauseTransaction().setTokenId(tokenID).execute(testEnv.client).getReceipt(testEnv.client); + // pause the token + new TokenPauseTransaction().setTokenId(tokenID).execute(testEnv.client).getReceipt(testEnv.client); - // cancel - new TokenCancelAirdropTransaction() - .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) - .execute(testEnv.client) - .getRecord(testEnv.client); + // cancel + new TokenCancelAirdropTransaction() + .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) + .execute(testEnv.client) + .getRecord(testEnv.client); - testEnv.close(); + } } @Test @DisplayName("Cancels the tokens when token is deleted") void canCancelTokensWhenTokenIsDeleted() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { - // create fungible token - var tokenID = EntityHelper.createFungibleToken(testEnv, 3); + // create fungible token + var tokenID = EntityHelper.createFungibleToken(testEnv, 3); - // create receiver with 0 auto associations - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); + // create receiver with 0 auto associations + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); - // airdrop the tokens - var record = new TokenAirdropTransaction() - .addTokenTransfer(tokenID, receiverAccountId, amount) - .addTokenTransfer(tokenID, testEnv.operatorId, -amount) - .execute(testEnv.client) - .getRecord(testEnv.client); + // airdrop the tokens + var record = new TokenAirdropTransaction() + .addTokenTransfer(tokenID, receiverAccountId, amount) + .addTokenTransfer(tokenID, testEnv.operatorId, -amount) + .execute(testEnv.client) + .getRecord(testEnv.client); - // delete the token - new TokenDeleteTransaction().setTokenId(tokenID).execute(testEnv.client).getReceipt(testEnv.client); + // delete the token + new TokenDeleteTransaction().setTokenId(tokenID).execute(testEnv.client).getReceipt(testEnv.client); - // cancel - new TokenCancelAirdropTransaction() - .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) - .execute(testEnv.client) - .getRecord(testEnv.client); + // cancel + new TokenCancelAirdropTransaction() + .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) + .execute(testEnv.client) + .getRecord(testEnv.client); - testEnv.close(); + } } @Test @DisplayName("Cancels the tokens when they are in pending state to multiple receivers") void canCancelTokensToMultipleReceivers() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // create fungible and nf token - var tokenID = EntityHelper.createFungibleToken(testEnv, 3); - var nftID = EntityHelper.createNft(testEnv); - // mint some NFTs - var mintReceipt = new TokenMintTransaction() - .setTokenId(nftID) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - var nftSerials = mintReceipt.serials; - - // create receiver1 with 0 auto associations - var receiver1AccountKey = PrivateKey.generateED25519(); - var receiver1AccountId = EntityHelper.createAccount(testEnv, receiver1AccountKey, 0); - - // create receiver2 with 0 auto associations - var receiver2AccountKey = PrivateKey.generateED25519(); - var receiver2AccountId = EntityHelper.createAccount(testEnv, receiver2AccountKey, 0); - - // airdrop the tokens to both - var record = new TokenAirdropTransaction() - .addNftTransfer(nftID.nft(nftSerials.get(0)), testEnv.operatorId, receiver1AccountId) - .addNftTransfer(nftID.nft(nftSerials.get(1)), testEnv.operatorId, receiver1AccountId) - .addTokenTransfer(tokenID, receiver1AccountId, amount) - .addTokenTransfer(tokenID, testEnv.operatorId, -amount) - .addNftTransfer(nftID.nft(nftSerials.get(2)), testEnv.operatorId, receiver2AccountId) - .addNftTransfer(nftID.nft(nftSerials.get(3)), testEnv.operatorId, receiver2AccountId) - .addTokenTransfer(tokenID, receiver2AccountId, amount) - .addTokenTransfer(tokenID, testEnv.operatorId, -amount) - .execute(testEnv.client) - .getRecord(testEnv.client); - - // verify the txn record - assertEquals(6, record.pendingAirdropRecords.size()); - - // cancel the tokens signing with receiver1 and receiver2 - var pendingAirdropIDs = record.pendingAirdropRecords.stream().map(PendingAirdropRecord::getPendingAirdropId) - .toList(); - record = new TokenCancelAirdropTransaction() - .setPendingAirdropIds(pendingAirdropIDs) - .execute(testEnv.client) - .getRecord(testEnv.client); - - // verify in the transaction record the pending airdrop ids for nft and ft - should no longer exist - assertEquals(0, record.pendingAirdropRecords.size()); - - // verify receiver1 does not hold the tokens via query - var receiverAccountBalance = new AccountBalanceQuery() - .setAccountId(receiver1AccountId) - .execute(testEnv.client); - assertNull(receiverAccountBalance.tokens.get(tokenID)); - assertNull(receiverAccountBalance.tokens.get(nftID)); - - // verify receiver2 does not hold the tokens via query - var receiver2AccountBalance = new AccountBalanceQuery() - .setAccountId(receiver1AccountId) - .execute(testEnv.client); - assertNull(receiver2AccountBalance.tokens.get(tokenID)); - assertNull(receiver2AccountBalance.tokens.get(nftID)); - - // verify the operator does hold the tokens - var operatorBalance = new AccountBalanceQuery() - .setAccountId(testEnv.operatorId) - .execute(testEnv.client); - assertEquals(fungibleInitialBalance, operatorBalance.tokens.get(tokenID)); - assertEquals(mitedNfts, operatorBalance.tokens.get(nftID)); - - testEnv.close(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + // create fungible and nf token + var tokenID = EntityHelper.createFungibleToken(testEnv, 3); + var nftID = EntityHelper.createNft(testEnv); + // mint some NFTs + var mintReceipt = new TokenMintTransaction() + .setTokenId(nftID) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + var nftSerials = mintReceipt.serials; + + // create receiver1 with 0 auto associations + var receiver1AccountKey = PrivateKey.generateED25519(); + var receiver1AccountId = EntityHelper.createAccount(testEnv, receiver1AccountKey, 0); + + // create receiver2 with 0 auto associations + var receiver2AccountKey = PrivateKey.generateED25519(); + var receiver2AccountId = EntityHelper.createAccount(testEnv, receiver2AccountKey, 0); + + // airdrop the tokens to both + var record = new TokenAirdropTransaction() + .addNftTransfer(nftID.nft(nftSerials.get(0)), testEnv.operatorId, receiver1AccountId) + .addNftTransfer(nftID.nft(nftSerials.get(1)), testEnv.operatorId, receiver1AccountId) + .addTokenTransfer(tokenID, receiver1AccountId, amount) + .addTokenTransfer(tokenID, testEnv.operatorId, -amount) + .addNftTransfer(nftID.nft(nftSerials.get(2)), testEnv.operatorId, receiver2AccountId) + .addNftTransfer(nftID.nft(nftSerials.get(3)), testEnv.operatorId, receiver2AccountId) + .addTokenTransfer(tokenID, receiver2AccountId, amount) + .addTokenTransfer(tokenID, testEnv.operatorId, -amount) + .execute(testEnv.client) + .getRecord(testEnv.client); + + // verify the txn record + assertEquals(6, record.pendingAirdropRecords.size()); + + // cancel the tokens signing with receiver1 and receiver2 + var pendingAirdropIDs = record.pendingAirdropRecords.stream().map(PendingAirdropRecord::getPendingAirdropId) + .toList(); + record = new TokenCancelAirdropTransaction() + .setPendingAirdropIds(pendingAirdropIDs) + .execute(testEnv.client) + .getRecord(testEnv.client); + + // verify in the transaction record the pending airdrop ids for nft and ft - should no longer exist + assertEquals(0, record.pendingAirdropRecords.size()); + + // verify receiver1 does not hold the tokens via query + var receiverAccountBalance = new AccountBalanceQuery() + .setAccountId(receiver1AccountId) + .execute(testEnv.client); + assertNull(receiverAccountBalance.tokens.get(tokenID)); + assertNull(receiverAccountBalance.tokens.get(nftID)); + + // verify receiver2 does not hold the tokens via query + var receiver2AccountBalance = new AccountBalanceQuery() + .setAccountId(receiver1AccountId) + .execute(testEnv.client); + assertNull(receiver2AccountBalance.tokens.get(tokenID)); + assertNull(receiver2AccountBalance.tokens.get(nftID)); + + // verify the operator does hold the tokens + var operatorBalance = new AccountBalanceQuery() + .setAccountId(testEnv.operatorId) + .execute(testEnv.client); + assertEquals(fungibleInitialBalance, operatorBalance.tokens.get(tokenID)); + assertEquals(mitedNfts, operatorBalance.tokens.get(nftID)); + + } } - @Test @DisplayName("Cancels the tokens when they are in pending state from multiple airdrop transactions") void canCancelTokensFromMultipleAirdropTxns() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // create fungible and nf token - var tokenID = EntityHelper.createFungibleToken(testEnv, 3); - var nftID = EntityHelper.createNft(testEnv); - // mint some NFTs - var mintReceipt = new TokenMintTransaction() - .setTokenId(nftID) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - var nftSerials = mintReceipt.serials; - - // create receiver with 0 auto associations - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); - - // airdrop some of the tokens to the receiver - var record1 = new TokenAirdropTransaction() - .addNftTransfer(nftID.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) - .execute(testEnv.client) - .getRecord(testEnv.client); - // airdrop some of the tokens to the receiver - var record2 = new TokenAirdropTransaction() - .addNftTransfer(nftID.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) - .execute(testEnv.client) - .getRecord(testEnv.client); - // airdrop some of the tokens to the receiver - var record3 = new TokenAirdropTransaction() - .addTokenTransfer(tokenID, receiverAccountId, amount) - .addTokenTransfer(tokenID, testEnv.operatorId, -amount) - .execute(testEnv.client) - .getRecord(testEnv.client); - - // get the PendingIds from the records - var pendingAirdropIDs = new ArrayList(); - pendingAirdropIDs.add(record1.pendingAirdropRecords.get(0).getPendingAirdropId()); - pendingAirdropIDs.add(record2.pendingAirdropRecords.get(0).getPendingAirdropId()); - pendingAirdropIDs.add(record3.pendingAirdropRecords.get(0).getPendingAirdropId()); - - // cancel the all the tokens with the receiver - var record = new TokenCancelAirdropTransaction() - .setPendingAirdropIds(pendingAirdropIDs) - .execute(testEnv.client) - .getRecord(testEnv.client); - - // verify in the transaction record the pending airdrop ids for nft and ft - should no longer exist - assertEquals(0, record.pendingAirdropRecords.size()); - - // verify the receiver does not hold the tokens via query - var receiverAccountBalance = new AccountBalanceQuery() - .setAccountId(receiverAccountId) - .execute(testEnv.client); - assertNull(receiverAccountBalance.tokens.get(tokenID)); - assertNull(receiverAccountBalance.tokens.get(nftID)); - - // verify the operator does hold the tokens - var operatorBalance = new AccountBalanceQuery() - .setAccountId(testEnv.operatorId) - .execute(testEnv.client); - assertEquals(fungibleInitialBalance, operatorBalance.tokens.get(tokenID)); - assertEquals(mitedNfts, operatorBalance.tokens.get(nftID)); - - testEnv.close(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + // create fungible and nf token + var tokenID = EntityHelper.createFungibleToken(testEnv, 3); + var nftID = EntityHelper.createNft(testEnv); + // mint some NFTs + var mintReceipt = new TokenMintTransaction() + .setTokenId(nftID) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + var nftSerials = mintReceipt.serials; + + // create receiver with 0 auto associations + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); + + // airdrop some of the tokens to the receiver + var record1 = new TokenAirdropTransaction() + .addNftTransfer(nftID.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) + .execute(testEnv.client) + .getRecord(testEnv.client); + // airdrop some of the tokens to the receiver + var record2 = new TokenAirdropTransaction() + .addNftTransfer(nftID.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) + .execute(testEnv.client) + .getRecord(testEnv.client); + // airdrop some of the tokens to the receiver + var record3 = new TokenAirdropTransaction() + .addTokenTransfer(tokenID, receiverAccountId, amount) + .addTokenTransfer(tokenID, testEnv.operatorId, -amount) + .execute(testEnv.client) + .getRecord(testEnv.client); + + // get the PendingIds from the records + var pendingAirdropIDs = new ArrayList(); + pendingAirdropIDs.add(record1.pendingAirdropRecords.get(0).getPendingAirdropId()); + pendingAirdropIDs.add(record2.pendingAirdropRecords.get(0).getPendingAirdropId()); + pendingAirdropIDs.add(record3.pendingAirdropRecords.get(0).getPendingAirdropId()); + + // cancel the all the tokens with the receiver + var record = new TokenCancelAirdropTransaction() + .setPendingAirdropIds(pendingAirdropIDs) + .execute(testEnv.client) + .getRecord(testEnv.client); + + // verify in the transaction record the pending airdrop ids for nft and ft - should no longer exist + assertEquals(0, record.pendingAirdropRecords.size()); + + // verify the receiver does not hold the tokens via query + var receiverAccountBalance = new AccountBalanceQuery() + .setAccountId(receiverAccountId) + .execute(testEnv.client); + assertNull(receiverAccountBalance.tokens.get(tokenID)); + assertNull(receiverAccountBalance.tokens.get(nftID)); + + // verify the operator does hold the tokens + var operatorBalance = new AccountBalanceQuery() + .setAccountId(testEnv.operatorId) + .execute(testEnv.client); + assertEquals(fungibleInitialBalance, operatorBalance.tokens.get(tokenID)); + assertEquals(mitedNfts, operatorBalance.tokens.get(nftID)); + + } } @Test @DisplayName("Cannot cancel the tokens when they are not airdropped") void cannotCancelTokensForNonExistingAirdrop() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // create fungible token - var tokenID = EntityHelper.createFungibleToken(testEnv, 3); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { - // create receiver with 0 auto associations - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); + // create fungible token + var tokenID = EntityHelper.createFungibleToken(testEnv, 3); - // airdrop the tokens - var record = new TokenAirdropTransaction() - .addTokenTransfer(tokenID, receiverAccountId, amount) - .addTokenTransfer(tokenID, testEnv.operatorId, -amount) - .execute(testEnv.client) - .getRecord(testEnv.client); + // create receiver with 0 auto associations + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); - // create receiver with 0 auto associations - var randomAccountKey = PrivateKey.generateED25519(); - var randomAccount = EntityHelper.createAccount(testEnv, randomAccountKey, 0); - - - // cancel the tokens with the random account which has not created pending airdrops - // fails with INVALID_SIGNATURE - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenCancelAirdropTransaction() - .setTransactionId(TransactionId.generate(randomAccount)) - .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) + // airdrop the tokens + var record = new TokenAirdropTransaction() + .addTokenTransfer(tokenID, receiverAccountId, amount) + .addTokenTransfer(tokenID, testEnv.operatorId, -amount) .execute(testEnv.client) .getRecord(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - testEnv.close(); + // create receiver with 0 auto associations + var randomAccountKey = PrivateKey.generateED25519(); + var randomAccount = EntityHelper.createAccount(testEnv, randomAccountKey, 0); + + // cancel the tokens with the random account which has not created pending airdrops + // fails with INVALID_SIGNATURE + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenCancelAirdropTransaction() + .setTransactionId(TransactionId.generate(randomAccount)) + .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) + .execute(testEnv.client) + .getRecord(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + } } @Test @DisplayName("Cannot cancel the tokens when they are already canceled") void canonCancelTokensForAlreadyCanceledAirdrop() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // create fungible token - var tokenID = EntityHelper.createFungibleToken(testEnv, 3); - - // create receiver with 0 auto associations - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); - - // airdrop the tokens - var record = new TokenAirdropTransaction() - .addTokenTransfer(tokenID, receiverAccountId, amount) - .addTokenTransfer(tokenID, testEnv.operatorId, -amount) - .execute(testEnv.client) - .getRecord(testEnv.client); - - // cancel the tokens with the receiver - new TokenCancelAirdropTransaction() - .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) - .execute(testEnv.client) - .getRecord(testEnv.client); - - // cancel the tokens with the receiver again - // fails with INVALID_PENDING_AIRDROP_ID - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + // create fungible token + var tokenID = EntityHelper.createFungibleToken(testEnv, 3); + + // create receiver with 0 auto associations + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); + + // airdrop the tokens + var record = new TokenAirdropTransaction() + .addTokenTransfer(tokenID, receiverAccountId, amount) + .addTokenTransfer(tokenID, testEnv.operatorId, -amount) + .execute(testEnv.client) + .getRecord(testEnv.client); + + // cancel the tokens with the receiver new TokenCancelAirdropTransaction() .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) .execute(testEnv.client) .getRecord(testEnv.client); - }).withMessageContaining(Status.INVALID_PENDING_AIRDROP_ID.toString()); - testEnv.close(); - } + // cancel the tokens with the receiver again + // fails with INVALID_PENDING_AIRDROP_ID + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenCancelAirdropTransaction() + .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) + .execute(testEnv.client) + .getRecord(testEnv.client); + }).withMessageContaining(Status.INVALID_PENDING_AIRDROP_ID.toString()); + } + } @Test @DisplayName("Cannot cancel the tokens with empty list") void canonCancelWithEmptyPendingAirdropsList() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { - // cancel the tokens with the receiver without setting pendingAirdropIds - // fails with EMPTY_PENDING_AIRDROP_ID_LIST - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenCancelAirdropTransaction() - .execute(testEnv.client) - .getRecord(testEnv.client); - }).withMessageContaining(Status.EMPTY_PENDING_AIRDROP_ID_LIST.toString()); + // cancel the tokens with the receiver without setting pendingAirdropIds + // fails with EMPTY_PENDING_AIRDROP_ID_LIST + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenCancelAirdropTransaction() + .execute(testEnv.client) + .getRecord(testEnv.client); + }).withMessageContaining(Status.EMPTY_PENDING_AIRDROP_ID_LIST.toString()); - testEnv.close(); + } } @Test @DisplayName("Cannot cancel the tokens with duplicate entries") void cannotCancelTokensWithDuplicateEntries() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { - // create fungible token - var tokenID = EntityHelper.createFungibleToken(testEnv, 3); + // create fungible token + var tokenID = EntityHelper.createFungibleToken(testEnv, 3); - // create receiver with 0 auto associations - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); + // create receiver with 0 auto associations + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); - // airdrop the tokens - var record = new TokenAirdropTransaction() - .addTokenTransfer(tokenID, receiverAccountId, amount) - .addTokenTransfer(tokenID, testEnv.operatorId, -amount) - .execute(testEnv.client) - .getRecord(testEnv.client); - - // cancel the tokens with duplicate pending airdrop token ids - // fails with PENDING_AIRDROP_ID_REPEATED - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenCancelAirdropTransaction() - .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) - .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) + // airdrop the tokens + var record = new TokenAirdropTransaction() + .addTokenTransfer(tokenID, receiverAccountId, amount) + .addTokenTransfer(tokenID, testEnv.operatorId, -amount) .execute(testEnv.client) .getRecord(testEnv.client); - }).withMessageContaining(Status.PENDING_AIRDROP_ID_REPEATED.toString()); - testEnv.close(); + // cancel the tokens with duplicate pending airdrop token ids + // fails with PENDING_AIRDROP_ID_REPEATED + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenCancelAirdropTransaction() + .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) + .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) + .execute(testEnv.client) + .getRecord(testEnv.client); + }).withMessageContaining(Status.PENDING_AIRDROP_ID_REPEATED.toString()); + + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenAirdropClaimIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenAirdropClaimIntegrationTest.java index 80eb956f5..07817fbc0 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenAirdropClaimIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenAirdropClaimIntegrationTest.java @@ -51,464 +51,463 @@ class TokenAirdropClaimIntegrationTest { @Test @DisplayName("Claims the tokens when they are in pending state") void canClaimTokens() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // create fungible and nf token - var tokenID = EntityHelper.createFungibleToken(testEnv, 3); - var nftID = EntityHelper.createNft(testEnv); - // mint some NFTs - var mintReceipt = new TokenMintTransaction() - .setTokenId(nftID) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - var nftSerials = mintReceipt.serials; - - // create receiver with 0 auto associations - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); - - // airdrop the tokens - var record = new TokenAirdropTransaction() - .addNftTransfer(nftID.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(nftID.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) - .addTokenTransfer(tokenID, receiverAccountId, amount) - .addTokenTransfer(tokenID, testEnv.operatorId, -amount) - .execute(testEnv.client) - .getRecord(testEnv.client); - - // verify the txn record - assertEquals(3, record.pendingAirdropRecords.size()); - - assertEquals(100, record.pendingAirdropRecords.get(0).getPendingAirdropAmount()); - assertEquals(tokenID, record.pendingAirdropRecords.get(0).getPendingAirdropId().getTokenId()); - assertNull(record.pendingAirdropRecords.get(0).getPendingAirdropId().getNftId()); - - assertEquals(0, record.pendingAirdropRecords.get(1).getPendingAirdropAmount()); - assertEquals(nftID.nft(1), record.pendingAirdropRecords.get(1).getPendingAirdropId().getNftId()); - assertNull(record.pendingAirdropRecords.get(1).getPendingAirdropId().getTokenId()); - - assertEquals(0, record.pendingAirdropRecords.get(2).getPendingAirdropAmount()); - assertEquals(nftID.nft(2), record.pendingAirdropRecords.get(2).getPendingAirdropId().getNftId()); - assertNull(record.pendingAirdropRecords.get(2).getPendingAirdropId().getTokenId()); - - // claim the tokens with the receiver - record = new TokenClaimAirdropTransaction() - .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) - .addPendingAirdrop(record.pendingAirdropRecords.get(1).getPendingAirdropId()) - .addPendingAirdrop(record.pendingAirdropRecords.get(2).getPendingAirdropId()) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .execute(testEnv.client) - .getRecord(testEnv.client); - - // verify in the transaction record the pending airdrop ids for nft and ft - should no longer exist - assertEquals(0, record.pendingAirdropRecords.size()); - - // verify the receiver holds the tokens via query - var receiverAccountBalance = new AccountBalanceQuery() - .setAccountId(receiverAccountId) - .execute(testEnv.client); - assertEquals(amount, receiverAccountBalance.tokens.get(tokenID)); - assertEquals(2, receiverAccountBalance.tokens.get(nftID)); - - // verify the operator does not hold the tokens - var operatorBalance = new AccountBalanceQuery() - .setAccountId(testEnv.operatorId) - .execute(testEnv.client); - assertEquals(fungibleInitialBalance - amount, operatorBalance.tokens.get(tokenID)); - assertEquals(mitedNfts - 2, operatorBalance.tokens.get(nftID)); - - testEnv.close(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + // create fungible and nf token + var tokenID = EntityHelper.createFungibleToken(testEnv, 3); + var nftID = EntityHelper.createNft(testEnv); + // mint some NFTs + var mintReceipt = new TokenMintTransaction() + .setTokenId(nftID) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + var nftSerials = mintReceipt.serials; + + // create receiver with 0 auto associations + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); + + // airdrop the tokens + var record = new TokenAirdropTransaction() + .addNftTransfer(nftID.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(nftID.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) + .addTokenTransfer(tokenID, receiverAccountId, amount) + .addTokenTransfer(tokenID, testEnv.operatorId, -amount) + .execute(testEnv.client) + .getRecord(testEnv.client); + + // verify the txn record + assertEquals(3, record.pendingAirdropRecords.size()); + + assertEquals(100, record.pendingAirdropRecords.get(0).getPendingAirdropAmount()); + assertEquals(tokenID, record.pendingAirdropRecords.get(0).getPendingAirdropId().getTokenId()); + assertNull(record.pendingAirdropRecords.get(0).getPendingAirdropId().getNftId()); + + assertEquals(0, record.pendingAirdropRecords.get(1).getPendingAirdropAmount()); + assertEquals(nftID.nft(1), record.pendingAirdropRecords.get(1).getPendingAirdropId().getNftId()); + assertNull(record.pendingAirdropRecords.get(1).getPendingAirdropId().getTokenId()); + + assertEquals(0, record.pendingAirdropRecords.get(2).getPendingAirdropAmount()); + assertEquals(nftID.nft(2), record.pendingAirdropRecords.get(2).getPendingAirdropId().getNftId()); + assertNull(record.pendingAirdropRecords.get(2).getPendingAirdropId().getTokenId()); + + // claim the tokens with the receiver + record = new TokenClaimAirdropTransaction() + .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) + .addPendingAirdrop(record.pendingAirdropRecords.get(1).getPendingAirdropId()) + .addPendingAirdrop(record.pendingAirdropRecords.get(2).getPendingAirdropId()) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getRecord(testEnv.client); + + // verify in the transaction record the pending airdrop ids for nft and ft - should no longer exist + assertEquals(0, record.pendingAirdropRecords.size()); + + // verify the receiver holds the tokens via query + var receiverAccountBalance = new AccountBalanceQuery() + .setAccountId(receiverAccountId) + .execute(testEnv.client); + assertEquals(amount, receiverAccountBalance.tokens.get(tokenID)); + assertEquals(2, receiverAccountBalance.tokens.get(nftID)); + + // verify the operator does not hold the tokens + var operatorBalance = new AccountBalanceQuery() + .setAccountId(testEnv.operatorId) + .execute(testEnv.client); + assertEquals(fungibleInitialBalance - amount, operatorBalance.tokens.get(tokenID)); + assertEquals(mitedNfts - 2, operatorBalance.tokens.get(nftID)); + + } } @Test @DisplayName("Claims the tokens when they are in pending state to multiple receivers") void canClaimTokensToMultipleReceivers() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // create fungible and nf token - var tokenID = EntityHelper.createFungibleToken(testEnv, 3); - var nftID = EntityHelper.createNft(testEnv); - // mint some NFTs - var mintReceipt = new TokenMintTransaction() - .setTokenId(nftID) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - var nftSerials = mintReceipt.serials; - - // create receiver1 with 0 auto associations - var receiver1AccountKey = PrivateKey.generateED25519(); - var receiver1AccountId = EntityHelper.createAccount(testEnv, receiver1AccountKey, 0); - - // create receiver2 with 0 auto associations - var receiver2AccountKey = PrivateKey.generateED25519(); - var receiver2AccountId = EntityHelper.createAccount(testEnv, receiver2AccountKey, 0); - - // airdrop the tokens to both - var record = new TokenAirdropTransaction() - .addNftTransfer(nftID.nft(nftSerials.get(0)), testEnv.operatorId, receiver1AccountId) - .addNftTransfer(nftID.nft(nftSerials.get(1)), testEnv.operatorId, receiver1AccountId) - .addTokenTransfer(tokenID, receiver1AccountId, amount) - .addTokenTransfer(tokenID, testEnv.operatorId, -amount) - .addNftTransfer(nftID.nft(nftSerials.get(2)), testEnv.operatorId, receiver2AccountId) - .addNftTransfer(nftID.nft(nftSerials.get(3)), testEnv.operatorId, receiver2AccountId) - .addTokenTransfer(tokenID, receiver2AccountId, amount) - .addTokenTransfer(tokenID, testEnv.operatorId, -amount) - .execute(testEnv.client) - .getRecord(testEnv.client); - - // verify the txn record - assertEquals(6, record.pendingAirdropRecords.size()); - - // claim the tokens signing with receiver1 and receiver2 - var pendingAirdropIDs = record.pendingAirdropRecords.stream().map(PendingAirdropRecord::getPendingAirdropId) - .toList(); - record = new TokenClaimAirdropTransaction() - .setPendingAirdropIds(pendingAirdropIDs) - .freezeWith(testEnv.client) - .sign(receiver1AccountKey) - .sign(receiver2AccountKey) - .execute(testEnv.client) - .getRecord(testEnv.client); - - // verify in the transaction record the pending airdrop ids for nft and ft - should no longer exist - assertEquals(0, record.pendingAirdropRecords.size()); - // verify receiver1 holds the tokens via query - var receiverAccountBalance = new AccountBalanceQuery() - .setAccountId(receiver1AccountId) - .execute(testEnv.client); - assertEquals(amount, receiverAccountBalance.tokens.get(tokenID)); - assertEquals(2, receiverAccountBalance.tokens.get(nftID)); - - // verify receiver2 holds the tokens via query - var receiver2AccountBalance = new AccountBalanceQuery() - .setAccountId(receiver1AccountId) - .execute(testEnv.client); - assertEquals(amount, receiver2AccountBalance.tokens.get(tokenID)); - assertEquals(2, receiver2AccountBalance.tokens.get(nftID)); - - // verify the operator does not hold the tokens - var operatorBalance = new AccountBalanceQuery() - .setAccountId(testEnv.operatorId) - .execute(testEnv.client); - assertEquals(fungibleInitialBalance - amount * 2, operatorBalance.tokens.get(tokenID)); - assertEquals(mitedNfts - 4, operatorBalance.tokens.get(nftID)); - - testEnv.close(); - } + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + // create fungible and nf token + var tokenID = EntityHelper.createFungibleToken(testEnv, 3); + var nftID = EntityHelper.createNft(testEnv); + // mint some NFTs + var mintReceipt = new TokenMintTransaction() + .setTokenId(nftID) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + var nftSerials = mintReceipt.serials; + + // create receiver1 with 0 auto associations + var receiver1AccountKey = PrivateKey.generateED25519(); + var receiver1AccountId = EntityHelper.createAccount(testEnv, receiver1AccountKey, 0); + + // create receiver2 with 0 auto associations + var receiver2AccountKey = PrivateKey.generateED25519(); + var receiver2AccountId = EntityHelper.createAccount(testEnv, receiver2AccountKey, 0); + + // airdrop the tokens to both + var record = new TokenAirdropTransaction() + .addNftTransfer(nftID.nft(nftSerials.get(0)), testEnv.operatorId, receiver1AccountId) + .addNftTransfer(nftID.nft(nftSerials.get(1)), testEnv.operatorId, receiver1AccountId) + .addTokenTransfer(tokenID, receiver1AccountId, amount) + .addTokenTransfer(tokenID, testEnv.operatorId, -amount) + .addNftTransfer(nftID.nft(nftSerials.get(2)), testEnv.operatorId, receiver2AccountId) + .addNftTransfer(nftID.nft(nftSerials.get(3)), testEnv.operatorId, receiver2AccountId) + .addTokenTransfer(tokenID, receiver2AccountId, amount) + .addTokenTransfer(tokenID, testEnv.operatorId, -amount) + .execute(testEnv.client) + .getRecord(testEnv.client); + // verify the txn record + assertEquals(6, record.pendingAirdropRecords.size()); + + // claim the tokens signing with receiver1 and receiver2 + var pendingAirdropIDs = record.pendingAirdropRecords.stream().map(PendingAirdropRecord::getPendingAirdropId) + .toList(); + record = new TokenClaimAirdropTransaction() + .setPendingAirdropIds(pendingAirdropIDs) + .freezeWith(testEnv.client) + .sign(receiver1AccountKey) + .sign(receiver2AccountKey) + .execute(testEnv.client) + .getRecord(testEnv.client); + + // verify in the transaction record the pending airdrop ids for nft and ft - should no longer exist + assertEquals(0, record.pendingAirdropRecords.size()); + // verify receiver1 holds the tokens via query + var receiverAccountBalance = new AccountBalanceQuery() + .setAccountId(receiver1AccountId) + .execute(testEnv.client); + assertEquals(amount, receiverAccountBalance.tokens.get(tokenID)); + assertEquals(2, receiverAccountBalance.tokens.get(nftID)); + + // verify receiver2 holds the tokens via query + var receiver2AccountBalance = new AccountBalanceQuery() + .setAccountId(receiver1AccountId) + .execute(testEnv.client); + assertEquals(amount, receiver2AccountBalance.tokens.get(tokenID)); + assertEquals(2, receiver2AccountBalance.tokens.get(nftID)); + + // verify the operator does not hold the tokens + var operatorBalance = new AccountBalanceQuery() + .setAccountId(testEnv.operatorId) + .execute(testEnv.client); + assertEquals(fungibleInitialBalance - amount * 2, operatorBalance.tokens.get(tokenID)); + assertEquals(mitedNfts - 4, operatorBalance.tokens.get(nftID)); + + } + } @Test @DisplayName("Claims the tokens when they are in pending state from multiple airdrop transactions") void canClaimTokensFromMultipleAirdropTxns() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // create fungible and nf token - var tokenID = EntityHelper.createFungibleToken(testEnv, 3); - var nftID = EntityHelper.createNft(testEnv); - // mint some NFTs - var mintReceipt = new TokenMintTransaction() - .setTokenId(nftID) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - var nftSerials = mintReceipt.serials; - - // create receiver with 0 auto associations - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); - - // airdrop some of the tokens to the receiver - var record1 = new TokenAirdropTransaction() - .addNftTransfer(nftID.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) - .execute(testEnv.client) - .getRecord(testEnv.client); - // airdrop some of the tokens to the receiver - var record2 = new TokenAirdropTransaction() - .addNftTransfer(nftID.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) - .execute(testEnv.client) - .getRecord(testEnv.client); - // airdrop some of the tokens to the receiver - var record3 = new TokenAirdropTransaction() - .addTokenTransfer(tokenID, receiverAccountId, amount) - .addTokenTransfer(tokenID, testEnv.operatorId, -amount) - .execute(testEnv.client) - .getRecord(testEnv.client); - - // get the PendingIds from the records - var pendingAirdropIDs = new ArrayList(); - pendingAirdropIDs.add(record1.pendingAirdropRecords.get(0).getPendingAirdropId()); - pendingAirdropIDs.add(record2.pendingAirdropRecords.get(0).getPendingAirdropId()); - pendingAirdropIDs.add(record3.pendingAirdropRecords.get(0).getPendingAirdropId()); - - // claim the all the tokens with the receiver - var record = new TokenClaimAirdropTransaction() - .setPendingAirdropIds(pendingAirdropIDs) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .execute(testEnv.client) - .getRecord(testEnv.client); - - // verify in the transaction record the pending airdrop ids for nft and ft - should no longer exist - assertEquals(0, record.pendingAirdropRecords.size()); - - // verify the receiver holds the tokens via query - var receiverAccountBalance = new AccountBalanceQuery() - .setAccountId(receiverAccountId) - .execute(testEnv.client); - assertEquals(amount, receiverAccountBalance.tokens.get(tokenID)); - assertEquals(2, receiverAccountBalance.tokens.get(nftID)); - - // verify the operator does not hold the tokens - var operatorBalance = new AccountBalanceQuery() - .setAccountId(testEnv.operatorId) - .execute(testEnv.client); - assertEquals(fungibleInitialBalance - amount, operatorBalance.tokens.get(tokenID)); - assertEquals(mitedNfts - 2, operatorBalance.tokens.get(nftID)); - - testEnv.close(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + // create fungible and nf token + var tokenID = EntityHelper.createFungibleToken(testEnv, 3); + var nftID = EntityHelper.createNft(testEnv); + // mint some NFTs + var mintReceipt = new TokenMintTransaction() + .setTokenId(nftID) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + var nftSerials = mintReceipt.serials; + + // create receiver with 0 auto associations + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); + + // airdrop some of the tokens to the receiver + var record1 = new TokenAirdropTransaction() + .addNftTransfer(nftID.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) + .execute(testEnv.client) + .getRecord(testEnv.client); + // airdrop some of the tokens to the receiver + var record2 = new TokenAirdropTransaction() + .addNftTransfer(nftID.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) + .execute(testEnv.client) + .getRecord(testEnv.client); + // airdrop some of the tokens to the receiver + var record3 = new TokenAirdropTransaction() + .addTokenTransfer(tokenID, receiverAccountId, amount) + .addTokenTransfer(tokenID, testEnv.operatorId, -amount) + .execute(testEnv.client) + .getRecord(testEnv.client); + + // get the PendingIds from the records + var pendingAirdropIDs = new ArrayList(); + pendingAirdropIDs.add(record1.pendingAirdropRecords.get(0).getPendingAirdropId()); + pendingAirdropIDs.add(record2.pendingAirdropRecords.get(0).getPendingAirdropId()); + pendingAirdropIDs.add(record3.pendingAirdropRecords.get(0).getPendingAirdropId()); + + // claim the all the tokens with the receiver + var record = new TokenClaimAirdropTransaction() + .setPendingAirdropIds(pendingAirdropIDs) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getRecord(testEnv.client); + + // verify in the transaction record the pending airdrop ids for nft and ft - should no longer exist + assertEquals(0, record.pendingAirdropRecords.size()); + + // verify the receiver holds the tokens via query + var receiverAccountBalance = new AccountBalanceQuery() + .setAccountId(receiverAccountId) + .execute(testEnv.client); + assertEquals(amount, receiverAccountBalance.tokens.get(tokenID)); + assertEquals(2, receiverAccountBalance.tokens.get(nftID)); + + // verify the operator does not hold the tokens + var operatorBalance = new AccountBalanceQuery() + .setAccountId(testEnv.operatorId) + .execute(testEnv.client); + assertEquals(fungibleInitialBalance - amount, operatorBalance.tokens.get(tokenID)); + assertEquals(mitedNfts - 2, operatorBalance.tokens.get(nftID)); + + } } @Test @DisplayName("Cannot claim the tokens when they are not airdropped") void cannotClaimTokensForNonExistingAirdrop() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { - // create fungible token - var tokenID = EntityHelper.createFungibleToken(testEnv, 3); + // create fungible token + var tokenID = EntityHelper.createFungibleToken(testEnv, 3); - // create receiver with 0 auto associations - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); + // create receiver with 0 auto associations + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); - // airdrop the tokens - var record = new TokenAirdropTransaction() - .addTokenTransfer(tokenID, receiverAccountId, amount) - .addTokenTransfer(tokenID, testEnv.operatorId, -amount) - .execute(testEnv.client) - .getRecord(testEnv.client); - - // claim the tokens with the operator which does not have pending airdrops - // fails with INVALID_SIGNATURE - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenClaimAirdropTransaction() - .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) + // airdrop the tokens + var record = new TokenAirdropTransaction() + .addTokenTransfer(tokenID, receiverAccountId, amount) + .addTokenTransfer(tokenID, testEnv.operatorId, -amount) .execute(testEnv.client) .getRecord(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - testEnv.close(); + // claim the tokens with the operator which does not have pending airdrops + // fails with INVALID_SIGNATURE + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenClaimAirdropTransaction() + .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) + .execute(testEnv.client) + .getRecord(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + } } @Test @DisplayName("Cannot claim the tokens when they are already claimed") void cannotClaimTokensForAlreadyClaimedAirdrop() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // create fungible token - var tokenID = EntityHelper.createFungibleToken(testEnv, 3); - - // create receiver with 0 auto associations - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); - - // airdrop the tokens - var record = new TokenAirdropTransaction() - .addTokenTransfer(tokenID, receiverAccountId, amount) - .addTokenTransfer(tokenID, testEnv.operatorId, -amount) - .execute(testEnv.client) - .getRecord(testEnv.client); - - // claim the tokens with the receiver - new TokenClaimAirdropTransaction() - .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .execute(testEnv.client) - .getRecord(testEnv.client); - - // claim the tokens with the receiver again - // fails with INVALID_PENDING_AIRDROP_ID - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + // create fungible token + var tokenID = EntityHelper.createFungibleToken(testEnv, 3); + + // create receiver with 0 auto associations + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); + + // airdrop the tokens + var record = new TokenAirdropTransaction() + .addTokenTransfer(tokenID, receiverAccountId, amount) + .addTokenTransfer(tokenID, testEnv.operatorId, -amount) + .execute(testEnv.client) + .getRecord(testEnv.client); + + // claim the tokens with the receiver new TokenClaimAirdropTransaction() .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) .freezeWith(testEnv.client) .sign(receiverAccountKey) .execute(testEnv.client) .getRecord(testEnv.client); - }).withMessageContaining(Status.INVALID_PENDING_AIRDROP_ID.toString()); - testEnv.close(); + // claim the tokens with the receiver again + // fails with INVALID_PENDING_AIRDROP_ID + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenClaimAirdropTransaction() + .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getRecord(testEnv.client); + }).withMessageContaining(Status.INVALID_PENDING_AIRDROP_ID.toString()); + + } } @Test @DisplayName("Cannot claim the tokens with empty list") void cannotClaimWithEmptyPendingAirdropsList() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { - // claim the tokens with the receiver without setting pendingAirdropIds - // fails with EMPTY_PENDING_AIRDROP_ID_LIST - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenClaimAirdropTransaction() - .execute(testEnv.client) - .getRecord(testEnv.client); - }).withMessageContaining(Status.EMPTY_PENDING_AIRDROP_ID_LIST.toString()); + // claim the tokens with the receiver without setting pendingAirdropIds + // fails with EMPTY_PENDING_AIRDROP_ID_LIST + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenClaimAirdropTransaction() + .execute(testEnv.client) + .getRecord(testEnv.client); + }).withMessageContaining(Status.EMPTY_PENDING_AIRDROP_ID_LIST.toString()); - testEnv.close(); + } } @Test @DisplayName("Cannot claim the tokens with duplicate entries") void cannotClaimTokensWithDuplicateEntries() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { - // create fungible token - var tokenID = EntityHelper.createFungibleToken(testEnv, 3); + // create fungible token + var tokenID = EntityHelper.createFungibleToken(testEnv, 3); - // create receiver with 0 auto associations - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); + // create receiver with 0 auto associations + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); - // airdrop the tokens - var record = new TokenAirdropTransaction() - .addTokenTransfer(tokenID, receiverAccountId, amount) - .addTokenTransfer(tokenID, testEnv.operatorId, -amount) - .execute(testEnv.client) - .getRecord(testEnv.client); - - // claim the tokens with duplicate pending airdrop token ids - // fails with PENDING_AIRDROP_ID_REPEATED - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenClaimAirdropTransaction() - .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) - .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) + // airdrop the tokens + var record = new TokenAirdropTransaction() + .addTokenTransfer(tokenID, receiverAccountId, amount) + .addTokenTransfer(tokenID, testEnv.operatorId, -amount) .execute(testEnv.client) .getRecord(testEnv.client); - }).withMessageContaining(Status.PENDING_AIRDROP_ID_REPEATED.toString()); - testEnv.close(); + // claim the tokens with duplicate pending airdrop token ids + // fails with PENDING_AIRDROP_ID_REPEATED + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenClaimAirdropTransaction() + .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) + .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) + .execute(testEnv.client) + .getRecord(testEnv.client); + }).withMessageContaining(Status.PENDING_AIRDROP_ID_REPEATED.toString()); + + } } @Test @DisplayName("Cannot claim the tokens when token is paused") void cannotClaimTokensWhenTokenIsPaused() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // create fungible token - var tokenID = EntityHelper.createFungibleToken(testEnv, 3); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { - // create receiver with 0 auto associations - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); + // create fungible token + var tokenID = EntityHelper.createFungibleToken(testEnv, 3); - // airdrop the tokens - var record = new TokenAirdropTransaction() - .addTokenTransfer(tokenID, receiverAccountId, amount) - .addTokenTransfer(tokenID, testEnv.operatorId, -amount) - .execute(testEnv.client) - .getRecord(testEnv.client); + // create receiver with 0 auto associations + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); - // pause the token - new TokenPauseTransaction().setTokenId(tokenID).execute(testEnv.client).getReceipt(testEnv.client); - - // claim the tokens with receiver - // fails with TOKEN_IS_PAUSED - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenClaimAirdropTransaction() - .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) + // airdrop the tokens + var record = new TokenAirdropTransaction() + .addTokenTransfer(tokenID, receiverAccountId, amount) + .addTokenTransfer(tokenID, testEnv.operatorId, -amount) .execute(testEnv.client) .getRecord(testEnv.client); - }).withMessageContaining(Status.TOKEN_IS_PAUSED.toString()); - testEnv.close(); + // pause the token + new TokenPauseTransaction().setTokenId(tokenID).execute(testEnv.client).getReceipt(testEnv.client); + + // claim the tokens with receiver + // fails with TOKEN_IS_PAUSED + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenClaimAirdropTransaction() + .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getRecord(testEnv.client); + }).withMessageContaining(Status.TOKEN_IS_PAUSED.toString()); + + } } @Test @DisplayName("Cannot claim the tokens when token is deleted") void cannotClaimTokensWhenTokenIsDeleted() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // create fungible token - var tokenID = EntityHelper.createFungibleToken(testEnv, 3); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { - // create receiver with 0 auto associations - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); + // create fungible token + var tokenID = EntityHelper.createFungibleToken(testEnv, 3); - // airdrop the tokens - var record = new TokenAirdropTransaction() - .addTokenTransfer(tokenID, receiverAccountId, amount) - .addTokenTransfer(tokenID, testEnv.operatorId, -amount) - .execute(testEnv.client) - .getRecord(testEnv.client); + // create receiver with 0 auto associations + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); - // delete the token - new TokenDeleteTransaction().setTokenId(tokenID).execute(testEnv.client).getReceipt(testEnv.client); - - // claim the tokens with receiver - // fails with TOKEN_IS_DELETED - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenClaimAirdropTransaction() - .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) + // airdrop the tokens + var record = new TokenAirdropTransaction() + .addTokenTransfer(tokenID, receiverAccountId, amount) + .addTokenTransfer(tokenID, testEnv.operatorId, -amount) .execute(testEnv.client) .getRecord(testEnv.client); - }).withMessageContaining(Status.TOKEN_WAS_DELETED.toString()); - testEnv.close(); + // delete the token + new TokenDeleteTransaction().setTokenId(tokenID).execute(testEnv.client).getReceipt(testEnv.client); + + // claim the tokens with receiver + // fails with TOKEN_IS_DELETED + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenClaimAirdropTransaction() + .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getRecord(testEnv.client); + }).withMessageContaining(Status.TOKEN_WAS_DELETED.toString()); + + } } @Test @DisplayName("Cannot claim the tokens when token is frozen") void cannotClaimTokensWhenTokenIsFrozen() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // create fungible token - var tokenID = EntityHelper.createFungibleToken(testEnv, 3); - - // create receiver with 0 auto associations - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); - - // airdrop the tokens - var record = new TokenAirdropTransaction() - .addTokenTransfer(tokenID, receiverAccountId, amount) - .addTokenTransfer(tokenID, testEnv.operatorId, -amount) - .execute(testEnv.client) - .getRecord(testEnv.client); - - // associate - new TokenAssociateTransaction() - .setAccountId(receiverAccountId) - .setTokenIds(Collections.singletonList(tokenID)) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // freeze the token - new TokenFreezeTransaction() - .setAccountId(receiverAccountId) - .setTokenId(tokenID) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // claim the tokens with receiver - // fails with ACCOUNT_FROZEN_FOR_TOKEN - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenClaimAirdropTransaction() - .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + // create fungible token + var tokenID = EntityHelper.createFungibleToken(testEnv, 3); + + // create receiver with 0 auto associations + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); + + // airdrop the tokens + var record = new TokenAirdropTransaction() + .addTokenTransfer(tokenID, receiverAccountId, amount) + .addTokenTransfer(tokenID, testEnv.operatorId, -amount) + .execute(testEnv.client) + .getRecord(testEnv.client); + + // associate + new TokenAssociateTransaction() + .setAccountId(receiverAccountId) + .setTokenIds(Collections.singletonList(tokenID)) .freezeWith(testEnv.client) .sign(receiverAccountKey) .execute(testEnv.client) - .getRecord(testEnv.client); - }).withMessageContaining(Status.ACCOUNT_FROZEN_FOR_TOKEN.toString()); + .getReceipt(testEnv.client); - testEnv.close(); + // freeze the token + new TokenFreezeTransaction() + .setAccountId(receiverAccountId) + .setTokenId(tokenID) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // claim the tokens with receiver + // fails with ACCOUNT_FROZEN_FOR_TOKEN + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenClaimAirdropTransaction() + .addPendingAirdrop(record.pendingAirdropRecords.get(0).getPendingAirdropId()) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getRecord(testEnv.client); + }).withMessageContaining(Status.ACCOUNT_FROZEN_FOR_TOKEN.toString()); + + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenAirdropTransactionIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenAirdropTransactionIntegrationTest.java index 30dea7dc6..899d6c374 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenAirdropTransactionIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenAirdropTransactionIntegrationTest.java @@ -55,439 +55,439 @@ class TokenAirdropTransactionIntegrationTest { @Test @DisplayName("Transfers tokens when the account is associated") void canAirdropAssociatedTokens() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // create fungible and nf token - var tokenID = EntityHelper.createFungibleToken(testEnv, 3); - var nftID = EntityHelper.createNft(testEnv); - // mint some NFTs - var mintReceipt = new TokenMintTransaction() - .setTokenId(nftID) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - var nftSerials = mintReceipt.serials; - - // create receiver with unlimited auto associations and receiverSig = false - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, -1); - - // airdrop the tokens - new TokenAirdropTransaction() - .addNftTransfer(nftID.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(nftID.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) - .addTokenTransfer(tokenID, receiverAccountId, amount) - .addTokenTransfer(tokenID, testEnv.operatorId, -amount) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // verify the receiver holds the tokens via query - var receiverAccountBalance = new AccountBalanceQuery() - .setAccountId(receiverAccountId) - .execute(testEnv.client); - assertEquals(amount, receiverAccountBalance.tokens.get(tokenID)); - assertEquals(2, receiverAccountBalance.tokens.get(nftID)); - - // verify the operator does not hold the tokens - var operatorBalance = new AccountBalanceQuery() - .setAccountId(testEnv.operatorId) - .execute(testEnv.client); - assertEquals(fungibleInitialBalance - amount, operatorBalance.tokens.get(tokenID)); - assertEquals(mitedNfts - 2, operatorBalance.tokens.get(nftID)); - - testEnv.close(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + // create fungible and nf token + var tokenID = EntityHelper.createFungibleToken(testEnv, 3); + var nftID = EntityHelper.createNft(testEnv); + // mint some NFTs + var mintReceipt = new TokenMintTransaction() + .setTokenId(nftID) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + var nftSerials = mintReceipt.serials; + + // create receiver with unlimited auto associations and receiverSig = false + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, -1); + + // airdrop the tokens + new TokenAirdropTransaction() + .addNftTransfer(nftID.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(nftID.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) + .addTokenTransfer(tokenID, receiverAccountId, amount) + .addTokenTransfer(tokenID, testEnv.operatorId, -amount) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // verify the receiver holds the tokens via query + var receiverAccountBalance = new AccountBalanceQuery() + .setAccountId(receiverAccountId) + .execute(testEnv.client); + assertEquals(amount, receiverAccountBalance.tokens.get(tokenID)); + assertEquals(2, receiverAccountBalance.tokens.get(nftID)); + + // verify the operator does not hold the tokens + var operatorBalance = new AccountBalanceQuery() + .setAccountId(testEnv.operatorId) + .execute(testEnv.client); + assertEquals(fungibleInitialBalance - amount, operatorBalance.tokens.get(tokenID)); + assertEquals(mitedNfts - 2, operatorBalance.tokens.get(nftID)); + + } } @Test @DisplayName("Tokens are in pending state when the account is not associated") void canAirdropNonAssociatedTokens() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // create fungible and nf token - var tokenID = EntityHelper.createFungibleToken(testEnv, 3); - var nftID = EntityHelper.createNft(testEnv); - // mint some NFTs - var mintReceipt = new TokenMintTransaction() - .setTokenId(nftID) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - var nftSerials = mintReceipt.serials; - - // create receiver with 0 auto associations and receiverSig = false - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); - - // airdrop the tokens - var txn = new TokenAirdropTransaction() - .addNftTransfer(nftID.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(nftID.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) - .addTokenTransfer(tokenID, receiverAccountId, amount) - .addTokenTransfer(tokenID, testEnv.operatorId, -amount) - .execute(testEnv.client); - txn.setValidateStatus(true).getReceipt(testEnv.client); - var record = txn.getRecord(testEnv.client); - - // verify in the transaction record the pending airdrops - assertThat(record.pendingAirdropRecords).isNotNull(); - assertFalse(record.pendingAirdropRecords.isEmpty()); - - // verify the receiver does not hold the tokens via query - var receiverAccountBalance = new AccountBalanceQuery() - .setAccountId(receiverAccountId) - .execute(testEnv.client); - assertNull(receiverAccountBalance.tokens.get(tokenID)); - assertNull(receiverAccountBalance.tokens.get(nftID)); - - // verify the operator does hold the tokens - var operatorBalance = new AccountBalanceQuery() - .setAccountId(testEnv.operatorId) - .execute(testEnv.client); - assertEquals(fungibleInitialBalance, operatorBalance.tokens.get(tokenID)); - assertEquals(mitedNfts, operatorBalance.tokens.get(nftID)); - - testEnv.close(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + // create fungible and nf token + var tokenID = EntityHelper.createFungibleToken(testEnv, 3); + var nftID = EntityHelper.createNft(testEnv); + // mint some NFTs + var mintReceipt = new TokenMintTransaction() + .setTokenId(nftID) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + var nftSerials = mintReceipt.serials; + + // create receiver with 0 auto associations and receiverSig = false + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); + + // airdrop the tokens + var txn = new TokenAirdropTransaction() + .addNftTransfer(nftID.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(nftID.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) + .addTokenTransfer(tokenID, receiverAccountId, amount) + .addTokenTransfer(tokenID, testEnv.operatorId, -amount) + .execute(testEnv.client); + txn.setValidateStatus(true).getReceipt(testEnv.client); + var record = txn.getRecord(testEnv.client); + + // verify in the transaction record the pending airdrops + assertThat(record.pendingAirdropRecords).isNotNull(); + assertFalse(record.pendingAirdropRecords.isEmpty()); + + // verify the receiver does not hold the tokens via query + var receiverAccountBalance = new AccountBalanceQuery() + .setAccountId(receiverAccountId) + .execute(testEnv.client); + assertNull(receiverAccountBalance.tokens.get(tokenID)); + assertNull(receiverAccountBalance.tokens.get(nftID)); + + // verify the operator does hold the tokens + var operatorBalance = new AccountBalanceQuery() + .setAccountId(testEnv.operatorId) + .execute(testEnv.client); + assertEquals(fungibleInitialBalance, operatorBalance.tokens.get(tokenID)); + assertEquals(mitedNfts, operatorBalance.tokens.get(nftID)); + + } } @Test @DisplayName("Airdrop creates a hollow account and transfers the tokens") void canAirdropToAlias() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // create fungible and nf token - var tokenID = EntityHelper.createFungibleToken(testEnv, 3); - var nftID = EntityHelper.createNft(testEnv); - // mint some NFTs - var mintReceipt = new TokenMintTransaction() - .setTokenId(nftID) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - var nftSerials = mintReceipt.serials; - - // airdrop the tokens to an alias - PrivateKey privateKey = PrivateKey.generateED25519(); - PublicKey publicKey = privateKey.getPublicKey(); - - AccountId aliasAccountId = publicKey.toAccountId(0, 0); - - // should lazy-create and transfer the tokens - new TokenAirdropTransaction() - .addNftTransfer(nftID.nft(nftSerials.get(0)), testEnv.operatorId, aliasAccountId) - .addNftTransfer(nftID.nft(nftSerials.get(1)), testEnv.operatorId, aliasAccountId) - .addTokenTransfer(tokenID, aliasAccountId, amount) - .addTokenTransfer(tokenID, testEnv.operatorId, -amount) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // verify the receiver holds the tokens via query - var receiverAccountBalance = new AccountBalanceQuery() - .setAccountId(aliasAccountId) - .execute(testEnv.client); - assertEquals(amount, receiverAccountBalance.tokens.get(tokenID)); - assertEquals(2, receiverAccountBalance.tokens.get(nftID)); - - // verify the operator does not hold the tokens - var operatorBalance = new AccountBalanceQuery() - .setAccountId(testEnv.operatorId) - .execute(testEnv.client); - assertEquals(fungibleInitialBalance - amount, operatorBalance.tokens.get(tokenID)); - assertEquals(mitedNfts - 2, operatorBalance.tokens.get(nftID)); - - testEnv.close(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + // create fungible and nf token + var tokenID = EntityHelper.createFungibleToken(testEnv, 3); + var nftID = EntityHelper.createNft(testEnv); + // mint some NFTs + var mintReceipt = new TokenMintTransaction() + .setTokenId(nftID) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + var nftSerials = mintReceipt.serials; + + // airdrop the tokens to an alias + PrivateKey privateKey = PrivateKey.generateED25519(); + PublicKey publicKey = privateKey.getPublicKey(); + + AccountId aliasAccountId = publicKey.toAccountId(0, 0); + + // should lazy-create and transfer the tokens + new TokenAirdropTransaction() + .addNftTransfer(nftID.nft(nftSerials.get(0)), testEnv.operatorId, aliasAccountId) + .addNftTransfer(nftID.nft(nftSerials.get(1)), testEnv.operatorId, aliasAccountId) + .addTokenTransfer(tokenID, aliasAccountId, amount) + .addTokenTransfer(tokenID, testEnv.operatorId, -amount) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // verify the receiver holds the tokens via query + var receiverAccountBalance = new AccountBalanceQuery() + .setAccountId(aliasAccountId) + .execute(testEnv.client); + assertEquals(amount, receiverAccountBalance.tokens.get(tokenID)); + assertEquals(2, receiverAccountBalance.tokens.get(nftID)); + + // verify the operator does not hold the tokens + var operatorBalance = new AccountBalanceQuery() + .setAccountId(testEnv.operatorId) + .execute(testEnv.client); + assertEquals(fungibleInitialBalance - amount, operatorBalance.tokens.get(tokenID)); + assertEquals(mitedNfts - 2, operatorBalance.tokens.get(nftID)); + + } } @Test @DisplayName("Can airdrop with custom fees") void canAirdropWithCustomFee() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // create receiver unlimited auto associations and receiverSig = false - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, -1); - - // create fungible token with custom fee another token - var customFeeTokenID = EntityHelper.createFungibleToken(testEnv, 3); - - // make the custom fee to be paid by the sender and the fee collector to be the operator account - CustomFixedFee fee = new CustomFixedFee() - .setFeeCollectorAccountId(testEnv.operatorId) - .setDenominatingTokenId(customFeeTokenID) - .setAmount(1) - .setAllCollectorsAreExempt(true); - - var tokenID = new TokenCreateTransaction() - .setTokenName("Test Fungible Token") - .setTokenSymbol("TFT") - .setTokenMemo("I was created for integration tests") - .setDecimals(3) - .setInitialSupply(fungibleInitialBalance) - .setMaxSupply(fungibleInitialBalance) - .setTreasuryAccountId(testEnv.operatorId) - .setSupplyType(TokenSupplyType.FINITE) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setMetadataKey(testEnv.operatorKey) - .setPauseKey(testEnv.operatorKey) - .setCustomFees(Collections.singletonList(fee)) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId; - - // create sender account with unlimited associations and send some tokens to it - var senderKey = PrivateKey.generateED25519(); - var senderAccountID = EntityHelper.createAccount(testEnv, senderKey, -1); - - // associate the token to the sender - new TokenAssociateTransaction() - .setAccountId(senderAccountID) - .setTokenIds(Collections.singletonList(customFeeTokenID)) - .freezeWith(testEnv.client) - .sign(senderKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // send tokens to the sender - new TransferTransaction() - .addTokenTransfer(customFeeTokenID, testEnv.operatorId, -amount) - .addTokenTransfer(customFeeTokenID, senderAccountID, amount) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TransferTransaction() - .addTokenTransfer(tokenID, testEnv.operatorId, -amount) - .addTokenTransfer(tokenID, senderAccountID, amount) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // airdrop the tokens from the sender to the receiver - new TokenAirdropTransaction() - .addTokenTransfer(tokenID, receiverAccountId, amount) - .addTokenTransfer(tokenID, senderAccountID, -amount) - .freezeWith(testEnv.client) - .sign(senderKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // verify the custom fee has been paid by the sender to the collector - var receiverAccountBalance = new AccountBalanceQuery() - .setAccountId(receiverAccountId) - .execute(testEnv.client); - assertEquals(amount, receiverAccountBalance.tokens.get(tokenID)); - - var senderAccountBalance = new AccountBalanceQuery() - .setAccountId(senderAccountID) - .execute(testEnv.client); - assertEquals(0, senderAccountBalance.tokens.get(tokenID)); - assertEquals(amount - 1, senderAccountBalance.tokens.get(customFeeTokenID)); - - var operatorBalance = new AccountBalanceQuery() - .setAccountId(testEnv.operatorId) - .execute(testEnv.client); - assertEquals(fungibleInitialBalance - amount + 1, operatorBalance.tokens.get(customFeeTokenID)); - assertEquals(fungibleInitialBalance - amount, operatorBalance.tokens.get(tokenID)); - - testEnv.close(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + // create receiver unlimited auto associations and receiverSig = false + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, -1); + + // create fungible token with custom fee another token + var customFeeTokenID = EntityHelper.createFungibleToken(testEnv, 3); + + // make the custom fee to be paid by the sender and the fee collector to be the operator account + CustomFixedFee fee = new CustomFixedFee() + .setFeeCollectorAccountId(testEnv.operatorId) + .setDenominatingTokenId(customFeeTokenID) + .setAmount(1) + .setAllCollectorsAreExempt(true); + + var tokenID = new TokenCreateTransaction() + .setTokenName("Test Fungible Token") + .setTokenSymbol("TFT") + .setTokenMemo("I was created for integration tests") + .setDecimals(3) + .setInitialSupply(fungibleInitialBalance) + .setMaxSupply(fungibleInitialBalance) + .setTreasuryAccountId(testEnv.operatorId) + .setSupplyType(TokenSupplyType.FINITE) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setMetadataKey(testEnv.operatorKey) + .setPauseKey(testEnv.operatorKey) + .setCustomFees(Collections.singletonList(fee)) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId; + + // create sender account with unlimited associations and send some tokens to it + var senderKey = PrivateKey.generateED25519(); + var senderAccountID = EntityHelper.createAccount(testEnv, senderKey, -1); + + // associate the token to the sender + new TokenAssociateTransaction() + .setAccountId(senderAccountID) + .setTokenIds(Collections.singletonList(customFeeTokenID)) + .freezeWith(testEnv.client) + .sign(senderKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // send tokens to the sender + new TransferTransaction() + .addTokenTransfer(customFeeTokenID, testEnv.operatorId, -amount) + .addTokenTransfer(customFeeTokenID, senderAccountID, amount) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TransferTransaction() + .addTokenTransfer(tokenID, testEnv.operatorId, -amount) + .addTokenTransfer(tokenID, senderAccountID, amount) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // airdrop the tokens from the sender to the receiver + new TokenAirdropTransaction() + .addTokenTransfer(tokenID, receiverAccountId, amount) + .addTokenTransfer(tokenID, senderAccountID, -amount) + .freezeWith(testEnv.client) + .sign(senderKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // verify the custom fee has been paid by the sender to the collector + var receiverAccountBalance = new AccountBalanceQuery() + .setAccountId(receiverAccountId) + .execute(testEnv.client); + assertEquals(amount, receiverAccountBalance.tokens.get(tokenID)); + + var senderAccountBalance = new AccountBalanceQuery() + .setAccountId(senderAccountID) + .execute(testEnv.client); + assertEquals(0, senderAccountBalance.tokens.get(tokenID)); + assertEquals(amount - 1, senderAccountBalance.tokens.get(customFeeTokenID)); + + var operatorBalance = new AccountBalanceQuery() + .setAccountId(testEnv.operatorId) + .execute(testEnv.client); + assertEquals(fungibleInitialBalance - amount + 1, operatorBalance.tokens.get(customFeeTokenID)); + assertEquals(fungibleInitialBalance - amount, operatorBalance.tokens.get(tokenID)); + + } } @Test @DisplayName("Can airdrop ft with receiverSig=true") void canAirdropTokensWithReceiverSigRequiredFungible() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // create fungible token - var tokenID = EntityHelper.createFungibleToken(testEnv, 3); - - // create receiver with unlimited auto associations and receiverSig = true - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = new AccountCreateTransaction() - .setKey(receiverAccountKey) - .setInitialBalance(new Hbar(1)) - .setReceiverSignatureRequired(true) - .setMaxAutomaticTokenAssociations(-1) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .accountId; - - // airdrop the tokens - new TokenAirdropTransaction() - .addTokenTransfer(tokenID, receiverAccountId, amount) - .addTokenTransfer(tokenID, testEnv.operatorId, -amount) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + // create fungible token + var tokenID = EntityHelper.createFungibleToken(testEnv, 3); + + // create receiver with unlimited auto associations and receiverSig = true + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = new AccountCreateTransaction() + .setKey(receiverAccountKey) + .setInitialBalance(new Hbar(1)) + .setReceiverSignatureRequired(true) + .setMaxAutomaticTokenAssociations(-1) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .accountId; + + // airdrop the tokens + new TokenAirdropTransaction() + .addTokenTransfer(tokenID, receiverAccountId, amount) + .addTokenTransfer(tokenID, testEnv.operatorId, -amount) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } @Test @DisplayName("Can airdrop nft with receiverSig=true") void canAirdropTokensWithReceiverSigRequiredNFT() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // create nft - var nftID = EntityHelper.createNft(testEnv); - // mint some NFTs - var mintReceipt = new TokenMintTransaction() - .setTokenId(nftID) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - var nftSerials = mintReceipt.serials; - - // create receiver with unlimited auto associations and receiverSig = true - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = new AccountCreateTransaction() - .setKey(receiverAccountKey) - .setInitialBalance(new Hbar(1)) - .setReceiverSignatureRequired(true) - .setMaxAutomaticTokenAssociations(-1) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .accountId; - - // airdrop the tokens - new TokenAirdropTransaction() - .addNftTransfer(nftID.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(nftID.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + // create nft + var nftID = EntityHelper.createNft(testEnv); + // mint some NFTs + var mintReceipt = new TokenMintTransaction() + .setTokenId(nftID) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + var nftSerials = mintReceipt.serials; + + // create receiver with unlimited auto associations and receiverSig = true + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = new AccountCreateTransaction() + .setKey(receiverAccountKey) + .setInitialBalance(new Hbar(1)) + .setReceiverSignatureRequired(true) + .setMaxAutomaticTokenAssociations(-1) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .accountId; + + // airdrop the tokens + new TokenAirdropTransaction() + .addNftTransfer(nftID.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(nftID.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } @Test @DisplayName("Cannot airdrop ft with no balance") void cannotAirdropTokensWithAllowanceAndWithoutBalanceFungible() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // create fungible token - var tokenID = EntityHelper.createFungibleToken(testEnv, 3); - - // create spender and approve to it some tokens - var spenderKey = PrivateKey.generateED25519(); - var spenderAccountID = EntityHelper.createAccount(testEnv, spenderKey, -1); - - // create sender - var senderKey = PrivateKey.generateED25519(); - var senderAccountID = EntityHelper.createAccount(testEnv, senderKey, -1); - - // transfer ft to sender - new TransferTransaction() - .addTokenTransfer(tokenID, testEnv.operatorId, -amount) - .addTokenTransfer(tokenID, senderAccountID, amount) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // approve allowance to the spender - new AccountAllowanceApproveTransaction() - .approveTokenAllowance(tokenID, senderAccountID, spenderAccountID, amount) - .freezeWith(testEnv.client) - .sign(senderKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // airdrop the tokens from the sender to the spender via approval - // fails with NOT_SUPPORTED - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenAirdropTransaction() - .addTokenTransfer(tokenID, spenderAccountID, amount) - .addApprovedTokenTransfer(tokenID, spenderAccountID, -amount) - .setTransactionId(TransactionId.generate(spenderAccountID)) + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + // create fungible token + var tokenID = EntityHelper.createFungibleToken(testEnv, 3); + + // create spender and approve to it some tokens + var spenderKey = PrivateKey.generateED25519(); + var spenderAccountID = EntityHelper.createAccount(testEnv, spenderKey, -1); + + // create sender + var senderKey = PrivateKey.generateED25519(); + var senderAccountID = EntityHelper.createAccount(testEnv, senderKey, -1); + + // transfer ft to sender + new TransferTransaction() + .addTokenTransfer(tokenID, testEnv.operatorId, -amount) + .addTokenTransfer(tokenID, senderAccountID, amount) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // approve allowance to the spender + new AccountAllowanceApproveTransaction() + .approveTokenAllowance(tokenID, senderAccountID, spenderAccountID, amount) .freezeWith(testEnv.client) - .sign(spenderKey) + .sign(senderKey) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.NOT_SUPPORTED.toString()); - testEnv.close(); + // airdrop the tokens from the sender to the spender via approval + // fails with NOT_SUPPORTED + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenAirdropTransaction() + .addTokenTransfer(tokenID, spenderAccountID, amount) + .addApprovedTokenTransfer(tokenID, spenderAccountID, -amount) + .setTransactionId(TransactionId.generate(spenderAccountID)) + .freezeWith(testEnv.client) + .sign(spenderKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.NOT_SUPPORTED.toString()); + + } } @Test @DisplayName("Cannot airdrop nft with no balance") void cannotAirdropTokensWithAllowanceAndWithoutBalanceNFT() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // create nft - var nftID = EntityHelper.createNft(testEnv); - // mint some NFTs - var mintReceipt = new TokenMintTransaction() - .setTokenId(nftID) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - var nftSerials = mintReceipt.serials; - - // create spender and approve to it some tokens - var spenderKey = PrivateKey.generateED25519(); - var spenderAccountID = EntityHelper.createAccount(testEnv, spenderKey, -1); - - // create sender - var senderKey = PrivateKey.generateED25519(); - var senderAccountID = EntityHelper.createAccount(testEnv, senderKey, -1); - - // transfer ft to sender - new TransferTransaction() - .addNftTransfer(nftID.nft(nftSerials.get(0)), testEnv.operatorId, senderAccountID) - .addNftTransfer(nftID.nft(nftSerials.get(1)), testEnv.operatorId, senderAccountID) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // approve allowance to the spender - new AccountAllowanceApproveTransaction() - .approveTokenNftAllowance(nftID.nft(nftSerials.get(0)), senderAccountID, spenderAccountID) - .approveTokenNftAllowance(nftID.nft(nftSerials.get(1)), senderAccountID, spenderAccountID) - .freezeWith(testEnv.client) - .sign(senderKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // airdrop the tokens from the sender to the spender via approval - // fails with NOT_SUPPORTED - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenAirdropTransaction() - .addApprovedNftTransfer(nftID.nft(nftSerials.get(0)), senderAccountID, spenderAccountID) - .addApprovedNftTransfer(nftID.nft(nftSerials.get(1)), senderAccountID, spenderAccountID) - .setTransactionId(TransactionId.generate(spenderAccountID)) - .freezeWith(testEnv.client) - .sign(spenderKey) + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + // create nft + var nftID = EntityHelper.createNft(testEnv); + // mint some NFTs + var mintReceipt = new TokenMintTransaction() + .setTokenId(nftID) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.NOT_SUPPORTED.toString()); + var nftSerials = mintReceipt.serials; - testEnv.close(); - } + // create spender and approve to it some tokens + var spenderKey = PrivateKey.generateED25519(); + var spenderAccountID = EntityHelper.createAccount(testEnv, spenderKey, -1); - @Test - @DisplayName("Cannot airdrop with invalid body") - void cannotAirdropTokensWithInvalidBody() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + // create sender + var senderKey = PrivateKey.generateED25519(); + var senderAccountID = EntityHelper.createAccount(testEnv, senderKey, -1); - // airdrop with no tokenID or NftID - // fails with EMPTY_TOKEN_TRANSFER_BODY - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenAirdropTransaction() + // transfer ft to sender + new TransferTransaction() + .addNftTransfer(nftID.nft(nftSerials.get(0)), testEnv.operatorId, senderAccountID) + .addNftTransfer(nftID.nft(nftSerials.get(1)), testEnv.operatorId, senderAccountID) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.EMPTY_TOKEN_TRANSFER_BODY.toString()); - - // create fungible token - var tokenID = EntityHelper.createFungibleToken(testEnv, 3); - // airdrop with invalid transfers - // fails with INVALID_TRANSACTION_BODY - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenAirdropTransaction() - .addTokenTransfer(tokenID, testEnv.operatorId, 100) - .addTokenTransfer(tokenID, testEnv.operatorId, 100) + // approve allowance to the spender + new AccountAllowanceApproveTransaction() + .approveTokenNftAllowance(nftID.nft(nftSerials.get(0)), senderAccountID, spenderAccountID) + .approveTokenNftAllowance(nftID.nft(nftSerials.get(1)), senderAccountID, spenderAccountID) + .freezeWith(testEnv.client) + .sign(senderKey) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_TRANSACTION_BODY.toString()); - testEnv.close(); + // airdrop the tokens from the sender to the spender via approval + // fails with NOT_SUPPORTED + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenAirdropTransaction() + .addApprovedNftTransfer(nftID.nft(nftSerials.get(0)), senderAccountID, spenderAccountID) + .addApprovedNftTransfer(nftID.nft(nftSerials.get(1)), senderAccountID, spenderAccountID) + .setTransactionId(TransactionId.generate(spenderAccountID)) + .freezeWith(testEnv.client) + .sign(spenderKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.NOT_SUPPORTED.toString()); + + } + } + + @Test + @DisplayName("Cannot airdrop with invalid body") + void cannotAirdropTokensWithInvalidBody() throws Exception { + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + // airdrop with no tokenID or NftID + // fails with EMPTY_TOKEN_TRANSFER_BODY + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenAirdropTransaction() + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.EMPTY_TOKEN_TRANSFER_BODY.toString()); + + // create fungible token + var tokenID = EntityHelper.createFungibleToken(testEnv, 3); + + // airdrop with invalid transfers + // fails with INVALID_TRANSACTION_BODY + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenAirdropTransaction() + .addTokenTransfer(tokenID, testEnv.operatorId, 100) + .addTokenTransfer(tokenID, testEnv.operatorId, 100) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_TRANSACTION_BODY.toString()); + + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenAutomaticAssociationIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenAutomaticAssociationIntegrationTest.java index 6d89521cc..80d98aef9 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenAutomaticAssociationIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenAutomaticAssociationIntegrationTest.java @@ -41,149 +41,149 @@ public class TokenAutomaticAssociationIntegrationTest { @Test @DisplayName("Can transfer Fungible Tokens to accounts with Limited Max Auto Associations") void canTransferFungibleTokensToAccountsWithLimitedMaxAutoAssociations() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var tokenId1 = EntityHelper.createFungibleToken(testEnv, 0); - var tokenId2 = EntityHelper.createFungibleToken(testEnv, 0); - var accountKey = PrivateKey.generateED25519(); - var accountMaxAutomaticTokenAssociations = 1; - var receiverAccountId = EntityHelper.createAccount(testEnv, accountKey, accountMaxAutomaticTokenAssociations); - - var accountInfoBeforeTokenAssociation = new AccountInfoQuery() - .setAccountId(receiverAccountId) - .execute(testEnv.client); - assertThat(accountInfoBeforeTokenAssociation.maxAutomaticTokenAssociations).isEqualTo(1); - assertThat(accountInfoBeforeTokenAssociation.tokenRelationships.size()).isEqualTo(0); - - - var transferRecord = new TransferTransaction() - .addTokenTransfer(tokenId1, testEnv.operatorId, -1) - .addTokenTransfer(tokenId1, receiverAccountId, 1) - .execute(testEnv.client) - .getRecord(testEnv.client); - assertThat(transferRecord.automaticTokenAssociations.size()).isEqualTo(1); - assertThat(transferRecord.automaticTokenAssociations.get(0).accountId).isEqualTo(receiverAccountId); - assertThat(transferRecord.automaticTokenAssociations.get(0).tokenId).isEqualTo(tokenId1); - - var accountInfoAfterTokenAssociation = new AccountInfoQuery() - .setAccountId(receiverAccountId) - .execute(testEnv.client); - assertThat(accountInfoAfterTokenAssociation.tokenRelationships.size()).isEqualTo(1); - assertThat(accountInfoAfterTokenAssociation.tokenRelationships.get(tokenId1).automaticAssociation).isTrue(); - - assertThatExceptionOfType(Exception.class).isThrownBy(() -> { - new TransferTransaction() - .addTokenTransfer(tokenId2, testEnv.operatorId, -1) - .addTokenTransfer(tokenId2, receiverAccountId, 1) + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var tokenId1 = EntityHelper.createFungibleToken(testEnv, 0); + var tokenId2 = EntityHelper.createFungibleToken(testEnv, 0); + var accountKey = PrivateKey.generateED25519(); + var accountMaxAutomaticTokenAssociations = 1; + var receiverAccountId = EntityHelper.createAccount(testEnv, accountKey, accountMaxAutomaticTokenAssociations); + + var accountInfoBeforeTokenAssociation = new AccountInfoQuery() + .setAccountId(receiverAccountId) + .execute(testEnv.client); + assertThat(accountInfoBeforeTokenAssociation.maxAutomaticTokenAssociations).isEqualTo(1); + assertThat(accountInfoBeforeTokenAssociation.tokenRelationships.size()).isEqualTo(0); + + + var transferRecord = new TransferTransaction() + .addTokenTransfer(tokenId1, testEnv.operatorId, -1) + .addTokenTransfer(tokenId1, receiverAccountId, 1) .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining("NO_REMAINING_AUTOMATIC_ASSOCIATIONS"); + .getRecord(testEnv.client); + assertThat(transferRecord.automaticTokenAssociations.size()).isEqualTo(1); + assertThat(transferRecord.automaticTokenAssociations.get(0).accountId).isEqualTo(receiverAccountId); + assertThat(transferRecord.automaticTokenAssociations.get(0).tokenId).isEqualTo(tokenId1); - new AccountUpdateTransaction() - .setAccountId(receiverAccountId) - .setMaxAutomaticTokenAssociations(2) - .freezeWith(testEnv.client) - .sign(accountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); + var accountInfoAfterTokenAssociation = new AccountInfoQuery() + .setAccountId(receiverAccountId) + .execute(testEnv.client); + assertThat(accountInfoAfterTokenAssociation.tokenRelationships.size()).isEqualTo(1); + assertThat(accountInfoAfterTokenAssociation.tokenRelationships.get(tokenId1).automaticAssociation).isTrue(); - var accountInfoAfterMaxAssocUpdate = new AccountInfoQuery() - .setAccountId(receiverAccountId) - .execute(testEnv.client); - assertThat(accountInfoAfterMaxAssocUpdate.maxAutomaticTokenAssociations).isEqualTo(2); + assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + new TransferTransaction() + .addTokenTransfer(tokenId2, testEnv.operatorId, -1) + .addTokenTransfer(tokenId2, receiverAccountId, 1) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining("NO_REMAINING_AUTOMATIC_ASSOCIATIONS"); - new TokenDeleteTransaction() - .setTokenId(tokenId1) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new AccountUpdateTransaction() + .setAccountId(receiverAccountId) + .setMaxAutomaticTokenAssociations(2) + .freezeWith(testEnv.client) + .sign(accountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); - new TokenDeleteTransaction() - .setTokenId(tokenId2) - .execute(testEnv.client) - .getReceipt(testEnv.client); + var accountInfoAfterMaxAssocUpdate = new AccountInfoQuery() + .setAccountId(receiverAccountId) + .execute(testEnv.client); + assertThat(accountInfoAfterMaxAssocUpdate.maxAutomaticTokenAssociations).isEqualTo(2); - testEnv.close(receiverAccountId, accountKey); + new TokenDeleteTransaction() + .setTokenId(tokenId1) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenDeleteTransaction() + .setTokenId(tokenId2) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } @Test @DisplayName("Can transfer Nfts to accounts with Limited Max Auto Associations") void canTransferNftsToAccountsWithLimitedMaxAutoAssociations() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var tokenId1 = EntityHelper.createNft(testEnv); - var tokenId2 = EntityHelper.createNft(testEnv); - var accountKey = PrivateKey.generateED25519(); - var accountMaxAutomaticTokenAssociations = 1; - var receiverAccountId = EntityHelper.createAccount(testEnv, accountKey, accountMaxAutomaticTokenAssociations); - - var mintReceiptToken1 = new TokenMintTransaction() - .setTokenId(tokenId1) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var mintReceiptToken2 = new TokenMintTransaction() - .setTokenId(tokenId2) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var accountInfoBeforeTokenAssociation = new AccountInfoQuery() - .setAccountId(receiverAccountId) - .execute(testEnv.client); - assertThat(accountInfoBeforeTokenAssociation.maxAutomaticTokenAssociations).isEqualTo(1); - assertThat(accountInfoBeforeTokenAssociation.tokenRelationships.size()).isEqualTo(0); - - - var serialsToTransfer = new ArrayList<>(mintReceiptToken2.serials); - var nftTransferTransaction = new TransferTransaction(); - for (var serial : serialsToTransfer) { - nftTransferTransaction.addNftTransfer(tokenId1.nft(serial), testEnv.operatorId, receiverAccountId); - } - var transferRecord = nftTransferTransaction - .execute(testEnv.client) - .getRecord(testEnv.client); - - assertThat(transferRecord.automaticTokenAssociations.size()).isEqualTo(1); - assertThat(transferRecord.automaticTokenAssociations.get(0).accountId).isEqualTo(receiverAccountId); - assertThat(transferRecord.automaticTokenAssociations.get(0).tokenId).isEqualTo(tokenId1); - - var accountInfoAfterTokenAssociation = new AccountInfoQuery() - .setAccountId(receiverAccountId) - .execute(testEnv.client); - assertThat(accountInfoAfterTokenAssociation.tokenRelationships.size()).isEqualTo(1); - assertThat(accountInfoAfterTokenAssociation.tokenRelationships.get(tokenId1).automaticAssociation).isTrue(); - - assertThatExceptionOfType(Exception.class).isThrownBy(() -> { - var serial = mintReceiptToken2.serials.get(0); - new TransferTransaction() - .addNftTransfer(tokenId2.nft(serial), testEnv.operatorId, receiverAccountId) + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var tokenId1 = EntityHelper.createNft(testEnv); + var tokenId2 = EntityHelper.createNft(testEnv); + var accountKey = PrivateKey.generateED25519(); + var accountMaxAutomaticTokenAssociations = 1; + var receiverAccountId = EntityHelper.createAccount(testEnv, accountKey, accountMaxAutomaticTokenAssociations); + + var mintReceiptToken1 = new TokenMintTransaction() + .setTokenId(tokenId1) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining("NO_REMAINING_AUTOMATIC_ASSOCIATIONS"); - new AccountUpdateTransaction() - .setAccountId(receiverAccountId) - .setMaxAutomaticTokenAssociations(2) - .freezeWith(testEnv.client) - .sign(accountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); + var mintReceiptToken2 = new TokenMintTransaction() + .setTokenId(tokenId2) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); - var accountInfoAfterMaxAssocUpdate = new AccountInfoQuery() - .setAccountId(receiverAccountId) - .execute(testEnv.client); - assertThat(accountInfoAfterMaxAssocUpdate.maxAutomaticTokenAssociations).isEqualTo(2); + var accountInfoBeforeTokenAssociation = new AccountInfoQuery() + .setAccountId(receiverAccountId) + .execute(testEnv.client); + assertThat(accountInfoBeforeTokenAssociation.maxAutomaticTokenAssociations).isEqualTo(1); + assertThat(accountInfoBeforeTokenAssociation.tokenRelationships.size()).isEqualTo(0); - new TokenDeleteTransaction() - .setTokenId(tokenId1) - .execute(testEnv.client) - .getReceipt(testEnv.client); - new TokenDeleteTransaction() - .setTokenId(tokenId2) - .execute(testEnv.client) - .getReceipt(testEnv.client); + var serialsToTransfer = new ArrayList<>(mintReceiptToken2.serials); + var nftTransferTransaction = new TransferTransaction(); + for (var serial : serialsToTransfer) { + nftTransferTransaction.addNftTransfer(tokenId1.nft(serial), testEnv.operatorId, receiverAccountId); + } + var transferRecord = nftTransferTransaction + .execute(testEnv.client) + .getRecord(testEnv.client); - testEnv.close(receiverAccountId, accountKey); + assertThat(transferRecord.automaticTokenAssociations.size()).isEqualTo(1); + assertThat(transferRecord.automaticTokenAssociations.get(0).accountId).isEqualTo(receiverAccountId); + assertThat(transferRecord.automaticTokenAssociations.get(0).tokenId).isEqualTo(tokenId1); + + var accountInfoAfterTokenAssociation = new AccountInfoQuery() + .setAccountId(receiverAccountId) + .execute(testEnv.client); + assertThat(accountInfoAfterTokenAssociation.tokenRelationships.size()).isEqualTo(1); + assertThat(accountInfoAfterTokenAssociation.tokenRelationships.get(tokenId1).automaticAssociation).isTrue(); + + assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + var serial = mintReceiptToken2.serials.get(0); + new TransferTransaction() + .addNftTransfer(tokenId2.nft(serial), testEnv.operatorId, receiverAccountId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining("NO_REMAINING_AUTOMATIC_ASSOCIATIONS"); + + new AccountUpdateTransaction() + .setAccountId(receiverAccountId) + .setMaxAutomaticTokenAssociations(2) + .freezeWith(testEnv.client) + .sign(accountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var accountInfoAfterMaxAssocUpdate = new AccountInfoQuery() + .setAccountId(receiverAccountId) + .execute(testEnv.client); + assertThat(accountInfoAfterMaxAssocUpdate.maxAutomaticTokenAssociations).isEqualTo(2); + + new TokenDeleteTransaction() + .setTokenId(tokenId1) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenDeleteTransaction() + .setTokenId(tokenId2) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } /** @@ -193,25 +193,25 @@ void canTransferNftsToAccountsWithLimitedMaxAutoAssociations() throws Exception @Test @DisplayName("Can set unlimited max auto associations for Account") void canSetUnlimitedMaxAutoAssociationsForAccount() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var accountKey = PrivateKey.generateED25519(); - var accountMaxAutomaticTokenAssociations = -1; - var accountId = EntityHelper.createAccount(testEnv, accountKey, accountMaxAutomaticTokenAssociations); - - new AccountUpdateTransaction() - .setAccountId(accountId) - .setMaxAutomaticTokenAssociations(accountMaxAutomaticTokenAssociations) - .freezeWith(testEnv.client) - .sign(accountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var accountInfoBeforeTokenAssociation = new AccountInfoQuery() - .setAccountId(accountId) - .execute(testEnv.client); - assertThat(accountInfoBeforeTokenAssociation.maxAutomaticTokenAssociations).isEqualTo(-1); - - testEnv.close(accountId, accountKey); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var accountKey = PrivateKey.generateED25519(); + var accountMaxAutomaticTokenAssociations = -1; + var accountId = EntityHelper.createAccount(testEnv, accountKey, accountMaxAutomaticTokenAssociations); + + new AccountUpdateTransaction() + .setAccountId(accountId) + .setMaxAutomaticTokenAssociations(accountMaxAutomaticTokenAssociations) + .freezeWith(testEnv.client) + .sign(accountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var accountInfoBeforeTokenAssociation = new AccountInfoQuery() + .setAccountId(accountId) + .execute(testEnv.client); + assertThat(accountInfoBeforeTokenAssociation.maxAutomaticTokenAssociations).isEqualTo(-1); + + } } /** @@ -221,65 +221,65 @@ void canSetUnlimitedMaxAutoAssociationsForAccount() throws Exception { @Test @DisplayName("Can transfer Fungible Tokens to accounts with Unlimited Max Auto Associations") void canTransferFungibleTokensToAccountsWithUnlimitedMaxAutoAssociations() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var tokenId1 = EntityHelper.createFungibleToken(testEnv, 3); - var tokenId2 = EntityHelper.createFungibleToken(testEnv, 3); - var accountKey = PrivateKey.generateED25519(); - var accountId1 = EntityHelper.createAccount(testEnv, accountKey, -1); - var accountId2 = EntityHelper.createAccount(testEnv, accountKey, 100); - - new AccountUpdateTransaction() - .setAccountId(accountId2) - .setMaxAutomaticTokenAssociations(-1) - .freezeWith(testEnv.client) - .sign(accountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // transfer to both receivers some token1 tokens - new TransferTransaction() - .addTokenTransfer(tokenId1, testEnv.operatorId, -1000) - .addTokenTransfer(tokenId1, accountId1, 1000) - .addTokenTransfer(tokenId1, testEnv.operatorId, -1000) - .addTokenTransfer(tokenId1, accountId2, 1000) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // transfer to both receivers some token2 tokens - new TransferTransaction() - .addTokenTransfer(tokenId2, testEnv.operatorId, -1000) - .addTokenTransfer(tokenId2, accountId1, 1000) - .addTokenTransfer(tokenId2, testEnv.operatorId, -1000) - .addTokenTransfer(tokenId2, accountId2, 1000) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // verify the balance of the receivers is 1000 - var accountId1Balance = new AccountBalanceQuery() - .setAccountId(accountId1) - .execute(testEnv.client); - - assertThat(accountId1Balance.tokens.get(tokenId1)).isEqualTo(1000); - assertThat(accountId1Balance.tokens.get(tokenId2)).isEqualTo(1000); - - var accountId2Balance = new AccountBalanceQuery() - .setAccountId(accountId2) - .execute(testEnv.client); - - assertThat(accountId2Balance.tokens.get(tokenId1)).isEqualTo(1000); - assertThat(accountId2Balance.tokens.get(tokenId2)).isEqualTo(1000); - - new TokenDeleteTransaction() - .setTokenId(tokenId1) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenDeleteTransaction() - .setTokenId(tokenId2) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(accountId1, accountKey); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var tokenId1 = EntityHelper.createFungibleToken(testEnv, 3); + var tokenId2 = EntityHelper.createFungibleToken(testEnv, 3); + var accountKey = PrivateKey.generateED25519(); + var accountId1 = EntityHelper.createAccount(testEnv, accountKey, -1); + var accountId2 = EntityHelper.createAccount(testEnv, accountKey, 100); + + new AccountUpdateTransaction() + .setAccountId(accountId2) + .setMaxAutomaticTokenAssociations(-1) + .freezeWith(testEnv.client) + .sign(accountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // transfer to both receivers some token1 tokens + new TransferTransaction() + .addTokenTransfer(tokenId1, testEnv.operatorId, -1000) + .addTokenTransfer(tokenId1, accountId1, 1000) + .addTokenTransfer(tokenId1, testEnv.operatorId, -1000) + .addTokenTransfer(tokenId1, accountId2, 1000) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // transfer to both receivers some token2 tokens + new TransferTransaction() + .addTokenTransfer(tokenId2, testEnv.operatorId, -1000) + .addTokenTransfer(tokenId2, accountId1, 1000) + .addTokenTransfer(tokenId2, testEnv.operatorId, -1000) + .addTokenTransfer(tokenId2, accountId2, 1000) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // verify the balance of the receivers is 1000 + var accountId1Balance = new AccountBalanceQuery() + .setAccountId(accountId1) + .execute(testEnv.client); + + assertThat(accountId1Balance.tokens.get(tokenId1)).isEqualTo(1000); + assertThat(accountId1Balance.tokens.get(tokenId2)).isEqualTo(1000); + + var accountId2Balance = new AccountBalanceQuery() + .setAccountId(accountId2) + .execute(testEnv.client); + + assertThat(accountId2Balance.tokens.get(tokenId1)).isEqualTo(1000); + assertThat(accountId2Balance.tokens.get(tokenId2)).isEqualTo(1000); + + new TokenDeleteTransaction() + .setTokenId(tokenId1) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenDeleteTransaction() + .setTokenId(tokenId2) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } /** @@ -289,39 +289,39 @@ void canTransferFungibleTokensToAccountsWithUnlimitedMaxAutoAssociations() throw @Test @DisplayName("Can transfer Fungible Tokens (With Decimals) to accounts with Unlimited Max Auto Associations") void canTransferFungibleTokensWithDecimalsToAccountsWithUnlimitedMaxAutoAssociations() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var tokenDecimals = 10; - var tokenId1 = EntityHelper.createFungibleToken(testEnv, tokenDecimals); - var tokenId2 = EntityHelper.createFungibleToken(testEnv, tokenDecimals); - var accountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, accountKey, -1); - - new TransferTransaction() - .addTokenTransferWithDecimals(tokenId1, testEnv.operatorId, -1000, tokenDecimals) - .addTokenTransferWithDecimals(tokenId1, receiverAccountId, 1000, tokenDecimals) - .addTokenTransferWithDecimals(tokenId2, testEnv.operatorId, -1000, tokenDecimals) - .addTokenTransferWithDecimals(tokenId2, receiverAccountId, 1000, tokenDecimals) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var receiverAccountBalance = new AccountBalanceQuery() - .setAccountId(receiverAccountId) - .execute(testEnv.client); - - assertThat(receiverAccountBalance.tokens.get(tokenId1)).isEqualTo(1000); - assertThat(receiverAccountBalance.tokens.get(tokenId2)).isEqualTo(1000); - - new TokenDeleteTransaction() - .setTokenId(tokenId1) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenDeleteTransaction() - .setTokenId(tokenId2) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(receiverAccountId, accountKey); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var tokenDecimals = 10; + var tokenId1 = EntityHelper.createFungibleToken(testEnv, tokenDecimals); + var tokenId2 = EntityHelper.createFungibleToken(testEnv, tokenDecimals); + var accountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, accountKey, -1); + + new TransferTransaction() + .addTokenTransferWithDecimals(tokenId1, testEnv.operatorId, -1000, tokenDecimals) + .addTokenTransferWithDecimals(tokenId1, receiverAccountId, 1000, tokenDecimals) + .addTokenTransferWithDecimals(tokenId2, testEnv.operatorId, -1000, tokenDecimals) + .addTokenTransferWithDecimals(tokenId2, receiverAccountId, 1000, tokenDecimals) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var receiverAccountBalance = new AccountBalanceQuery() + .setAccountId(receiverAccountId) + .execute(testEnv.client); + + assertThat(receiverAccountBalance.tokens.get(tokenId1)).isEqualTo(1000); + assertThat(receiverAccountBalance.tokens.get(tokenId2)).isEqualTo(1000); + + new TokenDeleteTransaction() + .setTokenId(tokenId1) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenDeleteTransaction() + .setTokenId(tokenId2) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } /** @@ -331,49 +331,49 @@ void canTransferFungibleTokensWithDecimalsToAccountsWithUnlimitedMaxAutoAssociat @Test @DisplayName("Can transfer Fungible Tokens on Behalf Of Owner to account with Unlimited Max Auto Associations") void canTransferFungibleTokensOnBehalfOfOwnerToAccountWithUnlimitedMaxAutoAssociations() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var tokenId1 = EntityHelper.createFungibleToken(testEnv, 3); - var tokenId2 = EntityHelper.createFungibleToken(testEnv, 3); - var accountKey = PrivateKey.generateED25519(); - var accountId = EntityHelper.createAccount(testEnv, accountKey, -1); - var spenderAccountKey = PrivateKey.generateED25519(); - var spenderAccountId = EntityHelper.createAccount(testEnv, spenderAccountKey, -1); - - new AccountAllowanceApproveTransaction() - .approveTokenAllowance(tokenId1, testEnv.operatorId, spenderAccountId, 2000) - .approveTokenAllowance(tokenId2, testEnv.operatorId, spenderAccountId, 2000) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var record = new TransferTransaction() - .addApprovedTokenTransfer(tokenId1, testEnv.operatorId, -1000) - .addTokenTransfer(tokenId1, accountId, 1000) - .addApprovedTokenTransfer(tokenId2, testEnv.operatorId, -1000) - .addTokenTransfer(tokenId2, accountId, 1000) - .setTransactionId(TransactionId.generate(spenderAccountId)) - .freezeWith(testEnv.client) - .sign(spenderAccountKey) - .execute(testEnv.client) - .getRecord(testEnv.client); - - var accountBalance = new AccountBalanceQuery() - .setAccountId(accountId) - .execute(testEnv.client); - - assertThat(accountBalance.tokens.get(tokenId1)).isEqualTo(1000); - assertThat(accountBalance.tokens.get(tokenId2)).isEqualTo(1000); - - new TokenDeleteTransaction() - .setTokenId(tokenId1) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenDeleteTransaction() - .setTokenId(tokenId2) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(accountId, accountKey); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var tokenId1 = EntityHelper.createFungibleToken(testEnv, 3); + var tokenId2 = EntityHelper.createFungibleToken(testEnv, 3); + var accountKey = PrivateKey.generateED25519(); + var accountId = EntityHelper.createAccount(testEnv, accountKey, -1); + var spenderAccountKey = PrivateKey.generateED25519(); + var spenderAccountId = EntityHelper.createAccount(testEnv, spenderAccountKey, -1); + + new AccountAllowanceApproveTransaction() + .approveTokenAllowance(tokenId1, testEnv.operatorId, spenderAccountId, 2000) + .approveTokenAllowance(tokenId2, testEnv.operatorId, spenderAccountId, 2000) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var record = new TransferTransaction() + .addApprovedTokenTransfer(tokenId1, testEnv.operatorId, -1000) + .addTokenTransfer(tokenId1, accountId, 1000) + .addApprovedTokenTransfer(tokenId2, testEnv.operatorId, -1000) + .addTokenTransfer(tokenId2, accountId, 1000) + .setTransactionId(TransactionId.generate(spenderAccountId)) + .freezeWith(testEnv.client) + .sign(spenderAccountKey) + .execute(testEnv.client) + .getRecord(testEnv.client); + + var accountBalance = new AccountBalanceQuery() + .setAccountId(accountId) + .execute(testEnv.client); + + assertThat(accountBalance.tokens.get(tokenId1)).isEqualTo(1000); + assertThat(accountBalance.tokens.get(tokenId2)).isEqualTo(1000); + + new TokenDeleteTransaction() + .setTokenId(tokenId1) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenDeleteTransaction() + .setTokenId(tokenId2) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } /** @@ -383,79 +383,79 @@ var record = new TransferTransaction() @Test @DisplayName("Can transfer Nfts to accounts with Unlimited Max Auto Associations") void canTransferNftsToAccountsWithUnlimitedMaxAutoAssociations() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var tokenId1 = EntityHelper.createNft(testEnv); - var tokenId2 = EntityHelper.createNft(testEnv); - var accountKey = PrivateKey.generateED25519(); - var accountId1 = EntityHelper.createAccount(testEnv, accountKey, -1); - var accountId2 = EntityHelper.createAccount(testEnv, accountKey, 100); - - var mintReceiptToken1 = new TokenMintTransaction() - .setTokenId(tokenId1) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var mintReceiptToken2 = new TokenMintTransaction() - .setTokenId(tokenId2) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var nftSerials = mintReceiptToken2.serials; - - new AccountUpdateTransaction() - .setAccountId(accountId2) - .setMaxAutomaticTokenAssociations(-1) - .freezeWith(testEnv.client) - .sign(accountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // transfer nft1 to both receivers, 2 for each - new TransferTransaction() - .addNftTransfer(tokenId1.nft(nftSerials.get(0)), testEnv.operatorId, accountId1) - .addNftTransfer(tokenId1.nft(nftSerials.get(1)), testEnv.operatorId, accountId1) - .addNftTransfer(tokenId1.nft(nftSerials.get(2)), testEnv.operatorId, accountId2) - .addNftTransfer(tokenId1.nft(nftSerials.get(3)), testEnv.operatorId, accountId2) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // transfer nft2 to both receivers, 2 for each - new TransferTransaction() - .addNftTransfer(tokenId2.nft(nftSerials.get(0)), testEnv.operatorId, accountId1) - .addNftTransfer(tokenId2.nft(nftSerials.get(1)), testEnv.operatorId, accountId1) - .addNftTransfer(tokenId2.nft(nftSerials.get(2)), testEnv.operatorId, accountId2) - .addNftTransfer(tokenId2.nft(nftSerials.get(3)), testEnv.operatorId, accountId2) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // verify the balance of the receivers is 2 - var accountId1Balance = new AccountBalanceQuery() - .setAccountId(accountId1) - .execute(testEnv.client); - - assertThat(accountId1Balance.tokens.get(tokenId1)).isEqualTo(2); - assertThat(accountId1Balance.tokens.get(tokenId2)).isEqualTo(2); - - var accountId2Balance = new AccountBalanceQuery() - .setAccountId(accountId2) - .execute(testEnv.client); - - assertThat(accountId2Balance.tokens.get(tokenId1)).isEqualTo(2); - assertThat(accountId2Balance.tokens.get(tokenId2)).isEqualTo(2); - - new TokenDeleteTransaction() - .setTokenId(tokenId1) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenDeleteTransaction() - .setTokenId(tokenId2) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(accountId1, accountKey); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var tokenId1 = EntityHelper.createNft(testEnv); + var tokenId2 = EntityHelper.createNft(testEnv); + var accountKey = PrivateKey.generateED25519(); + var accountId1 = EntityHelper.createAccount(testEnv, accountKey, -1); + var accountId2 = EntityHelper.createAccount(testEnv, accountKey, 100); + + var mintReceiptToken1 = new TokenMintTransaction() + .setTokenId(tokenId1) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var mintReceiptToken2 = new TokenMintTransaction() + .setTokenId(tokenId2) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var nftSerials = mintReceiptToken2.serials; + + new AccountUpdateTransaction() + .setAccountId(accountId2) + .setMaxAutomaticTokenAssociations(-1) + .freezeWith(testEnv.client) + .sign(accountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // transfer nft1 to both receivers, 2 for each + new TransferTransaction() + .addNftTransfer(tokenId1.nft(nftSerials.get(0)), testEnv.operatorId, accountId1) + .addNftTransfer(tokenId1.nft(nftSerials.get(1)), testEnv.operatorId, accountId1) + .addNftTransfer(tokenId1.nft(nftSerials.get(2)), testEnv.operatorId, accountId2) + .addNftTransfer(tokenId1.nft(nftSerials.get(3)), testEnv.operatorId, accountId2) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // transfer nft2 to both receivers, 2 for each + new TransferTransaction() + .addNftTransfer(tokenId2.nft(nftSerials.get(0)), testEnv.operatorId, accountId1) + .addNftTransfer(tokenId2.nft(nftSerials.get(1)), testEnv.operatorId, accountId1) + .addNftTransfer(tokenId2.nft(nftSerials.get(2)), testEnv.operatorId, accountId2) + .addNftTransfer(tokenId2.nft(nftSerials.get(3)), testEnv.operatorId, accountId2) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // verify the balance of the receivers is 2 + var accountId1Balance = new AccountBalanceQuery() + .setAccountId(accountId1) + .execute(testEnv.client); + + assertThat(accountId1Balance.tokens.get(tokenId1)).isEqualTo(2); + assertThat(accountId1Balance.tokens.get(tokenId2)).isEqualTo(2); + + var accountId2Balance = new AccountBalanceQuery() + .setAccountId(accountId2) + .execute(testEnv.client); + + assertThat(accountId2Balance.tokens.get(tokenId1)).isEqualTo(2); + assertThat(accountId2Balance.tokens.get(tokenId2)).isEqualTo(2); + + new TokenDeleteTransaction() + .setTokenId(tokenId1) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenDeleteTransaction() + .setTokenId(tokenId2) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } /** @@ -465,63 +465,63 @@ void canTransferNftsToAccountsWithUnlimitedMaxAutoAssociations() throws Exceptio @Test @DisplayName("Can transfer Nfts on Behalf Of Owner to account with Unlimited Max Auto Associations") void canTransferNftsOnBehalfOfOwnerToAccountWithUnlimitedMaxAutoAssociations() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var tokenId1 = EntityHelper.createNft(testEnv); - var tokenId2 = EntityHelper.createNft(testEnv); - var accountKey = PrivateKey.generateED25519(); - var accountId = EntityHelper.createAccount(testEnv, accountKey, -1); - var spenderAccountKey = PrivateKey.generateED25519(); - var spenderAccountId = EntityHelper.createAccount(testEnv, spenderAccountKey, -1); - - var mintReceiptToken1 = new TokenMintTransaction() - .setTokenId(tokenId1) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var mintReceiptToken2 = new TokenMintTransaction() - .setTokenId(tokenId2) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var nftSerials = mintReceiptToken2.serials; - - new AccountAllowanceApproveTransaction() - .approveTokenNftAllowanceAllSerials(tokenId1, testEnv.operatorId, spenderAccountId) - .approveTokenNftAllowanceAllSerials(tokenId2, testEnv.operatorId, spenderAccountId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TransferTransaction() - .addApprovedNftTransfer(tokenId1.nft(nftSerials.get(0)), testEnv.operatorId, accountId) - .addApprovedNftTransfer(tokenId1.nft(nftSerials.get(1)), testEnv.operatorId, accountId) - .addApprovedNftTransfer(tokenId2.nft(nftSerials.get(0)), testEnv.operatorId, accountId) - .addApprovedNftTransfer(tokenId2.nft(nftSerials.get(1)), testEnv.operatorId, accountId) - .setTransactionId(TransactionId.generate(spenderAccountId)) - .freezeWith(testEnv.client) - .sign(spenderAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var accountBalance = new AccountBalanceQuery() - .setAccountId(accountId) - .execute(testEnv.client); - - assertThat(accountBalance.tokens.get(tokenId1)).isEqualTo(2); - assertThat(accountBalance.tokens.get(tokenId2)).isEqualTo(2); - - new TokenDeleteTransaction() - .setTokenId(tokenId1) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenDeleteTransaction() - .setTokenId(tokenId2) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(accountId, accountKey); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var tokenId1 = EntityHelper.createNft(testEnv); + var tokenId2 = EntityHelper.createNft(testEnv); + var accountKey = PrivateKey.generateED25519(); + var accountId = EntityHelper.createAccount(testEnv, accountKey, -1); + var spenderAccountKey = PrivateKey.generateED25519(); + var spenderAccountId = EntityHelper.createAccount(testEnv, spenderAccountKey, -1); + + var mintReceiptToken1 = new TokenMintTransaction() + .setTokenId(tokenId1) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var mintReceiptToken2 = new TokenMintTransaction() + .setTokenId(tokenId2) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var nftSerials = mintReceiptToken2.serials; + + new AccountAllowanceApproveTransaction() + .approveTokenNftAllowanceAllSerials(tokenId1, testEnv.operatorId, spenderAccountId) + .approveTokenNftAllowanceAllSerials(tokenId2, testEnv.operatorId, spenderAccountId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TransferTransaction() + .addApprovedNftTransfer(tokenId1.nft(nftSerials.get(0)), testEnv.operatorId, accountId) + .addApprovedNftTransfer(tokenId1.nft(nftSerials.get(1)), testEnv.operatorId, accountId) + .addApprovedNftTransfer(tokenId2.nft(nftSerials.get(0)), testEnv.operatorId, accountId) + .addApprovedNftTransfer(tokenId2.nft(nftSerials.get(1)), testEnv.operatorId, accountId) + .setTransactionId(TransactionId.generate(spenderAccountId)) + .freezeWith(testEnv.client) + .sign(spenderAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var accountBalance = new AccountBalanceQuery() + .setAccountId(accountId) + .execute(testEnv.client); + + assertThat(accountBalance.tokens.get(tokenId1)).isEqualTo(2); + assertThat(accountBalance.tokens.get(tokenId2)).isEqualTo(2); + + new TokenDeleteTransaction() + .setTokenId(tokenId1) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenDeleteTransaction() + .setTokenId(tokenId2) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } /** @@ -531,43 +531,44 @@ void canTransferNftsOnBehalfOfOwnerToAccountWithUnlimitedMaxAutoAssociations() t @Test @DisplayName("Cannot Set Invalid Max Auto Associations Values") void cannotSetInvalidMaxAutoAssociationsValues() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var accountKey = PrivateKey.generateED25519(); - - assertThatExceptionOfType(Exception.class).isThrownBy(() -> { - new AccountCreateTransaction() - .setKey(accountKey) - .setMaxAutomaticTokenAssociations(-2) - .execute(testEnv.client); - }).withMessageContaining("INVALID_MAX_AUTO_ASSOCIATIONS"); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var accountKey = PrivateKey.generateED25519(); - assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + assertThatExceptionOfType(Exception.class).isThrownBy(() -> { new AccountCreateTransaction() .setKey(accountKey) - .setMaxAutomaticTokenAssociations(-1000) - .execute(testEnv.client); - }).withMessageContaining("INVALID_MAX_AUTO_ASSOCIATIONS"); - - var accountId = EntityHelper.createAccount(testEnv, accountKey, 100); - - assertThatExceptionOfType(Exception.class).isThrownBy(() -> { - new AccountUpdateTransaction() - .setAccountId(accountId) .setMaxAutomaticTokenAssociations(-2) - .freezeWith(testEnv.client) - .sign(accountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining("INVALID_MAX_AUTO_ASSOCIATIONS"); - - assertThatExceptionOfType(Exception.class).isThrownBy(() -> { - new AccountUpdateTransaction() - .setAccountId(accountId) - .setMaxAutomaticTokenAssociations(-1000) - .freezeWith(testEnv.client) - .sign(accountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining("INVALID_MAX_AUTO_ASSOCIATIONS"); + .execute(testEnv.client); + }).withMessageContaining("INVALID_MAX_AUTO_ASSOCIATIONS"); + + assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + new AccountCreateTransaction() + .setKey(accountKey) + .setMaxAutomaticTokenAssociations(-1000) + .execute(testEnv.client); + }).withMessageContaining("INVALID_MAX_AUTO_ASSOCIATIONS"); + + var accountId = EntityHelper.createAccount(testEnv, accountKey, 100); + + assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + new AccountUpdateTransaction() + .setAccountId(accountId) + .setMaxAutomaticTokenAssociations(-2) + .freezeWith(testEnv.client) + .sign(accountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining("INVALID_MAX_AUTO_ASSOCIATIONS"); + + assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + new AccountUpdateTransaction() + .setAccountId(accountId) + .setMaxAutomaticTokenAssociations(-1000) + .freezeWith(testEnv.client) + .sign(accountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining("INVALID_MAX_AUTO_ASSOCIATIONS"); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenBurnIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenBurnIntegrationTest.java index 434c378af..dde7405f2 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenBurnIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenBurnIntegrationTest.java @@ -44,209 +44,207 @@ class TokenBurnIntegrationTest { @Test @DisplayName("Can burn tokens") void canBurnTokens() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var response = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client); - - var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); - - var receipt = new TokenBurnTransaction() - .setAmount(10) - .setTokenId(tokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - assertThat(receipt.totalSupply).isEqualTo(1000000 - 10); - - testEnv.close(tokenId); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var response = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client); + + var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); + + var receipt = new TokenBurnTransaction() + .setAmount(10) + .setTokenId(tokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + assertThat(receipt.totalSupply).isEqualTo(1000000 - 10); + + } } @Test @DisplayName("Cannot burn tokens when token ID is not set") void cannotBurnTokensWhenTokenIDIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenBurnTransaction() - .setAmount(10) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_TOKEN_ID.toString()); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenBurnTransaction() + .setAmount(10) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_TOKEN_ID.toString()); - testEnv.close(); + } } @Test @DisplayName("Can burn tokens when amount is not set") void canBurnTokensWhenAmountIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var response = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client); - - var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); - - var receipt = new TokenBurnTransaction() - .setTokenId(tokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - assertThat(receipt.status).isEqualTo(Status.SUCCESS); - - testEnv.close(tokenId); - } - - @Test - @DisplayName("Cannot burn tokens when supply key does not sign transaction") - void cannotBurnTokensWhenSupplyKeyDoesNotSignTransaction() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var response = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(PrivateKey.generate()) - .setFreezeDefault(false) - .execute(testEnv.client); - - var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenBurnTransaction() + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var response = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client); + + var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); + + var receipt = new TokenBurnTransaction() .setTokenId(tokenId) - .setAmount(10) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - testEnv.close(tokenId); + assertThat(receipt.status).isEqualTo(Status.SUCCESS); + + } } + @Test + @DisplayName("Cannot burn tokens when supply key does not sign transaction") + void cannotBurnTokensWhenSupplyKeyDoesNotSignTransaction() throws Exception { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var response = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(PrivateKey.generate()) + .setFreezeDefault(false) + .execute(testEnv.client); + + var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenBurnTransaction() + .setTokenId(tokenId) + .setAmount(10) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + } + } @Test @DisplayName("Can burn NFTs") void canBurnNfts() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var createReceipt = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var tokenId = Objects.requireNonNull(createReceipt.tokenId); - - var mintReceipt = new TokenMintTransaction() - .setTokenId(tokenId) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenBurnTransaction() - .setSerials(mintReceipt.serials.subList(0, 4)) - .setTokenId(tokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(tokenId); - } + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var createReceipt = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client); + var tokenId = Objects.requireNonNull(createReceipt.tokenId); + + var mintReceipt = new TokenMintTransaction() + .setTokenId(tokenId) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenBurnTransaction() + .setSerials(mintReceipt.serials.subList(0, 4)) + .setTokenId(tokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } + } @Test @DisplayName("Cannot burn NFTs when NFT is not owned by treasury") void cannotBurnNftsWhenNftIsNotOwned() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var createReceipt = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var tokenId = Objects.requireNonNull(createReceipt.tokenId); - - var serials = new TokenMintTransaction() - .setTokenId(tokenId) - .setMetadata(NftMetadataGenerator.generate((byte) 1)) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .serials; - - var key = PrivateKey.generateED25519(); - - var accountId = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .accountId; - - new TokenAssociateTransaction() - .setAccountId(accountId) - .setTokenIds(Collections.singletonList(tokenId)) - .freezeWith(testEnv.client) - .signWithOperator(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TransferTransaction() - .addNftTransfer(tokenId.nft(serials.get(0)), testEnv.operatorId, accountId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenBurnTransaction() - .setSerials(serials) + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var createReceipt = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var tokenId = Objects.requireNonNull(createReceipt.tokenId); + + var serials = new TokenMintTransaction() .setTokenId(tokenId) + .setMetadata(NftMetadataGenerator.generate((byte) 1)) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .serials; + + var key = PrivateKey.generateED25519(); + + var accountId = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .accountId; + + new TokenAssociateTransaction() + .setAccountId(accountId) + .setTokenIds(Collections.singletonList(tokenId)) + .freezeWith(testEnv.client) + .signWithOperator(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TransferTransaction() + .addNftTransfer(tokenId.nft(serials.get(0)), testEnv.operatorId, accountId) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.TREASURY_MUST_OWN_BURNED_NFT.toString()); - testEnv.close(tokenId, accountId, key); + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenBurnTransaction() + .setSerials(serials) + .setTokenId(tokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.TREASURY_MUST_OWN_BURNED_NFT.toString()); + + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenCreateIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenCreateIntegrationTest.java index b01f3705d..598d25969 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenCreateIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenCreateIntegrationTest.java @@ -67,359 +67,349 @@ private static List createFractionalFeeList(int count, AccountId feeC @Test @DisplayName("Can create token with operator as all keys") void canCreateTokenWithOperatorAsAllKeys() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ - var response = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFeeScheduleKey(testEnv.operatorKey) - .setPauseKey(testEnv.operatorKey) - .setMetadataKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client); - - var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); - - testEnv.close(tokenId); + var response = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFeeScheduleKey(testEnv.operatorKey) + .setPauseKey(testEnv.operatorKey) + .setMetadataKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client); + + Objects.requireNonNull(response.getReceipt(testEnv.client)); + + } } @Test @DisplayName("Can create token with minimal properties set") @SuppressWarnings("UnusedVariable") void canCreateTokenWithMinimalPropertiesSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { - var tokenId = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTreasuryAccountId(testEnv.operatorId) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId; + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTreasuryAccountId(testEnv.operatorId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } @Test @DisplayName("Cannot create token when token name is not set") void cannotCreateTokenWhenTokenNameIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenCreateTransaction() - .setTokenSymbol("F") - .setTreasuryAccountId(testEnv.operatorId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenCreateTransaction() + .setTokenSymbol("F") + .setTreasuryAccountId(testEnv.operatorId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - }).withMessageContaining(Status.MISSING_TOKEN_NAME.toString()); + }).withMessageContaining(Status.MISSING_TOKEN_NAME.toString()); - testEnv.close(); + } } @Test @DisplayName("Cannot create token when token symbol is not set") void cannotCreateTokenWhenTokenSymbolIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenCreateTransaction() - .setTokenName("ffff") - .setTreasuryAccountId(testEnv.operatorId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenCreateTransaction() + .setTokenName("ffff") + .setTreasuryAccountId(testEnv.operatorId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - }).withMessageContaining(Status.MISSING_TOKEN_SYMBOL.toString()); + }).withMessageContaining(Status.MISSING_TOKEN_SYMBOL.toString()); - testEnv.close(); + } } @Test @DisplayName("Cannot create token when token treasury account ID is not set") void cannotCreateTokenWhenTokenTreasuryAccountIDIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .execute(testEnv.client) - .getReceipt(testEnv.client); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .execute(testEnv.client) + .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_TREASURY_ACCOUNT_FOR_TOKEN.toString()); + }).withMessageContaining(Status.INVALID_TREASURY_ACCOUNT_FOR_TOKEN.toString()); - testEnv.close(); + } } @Test @DisplayName("Cannot create token when token treasury account ID does not sign transaction") void cannotCreateTokenWhenTokenTreasuryAccountIDDoesNotSignTransaction() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTreasuryAccountId(AccountId.fromString("0.0.3")) - .execute(testEnv.client) - .getReceipt(testEnv.client); + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTreasuryAccountId(AccountId.fromString("0.0.3")) + .execute(testEnv.client) + .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - testEnv.close(); + } } @Test @DisplayName("Cannot create token when admin key does not sign transaction") void cannotCreateTokenWhenAdminKeyDoesNotSignTransaction() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { - var key = PrivateKey.generateED25519(); + var key = PrivateKey.generateED25519(); - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - testEnv.close(); + } } @Test @DisplayName("Can create token with custom fees") void canCreateTokenWithCustomFees() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var customFees = new ArrayList(); - customFees.add(new CustomFixedFee() - .setAmount(10) - .setFeeCollectorAccountId(testEnv.operatorId) - ); - customFees.add(new CustomFractionalFee() - .setNumerator(1) - .setDenominator(20) - .setMin(1) - .setMax(10) - .setFeeCollectorAccountId(testEnv.operatorId) - ); - - var tokenId = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setCustomFees(customFees) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId; - testEnv.close(tokenId); - } + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ - @Test - @DisplayName("Cannot create custom fee list with > 10 entries") - void cannotCreateMoreThanTenCustomFees() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + var customFees = new ArrayList(); + customFees.add(new CustomFixedFee() + .setAmount(10) + .setFeeCollectorAccountId(testEnv.operatorId) + ); + customFees.add(new CustomFractionalFee() + .setNumerator(1) + .setDenominator(20) + .setMin(1) + .setMax(10) + .setFeeCollectorAccountId(testEnv.operatorId) + ); - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { new TokenCreateTransaction() .setTokenName("ffff") .setTokenSymbol("F") - .setAdminKey(testEnv.operatorKey) .setTreasuryAccountId(testEnv.operatorId) - .setCustomFees(createFixedFeeList(11, testEnv.operatorId)) + .setAdminKey(testEnv.operatorKey) + .setCustomFees(customFees) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.CUSTOM_FEES_LIST_TOO_LONG.toString()); - - testEnv.close(); + } } + @Test + @DisplayName("Cannot create custom fee list with > 10 entries") + void cannotCreateMoreThanTenCustomFees() throws Exception { + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setAdminKey(testEnv.operatorKey) + .setTreasuryAccountId(testEnv.operatorId) + .setCustomFees(createFixedFeeList(11, testEnv.operatorId)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.CUSTOM_FEES_LIST_TOO_LONG.toString()); + + } + } @Test @DisplayName("Can create custom fee list with 10 fixed fees") void canCreateTenFixedFees() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ - var tokenId = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setCustomFees(createFixedFeeList(10, testEnv.operatorId)) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId; + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setCustomFees(createFixedFeeList(10, testEnv.operatorId)) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(tokenId); + } } - @Test @DisplayName("Can create custom fee list with 10 fractional fees") void canCreateTenFractionalFees() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ - var tokenId = new TokenCreateTransaction() + new TokenCreateTransaction() .setTokenName("ffff") .setTokenSymbol("F") .setAdminKey(testEnv.operatorKey) .setTreasuryAccountId(testEnv.operatorId) .setCustomFees(createFractionalFeeList(10, testEnv.operatorId)) .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId; + .getReceipt(testEnv.client); - testEnv.close(tokenId); + } } @Test @DisplayName("Cannot create a token with a custom fee where min > max") void cannotCreateMinGreaterThanMax() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setCustomFees(Collections.singletonList(new CustomFractionalFee() - .setNumerator(1) - .setDenominator(3) - .setMin(3) - .setMax(2) - .setFeeCollectorAccountId(testEnv.operatorId))) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.FRACTIONAL_FEE_MAX_AMOUNT_LESS_THAN_MIN_AMOUNT.toString()); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setCustomFees(Collections.singletonList(new CustomFractionalFee() + .setNumerator(1) + .setDenominator(3) + .setMin(3) + .setMax(2) + .setFeeCollectorAccountId(testEnv.operatorId))) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.FRACTIONAL_FEE_MAX_AMOUNT_LESS_THAN_MIN_AMOUNT.toString()); - testEnv.close(); + } } @Test @DisplayName("Cannot create a token with invalid fee collector account ID") void cannotCreateInvalidFeeCollector() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setAdminKey(testEnv.operatorKey) - .setTreasuryAccountId(testEnv.operatorId) - .setCustomFees(Collections.singletonList(new CustomFixedFee() - .setAmount(1))) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_CUSTOM_FEE_COLLECTOR.toString()); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setAdminKey(testEnv.operatorKey) + .setTreasuryAccountId(testEnv.operatorId) + .setCustomFees(Collections.singletonList(new CustomFixedFee() + .setAmount(1))) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_CUSTOM_FEE_COLLECTOR.toString()); - testEnv.close(); + } } @Test @DisplayName("Cannot create a token with a negative custom fee") void cannotCreateNegativeFee() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setAdminKey(testEnv.operatorKey) - .setTreasuryAccountId(testEnv.operatorId) - .setCustomFees(Collections.singletonList(new CustomFixedFee() - .setAmount(-1) - .setFeeCollectorAccountId(testEnv.operatorId))) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.CUSTOM_FEE_MUST_BE_POSITIVE.toString()); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setAdminKey(testEnv.operatorKey) + .setTreasuryAccountId(testEnv.operatorId) + .setCustomFees(Collections.singletonList(new CustomFixedFee() + .setAmount(-1) + .setFeeCollectorAccountId(testEnv.operatorId))) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.CUSTOM_FEE_MUST_BE_POSITIVE.toString()); - testEnv.close(); + } } - @Test @DisplayName("Cannot create custom fee with 0 denominator") void cannotCreateZeroDenominator() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setCustomFees(Collections.singletonList(new CustomFractionalFee() - .setNumerator(1) - .setDenominator(0) - .setMin(1) - .setMax(10) - .setFeeCollectorAccountId(testEnv.operatorId))) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.FRACTION_DIVIDES_BY_ZERO.toString()); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setCustomFees(Collections.singletonList(new CustomFractionalFee() + .setNumerator(1) + .setDenominator(0) + .setMin(1) + .setMax(10) + .setFeeCollectorAccountId(testEnv.operatorId))) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.FRACTION_DIVIDES_BY_ZERO.toString()); - testEnv.close(); + } } - @Test @DisplayName("Can create NFT") void canCreateNfts() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ - var response = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client); + var response = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client); - var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); + Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); - testEnv.close(tokenId); + } } - @Test @DisplayName("Can create NFT with royalty fee") void canCreateRoyaltyFee() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ - var tokenId = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTreasuryAccountId(testEnv.operatorId) - .setSupplyKey(testEnv.operatorKey) - .setAdminKey(testEnv.operatorKey) - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setCustomFees(Collections.singletonList(new CustomRoyaltyFee() - .setNumerator(1) - .setDenominator(10) - .setFallbackFee(new CustomFixedFee().setHbarAmount(new Hbar(1))) - .setFeeCollectorAccountId(testEnv.operatorId))) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId; + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTreasuryAccountId(testEnv.operatorId) + .setSupplyKey(testEnv.operatorKey) + .setAdminKey(testEnv.operatorKey) + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setCustomFees(Collections.singletonList(new CustomRoyaltyFee() + .setNumerator(1) + .setDenominator(10) + .setFallbackFee(new CustomFixedFee().setHbarAmount(new Hbar(1))) + .setFeeCollectorAccountId(testEnv.operatorId))) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(tokenId); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenDeleteIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenDeleteIntegrationTest.java index 0dc0a9d22..31f909c1e 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenDeleteIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenDeleteIntegrationTest.java @@ -36,95 +36,95 @@ class TokenDeleteIntegrationTest { @Test @DisplayName("Can delete token") void canDeleteToken() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var response = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client); - - var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); - - new TokenDeleteTransaction() - .setTokenId(tokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + var response = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client); + + var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); + + new TokenDeleteTransaction() + .setTokenId(tokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } @Test @DisplayName("Can delete token with only admin key set") void canDeleteTokenWithOnlyAdminKeySet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ - var response = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .execute(testEnv.client); + var response = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .execute(testEnv.client); - var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); + Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); - testEnv.close(tokenId); + } } @Test @DisplayName("Cannot delete token when admin key does not sign transaction") void cannotDeleteTokenWhenAdminKeyDoesNotSignTransaction() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { - var key = PrivateKey.generateED25519(); + var key = PrivateKey.generateED25519(); - var response = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(key) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client); + var response = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(key) + .freezeWith(testEnv.client) + .sign(key) + .execute(testEnv.client); - var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); + var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenDeleteTransaction() + .setTokenId(tokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { new TokenDeleteTransaction() .setTokenId(tokenId) + .freezeWith(testEnv.client) + .sign(key) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - new TokenDeleteTransaction() - .setTokenId(tokenId) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - testEnv.close(); + } } @Test @DisplayName("Cannot delete token when token ID is not set") void cannotDeleteTokenWhenTokenIDIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenDeleteTransaction() - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_TOKEN_ID.toString()); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenDeleteTransaction() + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_TOKEN_ID.toString()); - testEnv.close(); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenDissociateIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenDissociateIntegrationTest.java index 80348a092..f6dcaceac 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenDissociateIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenDissociateIntegrationTest.java @@ -40,188 +40,188 @@ class TokenDissociateIntegrationTest { @Test @DisplayName("Can dissociate account with token") void canAssociateAccountWithToken() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var key = PrivateKey.generateED25519(); - - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); - - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var key = PrivateKey.generateED25519(); + + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); + + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + new TokenAssociateTransaction() + .setAccountId(accountId) + .setTokenIds(Collections.singletonList(tokenId)) + .freezeWith(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenDissociateTransaction() + .setAccountId(accountId) + .setTokenIds(Collections.singletonList(tokenId)) + .freezeWith(testEnv.client) + .sign(key) .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - new TokenAssociateTransaction() - .setAccountId(accountId) - .setTokenIds(Collections.singletonList(tokenId)) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenDissociateTransaction() - .setAccountId(accountId) - .setTokenIds(Collections.singletonList(tokenId)) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(tokenId, accountId, key); + .getReceipt(testEnv.client); + + } } @Test @DisplayName("Can execute token dissociate transaction even when token IDs are not set") void canExecuteTokenDissociateTransactionEvenWhenTokenIDsAreNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ - var key = PrivateKey.generateED25519(); + var key = PrivateKey.generateED25519(); - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - new TokenDissociateTransaction() - .setAccountId(accountId) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TokenDissociateTransaction() + .setAccountId(accountId) + .freezeWith(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(accountId, key); + } } @Test @DisplayName("Cannot dissociate account with tokens when account ID is not set") void cannotDissociateAccountWithTokensWhenAccountIDIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ - var key = PrivateKey.generateED25519(); + var key = PrivateKey.generateED25519(); - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenDissociateTransaction() - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_ACCOUNT_ID.toString()); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenDissociateTransaction() + .freezeWith(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_ACCOUNT_ID.toString()); - testEnv.close(accountId, key); + } } @Test @DisplayName("Cannot dissociate account with tokens when account does not sign transaction") void cannotDissociateAccountWhenAccountDoesNotSignTransaction() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var key = PrivateKey.generateED25519(); - - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); - - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenDissociateTransaction() - .setAccountId(accountId) - .setTokenIds(Collections.singletonList(tokenId)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - testEnv.close(tokenId, accountId, key); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var key = PrivateKey.generateED25519(); + + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); + + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenDissociateTransaction() + .setAccountId(accountId) + .setTokenIds(Collections.singletonList(tokenId)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + } } @Test @DisplayName("Cannot dissociate account from token when account was not associated with") void cannotDissociateAccountFromTokenWhenAccountWasNotAssociatedWith() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var key = PrivateKey.generateED25519(); - - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); - - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenDissociateTransaction() - .setAccountId(accountId) - .setTokenIds(Collections.singletonList(tokenId)) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.TOKEN_NOT_ASSOCIATED_TO_ACCOUNT.toString()); - - testEnv.close(tokenId, accountId, key); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var key = PrivateKey.generateED25519(); + + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); + + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenDissociateTransaction() + .setAccountId(accountId) + .setTokenIds(Collections.singletonList(tokenId)) + .freezeWith(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.TOKEN_NOT_ASSOCIATED_TO_ACCOUNT.toString()); + + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenFeeScheduleUpdateIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenFeeScheduleUpdateIntegrationTest.java index d347f2371..5f18cd339 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenFeeScheduleUpdateIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenFeeScheduleUpdateIntegrationTest.java @@ -43,159 +43,159 @@ class TokenFeeScheduleUpdateIntegrationTest { @Test @DisplayName("Can update token fees") void canUpdateToken() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var response = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFeeScheduleKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client); - - var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); - - @Var var info = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(info.tokenId).isEqualTo(tokenId); - assertThat(info.name).isEqualTo("ffff"); - assertThat(info.symbol).isEqualTo("F"); - assertThat(info.decimals).isEqualTo(3); - assertThat(testEnv.operatorId).isEqualTo(info.treasuryAccountId); - assertThat(info.adminKey).isNotNull(); - assertThat(info.freezeKey).isNotNull(); - assertThat(info.wipeKey).isNotNull(); - assertThat(info.kycKey).isNotNull(); - assertThat(info.supplyKey).isNotNull(); - assertThat(info.adminKey.toString()).isEqualTo(testEnv.operatorKey.toString()); - assertThat(info.freezeKey.toString()).isEqualTo(testEnv.operatorKey.toString()); - assertThat(info.wipeKey.toString()).isEqualTo(testEnv.operatorKey.toString()); - assertThat(info.kycKey.toString()).isEqualTo(testEnv.operatorKey.toString()); - assertThat(info.supplyKey.toString()).isEqualTo(testEnv.operatorKey.toString()); - assertThat(info.feeScheduleKey.toString()).isEqualTo(testEnv.operatorKey.toString()); - assertThat(info.defaultFreezeStatus).isNotNull(); - assertThat(info.defaultFreezeStatus).isFalse(); - assertThat(info.defaultKycStatus).isNotNull(); - assertThat(info.defaultKycStatus).isFalse(); - assertThat(info.customFees.size()).isEqualTo(0); - - var customFees = new ArrayList(); - customFees.add(new CustomFixedFee() - .setAmount(10) - .setFeeCollectorAccountId(testEnv.operatorId) - ); - customFees.add(new CustomFractionalFee() - .setNumerator(1) - .setDenominator(20) - .setMin(1) - .setMax(10) - .setFeeCollectorAccountId(testEnv.operatorId) - ); - - new TokenFeeScheduleUpdateTransaction() - .setTokenId(tokenId) - .setCustomFees(customFees) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - info = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(info.tokenId).isEqualTo(tokenId); - assertThat(info.name).isEqualTo("ffff"); - assertThat(info.symbol).isEqualTo("F"); - assertThat(info.decimals).isEqualTo(3); - assertThat(info.treasuryAccountId).isEqualTo(testEnv.operatorId); - assertThat(info.adminKey).isNotNull(); - assertThat(info.freezeKey).isNotNull(); - assertThat(info.wipeKey).isNotNull(); - assertThat(info.kycKey).isNotNull(); - assertThat(info.supplyKey).isNotNull(); - assertThat(info.adminKey.toString()).isEqualTo(testEnv.operatorKey.toString()); - assertThat(info.freezeKey.toString()).isEqualTo(testEnv.operatorKey.toString()); - assertThat(info.wipeKey.toString()).isEqualTo(testEnv.operatorKey.toString()); - assertThat(info.kycKey.toString()).isEqualTo(testEnv.operatorKey.toString()); - assertThat(info.supplyKey.toString()).isEqualTo(testEnv.operatorKey.toString()); - assertThat(info.feeScheduleKey.toString()).isEqualTo(testEnv.operatorKey.toString()); - assertThat(info.defaultFreezeStatus).isNotNull(); - assertThat(info.defaultFreezeStatus).isFalse(); - assertThat(info.defaultKycStatus).isNotNull(); - assertThat(info.defaultKycStatus).isFalse(); - - var fees = info.customFees; - assertThat(fees.size()).isEqualTo(2); - @Var int fixedCount = 0; - @Var int fractionalCount = 0; - for (var fee : fees) { - if (fee instanceof CustomFixedFee) { - fixedCount++; - var fixed = (CustomFixedFee) fee; - assertThat(fixed.getAmount()).isEqualTo(10); - assertThat(fixed.getFeeCollectorAccountId()).isEqualTo(testEnv.operatorId); - assertThat(fixed.getDenominatingTokenId()).isNull(); - } else if (fee instanceof CustomFractionalFee) { - fractionalCount++; - var fractional = (CustomFractionalFee) fee; - assertThat(fractional.getNumerator()).isEqualTo(1); - assertThat(fractional.getDenominator()).isEqualTo(20); - assertThat(fractional.getMin()).isEqualTo(1); - assertThat(fractional.getMax()).isEqualTo(10); - assertThat(fractional.getFeeCollectorAccountId()).isEqualTo(testEnv.operatorId); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var response = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFeeScheduleKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client); + + var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); + + @Var var info = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(info.tokenId).isEqualTo(tokenId); + assertThat(info.name).isEqualTo("ffff"); + assertThat(info.symbol).isEqualTo("F"); + assertThat(info.decimals).isEqualTo(3); + assertThat(testEnv.operatorId).isEqualTo(info.treasuryAccountId); + assertThat(info.adminKey).isNotNull(); + assertThat(info.freezeKey).isNotNull(); + assertThat(info.wipeKey).isNotNull(); + assertThat(info.kycKey).isNotNull(); + assertThat(info.supplyKey).isNotNull(); + assertThat(info.adminKey.toString()).isEqualTo(testEnv.operatorKey.toString()); + assertThat(info.freezeKey.toString()).isEqualTo(testEnv.operatorKey.toString()); + assertThat(info.wipeKey.toString()).isEqualTo(testEnv.operatorKey.toString()); + assertThat(info.kycKey.toString()).isEqualTo(testEnv.operatorKey.toString()); + assertThat(info.supplyKey.toString()).isEqualTo(testEnv.operatorKey.toString()); + assertThat(info.feeScheduleKey.toString()).isEqualTo(testEnv.operatorKey.toString()); + assertThat(info.defaultFreezeStatus).isNotNull(); + assertThat(info.defaultFreezeStatus).isFalse(); + assertThat(info.defaultKycStatus).isNotNull(); + assertThat(info.defaultKycStatus).isFalse(); + assertThat(info.customFees.size()).isEqualTo(0); + + var customFees = new ArrayList(); + customFees.add(new CustomFixedFee() + .setAmount(10) + .setFeeCollectorAccountId(testEnv.operatorId) + ); + customFees.add(new CustomFractionalFee() + .setNumerator(1) + .setDenominator(20) + .setMin(1) + .setMax(10) + .setFeeCollectorAccountId(testEnv.operatorId) + ); + + new TokenFeeScheduleUpdateTransaction() + .setTokenId(tokenId) + .setCustomFees(customFees) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + info = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(info.tokenId).isEqualTo(tokenId); + assertThat(info.name).isEqualTo("ffff"); + assertThat(info.symbol).isEqualTo("F"); + assertThat(info.decimals).isEqualTo(3); + assertThat(info.treasuryAccountId).isEqualTo(testEnv.operatorId); + assertThat(info.adminKey).isNotNull(); + assertThat(info.freezeKey).isNotNull(); + assertThat(info.wipeKey).isNotNull(); + assertThat(info.kycKey).isNotNull(); + assertThat(info.supplyKey).isNotNull(); + assertThat(info.adminKey.toString()).isEqualTo(testEnv.operatorKey.toString()); + assertThat(info.freezeKey.toString()).isEqualTo(testEnv.operatorKey.toString()); + assertThat(info.wipeKey.toString()).isEqualTo(testEnv.operatorKey.toString()); + assertThat(info.kycKey.toString()).isEqualTo(testEnv.operatorKey.toString()); + assertThat(info.supplyKey.toString()).isEqualTo(testEnv.operatorKey.toString()); + assertThat(info.feeScheduleKey.toString()).isEqualTo(testEnv.operatorKey.toString()); + assertThat(info.defaultFreezeStatus).isNotNull(); + assertThat(info.defaultFreezeStatus).isFalse(); + assertThat(info.defaultKycStatus).isNotNull(); + assertThat(info.defaultKycStatus).isFalse(); + + var fees = info.customFees; + assertThat(fees.size()).isEqualTo(2); + @Var int fixedCount = 0; + @Var int fractionalCount = 0; + for (var fee : fees) { + if (fee instanceof CustomFixedFee) { + fixedCount++; + var fixed = (CustomFixedFee) fee; + assertThat(fixed.getAmount()).isEqualTo(10); + assertThat(fixed.getFeeCollectorAccountId()).isEqualTo(testEnv.operatorId); + assertThat(fixed.getDenominatingTokenId()).isNull(); + } else if (fee instanceof CustomFractionalFee) { + fractionalCount++; + var fractional = (CustomFractionalFee) fee; + assertThat(fractional.getNumerator()).isEqualTo(1); + assertThat(fractional.getDenominator()).isEqualTo(20); + assertThat(fractional.getMin()).isEqualTo(1); + assertThat(fractional.getMax()).isEqualTo(10); + assertThat(fractional.getFeeCollectorAccountId()).isEqualTo(testEnv.operatorId); + } } - } - assertThat(fixedCount).isEqualTo(1); - assertThat(fractionalCount).isEqualTo(1); + assertThat(fixedCount).isEqualTo(1); + assertThat(fractionalCount).isEqualTo(1); - testEnv.close(tokenId); + } } @Test @DisplayName("Cannot update fee schedule with any key other than fee schedule key") void cannotUpdateWithAnyOtherKey() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var response = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFeeScheduleKey(PrivateKey.generate()) - .setFreezeDefault(false) - .execute(testEnv.client); - - var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); - - var customFees = new ArrayList(); - customFees.add(new CustomFixedFee() - .setAmount(10) - .setFeeCollectorAccountId(testEnv.operatorId) - ); - customFees.add(new CustomFractionalFee() - .setNumerator(1) - .setDenominator(20) - .setMin(1) - .setMax(10) - .setFeeCollectorAccountId(testEnv.operatorId) - ); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenFeeScheduleUpdateTransaction() - .setTokenId(tokenId) - .setCustomFees(customFees) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var response = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFeeScheduleKey(PrivateKey.generate()) + .setFreezeDefault(false) + .execute(testEnv.client); + + var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); + + var customFees = new ArrayList(); + customFees.add(new CustomFixedFee() + .setAmount(10) + .setFeeCollectorAccountId(testEnv.operatorId) + ); + customFees.add(new CustomFractionalFee() + .setNumerator(1) + .setDenominator(20) + .setMin(1) + .setMax(10) + .setFeeCollectorAccountId(testEnv.operatorId) + ); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenFeeScheduleUpdateTransaction() + .setTokenId(tokenId) + .setCustomFees(customFees) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - testEnv.close(tokenId); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenFreezeIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenFreezeIntegrationTest.java index 0ed5ccf11..c9fb87a6d 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenFreezeIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenFreezeIntegrationTest.java @@ -40,131 +40,88 @@ class TokenFreezeIntegrationTest { @Test @DisplayName("Can freeze account with token") void canFreezeAccountWithToken() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var key = PrivateKey.generateED25519(); - - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); - - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - new TokenAssociateTransaction() - .setAccountId(accountId) - .setTokenIds(Collections.singletonList(tokenId)) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenFreezeTransaction() - .setAccountId(accountId) - .setTokenId(tokenId) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(tokenId, accountId, key); - } - - @Test - @DisplayName("Cannot freeze account on token when token ID is not set") - void cannotFreezeAccountOnTokenWhenTokenIDIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var key = PrivateKey.generateED25519(); - - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); - - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenFreezeTransaction() + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var key = PrivateKey.generateED25519(); + + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); + + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + new TokenAssociateTransaction() .setAccountId(accountId) + .setTokenIds(Collections.singletonList(tokenId)) .freezeWith(testEnv.client) .sign(key) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_TOKEN_ID.toString()); - testEnv.close(accountId, key); - } - - @Test - @DisplayName("Cannot freeze account on token when account ID is not set") - void cannotFreezeAccountOnTokenWhenAccountIDIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var key = PrivateKey.generateED25519(); - - var response = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client); - - var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); - - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { new TokenFreezeTransaction() + .setAccountId(accountId) .setTokenId(tokenId) .freezeWith(testEnv.client) .sign(key) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_ACCOUNT_ID.toString()); - testEnv.close(tokenId); + } } @Test - @DisplayName("Cannot freeze account on token when account was not associated with") - void cannotFreezeAccountOnTokenWhenAccountWasNotAssociatedWith() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + @DisplayName("Cannot freeze account on token when token ID is not set") + void cannotFreezeAccountOnTokenWhenTokenIDIsNotSet() throws Exception { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var key = PrivateKey.generateED25519(); - var key = PrivateKey.generateED25519(); + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenFreezeTransaction() + .setAccountId(accountId) + .freezeWith(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_TOKEN_ID.toString()); + + } + } + + @Test + @DisplayName("Cannot freeze account on token when account ID is not set") + void cannotFreezeAccountOnTokenWhenAccountIDIsNotSet() throws Exception { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + var key = PrivateKey.generateED25519(); - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() + var response = new TokenCreateTransaction() .setTokenName("ffff") .setTokenSymbol("F") .setDecimals(3) @@ -176,21 +133,64 @@ void cannotFreezeAccountOnTokenWhenAccountWasNotAssociatedWith() throws Exceptio .setKycKey(testEnv.operatorKey) .setSupplyKey(testEnv.operatorKey) .setFreezeDefault(false) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); + .execute(testEnv.client); - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenFreezeTransaction() - .setAccountId(accountId) - .setTokenId(tokenId) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.TOKEN_NOT_ASSOCIATED_TO_ACCOUNT.toString()); + var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenFreezeTransaction() + .setTokenId(tokenId) + .freezeWith(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_ACCOUNT_ID.toString()); + + } + } - testEnv.close(tokenId, accountId, key); + @Test + @DisplayName("Cannot freeze account on token when account was not associated with") + void cannotFreezeAccountOnTokenWhenAccountWasNotAssociatedWith() throws Exception { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var key = PrivateKey.generateED25519(); + + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); + + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenFreezeTransaction() + .setAccountId(accountId) + .setTokenId(tokenId) + .freezeWith(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.TOKEN_NOT_ASSOCIATED_TO_ACCOUNT.toString()); + + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenGrantKycIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenGrantKycIntegrationTest.java index 3be32ce17..08b7efb4e 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenGrantKycIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenGrantKycIntegrationTest.java @@ -40,131 +40,88 @@ class TokenGrantKycIntegrationTest { @Test @DisplayName("Can grant kyc to account with token") void canGrantKycAccountWithToken() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var key = PrivateKey.generateED25519(); - - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); - - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - new TokenAssociateTransaction() - .setAccountId(accountId) - .setTokenIds(Collections.singletonList(tokenId)) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenGrantKycTransaction() - .setAccountId(accountId) - .setTokenId(tokenId) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(tokenId, accountId, key); - } - - @Test - @DisplayName("Cannot grant kyc to account on token when token ID is not set") - void cannotGrantKycToAccountOnTokenWhenTokenIDIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1); - - var key = PrivateKey.generateED25519(); - - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); - - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenGrantKycTransaction() + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var key = PrivateKey.generateED25519(); + + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); + + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + new TokenAssociateTransaction() .setAccountId(accountId) + .setTokenIds(Collections.singletonList(tokenId)) .freezeWith(testEnv.client) .sign(key) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_TOKEN_ID.toString()); - testEnv.close(accountId, key); - } - - @Test - @DisplayName("Cannot grant kyc to account on token when account ID is not set") - void cannotGrantKycToAccountOnTokenWhenAccountIDIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var key = PrivateKey.generateED25519(); - - var response = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client); - - var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); - - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { new TokenGrantKycTransaction() + .setAccountId(accountId) .setTokenId(tokenId) .freezeWith(testEnv.client) .sign(key) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_ACCOUNT_ID.toString()); - testEnv.close(tokenId); + } } @Test - @DisplayName("Cannot grant kyc to account on token when account was not associated with") - void cannotGrantKycToAccountOnTokenWhenAccountWasNotAssociatedWith() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + @DisplayName("Cannot grant kyc to account on token when token ID is not set") + void cannotGrantKycToAccountOnTokenWhenTokenIDIsNotSet() throws Exception { + try(var testEnv = new IntegrationTestEnv(1)){ + + var key = PrivateKey.generateED25519(); - var key = PrivateKey.generateED25519(); + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenGrantKycTransaction() + .setAccountId(accountId) + .freezeWith(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_TOKEN_ID.toString()); + + } + } + + @Test + @DisplayName("Cannot grant kyc to account on token when account ID is not set") + void cannotGrantKycToAccountOnTokenWhenAccountIDIsNotSet() throws Exception { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + var key = PrivateKey.generateED25519(); - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() + var response = new TokenCreateTransaction() .setTokenName("ffff") .setTokenSymbol("F") .setDecimals(3) @@ -176,21 +133,64 @@ void cannotGrantKycToAccountOnTokenWhenAccountWasNotAssociatedWith() throws Exce .setKycKey(testEnv.operatorKey) .setSupplyKey(testEnv.operatorKey) .setFreezeDefault(false) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); + .execute(testEnv.client); - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenGrantKycTransaction() - .setAccountId(accountId) - .setTokenId(tokenId) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.TOKEN_NOT_ASSOCIATED_TO_ACCOUNT.toString()); + var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenGrantKycTransaction() + .setTokenId(tokenId) + .freezeWith(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_ACCOUNT_ID.toString()); + + } + } - testEnv.close(tokenId, accountId, key); + @Test + @DisplayName("Cannot grant kyc to account on token when account was not associated with") + void cannotGrantKycToAccountOnTokenWhenAccountWasNotAssociatedWith() throws Exception { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var key = PrivateKey.generateED25519(); + + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); + + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenGrantKycTransaction() + .setAccountId(accountId) + .setTokenId(tokenId) + .freezeWith(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.TOKEN_NOT_ASSOCIATED_TO_ACCOUNT.toString()); + + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenInfoIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenInfoIntegrationTest.java index bc3e67bfd..ee7950536 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenInfoIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenInfoIntegrationTest.java @@ -34,7 +34,6 @@ import java.util.Objects; -import static org.assertj.core.api.Assertions.as; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatExceptionOfType; @@ -43,266 +42,262 @@ class TokenInfoIntegrationTest { @Test @DisplayName("Can query token info when all keys are different") void canQueryTokenInfoWhenAllKeysAreDifferent() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var key1 = PrivateKey.generateED25519(); - var key2 = PrivateKey.generateED25519(); - var key3 = PrivateKey.generateED25519(); - var key4 = PrivateKey.generateED25519(); - var key5 = PrivateKey.generateED25519(); - var key6 = PrivateKey.generateED25519(); - var key7 = PrivateKey.generateED25519(); - - var response = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(key1) - .setFreezeKey(key2) - .setWipeKey(key3) - .setKycKey(key4) - .setSupplyKey(key5) - .setPauseKey(key6) - .setMetadataKey(key7) - .setFreezeDefault(false) - .freezeWith(testEnv.client) - .sign(key1) - .execute(testEnv.client); - - var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); - - var info = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(info.tokenId).isEqualTo(tokenId); - assertThat(info.name).isEqualTo("ffff"); - assertThat(info.symbol).isEqualTo("F"); - assertThat(info.decimals).isEqualTo(3); - assertThat(info.treasuryAccountId).isEqualTo(testEnv.operatorId); - assertThat(info.adminKey).isNotNull(); - assertThat(info.freezeKey).isNotNull(); - assertThat(info.wipeKey).isNotNull(); - assertThat(info.kycKey).isNotNull(); - assertThat(info.supplyKey).isNotNull(); - assertThat(info.pauseKey).isNotNull(); - assertThat(info.metadataKey).isNotNull(); - assertThat(info.adminKey.toString()).isEqualTo(key1.getPublicKey().toString()); - assertThat(info.freezeKey.toString()).isEqualTo(key2.getPublicKey().toString()); - assertThat(info.wipeKey.toString()).isEqualTo(key3.getPublicKey().toString()); - assertThat(info.kycKey.toString()).isEqualTo(key4.getPublicKey().toString()); - assertThat(info.supplyKey.toString()).isEqualTo(key5.getPublicKey().toString()); - assertThat(info.pauseKey.toString()).isEqualTo(key6.getPublicKey().toString()); - assertThat(info.metadataKey.toString()).isEqualTo(key7.getPublicKey().toString()); - assertThat(info.defaultFreezeStatus).isNotNull(); - assertThat(info.defaultFreezeStatus).isFalse(); - assertThat(info.defaultKycStatus).isNotNull(); - assertThat(info.defaultKycStatus).isFalse(); - assertThat(info.tokenType).isEqualTo(TokenType.FUNGIBLE_COMMON); - assertThat(info.supplyType).isEqualTo(TokenSupplyType.INFINITE); - - new TokenDeleteTransaction() - .setTokenId(tokenId) - .freezeWith(testEnv.client) - .sign(key1) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + var key1 = PrivateKey.generateED25519(); + var key2 = PrivateKey.generateED25519(); + var key3 = PrivateKey.generateED25519(); + var key4 = PrivateKey.generateED25519(); + var key5 = PrivateKey.generateED25519(); + var key6 = PrivateKey.generateED25519(); + var key7 = PrivateKey.generateED25519(); + + var response = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(key1) + .setFreezeKey(key2) + .setWipeKey(key3) + .setKycKey(key4) + .setSupplyKey(key5) + .setPauseKey(key6) + .setMetadataKey(key7) + .setFreezeDefault(false) + .freezeWith(testEnv.client) + .sign(key1) + .execute(testEnv.client); + + var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); + + var info = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(info.tokenId).isEqualTo(tokenId); + assertThat(info.name).isEqualTo("ffff"); + assertThat(info.symbol).isEqualTo("F"); + assertThat(info.decimals).isEqualTo(3); + assertThat(info.treasuryAccountId).isEqualTo(testEnv.operatorId); + assertThat(info.adminKey).isNotNull(); + assertThat(info.freezeKey).isNotNull(); + assertThat(info.wipeKey).isNotNull(); + assertThat(info.kycKey).isNotNull(); + assertThat(info.supplyKey).isNotNull(); + assertThat(info.pauseKey).isNotNull(); + assertThat(info.metadataKey).isNotNull(); + assertThat(info.adminKey.toString()).isEqualTo(key1.getPublicKey().toString()); + assertThat(info.freezeKey.toString()).isEqualTo(key2.getPublicKey().toString()); + assertThat(info.wipeKey.toString()).isEqualTo(key3.getPublicKey().toString()); + assertThat(info.kycKey.toString()).isEqualTo(key4.getPublicKey().toString()); + assertThat(info.supplyKey.toString()).isEqualTo(key5.getPublicKey().toString()); + assertThat(info.pauseKey.toString()).isEqualTo(key6.getPublicKey().toString()); + assertThat(info.metadataKey.toString()).isEqualTo(key7.getPublicKey().toString()); + assertThat(info.defaultFreezeStatus).isNotNull(); + assertThat(info.defaultFreezeStatus).isFalse(); + assertThat(info.defaultKycStatus).isNotNull(); + assertThat(info.defaultKycStatus).isFalse(); + assertThat(info.tokenType).isEqualTo(TokenType.FUNGIBLE_COMMON); + assertThat(info.supplyType).isEqualTo(TokenSupplyType.INFINITE); + + new TokenDeleteTransaction() + .setTokenId(tokenId) + .freezeWith(testEnv.client) + .sign(key1) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } @Test @DisplayName("Can query token with minimal properties") void canQueryTokenInfoWhenTokenIsCreatedWithMinimalProperties() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var response = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTreasuryAccountId(testEnv.operatorId) - .execute(testEnv.client); - - var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); - - var info = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(info.tokenId).isEqualTo(tokenId); - assertThat(info.name).isEqualTo("ffff"); - assertThat(info.symbol).isEqualTo("F"); - assertThat(info.decimals).isEqualTo(0); - assertThat(info.totalSupply).isEqualTo(0); - assertThat(info.treasuryAccountId).isEqualTo(testEnv.operatorId); - assertThat(info.adminKey).isNull(); - assertThat(info.freezeKey).isNull(); - assertThat(info.wipeKey).isNull(); - assertThat(info.kycKey).isNull(); - assertThat(info.supplyKey).isNull(); - assertThat(info.pauseKey).isNull(); - assertThat(info.metadataKey).isNull(); - assertThat(info.defaultFreezeStatus).isNull(); - assertThat(info.defaultKycStatus).isNull(); - assertThat(info.tokenType).isEqualTo(TokenType.FUNGIBLE_COMMON); - assertThat(info.supplyType).isEqualTo(TokenSupplyType.INFINITE); - - testEnv.close(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + var response = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTreasuryAccountId(testEnv.operatorId) + .execute(testEnv.client); + + var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); + + var info = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(info.tokenId).isEqualTo(tokenId); + assertThat(info.name).isEqualTo("ffff"); + assertThat(info.symbol).isEqualTo("F"); + assertThat(info.decimals).isEqualTo(0); + assertThat(info.totalSupply).isEqualTo(0); + assertThat(info.treasuryAccountId).isEqualTo(testEnv.operatorId); + assertThat(info.adminKey).isNull(); + assertThat(info.freezeKey).isNull(); + assertThat(info.wipeKey).isNull(); + assertThat(info.kycKey).isNull(); + assertThat(info.supplyKey).isNull(); + assertThat(info.pauseKey).isNull(); + assertThat(info.metadataKey).isNull(); + assertThat(info.defaultFreezeStatus).isNull(); + assertThat(info.defaultKycStatus).isNull(); + assertThat(info.tokenType).isEqualTo(TokenType.FUNGIBLE_COMMON); + assertThat(info.supplyType).isEqualTo(TokenSupplyType.INFINITE); + + } } - @Test @DisplayName("Can query NFT") void canQueryNfts() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var response = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setSupplyType(TokenSupplyType.FINITE) - .setMaxSupply(5000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .execute(testEnv.client); - - var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); - - var mintReceipt = new TokenMintTransaction() - .setTokenId(tokenId) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - assertThat(mintReceipt.serials.size()).isEqualTo(10); - - var info = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(info.tokenId).isEqualTo(tokenId); - assertThat(info.name).isEqualTo("ffff"); - assertThat(info.symbol).isEqualTo("F"); - assertThat(info.decimals).isEqualTo(0); - assertThat(info.totalSupply).isEqualTo(10); - assertThat(testEnv.operatorId).isEqualTo(info.treasuryAccountId); - assertThat(info.adminKey).isNotNull(); - assertThat(info.freezeKey).isNull(); - assertThat(info.wipeKey).isNull(); - assertThat(info.kycKey).isNull(); - assertThat(info.supplyKey).isNotNull(); - assertThat(info.pauseKey).isNull(); - assertThat(info.metadataKey).isNull(); - assertThat(info.defaultFreezeStatus).isNull(); - assertThat(info.defaultKycStatus).isNull(); - assertThat(info.tokenType).isEqualTo(TokenType.NON_FUNGIBLE_UNIQUE); - assertThat(info.supplyType).isEqualTo(TokenSupplyType.FINITE); - assertThat(info.maxSupply).isEqualTo(5000); - - testEnv.close(tokenId); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var response = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setSupplyType(TokenSupplyType.FINITE) + .setMaxSupply(5000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .execute(testEnv.client); + + var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); + + var mintReceipt = new TokenMintTransaction() + .setTokenId(tokenId) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + assertThat(mintReceipt.serials.size()).isEqualTo(10); + + var info = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(info.tokenId).isEqualTo(tokenId); + assertThat(info.name).isEqualTo("ffff"); + assertThat(info.symbol).isEqualTo("F"); + assertThat(info.decimals).isEqualTo(0); + assertThat(info.totalSupply).isEqualTo(10); + assertThat(testEnv.operatorId).isEqualTo(info.treasuryAccountId); + assertThat(info.adminKey).isNotNull(); + assertThat(info.freezeKey).isNull(); + assertThat(info.wipeKey).isNull(); + assertThat(info.kycKey).isNull(); + assertThat(info.supplyKey).isNotNull(); + assertThat(info.pauseKey).isNull(); + assertThat(info.metadataKey).isNull(); + assertThat(info.defaultFreezeStatus).isNull(); + assertThat(info.defaultKycStatus).isNull(); + assertThat(info.tokenType).isEqualTo(TokenType.NON_FUNGIBLE_UNIQUE); + assertThat(info.supplyType).isEqualTo(TokenSupplyType.FINITE); + assertThat(info.maxSupply).isEqualTo(5000); + + } } @Test @DisplayName("Get cost of token info query") void getCostQueryTokenInfo() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ - var response = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .execute(testEnv.client); + var response = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .execute(testEnv.client); - var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); + var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); - var infoQuery = new TokenInfoQuery() - .setTokenId(tokenId); + var infoQuery = new TokenInfoQuery() + .setTokenId(tokenId); - var cost = infoQuery.getCost(testEnv.client); + var cost = infoQuery.getCost(testEnv.client); - infoQuery.setQueryPayment(cost).execute(testEnv.client); + infoQuery.setQueryPayment(cost).execute(testEnv.client); - testEnv.close(tokenId); + } } @Test @DisplayName("Get cost of token info query, with big max") void getCostBigMaxQueryTokenInfo() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ - var response = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .execute(testEnv.client); + var response = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .execute(testEnv.client); - var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); + var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); - var infoQuery = new TokenInfoQuery() - .setTokenId(tokenId) - .setMaxQueryPayment(new Hbar(1000)); + var infoQuery = new TokenInfoQuery() + .setTokenId(tokenId) + .setMaxQueryPayment(new Hbar(1000)); - var cost = infoQuery.getCost(testEnv.client); + var cost = infoQuery.getCost(testEnv.client); - infoQuery.setQueryPayment(cost).execute(testEnv.client); + infoQuery.setQueryPayment(cost).execute(testEnv.client); - testEnv.close(tokenId); + } } @Test @DisplayName("Can query token info when all keys are different") void getCostSmallMaxTokenInfo() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ - var response = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .execute(testEnv.client); + var response = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .execute(testEnv.client); - var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); + var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); - var infoQuery = new TokenInfoQuery() - .setTokenId(tokenId) - .setMaxQueryPayment(Hbar.fromTinybars(1)); + var infoQuery = new TokenInfoQuery() + .setTokenId(tokenId) + .setMaxQueryPayment(Hbar.fromTinybars(1)); - assertThatExceptionOfType(MaxQueryPaymentExceededException.class).isThrownBy(() -> { - infoQuery.execute(testEnv.client); - }); + assertThatExceptionOfType(MaxQueryPaymentExceededException.class).isThrownBy(() -> { + infoQuery.execute(testEnv.client); + }); - testEnv.close(tokenId); + } } @Test @DisplayName("Throws insufficient transaction fee error") void getCostInsufficientTxFeeQueryTokenInfo() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ - var response = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .execute(testEnv.client); + var response = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .execute(testEnv.client); - var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); + var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); - var infoQuery = new TokenInfoQuery() - .setTokenId(tokenId) - .setMaxQueryPayment(new Hbar(1000)); + var infoQuery = new TokenInfoQuery() + .setTokenId(tokenId) + .setMaxQueryPayment(new Hbar(1000)); - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - infoQuery.setQueryPayment(Hbar.fromTinybars(1)).execute(testEnv.client); - }).satisfies(error -> assertThat(error.status.toString()).isEqualTo("INSUFFICIENT_TX_FEE")); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + infoQuery.setQueryPayment(Hbar.fromTinybars(1)).execute(testEnv.client); + }).satisfies(error -> assertThat(error.status.toString()).isEqualTo("INSUFFICIENT_TX_FEE")); - testEnv.close(tokenId); + } } } - - - diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenManualAssociationIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenManualAssociationIntegrationTest.java index 023ceaff0..e41bdcb61 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenManualAssociationIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenManualAssociationIntegrationTest.java @@ -46,204 +46,206 @@ class TokenManualAssociationIntegrationTest { @Test @DisplayName("Can Manually associate Account with a Fungible Token") void canManuallyAssociateAccountWithFungibleToken() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var tokenDecimals = 3; - var tokenId = EntityHelper.createFungibleToken(testEnv, 3); - var accountKey = PrivateKey.generateED25519(); - var accountMaxAutomaticTokenAssociations = 0; - var receiverAccountId = EntityHelper.createAccount(testEnv, accountKey, accountMaxAutomaticTokenAssociations); - - new TokenAssociateTransaction() - .setAccountId(receiverAccountId) - .setTokenIds(Collections.singletonList(tokenId)) - .freezeWith(testEnv.client) - .sign(accountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var accountInfo = new AccountInfoQuery() - .setAccountId(receiverAccountId) - .execute(testEnv.client); - - assertThat(accountInfo.tokenRelationships.get(tokenId).decimals).isEqualTo(tokenDecimals); - - new TransferTransaction() - .addTokenTransfer(tokenId, testEnv.operatorId, -10) - .addTokenTransfer(tokenId, receiverAccountId, 10) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var accountBalance = new AccountBalanceQuery() - .setAccountId(receiverAccountId) - .execute(testEnv.client); - - assertThat(accountBalance.tokens.get(tokenId)).isEqualTo(10); - - testEnv.close(tokenId, receiverAccountId, accountKey); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var tokenDecimals = 3; + var tokenId = EntityHelper.createFungibleToken(testEnv, 3); + var accountKey = PrivateKey.generateED25519(); + var accountMaxAutomaticTokenAssociations = 0; + var receiverAccountId = EntityHelper.createAccount(testEnv, accountKey, accountMaxAutomaticTokenAssociations); + + new TokenAssociateTransaction() + .setAccountId(receiverAccountId) + .setTokenIds(Collections.singletonList(tokenId)) + .freezeWith(testEnv.client) + .sign(accountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var accountInfo = new AccountInfoQuery() + .setAccountId(receiverAccountId) + .execute(testEnv.client); + + assertThat(accountInfo.tokenRelationships.get(tokenId).decimals).isEqualTo(tokenDecimals); + + new TransferTransaction() + .addTokenTransfer(tokenId, testEnv.operatorId, -10) + .addTokenTransfer(tokenId, receiverAccountId, 10) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var accountBalance = new AccountBalanceQuery() + .setAccountId(receiverAccountId) + .execute(testEnv.client); + + assertThat(accountBalance.tokens.get(tokenId)).isEqualTo(10); + + } } @Test @DisplayName("Can Manually associate Account with Nft") void canManuallyAssociateAccountWithNft() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var tokenId = EntityHelper.createNft(testEnv); - var accountKey = PrivateKey.generateED25519(); - var accountMaxAutomaticTokenAssociations = 0; - var receiverAccountId = EntityHelper.createAccount(testEnv, accountKey, accountMaxAutomaticTokenAssociations); - - var mintReceiptToken = new TokenMintTransaction() - .setTokenId(tokenId) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenAssociateTransaction() - .setAccountId(receiverAccountId) - .setTokenIds(Collections.singletonList(tokenId)) - .freezeWith(testEnv.client) - .sign(accountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var serialsToTransfer = new ArrayList<>(mintReceiptToken.serials); - var nftTransferTransaction = new TransferTransaction(); - for (var serial : serialsToTransfer) { - nftTransferTransaction.addNftTransfer(tokenId.nft(serial), testEnv.operatorId, receiverAccountId); - } - nftTransferTransaction - .execute(testEnv.client) - .getReceipt(testEnv.client); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var tokenId = EntityHelper.createNft(testEnv); + var accountKey = PrivateKey.generateED25519(); + var accountMaxAutomaticTokenAssociations = 0; + var receiverAccountId = EntityHelper.createAccount(testEnv, accountKey, accountMaxAutomaticTokenAssociations); + + var mintReceiptToken = new TokenMintTransaction() + .setTokenId(tokenId) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenAssociateTransaction() + .setAccountId(receiverAccountId) + .setTokenIds(Collections.singletonList(tokenId)) + .freezeWith(testEnv.client) + .sign(accountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var serialsToTransfer = new ArrayList<>(mintReceiptToken.serials); + var nftTransferTransaction = new TransferTransaction(); + for (var serial : serialsToTransfer) { + nftTransferTransaction.addNftTransfer(tokenId.nft(serial), testEnv.operatorId, receiverAccountId); + } + nftTransferTransaction + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(tokenId, receiverAccountId, accountKey); + } } @Test @DisplayName("Can Manually associate Contract with a Fungible Token") void canManuallyAssociateContractWithFungibleToken() throws Exception { - var testEnv = new IntegrationTestEnv(1); - var tokenDecimals = 3; - var tokenId = EntityHelper.createFungibleToken(testEnv, 3); - var contractId = EntityHelper.createContract(testEnv, testEnv.operatorKey); - - new TokenAssociateTransaction() - .setAccountId(new AccountId(contractId.num)) - .setTokenIds(Collections.singletonList(tokenId)) - .freezeWith(testEnv.client) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var contractInfo = new ContractInfoQuery() - .setContractId(contractId) - .execute(testEnv.client); - - assertThat(contractInfo.contractId).isEqualTo(contractId); - assertThat(contractInfo.accountId).isNotNull(); - assertThat(Objects.requireNonNull(contractInfo.accountId).toString()).isEqualTo(Objects.requireNonNull(contractId).toString()); - assertThat(contractInfo.adminKey).isNotNull(); - assertThat(Objects.requireNonNull(contractInfo.adminKey).toString()).isEqualTo(Objects.requireNonNull(testEnv.operatorKey).toString()); - assertThat(contractInfo.storage).isEqualTo(128); - assertThat(contractInfo.contractMemo).isEqualTo("[e2e::ContractMemo]"); - assertThat(contractInfo.tokenRelationships.get(tokenId).decimals).isEqualTo(tokenDecimals); - - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(tokenId); + try(var testEnv = new IntegrationTestEnv(1)){ + var tokenDecimals = 3; + var tokenId = EntityHelper.createFungibleToken(testEnv, 3); + var contractId = EntityHelper.createContract(testEnv, testEnv.operatorKey); + + new TokenAssociateTransaction() + .setAccountId(new AccountId(contractId.num)) + .setTokenIds(Collections.singletonList(tokenId)) + .freezeWith(testEnv.client) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var contractInfo = new ContractInfoQuery() + .setContractId(contractId) + .execute(testEnv.client); + + assertThat(contractInfo.contractId).isEqualTo(contractId); + assertThat(contractInfo.accountId).isNotNull(); + assertThat(Objects.requireNonNull(contractInfo.accountId).toString()).isEqualTo(Objects.requireNonNull(contractId).toString()); + assertThat(contractInfo.adminKey).isNotNull(); + assertThat(Objects.requireNonNull(contractInfo.adminKey).toString()).isEqualTo(Objects.requireNonNull(testEnv.operatorKey).toString()); + assertThat(contractInfo.storage).isEqualTo(128); + assertThat(contractInfo.contractMemo).isEqualTo("[e2e::ContractMemo]"); + assertThat(contractInfo.tokenRelationships.get(tokenId).decimals).isEqualTo(tokenDecimals); + + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .setContractId(contractId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } @Test @DisplayName("Can Manually associate contract with Nft") void canManuallyAssociateContractWithNft() throws Exception { - var testEnv = new IntegrationTestEnv(1); - var tokenId = EntityHelper.createNft(testEnv); - var contractId = EntityHelper.createContract(testEnv, testEnv.operatorKey); - - new TokenAssociateTransaction() - .setAccountId(new AccountId(contractId.num)) - .setTokenIds(Collections.singletonList(tokenId)) - .freezeWith(testEnv.client) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var contractInfo = new ContractInfoQuery() - .setContractId(contractId) - .execute(testEnv.client); - - assertThat(contractInfo.contractId).isEqualTo(contractId); - assertThat(contractInfo.accountId).isNotNull(); - assertThat(Objects.requireNonNull(contractInfo.accountId).toString()).isEqualTo(Objects.requireNonNull(contractId).toString()); - assertThat(contractInfo.adminKey).isNotNull(); - assertThat(Objects.requireNonNull(contractInfo.adminKey).toString()).isEqualTo(Objects.requireNonNull(testEnv.operatorKey).toString()); - assertThat(contractInfo.storage).isEqualTo(128); - assertThat(contractInfo.contractMemo).isEqualTo("[e2e::ContractMemo]"); - - new ContractDeleteTransaction() - .setTransferAccountId(testEnv.operatorId) - .setContractId(contractId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(tokenId); + try(var testEnv = new IntegrationTestEnv(1)){ + var tokenId = EntityHelper.createNft(testEnv); + var contractId = EntityHelper.createContract(testEnv, testEnv.operatorKey); + + new TokenAssociateTransaction() + .setAccountId(new AccountId(contractId.num)) + .setTokenIds(Collections.singletonList(tokenId)) + .freezeWith(testEnv.client) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var contractInfo = new ContractInfoQuery() + .setContractId(contractId) + .execute(testEnv.client); + + assertThat(contractInfo.contractId).isEqualTo(contractId); + assertThat(contractInfo.accountId).isNotNull(); + assertThat(Objects.requireNonNull(contractInfo.accountId).toString()).isEqualTo(Objects.requireNonNull(contractId).toString()); + assertThat(contractInfo.adminKey).isNotNull(); + assertThat(Objects.requireNonNull(contractInfo.adminKey).toString()).isEqualTo(Objects.requireNonNull(testEnv.operatorKey).toString()); + assertThat(contractInfo.storage).isEqualTo(128); + assertThat(contractInfo.contractMemo).isEqualTo("[e2e::ContractMemo]"); + + new ContractDeleteTransaction() + .setTransferAccountId(testEnv.operatorId) + .setContractId(contractId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } @Test @DisplayName("Can execute token associate transaction even when token IDs are not set") void canExecuteTokenAssociateTransactionEvenWhenTokenIDsAreNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var accountKey = PrivateKey.generateED25519(); - var accountMaxAutomaticTokenAssociations = 0; - var accountId = EntityHelper.createAccount(testEnv, accountKey, accountMaxAutomaticTokenAssociations); - - new TokenAssociateTransaction() - .setAccountId(accountId) - .freezeWith(testEnv.client) - .sign(accountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(accountId, accountKey); - } - - @Test - @DisplayName("Cannot Manually associate Account with a Token when Account ID is not set") - void cannotAssociateAccountWithTokensWhenAccountIDIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var accountKey = PrivateKey.generateED25519(); - var accountMaxAutomaticTokenAssociations = 0; - var accountId = EntityHelper.createAccount(testEnv, accountKey, accountMaxAutomaticTokenAssociations); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var accountKey = PrivateKey.generateED25519(); + var accountMaxAutomaticTokenAssociations = 0; + var accountId = EntityHelper.createAccount(testEnv, accountKey, accountMaxAutomaticTokenAssociations); - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { new TokenAssociateTransaction() + .setAccountId(accountId) .freezeWith(testEnv.client) .sign(accountKey) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_ACCOUNT_ID.toString()); - testEnv.close(accountId, accountKey); + } + } + + @Test + @DisplayName("Cannot Manually associate Account with a Token when Account ID is not set") + void cannotAssociateAccountWithTokensWhenAccountIDIsNotSet() throws Exception { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var accountKey = PrivateKey.generateED25519(); + var accountMaxAutomaticTokenAssociations = 0; + var accountId = EntityHelper.createAccount(testEnv, accountKey, accountMaxAutomaticTokenAssociations); + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenAssociateTransaction() + .freezeWith(testEnv.client) + .sign(accountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_ACCOUNT_ID.toString()); + + } } @Test @DisplayName("Cannot Manually Associate Account with a Token when Account Does Not sign transaction") void cannotAssociateAccountWhenAccountDoesNotSignTransaction() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var tokenDecimals = 3; - var tokenId = EntityHelper.createFungibleToken(testEnv, tokenDecimals); - var accountKey = PrivateKey.generateED25519(); - var accountMaxAutomaticTokenAssociations = 0; - var accountId = EntityHelper.createAccount(testEnv, accountKey, accountMaxAutomaticTokenAssociations); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenAssociateTransaction() - .setAccountId(accountId) - .setTokenIds(Collections.singletonList(tokenId)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var tokenDecimals = 3; + var tokenId = EntityHelper.createFungibleToken(testEnv, tokenDecimals); + var accountKey = PrivateKey.generateED25519(); + var accountMaxAutomaticTokenAssociations = 0; + var accountId = EntityHelper.createAccount(testEnv, accountKey, accountMaxAutomaticTokenAssociations); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenAssociateTransaction() + .setAccountId(accountId) + .setTokenIds(Collections.singletonList(tokenId)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - testEnv.close(tokenId, accountId, accountKey); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenMintIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenMintIntegrationTest.java index db6a83e28..44bf44fb9 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenMintIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenMintIntegrationTest.java @@ -41,225 +41,221 @@ class TokenMintIntegrationTest { @Test @DisplayName("Can mint tokens") void canMintTokens() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var receipt = new TokenMintTransaction() + .setAmount(10) + .setTokenId(tokenId) .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var receipt = new TokenMintTransaction() - .setAmount(10) - .setTokenId(tokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + .getReceipt(testEnv.client); - assertThat(receipt.totalSupply).isEqualTo(1000000 + 10); + assertThat(receipt.totalSupply).isEqualTo(1000000 + 10); - testEnv.close(tokenId); + } } - @Test @DisplayName("Cannot mint more tokens than max supply") void cannotMintMoreThanMaxSupply() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setSupplyType(TokenSupplyType.FINITE) - .setMaxSupply(5) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenMintTransaction() - .setTokenId(tokenId) - .setAmount(6) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.TOKEN_MAX_SUPPLY_REACHED.toString()); - - testEnv.close(tokenId); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setSupplyType(TokenSupplyType.FINITE) + .setMaxSupply(5) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenMintTransaction() + .setTokenId(tokenId) + .setAmount(6) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.TOKEN_MAX_SUPPLY_REACHED.toString()); + + } } @Test @DisplayName("Cannot mint tokens when token ID is not set") void cannotMintTokensWhenTokenIDIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenMintTransaction() - .setAmount(10) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_TOKEN_ID.toString()); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenMintTransaction() + .setAmount(10) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_TOKEN_ID.toString()); - testEnv.close(); + } } @Test @DisplayName("Can mint tokens when amount is not set") void canMintTokensWhenAmountIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var receipt = new TokenMintTransaction() + .setTokenId(tokenId) .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var receipt = new TokenMintTransaction() - .setTokenId(tokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + .getReceipt(testEnv.client); - assertThat(receipt.status).isEqualTo(Status.SUCCESS); + assertThat(receipt.status).isEqualTo(Status.SUCCESS); - testEnv.close(tokenId); + } } @Test @DisplayName("Cannot mint tokens when supply key does not sign transaction") void cannotMintTokensWhenSupplyKeyDoesNotSignTransaction() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var key = PrivateKey.generateED25519(); - - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); - - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(key) - .setFreezeDefault(false) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenMintTransaction() - .setTokenId(tokenId) - .setAmount(10) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - testEnv.close(tokenId, accountId, key); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var key = PrivateKey.generateED25519(); + + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); + + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(key) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenMintTransaction() + .setTokenId(tokenId) + .setAmount(10) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + } } - @Test @DisplayName("Can mint NFTs") void canMintNfts() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var receipt = new TokenMintTransaction() + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .setTokenId(tokenId) .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var receipt = new TokenMintTransaction() - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .setTokenId(tokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + .getReceipt(testEnv.client); - assertThat(receipt.serials.size()).isEqualTo(10); + assertThat(receipt.serials.size()).isEqualTo(10); - testEnv.close(tokenId); + } } - @Test @DisplayName("Cannot mint NFTs if metadata too big") void cannotMintNftsIfMetadataTooBig() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenMintTransaction() - .setMetadata(NftMetadataGenerator.generateOneLarge()) - .setTokenId(tokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.METADATA_TOO_LONG.toString()); - - testEnv.close(tokenId); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenMintTransaction() + .setMetadata(NftMetadataGenerator.generateOneLarge()) + .setTokenId(tokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.METADATA_TOO_LONG.toString()); + + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenNftInfoIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenNftInfoIntegrationTest.java index 386eaa21b..e9b8952bc 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenNftInfoIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenNftInfoIntegrationTest.java @@ -42,222 +42,222 @@ class TokenNftInfoIntegrationTest { @Test @DisplayName("Can query NFT info by NftId") void canQueryNftInfoByNftId() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var createReceipt = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var tokenId = Objects.requireNonNull(createReceipt.tokenId); - - byte[] metadata = {50}; - - var mintReceipt = new TokenMintTransaction() - .setTokenId(tokenId) - .addMetadata(metadata) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var nftId = tokenId.nft(mintReceipt.serials.get(0)); - - var nftInfos = new TokenNftInfoQuery() - .setNftId(nftId) - .execute(testEnv.client); - - assertThat(nftInfos.size()).isEqualTo(1); - assertThat(nftInfos.get(0).nftId).isEqualTo(nftId); - assertThat(nftInfos.get(0).accountId).isEqualTo(testEnv.operatorId); - assertThat(nftInfos.get(0).metadata[0]).isEqualTo((byte) 50); - - testEnv.close(tokenId); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var createReceipt = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var tokenId = Objects.requireNonNull(createReceipt.tokenId); + + byte[] metadata = {50}; + + var mintReceipt = new TokenMintTransaction() + .setTokenId(tokenId) + .addMetadata(metadata) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var nftId = tokenId.nft(mintReceipt.serials.get(0)); + + var nftInfos = new TokenNftInfoQuery() + .setNftId(nftId) + .execute(testEnv.client); + + assertThat(nftInfos.size()).isEqualTo(1); + assertThat(nftInfos.get(0).nftId).isEqualTo(nftId); + assertThat(nftInfos.get(0).accountId).isEqualTo(testEnv.operatorId); + assertThat(nftInfos.get(0).metadata[0]).isEqualTo((byte) 50); + + } } @Test @DisplayName("Cannot query NFT info by invalid NftId") void cannotQueryNftInfoByInvalidNftId() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var createReceipt = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var tokenId = Objects.requireNonNull(createReceipt.tokenId); - - byte[] metadata = {50}; - - var mintReceipt = new TokenMintTransaction() - .setTokenId(tokenId) - .addMetadata(metadata) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var nftId = tokenId.nft(mintReceipt.serials.get(0)); - var invalidNftId = new NftId(nftId.tokenId, nftId.serial + 1); - - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenNftInfoQuery() - .setNftId(invalidNftId) - .execute(testEnv.client); - }).withMessageContaining(Status.INVALID_NFT_ID.toString()); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var createReceipt = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var tokenId = Objects.requireNonNull(createReceipt.tokenId); + + byte[] metadata = {50}; + + var mintReceipt = new TokenMintTransaction() + .setTokenId(tokenId) + .addMetadata(metadata) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var nftId = tokenId.nft(mintReceipt.serials.get(0)); + var invalidNftId = new NftId(nftId.tokenId, nftId.serial + 1); + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenNftInfoQuery() + .setNftId(invalidNftId) + .execute(testEnv.client); + }).withMessageContaining(Status.INVALID_NFT_ID.toString()); - testEnv.close(tokenId); + } } @Test @DisplayName("Cannot query NFT info by invalid NftId Serial Number") void cannotQueryNftInfoByInvalidSerialNumber() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var createReceipt = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var tokenId = Objects.requireNonNull(createReceipt.tokenId); - - byte[] metadata = {50}; - - var mintReceipt = new TokenMintTransaction() - .setTokenId(tokenId) - .addMetadata(metadata) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var nftId = tokenId.nft(mintReceipt.serials.get(0)); - var invalidNftId = new NftId(nftId.tokenId, -1L); - - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenNftInfoQuery() - .byNftId(invalidNftId) - .execute(testEnv.client); - }).withMessageContaining(Status.INVALID_TOKEN_NFT_SERIAL_NUMBER.toString()); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var createReceipt = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var tokenId = Objects.requireNonNull(createReceipt.tokenId); + + byte[] metadata = {50}; + + var mintReceipt = new TokenMintTransaction() + .setTokenId(tokenId) + .addMetadata(metadata) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var nftId = tokenId.nft(mintReceipt.serials.get(0)); + var invalidNftId = new NftId(nftId.tokenId, -1L); + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenNftInfoQuery() + .byNftId(invalidNftId) + .execute(testEnv.client); + }).withMessageContaining(Status.INVALID_TOKEN_NFT_SERIAL_NUMBER.toString()); - testEnv.close(tokenId); + } } @Disabled @Test @DisplayName("Can query NFT info by AccountId") void canQueryNftInfoByAccountId() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var createReceipt = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var tokenId = Objects.requireNonNull(createReceipt.tokenId); - - List metadatas = NftMetadataGenerator.generate((byte) 10); - - var mintReceipt = new TokenMintTransaction() - .setTokenId(tokenId) - .setMetadata(metadatas) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var nftInfos = new TokenNftInfoQuery() - .byAccountId(testEnv.operatorId) - .setEnd(10) - .execute(testEnv.client); - - assertThat(nftInfos.size()).isEqualTo(10); - - var serials = new ArrayList(mintReceipt.serials); - - for (var info : nftInfos) { - assertThat(info.nftId.tokenId).isEqualTo(tokenId); - assertThat(serials.remove(info.nftId.serial)).isTrue(); - assertThat(info.accountId).isEqualTo(testEnv.operatorId); - } + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var createReceipt = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var tokenId = Objects.requireNonNull(createReceipt.tokenId); + + List metadatas = NftMetadataGenerator.generate((byte) 10); + + var mintReceipt = new TokenMintTransaction() + .setTokenId(tokenId) + .setMetadata(metadatas) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var nftInfos = new TokenNftInfoQuery() + .byAccountId(testEnv.operatorId) + .setEnd(10) + .execute(testEnv.client); - testEnv.close(tokenId); + assertThat(nftInfos.size()).isEqualTo(10); + + var serials = new ArrayList(mintReceipt.serials); + + for (var info : nftInfos) { + assertThat(info.nftId.tokenId).isEqualTo(tokenId); + assertThat(serials.remove(info.nftId.serial)).isTrue(); + assertThat(info.accountId).isEqualTo(testEnv.operatorId); + } + + } } @Disabled @Test @DisplayName("Can query NFT info by TokenId") void canQueryNftInfoByTokenId() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var createReceipt = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var tokenId = Objects.requireNonNull(createReceipt.tokenId); - - List metadatas = NftMetadataGenerator.generate((byte) 10); - - var mintReceipt = new TokenMintTransaction() - .setTokenId(tokenId) - .setMetadata(metadatas) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var nftInfos = new TokenNftInfoQuery() - .byTokenId(tokenId) - .setEnd(10) - .execute(testEnv.client); - - assertThat(nftInfos.size()).isEqualTo(10); - - var serials = new ArrayList(mintReceipt.serials); - - for (var info : nftInfos) { - assertThat(info.nftId.tokenId).isEqualTo(tokenId); - assertThat(serials.remove(info.nftId.serial)).isTrue(); - assertThat(info.accountId).isEqualTo(testEnv.operatorId); - } + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var createReceipt = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var tokenId = Objects.requireNonNull(createReceipt.tokenId); + + List metadatas = NftMetadataGenerator.generate((byte) 10); + + var mintReceipt = new TokenMintTransaction() + .setTokenId(tokenId) + .setMetadata(metadatas) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var nftInfos = new TokenNftInfoQuery() + .byTokenId(tokenId) + .setEnd(10) + .execute(testEnv.client); + + assertThat(nftInfos.size()).isEqualTo(10); + + var serials = new ArrayList(mintReceipt.serials); - testEnv.close(tokenId); + for (var info : nftInfos) { + assertThat(info.nftId.tokenId).isEqualTo(tokenId); + assertThat(serials.remove(info.nftId.serial)).isTrue(); + assertThat(info.accountId).isEqualTo(testEnv.operatorId); + } + + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenNftTransferIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenNftTransferIntegrationTest.java index 13d7b8113..752bb6153 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenNftTransferIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenNftTransferIntegrationTest.java @@ -46,129 +46,129 @@ class TokenNftTransferIntegrationTest { @Test @DisplayName("Can transfer NFTs") void canTransferNfts() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var key = PrivateKey.generateED25519(); - - @Var TransactionResponse response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); - - var accountId = response.getReceipt(testEnv.client).accountId; - assertThat(accountId).isNotNull(); - - response = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client); - - var tokenId = response.getReceipt(testEnv.client).tokenId; - assertThat(tokenId).isNotNull(); - - var mintReceipt = new TokenMintTransaction() - .setTokenId(tokenId) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenAssociateTransaction() - .setAccountId(accountId) - .setTokenIds(Collections.singletonList(tokenId)) - .freezeWith(testEnv.client) - .signWithOperator(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenGrantKycTransaction() - .setAccountId(accountId) - .setTokenId(tokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var serialsToTransfer = new ArrayList(mintReceipt.serials.subList(0, 4)); - var transfer = new TransferTransaction(); - for (var serial : serialsToTransfer) { - transfer.addNftTransfer(tokenId.nft(serial), testEnv.operatorId, accountId); - } - transfer.execute(testEnv.client).getReceipt(testEnv.client); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var key = PrivateKey.generateED25519(); + + @Var TransactionResponse response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); + + var accountId = response.getReceipt(testEnv.client).accountId; + assertThat(accountId).isNotNull(); + + response = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client); + + var tokenId = response.getReceipt(testEnv.client).tokenId; + assertThat(tokenId).isNotNull(); + + var mintReceipt = new TokenMintTransaction() + .setTokenId(tokenId) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenAssociateTransaction() + .setAccountId(accountId) + .setTokenIds(Collections.singletonList(tokenId)) + .freezeWith(testEnv.client) + .signWithOperator(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenGrantKycTransaction() + .setAccountId(accountId) + .setTokenId(tokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var serialsToTransfer = new ArrayList(mintReceipt.serials.subList(0, 4)); + var transfer = new TransferTransaction(); + for (var serial : serialsToTransfer) { + transfer.addNftTransfer(tokenId.nft(serial), testEnv.operatorId, accountId); + } + transfer.execute(testEnv.client).getReceipt(testEnv.client); - new TokenWipeTransaction() - .setTokenId(tokenId) - .setAccountId(accountId) - .setSerials(serialsToTransfer) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TokenWipeTransaction() + .setTokenId(tokenId) + .setAccountId(accountId) + .setSerials(serialsToTransfer) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(tokenId, accountId, key); + } } @Test @DisplayName("Cannot transfer NFTs you don't own") void cannotTransferUnownedNfts() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var key = PrivateKey.generateED25519(); - - @Var TransactionResponse response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); - - var accountId = response.getReceipt(testEnv.client).accountId; - assertThat(accountId).isNotNull(); - - response = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client); - - var tokenId = response.getReceipt(testEnv.client).tokenId; - assertThat(tokenId).isNotNull(); - - var mintReceipt = new TokenMintTransaction() - .setTokenId(tokenId) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenAssociateTransaction() - .setAccountId(accountId) - .setTokenIds(Collections.singletonList(tokenId)) - .freezeWith(testEnv.client) - .signWithOperator(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var serialsToTransfer = new ArrayList(mintReceipt.serials.subList(0, 4)); - var transfer = new TransferTransaction(); - for (var serial : serialsToTransfer) { - // Try to transfer in wrong direction - transfer.addNftTransfer(tokenId.nft(serial), accountId, testEnv.operatorId); - } - transfer.freezeWith(testEnv.client).sign(key); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var key = PrivateKey.generateED25519(); + + @Var TransactionResponse response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); + + var accountId = response.getReceipt(testEnv.client).accountId; + assertThat(accountId).isNotNull(); + + response = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client); + + var tokenId = response.getReceipt(testEnv.client).tokenId; + assertThat(tokenId).isNotNull(); + + var mintReceipt = new TokenMintTransaction() + .setTokenId(tokenId) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenAssociateTransaction() + .setAccountId(accountId) + .setTokenIds(Collections.singletonList(tokenId)) + .freezeWith(testEnv.client) + .signWithOperator(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var serialsToTransfer = new ArrayList(mintReceipt.serials.subList(0, 4)); + var transfer = new TransferTransaction(); + for (var serial : serialsToTransfer) { + // Try to transfer in wrong direction + transfer.addNftTransfer(tokenId.nft(serial), accountId, testEnv.operatorId); + } + transfer.freezeWith(testEnv.client).sign(key); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + transfer.execute(testEnv.client).getReceipt(testEnv.client); + }).withMessageContaining(Status.SENDER_DOES_NOT_OWN_NFT_SERIAL_NO.toString()); - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - transfer.execute(testEnv.client).getReceipt(testEnv.client); - }).withMessageContaining(Status.SENDER_DOES_NOT_OWN_NFT_SERIAL_NO.toString()); - - testEnv.close(tokenId, accountId, key); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenPauseIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenPauseIntegrationTest.java index 395e5b458..f63743935 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenPauseIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenPauseIntegrationTest.java @@ -39,45 +39,47 @@ public class TokenPauseIntegrationTest { @Test @DisplayName("Can execute token pause transaction") void canExecuteTokenPauseTransaction() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var accountKey = PrivateKey.generateED25519(); - var testTokenAmount = 10; - var accountId = new AccountCreateTransaction().setKey(accountKey).setInitialBalance(new Hbar(2)) - .execute(testEnv.client).getReceipt(testEnv.client).accountId; + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { - var tokenId = new TokenCreateTransaction().setTokenName("ffff").setTokenSymbol("F").setInitialSupply(1000000) - .setDecimals(3).setTreasuryAccountId(testEnv.operatorId).setAdminKey(testEnv.operatorKey) - .setPauseKey(testEnv.operatorKey).setFreezeDefault(false).execute(testEnv.client) - .getReceipt(testEnv.client).tokenId; + var accountKey = PrivateKey.generateED25519(); + var testTokenAmount = 10; + var accountId = new AccountCreateTransaction().setKey(accountKey).setInitialBalance(new Hbar(2)) + .execute(testEnv.client).getReceipt(testEnv.client) + .accountId; - new TokenAssociateTransaction().setAccountId(accountId).setTokenIds(Collections.singletonList(tokenId)) - .freezeWith(testEnv.client).sign(accountKey).execute(testEnv.client).getReceipt(testEnv.client); + var tokenId = new TokenCreateTransaction().setTokenName("ffff").setTokenSymbol("F").setInitialSupply(1000000) + .setDecimals(3).setTreasuryAccountId(testEnv.operatorId).setAdminKey(testEnv.operatorKey) + .setPauseKey(testEnv.operatorKey).setFreezeDefault(false).execute(testEnv.client) + .getReceipt(testEnv.client).tokenId; - new TransferTransaction().addTokenTransfer(tokenId, accountId, testTokenAmount) - .addTokenTransfer(tokenId, testEnv.operatorId, -testTokenAmount).execute(testEnv.client) - .getReceipt(testEnv.client); + new TokenAssociateTransaction().setAccountId(accountId).setTokenIds(Collections.singletonList(tokenId)) + .freezeWith(testEnv.client).sign(accountKey).execute(testEnv.client).getReceipt(testEnv.client); - new TokenPauseTransaction().setTokenId(tokenId).freezeWith(testEnv.client).execute(testEnv.client) - .getReceipt(testEnv.client); - - assertThrows(ReceiptStatusException.class, () -> { new TransferTransaction().addTokenTransfer(tokenId, accountId, testTokenAmount) - .addTokenTransfer(tokenId, testEnv.operatorId, -testTokenAmount).freezeWith(testEnv.client) - .sign(accountKey).execute(testEnv.client).getReceipt(testEnv.client); - }); + .addTokenTransfer(tokenId, testEnv.operatorId, -testTokenAmount).execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenPauseTransaction().setTokenId(tokenId).freezeWith(testEnv.client).execute(testEnv.client) + .getReceipt(testEnv.client); + + assertThrows(ReceiptStatusException.class, () -> { + new TransferTransaction().addTokenTransfer(tokenId, accountId, testTokenAmount) + .addTokenTransfer(tokenId, testEnv.operatorId, -testTokenAmount).freezeWith(testEnv.client) + .sign(accountKey).execute(testEnv.client).getReceipt(testEnv.client); + }); - testEnv.close(); + } } @Test @DisplayName("Cannot pause with no token ID") void cannotPauseWithNoTokenId() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { - assertThrows(PrecheckStatusException.class, () -> { - new TokenPauseTransaction().execute(testEnv.client).getReceipt(testEnv.client); - }); + assertThrows(PrecheckStatusException.class, () -> { + new TokenPauseTransaction().execute(testEnv.client).getReceipt(testEnv.client); + }); - testEnv.close(); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenRejectFlowIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenRejectFlowIntegrationTest.java index eaaca79ff..657197434 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenRejectFlowIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenRejectFlowIntegrationTest.java @@ -40,224 +40,224 @@ public class TokenRejectFlowIntegrationTest { @Test @DisplayName("Can execute TokenReject flow for Fungible Token") void canExecuteTokenRejectFlowForFungibleToken() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var ftTokenId = EntityHelper.createFungibleToken(testEnv, 3); - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); - - // manually associate ft - new TokenAssociateTransaction() - .setAccountId(receiverAccountId) - .setTokenIds(Collections.singletonList(ftTokenId)) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // transfer fts to the receiver - new TransferTransaction() - .addTokenTransfer(ftTokenId, testEnv.operatorId, -10) - .addTokenTransfer(ftTokenId, receiverAccountId, 10) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // execute the token reject flow - new TokenRejectFlow() - .setOwnerId(receiverAccountId) - .addTokenId(ftTokenId) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // verify the tokens are transferred back to the treasury - var treasuryAccountBalance = new AccountBalanceQuery() - .setAccountId(testEnv.operatorId) - .execute(testEnv.client); - - assertThat(treasuryAccountBalance.tokens.get(ftTokenId)).isEqualTo(1_000_000); - - // verify the allowance - should be 0, because TokenRejectFlow dissociates - assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var ftTokenId = EntityHelper.createFungibleToken(testEnv, 3); + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); + + // manually associate ft + new TokenAssociateTransaction() + .setAccountId(receiverAccountId) + .setTokenIds(Collections.singletonList(ftTokenId)) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // transfer fts to the receiver new TransferTransaction() .addTokenTransfer(ftTokenId, testEnv.operatorId, -10) .addTokenTransfer(ftTokenId, receiverAccountId, 10) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining("TOKEN_NOT_ASSOCIATED_TO_ACCOUNT"); - new TokenDeleteTransaction() - .setTokenId(ftTokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + // execute the token reject flow + new TokenRejectFlow() + .setOwnerId(receiverAccountId) + .addTokenId(ftTokenId) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // verify the tokens are transferred back to the treasury + var treasuryAccountBalance = new AccountBalanceQuery() + .setAccountId(testEnv.operatorId) + .execute(testEnv.client); + + assertThat(treasuryAccountBalance.tokens.get(ftTokenId)).isEqualTo(1_000_000); + + // verify the allowance - should be 0, because TokenRejectFlow dissociates + assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + new TransferTransaction() + .addTokenTransfer(ftTokenId, testEnv.operatorId, -10) + .addTokenTransfer(ftTokenId, receiverAccountId, 10) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining("TOKEN_NOT_ASSOCIATED_TO_ACCOUNT"); + + new TokenDeleteTransaction() + .setTokenId(ftTokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(receiverAccountId, receiverAccountKey); + } } @Test @DisplayName("Can execute TokenReject flow for Fungible Token (Async)") void canExecuteTokenRejectFlowForFungibleTokenAsync() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var ftTokenId = EntityHelper.createFungibleToken(testEnv, 3); - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); - - // manually associate ft - new TokenAssociateTransaction() - .setAccountId(receiverAccountId) - .setTokenIds(Collections.singletonList(ftTokenId)) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // transfer fts to the receiver - new TransferTransaction() - .addTokenTransfer(ftTokenId, testEnv.operatorId, -10) - .addTokenTransfer(ftTokenId, receiverAccountId, 10) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // execute the token reject flow - new TokenRejectFlow() - .setOwnerId(receiverAccountId) - .addTokenId(ftTokenId) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .executeAsync(testEnv.client).get() - .getReceipt(testEnv.client); - - // verify the tokens are transferred back to the treasury - var treasuryAccountBalance = new AccountBalanceQuery() - .setAccountId(testEnv.operatorId) - .execute(testEnv.client); - - assertThat(treasuryAccountBalance.tokens.get(ftTokenId)).isEqualTo(1_000_000); - - // verify the tokens are not associated with the receiver - assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var ftTokenId = EntityHelper.createFungibleToken(testEnv, 3); + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); + + // manually associate ft + new TokenAssociateTransaction() + .setAccountId(receiverAccountId) + .setTokenIds(Collections.singletonList(ftTokenId)) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // transfer fts to the receiver new TransferTransaction() .addTokenTransfer(ftTokenId, testEnv.operatorId, -10) .addTokenTransfer(ftTokenId, receiverAccountId, 10) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining("TOKEN_NOT_ASSOCIATED_TO_ACCOUNT"); - new TokenDeleteTransaction() - .setTokenId(ftTokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + // execute the token reject flow + new TokenRejectFlow() + .setOwnerId(receiverAccountId) + .addTokenId(ftTokenId) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .executeAsync(testEnv.client).get() + .getReceipt(testEnv.client); + + // verify the tokens are transferred back to the treasury + var treasuryAccountBalance = new AccountBalanceQuery() + .setAccountId(testEnv.operatorId) + .execute(testEnv.client); + + assertThat(treasuryAccountBalance.tokens.get(ftTokenId)).isEqualTo(1_000_000); + + // verify the tokens are not associated with the receiver + assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + new TransferTransaction() + .addTokenTransfer(ftTokenId, testEnv.operatorId, -10) + .addTokenTransfer(ftTokenId, receiverAccountId, 10) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining("TOKEN_NOT_ASSOCIATED_TO_ACCOUNT"); + + new TokenDeleteTransaction() + .setTokenId(ftTokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(receiverAccountId, receiverAccountKey); + } } @Test @DisplayName("Can execute TokenReject flow for NFT") void canExecuteTokenRejectFlowForNft() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ var nftTokenId = EntityHelper.createNft(testEnv); - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); - - var mintReceiptToken = new TokenMintTransaction() - .setTokenId(nftTokenId) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var nftSerials = mintReceiptToken.serials; - - // manually associate bft - new TokenAssociateTransaction() - .setAccountId(receiverAccountId) - .setTokenIds(Collections.singletonList(nftTokenId)) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // transfer nfts to the receiver - new TransferTransaction() - .addNftTransfer(nftTokenId.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(nftTokenId.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // execute the token reject flow - new TokenRejectFlow() - .setOwnerId(receiverAccountId) - .setNftIds(List.of(nftTokenId.nft(nftSerials.get(0)), nftTokenId.nft(nftSerials.get(1)))) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // verify the token is transferred back to the treasury - var nftTokenIdNftInfo = new TokenNftInfoQuery() - .setNftId(nftTokenId.nft(nftSerials.get(1))) - .execute(testEnv.client); - - assertThat(nftTokenIdNftInfo.get(0).accountId).isEqualTo(testEnv.operatorId); - - // verify the tokens are not associated with the receiver - assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); + + var mintReceiptToken = new TokenMintTransaction() + .setTokenId(nftTokenId) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var nftSerials = mintReceiptToken.serials; + + // manually associate bft + new TokenAssociateTransaction() + .setAccountId(receiverAccountId) + .setTokenIds(Collections.singletonList(nftTokenId)) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // transfer nfts to the receiver new TransferTransaction() + .addNftTransfer(nftTokenId.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) .addNftTransfer(nftTokenId.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining("TOKEN_NOT_ASSOCIATED_TO_ACCOUNT"); - new TokenDeleteTransaction() - .setTokenId(nftTokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + // execute the token reject flow + new TokenRejectFlow() + .setOwnerId(receiverAccountId) + .setNftIds(List.of(nftTokenId.nft(nftSerials.get(0)), nftTokenId.nft(nftSerials.get(1)))) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // verify the token is transferred back to the treasury + var nftTokenIdNftInfo = new TokenNftInfoQuery() + .setNftId(nftTokenId.nft(nftSerials.get(1))) + .execute(testEnv.client); + + assertThat(nftTokenIdNftInfo.get(0).accountId).isEqualTo(testEnv.operatorId); + + // verify the tokens are not associated with the receiver + assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + new TransferTransaction() + .addNftTransfer(nftTokenId.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining("TOKEN_NOT_ASSOCIATED_TO_ACCOUNT"); + + new TokenDeleteTransaction() + .setTokenId(nftTokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(receiverAccountId, receiverAccountKey); + } } @Test @DisplayName("Cannot execute TokenReject flow for NFT when rejecting Only Part Of Owned NFTs") void canExecuteTokenRejectFlowForNftWhenRejectingOnlyPartOfOwnedNFTs() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var nftTokenId1 = EntityHelper.createNft(testEnv); - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); - - var mintReceiptToken = new TokenMintTransaction() - .setTokenId(nftTokenId1) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var nftSerials = mintReceiptToken.serials; - - // manually associate bft - new TokenAssociateTransaction() - .setAccountId(receiverAccountId) - .setTokenIds(Collections.singletonList(nftTokenId1)) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // transfer nfts to the receiver - new TransferTransaction() - .addNftTransfer(nftTokenId1.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(nftTokenId1.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // execute the token reject flow - assertThatExceptionOfType(Exception.class).isThrownBy(() -> { - new TokenRejectFlow() - .setOwnerId(receiverAccountId) - .addNftId(nftTokenId1.nft(nftSerials.get(1))) + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var nftTokenId1 = EntityHelper.createNft(testEnv); + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 0); + + var mintReceiptToken = new TokenMintTransaction() + .setTokenId(nftTokenId1) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var nftSerials = mintReceiptToken.serials; + + // manually associate bft + new TokenAssociateTransaction() + .setAccountId(receiverAccountId) + .setTokenIds(Collections.singletonList(nftTokenId1)) .freezeWith(testEnv.client) .sign(receiverAccountKey) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining("ACCOUNT_STILL_OWNS_NFTS"); - testEnv.close(receiverAccountId, receiverAccountKey); + // transfer nfts to the receiver + new TransferTransaction() + .addNftTransfer(nftTokenId1.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(nftTokenId1.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // execute the token reject flow + assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + new TokenRejectFlow() + .setOwnerId(receiverAccountId) + .addNftId(nftTokenId1.nft(nftSerials.get(1))) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining("ACCOUNT_STILL_OWNS_NFTS"); + + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenRejectIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenRejectIntegrationTest.java index b25eab39b..01746132d 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenRejectIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenRejectIntegrationTest.java @@ -51,582 +51,562 @@ public class TokenRejectIntegrationTest { @Test @DisplayName("Can execute TokenReject transaction for Fungible Token") void canExecuteTokenRejectTransactionForFungibleToken() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var tokenId1 = EntityHelper.createFungibleToken(testEnv, 3); - var tokenId2 = EntityHelper.createFungibleToken(testEnv, 3); - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 100); - - // transfer fts to the receiver - new TransferTransaction() - .addTokenTransfer(tokenId1, testEnv.operatorId, -10) - .addTokenTransfer(tokenId1, receiverAccountId, 10) - .addTokenTransfer(tokenId2, testEnv.operatorId, -10) - .addTokenTransfer(tokenId2, receiverAccountId, 10) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // reject the token - new TokenRejectTransaction() - .setOwnerId(receiverAccountId) - .setTokenIds(List.of(tokenId1, tokenId2)) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // verify the balance of the receiver is 0 - var receiverAccountBalance = new AccountBalanceQuery() - .setAccountId(receiverAccountId) - .execute(testEnv.client); - - assertThat(receiverAccountBalance.tokens.get(tokenId1)).isEqualTo(0); - assertThat(receiverAccountBalance.tokens.get(tokenId2)).isEqualTo(0); - - // verify the tokens are transferred back to the treasury - var treasuryAccountBalance = new AccountBalanceQuery() - .setAccountId(testEnv.operatorId) - .execute(testEnv.client); - - assertThat(treasuryAccountBalance.tokens.get(tokenId1)).isEqualTo(1_000_000); - assertThat(treasuryAccountBalance.tokens.get(tokenId2)).isEqualTo(1_000_000); - - new TokenDeleteTransaction() - .setTokenId(tokenId1) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenDeleteTransaction() - .setTokenId(tokenId2) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(receiverAccountId, receiverAccountKey); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var tokenId1 = EntityHelper.createFungibleToken(testEnv, 3); + var tokenId2 = EntityHelper.createFungibleToken(testEnv, 3); + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 100); + + // transfer fts to the receiver + new TransferTransaction() + .addTokenTransfer(tokenId1, testEnv.operatorId, -10) + .addTokenTransfer(tokenId1, receiverAccountId, 10) + .addTokenTransfer(tokenId2, testEnv.operatorId, -10) + .addTokenTransfer(tokenId2, receiverAccountId, 10) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // reject the token + new TokenRejectTransaction() + .setOwnerId(receiverAccountId) + .setTokenIds(List.of(tokenId1, tokenId2)) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // verify the balance of the receiver is 0 + var receiverAccountBalance = new AccountBalanceQuery() + .setAccountId(receiverAccountId) + .execute(testEnv.client); + + assertThat(receiverAccountBalance.tokens.get(tokenId1)).isEqualTo(0); + assertThat(receiverAccountBalance.tokens.get(tokenId2)).isEqualTo(0); + + // verify the tokens are transferred back to the treasury + var treasuryAccountBalance = new AccountBalanceQuery() + .setAccountId(testEnv.operatorId) + .execute(testEnv.client); + + assertThat(treasuryAccountBalance.tokens.get(tokenId1)).isEqualTo(1_000_000); + assertThat(treasuryAccountBalance.tokens.get(tokenId2)).isEqualTo(1_000_000); + + new TokenDeleteTransaction() + .setTokenId(tokenId1) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenDeleteTransaction() + .setTokenId(tokenId2) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } @Test @DisplayName("Can execute TokenReject transaction for NFT") void canExecuteTokenRejectTransactionForNft() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var tokenId1 = EntityHelper.createNft(testEnv); - var tokenId2 = EntityHelper.createNft(testEnv); - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 100); - - var mintReceiptToken1 = new TokenMintTransaction() - .setTokenId(tokenId1) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var mintReceiptToken2 = new TokenMintTransaction() - .setTokenId(tokenId2) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var nftSerials = mintReceiptToken2.serials; - - // transfer nfts to the receiver - new TransferTransaction() - .addNftTransfer(tokenId1.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(tokenId1.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(tokenId2.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(tokenId2.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // reject one of the nfts - new TokenRejectTransaction() - .setOwnerId(receiverAccountId) - .setNftIds(List.of(tokenId1.nft(nftSerials.get(1)), tokenId2.nft(nftSerials.get(1)))) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // verify the balance is decremented by 1 - var receiverAccountBalance = new AccountBalanceQuery() - .setAccountId(receiverAccountId) - .execute(testEnv.client); - - assertThat(receiverAccountBalance.tokens.get(tokenId1)).isEqualTo(1); - assertThat(receiverAccountBalance.tokens.get(tokenId2)).isEqualTo(1); - - // verify the token is transferred back to the treasury - var tokenId1NftInfo = new TokenNftInfoQuery() - .setNftId(tokenId1.nft(nftSerials.get(1))) - .execute(testEnv.client); - - assertThat(tokenId1NftInfo.get(0).accountId).isEqualTo(testEnv.operatorId); - - var tokenId2NftInfo = new TokenNftInfoQuery() - .setNftId(tokenId2.nft(nftSerials.get(1))) - .execute(testEnv.client); - - assertThat(tokenId2NftInfo.get(0).accountId).isEqualTo(testEnv.operatorId); - - new TokenDeleteTransaction() - .setTokenId(tokenId1) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenDeleteTransaction() - .setTokenId(tokenId2) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(receiverAccountId, receiverAccountKey); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var tokenId1 = EntityHelper.createNft(testEnv); + var tokenId2 = EntityHelper.createNft(testEnv); + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 100); + + var mintReceiptToken1 = new TokenMintTransaction() + .setTokenId(tokenId1) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var mintReceiptToken2 = new TokenMintTransaction() + .setTokenId(tokenId2) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var nftSerials = mintReceiptToken2.serials; + + // transfer nfts to the receiver + new TransferTransaction() + .addNftTransfer(tokenId1.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(tokenId1.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(tokenId2.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(tokenId2.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // reject one of the nfts + new TokenRejectTransaction() + .setOwnerId(receiverAccountId) + .setNftIds(List.of(tokenId1.nft(nftSerials.get(1)), tokenId2.nft(nftSerials.get(1)))) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // verify the balance is decremented by 1 + var receiverAccountBalance = new AccountBalanceQuery() + .setAccountId(receiverAccountId) + .execute(testEnv.client); + + assertThat(receiverAccountBalance.tokens.get(tokenId1)).isEqualTo(1); + assertThat(receiverAccountBalance.tokens.get(tokenId2)).isEqualTo(1); + + // verify the token is transferred back to the treasury + var tokenId1NftInfo = new TokenNftInfoQuery() + .setNftId(tokenId1.nft(nftSerials.get(1))) + .execute(testEnv.client); + + assertThat(tokenId1NftInfo.get(0).accountId).isEqualTo(testEnv.operatorId); + + var tokenId2NftInfo = new TokenNftInfoQuery() + .setNftId(tokenId2.nft(nftSerials.get(1))) + .execute(testEnv.client); + + assertThat(tokenId2NftInfo.get(0).accountId).isEqualTo(testEnv.operatorId); + + new TokenDeleteTransaction() + .setTokenId(tokenId1) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenDeleteTransaction() + .setTokenId(tokenId2) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } @Test @DisplayName("Can execute TokenReject transaction for FT and NFT in One Tx") void canExecuteTokenRejectTransactionForFtAndNftInOneTx() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var ftTokenId1 = EntityHelper.createFungibleToken(testEnv, 3); - var ftTokenId2 = EntityHelper.createFungibleToken(testEnv, 3); - var nftTokenId1 = EntityHelper.createNft(testEnv); - var nftTokenId2 = EntityHelper.createNft(testEnv); - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 100); - - var mintReceiptNftToken1 = new TokenMintTransaction() - .setTokenId(nftTokenId1) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var mintReceiptNftToken2 = new TokenMintTransaction() - .setTokenId(nftTokenId2) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var nftSerials = mintReceiptNftToken2.serials; - - // transfer fts to the receiver - new TransferTransaction() - .addTokenTransfer(ftTokenId1, testEnv.operatorId, -10) - .addTokenTransfer(ftTokenId1, receiverAccountId, 10) - .addTokenTransfer(ftTokenId2, testEnv.operatorId, -10) - .addTokenTransfer(ftTokenId2, receiverAccountId, 10) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // transfer nfts to the receiver - new TransferTransaction() - .addNftTransfer(nftTokenId1.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(nftTokenId1.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(nftTokenId2.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(nftTokenId2.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // reject the token - new TokenRejectTransaction() - .setOwnerId(receiverAccountId) - .setTokenIds(List.of(ftTokenId1, ftTokenId2)) - .setNftIds(List.of(nftTokenId1.nft(nftSerials.get(1)), nftTokenId2.nft(nftSerials.get(1)))) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // verify the balance of the receiver is 0 - var receiverAccountBalance = new AccountBalanceQuery() - .setAccountId(receiverAccountId) - .execute(testEnv.client); - - assertThat(receiverAccountBalance.tokens.get(ftTokenId1)).isEqualTo(0); - assertThat(receiverAccountBalance.tokens.get(ftTokenId2)).isEqualTo(0); - assertThat(receiverAccountBalance.tokens.get(nftTokenId1)).isEqualTo(1); - assertThat(receiverAccountBalance.tokens.get(nftTokenId2)).isEqualTo(1); - - // verify the tokens are transferred back to the treasury - var treasuryAccountBalance = new AccountBalanceQuery() - .setAccountId(testEnv.operatorId) - .execute(testEnv.client); - - assertThat(treasuryAccountBalance.tokens.get(ftTokenId1)).isEqualTo(1_000_000); - assertThat(treasuryAccountBalance.tokens.get(ftTokenId2)).isEqualTo(1_000_000); - - var tokenId1NftInfo = new TokenNftInfoQuery() - .setNftId(nftTokenId1.nft(nftSerials.get(1))) - .execute(testEnv.client); - - assertThat(tokenId1NftInfo.get(0).accountId).isEqualTo(testEnv.operatorId); - - var tokenId2NftInfo = new TokenNftInfoQuery() - .setNftId(nftTokenId2.nft(nftSerials.get(1))) - .execute(testEnv.client); - - assertThat(tokenId2NftInfo.get(0).accountId).isEqualTo(testEnv.operatorId); - - new TokenDeleteTransaction() - .setTokenId(ftTokenId1) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenDeleteTransaction() - .setTokenId(ftTokenId2) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenDeleteTransaction() - .setTokenId(nftTokenId1) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenDeleteTransaction() - .setTokenId(nftTokenId2) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(receiverAccountId, receiverAccountKey); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var ftTokenId1 = EntityHelper.createFungibleToken(testEnv, 3); + var ftTokenId2 = EntityHelper.createFungibleToken(testEnv, 3); + var nftTokenId1 = EntityHelper.createNft(testEnv); + var nftTokenId2 = EntityHelper.createNft(testEnv); + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 100); + + var mintReceiptNftToken1 = new TokenMintTransaction() + .setTokenId(nftTokenId1) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var mintReceiptNftToken2 = new TokenMintTransaction() + .setTokenId(nftTokenId2) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var nftSerials = mintReceiptNftToken2.serials; + + // transfer fts to the receiver + new TransferTransaction() + .addTokenTransfer(ftTokenId1, testEnv.operatorId, -10) + .addTokenTransfer(ftTokenId1, receiverAccountId, 10) + .addTokenTransfer(ftTokenId2, testEnv.operatorId, -10) + .addTokenTransfer(ftTokenId2, receiverAccountId, 10) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // transfer nfts to the receiver + new TransferTransaction() + .addNftTransfer(nftTokenId1.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(nftTokenId1.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(nftTokenId2.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(nftTokenId2.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // reject the token + new TokenRejectTransaction() + .setOwnerId(receiverAccountId) + .setTokenIds(List.of(ftTokenId1, ftTokenId2)) + .setNftIds(List.of(nftTokenId1.nft(nftSerials.get(1)), nftTokenId2.nft(nftSerials.get(1)))) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // verify the balance of the receiver is 0 + var receiverAccountBalance = new AccountBalanceQuery() + .setAccountId(receiverAccountId) + .execute(testEnv.client); + + assertThat(receiverAccountBalance.tokens.get(ftTokenId1)).isEqualTo(0); + assertThat(receiverAccountBalance.tokens.get(ftTokenId2)).isEqualTo(0); + assertThat(receiverAccountBalance.tokens.get(nftTokenId1)).isEqualTo(1); + assertThat(receiverAccountBalance.tokens.get(nftTokenId2)).isEqualTo(1); + + // verify the tokens are transferred back to the treasury + var treasuryAccountBalance = new AccountBalanceQuery() + .setAccountId(testEnv.operatorId) + .execute(testEnv.client); + + assertThat(treasuryAccountBalance.tokens.get(ftTokenId1)).isEqualTo(1_000_000); + assertThat(treasuryAccountBalance.tokens.get(ftTokenId2)).isEqualTo(1_000_000); + + var tokenId1NftInfo = new TokenNftInfoQuery() + .setNftId(nftTokenId1.nft(nftSerials.get(1))) + .execute(testEnv.client); + + assertThat(tokenId1NftInfo.get(0).accountId).isEqualTo(testEnv.operatorId); + + var tokenId2NftInfo = new TokenNftInfoQuery() + .setNftId(nftTokenId2.nft(nftSerials.get(1))) + .execute(testEnv.client); + + assertThat(tokenId2NftInfo.get(0).accountId).isEqualTo(testEnv.operatorId); + + new TokenDeleteTransaction() + .setTokenId(ftTokenId1) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenDeleteTransaction() + .setTokenId(ftTokenId2) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenDeleteTransaction() + .setTokenId(nftTokenId1) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenDeleteTransaction() + .setTokenId(nftTokenId2) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } @Test @DisplayName("Can execute TokenReject transaction for FT and NFT when Treasury receiverSigRequired is Enabled") void canExecuteTokenRejectTransactionForFtAndNftWhenTreasuryReceiverSigRequiredIsEnabled() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 100); - - var treasuryAccountKey = PrivateKey.generateED25519(); - var treasuryAccountId = new AccountCreateTransaction() - .setKey(treasuryAccountKey) - .setInitialBalance(new Hbar(0)) - .setReceiverSignatureRequired(true) - .setMaxAutomaticTokenAssociations(100) - .freezeWith(testEnv.client) - .sign(treasuryAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .accountId; - - var ftTokenId = new TokenCreateTransaction() - .setTokenName("Test Fungible Token") - .setTokenSymbol("TFT") - .setTokenMemo("I was created for integration tests") - .setDecimals(18) - .setInitialSupply(1_000_000) - .setMaxSupply(1_000_000) - .setTreasuryAccountId(treasuryAccountId) - .setSupplyType(TokenSupplyType.FINITE) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setMetadataKey(testEnv.operatorKey) - .freezeWith(testEnv.client) - .sign(treasuryAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId; - - // transfer fts to the receiver - new TransferTransaction() - .addTokenTransfer(ftTokenId, treasuryAccountId, -10) - .addTokenTransfer(ftTokenId, receiverAccountId, 10) - .freezeWith(testEnv.client) - .sign(treasuryAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // reject the token - new TokenRejectTransaction() - .setOwnerId(receiverAccountId) - .addTokenId(ftTokenId) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // verify the balance of the receiver is 0 - var receiverAccountBalanceFt = new AccountBalanceQuery() - .setAccountId(receiverAccountId) - .execute(testEnv.client); - - assertThat(receiverAccountBalanceFt.tokens.get(ftTokenId)).isEqualTo(0); - - // verify the tokens are transferred back to the treasury - var treasuryAccountBalance = new AccountBalanceQuery() - .setAccountId(treasuryAccountId) - .execute(testEnv.client); - - assertThat(treasuryAccountBalance.tokens.get(ftTokenId)).isEqualTo(1_000_000); - - // same test for nft - - var nftTokenId = new TokenCreateTransaction() - .setTokenName("Test NFT") - .setTokenSymbol("TNFT") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(treasuryAccountId) - .setSupplyType(TokenSupplyType.FINITE) - .setMaxSupply(10) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setMetadataKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .freezeWith(testEnv.client) - .sign(treasuryAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId; - - var mintReceiptNftToken = new TokenMintTransaction() - .setTokenId(nftTokenId) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var nftSerials = mintReceiptNftToken.serials; - - // transfer nfts to the receiver - new TransferTransaction() - .addNftTransfer(nftTokenId.nft(nftSerials.get(0)), treasuryAccountId, receiverAccountId) - .addNftTransfer(nftTokenId.nft(nftSerials.get(1)), treasuryAccountId, receiverAccountId) - .freezeWith(testEnv.client) - .sign(treasuryAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // reject the token - new TokenRejectTransaction() - .setOwnerId(receiverAccountId) - .addNftId(nftTokenId.nft(nftSerials.get(1))) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // verify the balance is decremented by 1 - var receiverAccountBalanceNft = new AccountBalanceQuery() - .setAccountId(receiverAccountId) - .execute(testEnv.client); - - assertThat(receiverAccountBalanceNft.tokens.get(nftTokenId)).isEqualTo(1); - - // verify the token is transferred back to the treasury - var nftTokenIdInfo = new TokenNftInfoQuery() - .setNftId(nftTokenId.nft(nftSerials.get(1))) - .execute(testEnv.client); - - assertThat(nftTokenIdInfo.get(0).accountId).isEqualTo(treasuryAccountId); - - new TokenDeleteTransaction() - .setTokenId(ftTokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenDeleteTransaction() - .setTokenId(nftTokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(treasuryAccountId, treasuryAccountKey); - } + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 100); + + var treasuryAccountKey = PrivateKey.generateED25519(); + var treasuryAccountId = new AccountCreateTransaction() + .setKey(treasuryAccountKey) + .setInitialBalance(new Hbar(0)) + .setReceiverSignatureRequired(true) + .setMaxAutomaticTokenAssociations(100) + .freezeWith(testEnv.client) + .sign(treasuryAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .accountId; + + var ftTokenId = new TokenCreateTransaction() + .setTokenName("Test Fungible Token") + .setTokenSymbol("TFT") + .setTokenMemo("I was created for integration tests") + .setDecimals(18) + .setInitialSupply(1_000_000) + .setMaxSupply(1_000_000) + .setTreasuryAccountId(treasuryAccountId) + .setSupplyType(TokenSupplyType.FINITE) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setMetadataKey(testEnv.operatorKey) + .freezeWith(testEnv.client) + .sign(treasuryAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId; - @Test - @DisplayName("Cannot execute TokenReject transaction for FT and NFT when Token is Frozen") - void canExecuteTokenRejectTransactionForFtAndNftWhenTokenIsFrozen() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var ftTokenId = EntityHelper.createFungibleToken(testEnv, 18); - var nftTokenId = EntityHelper.createNft(testEnv); - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 100); - - // transfer fts to the receiver - new TransferTransaction() - .addTokenTransfer(ftTokenId, testEnv.operatorId, -10) - .addTokenTransfer(ftTokenId, receiverAccountId, 10) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // freeze ft - new TokenFreezeTransaction() - .setTokenId(ftTokenId) - .setAccountId(receiverAccountId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // reject the token - should fail with ACCOUNT_FROZEN_FOR_TOKEN - assertThatExceptionOfType(Exception.class).isThrownBy(() -> { - new TokenRejectTransaction() - .setOwnerId(receiverAccountId) - .addTokenId(ftTokenId) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining("ACCOUNT_FROZEN_FOR_TOKEN"); - - // same test for nft - - var mintReceipt = new TokenMintTransaction() - .setTokenId(nftTokenId) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var nftSerials = mintReceipt.serials; - - // transfer nfts to the receiver - new TransferTransaction() - .addNftTransfer(nftTokenId.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(nftTokenId.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // freeze nft - new TokenFreezeTransaction() - .setTokenId(nftTokenId) - .setAccountId(receiverAccountId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // reject the token - should fail with ACCOUNT_FROZEN_FOR_TOKEN - assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + // transfer fts to the receiver + new TransferTransaction() + .addTokenTransfer(ftTokenId, treasuryAccountId, -10) + .addTokenTransfer(ftTokenId, receiverAccountId, 10) + .freezeWith(testEnv.client) + .sign(treasuryAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // reject the token new TokenRejectTransaction() .setOwnerId(receiverAccountId) - .addNftId(nftTokenId.nft(nftSerials.get(1))) + .addTokenId(ftTokenId) .freezeWith(testEnv.client) .sign(receiverAccountKey) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining("ACCOUNT_FROZEN_FOR_TOKEN"); - new TokenDeleteTransaction() - .setTokenId(ftTokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + // verify the balance of the receiver is 0 + var receiverAccountBalanceFt = new AccountBalanceQuery() + .setAccountId(receiverAccountId) + .execute(testEnv.client); + + assertThat(receiverAccountBalanceFt.tokens.get(ftTokenId)).isEqualTo(0); + + // verify the tokens are transferred back to the treasury + var treasuryAccountBalance = new AccountBalanceQuery() + .setAccountId(treasuryAccountId) + .execute(testEnv.client); + + assertThat(treasuryAccountBalance.tokens.get(ftTokenId)).isEqualTo(1_000_000); + + // same test for nft + + var nftTokenId = new TokenCreateTransaction() + .setTokenName("Test NFT") + .setTokenSymbol("TNFT") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(treasuryAccountId) + .setSupplyType(TokenSupplyType.FINITE) + .setMaxSupply(10) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setMetadataKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .freezeWith(testEnv.client) + .sign(treasuryAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId; - new TokenDeleteTransaction() - .setTokenId(nftTokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + var mintReceiptNftToken = new TokenMintTransaction() + .setTokenId(nftTokenId) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(receiverAccountId, receiverAccountKey); - } + var nftSerials = mintReceiptNftToken.serials; - @Test - @DisplayName("Cannot execute TokenReject transaction for FT and NFT when Token is Paused") - void canExecuteTokenRejectTransactionForFtAndNftWhenTokenIsPaused() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var ftTokenId = EntityHelper.createFungibleToken(testEnv, 18); - var nftTokenId = EntityHelper.createNft(testEnv); - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 100); - - // transfer fts to the receiver - new TransferTransaction() - .addTokenTransfer(ftTokenId, testEnv.operatorId, -10) - .addTokenTransfer(ftTokenId, receiverAccountId, 10) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // pause ft - new TokenPauseTransaction() - .setTokenId(ftTokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // reject the token - should fail with TOKEN_IS_PAUSED - assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + // transfer nfts to the receiver + new TransferTransaction() + .addNftTransfer(nftTokenId.nft(nftSerials.get(0)), treasuryAccountId, receiverAccountId) + .addNftTransfer(nftTokenId.nft(nftSerials.get(1)), treasuryAccountId, receiverAccountId) + .freezeWith(testEnv.client) + .sign(treasuryAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // reject the token new TokenRejectTransaction() .setOwnerId(receiverAccountId) - .addTokenId(ftTokenId) + .addNftId(nftTokenId.nft(nftSerials.get(1))) .freezeWith(testEnv.client) .sign(receiverAccountKey) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining("TOKEN_IS_PAUSED"); - // same test for nft + // verify the balance is decremented by 1 + var receiverAccountBalanceNft = new AccountBalanceQuery() + .setAccountId(receiverAccountId) + .execute(testEnv.client); + + assertThat(receiverAccountBalanceNft.tokens.get(nftTokenId)).isEqualTo(1); - var mintReceipt = new TokenMintTransaction() - .setTokenId(nftTokenId) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); + // verify the token is transferred back to the treasury + var nftTokenIdInfo = new TokenNftInfoQuery() + .setNftId(nftTokenId.nft(nftSerials.get(1))) + .execute(testEnv.client); - var nftSerials = mintReceipt.serials; + assertThat(nftTokenIdInfo.get(0).accountId).isEqualTo(treasuryAccountId); + + new TokenDeleteTransaction() + .setTokenId(ftTokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenDeleteTransaction() + .setTokenId(nftTokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } + } + + @Test + @DisplayName("Cannot execute TokenReject transaction for FT and NFT when Token is Frozen") + void canExecuteTokenRejectTransactionForFtAndNftWhenTokenIsFrozen() throws Exception { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var ftTokenId = EntityHelper.createFungibleToken(testEnv, 18); + var nftTokenId = EntityHelper.createNft(testEnv); + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 100); - // transfer nfts to the receiver - new TransferTransaction() - .addNftTransfer(nftTokenId.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(nftTokenId.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + // transfer fts to the receiver + new TransferTransaction() + .addTokenTransfer(ftTokenId, testEnv.operatorId, -10) + .addTokenTransfer(ftTokenId, receiverAccountId, 10) + .execute(testEnv.client) + .getReceipt(testEnv.client); - // pause nft - new TokenPauseTransaction() - .setTokenId(nftTokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + // freeze ft + new TokenFreezeTransaction() + .setTokenId(ftTokenId) + .setAccountId(receiverAccountId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - // reject the token - should fail with TOKEN_IS_PAUSED - assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + // reject the token - should fail with ACCOUNT_FROZEN_FOR_TOKEN + assertThatExceptionOfType(Exception.class).isThrownBy(() -> { new TokenRejectTransaction() .setOwnerId(receiverAccountId) - .addNftId(nftTokenId.nft(nftSerials.get(1))) + .addTokenId(ftTokenId) .freezeWith(testEnv.client) .sign(receiverAccountKey) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining("TOKEN_IS_PAUSED"); + }).withMessageContaining("ACCOUNT_FROZEN_FOR_TOKEN"); + + // same test for nft + + var mintReceipt = new TokenMintTransaction() + .setTokenId(nftTokenId) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var nftSerials = mintReceipt.serials; + + // transfer nfts to the receiver + new TransferTransaction() + .addNftTransfer(nftTokenId.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(nftTokenId.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // freeze nft + new TokenFreezeTransaction() + .setTokenId(nftTokenId) + .setAccountId(receiverAccountId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // reject the token - should fail with ACCOUNT_FROZEN_FOR_TOKEN + assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + new TokenRejectTransaction() + .setOwnerId(receiverAccountId) + .addNftId(nftTokenId.nft(nftSerials.get(1))) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining("ACCOUNT_FROZEN_FOR_TOKEN"); + + new TokenDeleteTransaction() + .setTokenId(ftTokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenDeleteTransaction() + .setTokenId(nftTokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(receiverAccountId, receiverAccountKey); + } + } + + @Test + @DisplayName("Cannot execute TokenReject transaction for FT and NFT when Token is Paused") + void canExecuteTokenRejectTransactionForFtAndNftWhenTokenIsPaused() throws Exception { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var ftTokenId = EntityHelper.createFungibleToken(testEnv, 18); + var nftTokenId = EntityHelper.createNft(testEnv); + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 100); + + // transfer fts to the receiver + new TransferTransaction() + .addTokenTransfer(ftTokenId, testEnv.operatorId, -10) + .addTokenTransfer(ftTokenId, receiverAccountId, 10) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // pause ft + new TokenPauseTransaction() + .setTokenId(ftTokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // reject the token - should fail with TOKEN_IS_PAUSED + assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + new TokenRejectTransaction() + .setOwnerId(receiverAccountId) + .addTokenId(ftTokenId) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining("TOKEN_IS_PAUSED"); + + // same test for nft + + var mintReceipt = new TokenMintTransaction() + .setTokenId(nftTokenId) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var nftSerials = mintReceipt.serials; + + // transfer nfts to the receiver + new TransferTransaction() + .addNftTransfer(nftTokenId.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(nftTokenId.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // pause nft + new TokenPauseTransaction() + .setTokenId(nftTokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // reject the token - should fail with TOKEN_IS_PAUSED + assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + new TokenRejectTransaction() + .setOwnerId(receiverAccountId) + .addNftId(nftTokenId.nft(nftSerials.get(1))) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining("TOKEN_IS_PAUSED"); + + } } @Test @Disabled // temp disabled till issue re nfts will be resolved on services side @DisplayName("Can remove allowance when executing TokenReject transaction for FT and NFT") void canRemoveAllowanceWhenExecutingTokenRejectForFtAndNft() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var ftTokenId = EntityHelper.createFungibleToken(testEnv, 3); - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, -1); - var spenderAccountKey = PrivateKey.generateED25519(); - var spenderAccountId = EntityHelper.createAccount(testEnv, spenderAccountKey, -1); - - // transfer ft to the receiver - new TransferTransaction() - .addTokenTransfer(ftTokenId, testEnv.operatorId, -10) - .addTokenTransfer(ftTokenId, receiverAccountId, 10) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // approve allowance to the spender - new AccountAllowanceApproveTransaction() - .approveTokenAllowance(ftTokenId, receiverAccountId, spenderAccountId, 10) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // verify the spender has allowance - new TransferTransaction() - .addApprovedTokenTransfer(ftTokenId, receiverAccountId, -5) - .addTokenTransfer(ftTokenId, spenderAccountId, 5) - .setTransactionId(TransactionId.generate(spenderAccountId)) - .freezeWith(testEnv.client) - .sign(spenderAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // reject the token - new TokenRejectTransaction() - .setOwnerId(receiverAccountId) - .addTokenId(ftTokenId) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // verify the allowance - should be 0 , because the receiver is no longer the owner - assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var ftTokenId = EntityHelper.createFungibleToken(testEnv, 3); + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, -1); + var spenderAccountKey = PrivateKey.generateED25519(); + var spenderAccountId = EntityHelper.createAccount(testEnv, spenderAccountKey, -1); + + // transfer ft to the receiver + new TransferTransaction() + .addTokenTransfer(ftTokenId, testEnv.operatorId, -10) + .addTokenTransfer(ftTokenId, receiverAccountId, 10) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // approve allowance to the spender + new AccountAllowanceApproveTransaction() + .approveTokenAllowance(ftTokenId, receiverAccountId, spenderAccountId, 10) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // verify the spender has allowance new TransferTransaction() .addApprovedTokenTransfer(ftTokenId, receiverAccountId, -5) .addTokenTransfer(ftTokenId, spenderAccountId, 5) @@ -635,435 +615,457 @@ void canRemoveAllowanceWhenExecutingTokenRejectForFtAndNft() throws Exception { .sign(spenderAccountKey) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining("SPENDER_DOES_NOT_HAVE_ALLOWANCE"); - - // same test for nft - - var nftTokenId = EntityHelper.createNft(testEnv); - - var mintReceipt = new TokenMintTransaction() - .setTokenId(nftTokenId) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var nftSerials = mintReceipt.serials; - - // transfer nfts to the receiver - new TransferTransaction() - .addNftTransfer(nftTokenId.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(nftTokenId.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(nftTokenId.nft(nftSerials.get(2)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(nftTokenId.nft(nftSerials.get(3)), testEnv.operatorId, receiverAccountId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // approve allowance to the spender - new AccountAllowanceApproveTransaction() - .approveTokenNftAllowance(nftTokenId.nft(nftSerials.get(0)), receiverAccountId, spenderAccountId) - .approveTokenNftAllowance(nftTokenId.nft(nftSerials.get(1)), receiverAccountId, spenderAccountId) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // verify the spender has allowance - new TransferTransaction() - .addApprovedNftTransfer(nftTokenId.nft(nftSerials.get(0)), receiverAccountId, spenderAccountId) - .setTransactionId(TransactionId.generate(spenderAccountId)) - .freezeWith(testEnv.client) - .sign(spenderAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // reject the token - new TokenRejectTransaction() - .setOwnerId(receiverAccountId) - .setNftIds(List.of(nftTokenId.nft(nftSerials.get(1)), nftTokenId.nft(nftSerials.get(2)))) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // verify the allowance - should be 0 , because the receiver is no longer the owner - assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + + // reject the token + new TokenRejectTransaction() + .setOwnerId(receiverAccountId) + .addTokenId(ftTokenId) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // verify the allowance - should be 0 , because the receiver is no longer the owner + assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + new TransferTransaction() + .addApprovedTokenTransfer(ftTokenId, receiverAccountId, -5) + .addTokenTransfer(ftTokenId, spenderAccountId, 5) + .setTransactionId(TransactionId.generate(spenderAccountId)) + .freezeWith(testEnv.client) + .sign(spenderAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining("SPENDER_DOES_NOT_HAVE_ALLOWANCE"); + + // same test for nft + + var nftTokenId = EntityHelper.createNft(testEnv); + + var mintReceipt = new TokenMintTransaction() + .setTokenId(nftTokenId) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var nftSerials = mintReceipt.serials; + + // transfer nfts to the receiver new TransferTransaction() - .addApprovedNftTransfer(nftTokenId.nft(nftSerials.get(1)), receiverAccountId, spenderAccountId) - .addApprovedNftTransfer(nftTokenId.nft(nftSerials.get(2)), receiverAccountId, spenderAccountId) + .addNftTransfer(nftTokenId.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(nftTokenId.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(nftTokenId.nft(nftSerials.get(2)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(nftTokenId.nft(nftSerials.get(3)), testEnv.operatorId, receiverAccountId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // approve allowance to the spender + new AccountAllowanceApproveTransaction() + .approveTokenNftAllowance(nftTokenId.nft(nftSerials.get(0)), receiverAccountId, spenderAccountId) + .approveTokenNftAllowance(nftTokenId.nft(nftSerials.get(1)), receiverAccountId, spenderAccountId) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // verify the spender has allowance + new TransferTransaction() + .addApprovedNftTransfer(nftTokenId.nft(nftSerials.get(0)), receiverAccountId, spenderAccountId) .setTransactionId(TransactionId.generate(spenderAccountId)) .freezeWith(testEnv.client) .sign(spenderAccountKey) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining("SPENDER_DOES_NOT_HAVE_ALLOWANCE"); - new TokenDeleteTransaction() - .setTokenId(ftTokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + // reject the token + new TokenRejectTransaction() + .setOwnerId(receiverAccountId) + .setNftIds(List.of(nftTokenId.nft(nftSerials.get(1)), nftTokenId.nft(nftSerials.get(2)))) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); - new TokenDeleteTransaction() - .setTokenId(nftTokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + // verify the allowance - should be 0 , because the receiver is no longer the owner + assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + new TransferTransaction() + .addApprovedNftTransfer(nftTokenId.nft(nftSerials.get(1)), receiverAccountId, spenderAccountId) + .addApprovedNftTransfer(nftTokenId.nft(nftSerials.get(2)), receiverAccountId, spenderAccountId) + .setTransactionId(TransactionId.generate(spenderAccountId)) + .freezeWith(testEnv.client) + .sign(spenderAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining("SPENDER_DOES_NOT_HAVE_ALLOWANCE"); + + new TokenDeleteTransaction() + .setTokenId(ftTokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(receiverAccountId, receiverAccountKey); + new TokenDeleteTransaction() + .setTokenId(nftTokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } @Test @DisplayName("Cannot reject NFT when executing TokenReject with Add or Set TokenId") void cannotRejectNftWhenUsingAddOrSetTokenId() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var nftTokenId = EntityHelper.createNft(testEnv); - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 100); - - var mintReceiptNftToken = new TokenMintTransaction() - .setTokenId(nftTokenId) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var nftSerials = mintReceiptNftToken.serials; - - // transfer nfts to the receiver - new TransferTransaction() - .addNftTransfer(nftTokenId.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(nftTokenId.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(nftTokenId.nft(nftSerials.get(2)), testEnv.operatorId, receiverAccountId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // reject the whole collection (addTokenId) - should fail - assertThatExceptionOfType(Exception.class).isThrownBy(() -> { - new TokenRejectTransaction() - .setOwnerId(receiverAccountId) - .addTokenId(nftTokenId) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining("ACCOUNT_AMOUNT_TRANSFERS_ONLY_ALLOWED_FOR_FUNGIBLE_COMMON"); - - // reject the whole collection (setTokenIds) - should fail - assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var nftTokenId = EntityHelper.createNft(testEnv); + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 100); + + var mintReceiptNftToken = new TokenMintTransaction() + .setTokenId(nftTokenId) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var nftSerials = mintReceiptNftToken.serials; + + // transfer nfts to the receiver + new TransferTransaction() + .addNftTransfer(nftTokenId.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(nftTokenId.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(nftTokenId.nft(nftSerials.get(2)), testEnv.operatorId, receiverAccountId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // reject the whole collection (addTokenId) - should fail + assertThatExceptionOfType(Exception.class).isThrownBy(() -> { new TokenRejectTransaction() .setOwnerId(receiverAccountId) - .setTokenIds(List.of(nftTokenId)) + .addTokenId(nftTokenId) .freezeWith(testEnv.client) .sign(receiverAccountKey) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining("ACCOUNT_AMOUNT_TRANSFERS_ONLY_ALLOWED_FOR_FUNGIBLE_COMMON"); - - new TokenDeleteTransaction() - .setTokenId(nftTokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + }).withMessageContaining("ACCOUNT_AMOUNT_TRANSFERS_ONLY_ALLOWED_FOR_FUNGIBLE_COMMON"); + + // reject the whole collection (setTokenIds) - should fail + assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + new TokenRejectTransaction() + .setOwnerId(receiverAccountId) + .setTokenIds(List.of(nftTokenId)) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining("ACCOUNT_AMOUNT_TRANSFERS_ONLY_ALLOWED_FOR_FUNGIBLE_COMMON"); + + new TokenDeleteTransaction() + .setTokenId(nftTokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(receiverAccountId, receiverAccountKey); + } } @Test @DisplayName("Cannot Reject a Token when executing TokenReject and Duplicating Token Reference") void cannotRejectTokenWhenExecutingTokenRejectAndDuplicatingTokenReference() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var ftTokenId = EntityHelper.createFungibleToken(testEnv, 3); - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 100); - - // transfer fts to the receiver - new TransferTransaction() - .addTokenTransfer(ftTokenId, testEnv.operatorId, -10) - .addTokenTransfer(ftTokenId, receiverAccountId, 10) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // reject the token with duplicate token id - should fail with TOKEN_REFERENCE_REPEATED - assertThatExceptionOfType(Exception.class).isThrownBy(() -> { - new TokenRejectTransaction() - .setOwnerId(receiverAccountId) - .setTokenIds(List.of(ftTokenId, ftTokenId)) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var ftTokenId = EntityHelper.createFungibleToken(testEnv, 3); + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 100); + + // transfer fts to the receiver + new TransferTransaction() + .addTokenTransfer(ftTokenId, testEnv.operatorId, -10) + .addTokenTransfer(ftTokenId, receiverAccountId, 10) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining("TOKEN_REFERENCE_REPEATED"); - // same test for nft + // reject the token with duplicate token id - should fail with TOKEN_REFERENCE_REPEATED + assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + new TokenRejectTransaction() + .setOwnerId(receiverAccountId) + .setTokenIds(List.of(ftTokenId, ftTokenId)) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining("TOKEN_REFERENCE_REPEATED"); - var nftTokenId = EntityHelper.createNft(testEnv); + // same test for nft - var mintReceipt = new TokenMintTransaction() - .setTokenId(nftTokenId) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); + var nftTokenId = EntityHelper.createNft(testEnv); - var nftSerials = mintReceipt.serials; + var mintReceipt = new TokenMintTransaction() + .setTokenId(nftTokenId) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); - // transfer nfts to the receiver - new TransferTransaction() - .addNftTransfer(nftTokenId.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + var nftSerials = mintReceipt.serials; - // reject the nft with duplicate nft id - should fail with TOKEN_REFERENCE_REPEATED - assertThatExceptionOfType(Exception.class).isThrownBy(() -> { - new TokenRejectTransaction() - .setOwnerId(receiverAccountId) - .setNftIds(List.of(nftTokenId.nft(nftSerials.get(0)), nftTokenId.nft(nftSerials.get(0)))) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) + // transfer nfts to the receiver + new TransferTransaction() + .addNftTransfer(nftTokenId.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining("TOKEN_REFERENCE_REPEATED"); - new TokenDeleteTransaction() - .setTokenId(ftTokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + // reject the nft with duplicate nft id - should fail with TOKEN_REFERENCE_REPEATED + assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + new TokenRejectTransaction() + .setOwnerId(receiverAccountId) + .setNftIds(List.of(nftTokenId.nft(nftSerials.get(0)), nftTokenId.nft(nftSerials.get(0)))) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining("TOKEN_REFERENCE_REPEATED"); + + new TokenDeleteTransaction() + .setTokenId(ftTokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - new TokenDeleteTransaction() - .setTokenId(nftTokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TokenDeleteTransaction() + .setTokenId(nftTokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(receiverAccountId, receiverAccountKey); + } } @Test @DisplayName("Cannot Reject a Token when Owner Has Empty Balance") void cannotRejectTokenWhenOwnerHasEmptyBalance() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var ftTokenId = EntityHelper.createFungibleToken(testEnv, 3); - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 100); - - // skip the transfer - // associate the receiver - new TokenAssociateTransaction() - .setAccountId(receiverAccountId) - .setTokenIds(Collections.singletonList(ftTokenId)) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // reject the token - should fail with INSUFFICIENT_TOKEN_BALANCE - assertThatExceptionOfType(Exception.class).isThrownBy(() -> { - new TokenRejectTransaction() - .setOwnerId(receiverAccountId) - .addTokenId(ftTokenId) + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var ftTokenId = EntityHelper.createFungibleToken(testEnv, 3); + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 100); + + // skip the transfer + // associate the receiver + new TokenAssociateTransaction() + .setAccountId(receiverAccountId) + .setTokenIds(Collections.singletonList(ftTokenId)) .freezeWith(testEnv.client) .sign(receiverAccountKey) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining("INSUFFICIENT_TOKEN_BALANCE"); - // same test for nft + // reject the token - should fail with INSUFFICIENT_TOKEN_BALANCE + assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + new TokenRejectTransaction() + .setOwnerId(receiverAccountId) + .addTokenId(ftTokenId) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining("INSUFFICIENT_TOKEN_BALANCE"); - var nftTokenId = EntityHelper.createNft(testEnv); + // same test for nft - var mintReceipt = new TokenMintTransaction() - .setTokenId(nftTokenId) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); + var nftTokenId = EntityHelper.createNft(testEnv); - var nftSerials = mintReceipt.serials; + var mintReceipt = new TokenMintTransaction() + .setTokenId(nftTokenId) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); - // skip the transfer - // associate the receiver - new TokenAssociateTransaction() - .setAccountId(receiverAccountId) - .setTokenIds(Collections.singletonList(nftTokenId)) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); + var nftSerials = mintReceipt.serials; - // reject the nft - should fail with INVALID_OWNER_ID - assertThatExceptionOfType(Exception.class).isThrownBy(() -> { - new TokenRejectTransaction() - .setOwnerId(receiverAccountId) - .addNftId(nftTokenId.nft(nftSerials.get(0))) + // skip the transfer + // associate the receiver + new TokenAssociateTransaction() + .setAccountId(receiverAccountId) + .setTokenIds(Collections.singletonList(nftTokenId)) .freezeWith(testEnv.client) .sign(receiverAccountKey) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining("INVALID_OWNER_ID"); - new TokenDeleteTransaction() - .setTokenId(ftTokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + // reject the nft - should fail with INVALID_OWNER_ID + assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + new TokenRejectTransaction() + .setOwnerId(receiverAccountId) + .addNftId(nftTokenId.nft(nftSerials.get(0))) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining("INVALID_OWNER_ID"); + + new TokenDeleteTransaction() + .setTokenId(ftTokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - new TokenDeleteTransaction() - .setTokenId(nftTokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TokenDeleteTransaction() + .setTokenId(nftTokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(receiverAccountId, receiverAccountKey); + } } @Test @DisplayName("Cannot Reject a Token when Treasury Rejects itself") void cannotRejectTokenWhenTreasuryRejects() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var ftTokenId = EntityHelper.createFungibleToken(testEnv, 3); - - // skip the transfer - // reject the token with the treasury - should fail with ACCOUNT_IS_TREASURY - assertThatExceptionOfType(Exception.class).isThrownBy(() -> { - new TokenRejectTransaction() - .setOwnerId(testEnv.operatorId) - .addTokenId(ftTokenId) + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var ftTokenId = EntityHelper.createFungibleToken(testEnv, 3); + + // skip the transfer + // reject the token with the treasury - should fail with ACCOUNT_IS_TREASURY + assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + new TokenRejectTransaction() + .setOwnerId(testEnv.operatorId) + .addTokenId(ftTokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining("ACCOUNT_IS_TREASURY"); + + // same test for nft + + var nftTokenId = EntityHelper.createNft(testEnv); + + var mintReceipt = new TokenMintTransaction() + .setTokenId(nftTokenId) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining("ACCOUNT_IS_TREASURY"); - - // same test for nft - - var nftTokenId = EntityHelper.createNft(testEnv); - var mintReceipt = new TokenMintTransaction() - .setTokenId(nftTokenId) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); + var nftSerials = mintReceipt.serials; - var nftSerials = mintReceipt.serials; + // skip the transfer + // reject the nft with the treasury - should fail with ACCOUNT_IS_TREASURY + assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + new TokenRejectTransaction() + .setOwnerId(testEnv.operatorId) + .addNftId(nftTokenId.nft(nftSerials.get(0))) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining("ACCOUNT_IS_TREASURY"); - // skip the transfer - // reject the nft with the treasury - should fail with ACCOUNT_IS_TREASURY - assertThatExceptionOfType(Exception.class).isThrownBy(() -> { - new TokenRejectTransaction() - .setOwnerId(testEnv.operatorId) - .addNftId(nftTokenId.nft(nftSerials.get(0))) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining("ACCOUNT_IS_TREASURY"); - - testEnv.close(ftTokenId); + } } @Test @DisplayName("Cannot Reject a Token with Invalid Signature") void cannotRejectTokenWithInvalidSignature() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var ftTokenId = EntityHelper.createFungibleToken(testEnv, 3); - var randomKey = PrivateKey.generateED25519(); - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 100); - - // transfer fts to the receiver - new TransferTransaction() - .addTokenTransfer(ftTokenId, testEnv.operatorId, -10) - .addTokenTransfer(ftTokenId, receiverAccountId, 10) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // reject the token with different key - should fail with INVALID_SIGNATURE - assertThatExceptionOfType(Exception.class).isThrownBy(() -> { - new TokenRejectTransaction() - .setOwnerId(receiverAccountId) - .addTokenId(ftTokenId) - .freezeWith(testEnv.client) - .sign(randomKey) + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var ftTokenId = EntityHelper.createFungibleToken(testEnv, 3); + var randomKey = PrivateKey.generateED25519(); + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, 100); + + // transfer fts to the receiver + new TransferTransaction() + .addTokenTransfer(ftTokenId, testEnv.operatorId, -10) + .addTokenTransfer(ftTokenId, receiverAccountId, 10) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining("INVALID_SIGNATURE"); - new TokenDeleteTransaction() - .setTokenId(ftTokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + // reject the token with different key - should fail with INVALID_SIGNATURE + assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + new TokenRejectTransaction() + .setOwnerId(receiverAccountId) + .addTokenId(ftTokenId) + .freezeWith(testEnv.client) + .sign(randomKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining("INVALID_SIGNATURE"); + + new TokenDeleteTransaction() + .setTokenId(ftTokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(receiverAccountId, receiverAccountKey); + } } @Test @DisplayName("Cannot Reject a Token when Token Or NFT ID is not set") void cannotRejectTokenWhenTokenOrNFTIdIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // reject the token with invalid token - should fail with EMPTY_TOKEN_REFERENCE_LIST - assertThatExceptionOfType(Exception.class).isThrownBy(() -> { - new TokenRejectTransaction() - .setOwnerId(testEnv.operatorId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining("EMPTY_TOKEN_REFERENCE_LIST"); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + // reject the token with invalid token - should fail with EMPTY_TOKEN_REFERENCE_LIST + assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + new TokenRejectTransaction() + .setOwnerId(testEnv.operatorId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining("EMPTY_TOKEN_REFERENCE_LIST"); + + } } @Test @DisplayName("Cannot Reject a Token when executing TokenReject and Token Reference List Size Exceeded") void cannotRejectTokenWhenTokenReferenceListSizeExceeded() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var ftTokenId = EntityHelper.createFungibleToken(testEnv, 18); - var receiverAccountKey = PrivateKey.generateED25519(); - var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, -1); - var nftTokenId = EntityHelper.createNft(testEnv); - - var mintReceipt = new TokenMintTransaction() - .setTokenId(nftTokenId) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var nftSerials = mintReceipt.serials; - - // transfer the tokens to the receiver - new TransferTransaction() - .addTokenTransfer(ftTokenId, testEnv.operatorId, -10) - .addTokenTransfer(ftTokenId, receiverAccountId, 10) - .addNftTransfer(nftTokenId.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(nftTokenId.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(nftTokenId.nft(nftSerials.get(2)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(nftTokenId.nft(nftSerials.get(3)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(nftTokenId.nft(nftSerials.get(4)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(nftTokenId.nft(nftSerials.get(5)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(nftTokenId.nft(nftSerials.get(6)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(nftTokenId.nft(nftSerials.get(7)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(nftTokenId.nft(nftSerials.get(8)), testEnv.operatorId, receiverAccountId) - .addNftTransfer(nftTokenId.nft(nftSerials.get(9)), testEnv.operatorId, receiverAccountId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // reject the token with 11 token references - should fail with TOKEN_REFERENCE_LIST_SIZE_LIMIT_EXCEEDED - assertThatExceptionOfType(Exception.class).isThrownBy(() -> { - new TokenRejectTransaction() - .setOwnerId(receiverAccountId) - .addTokenId(ftTokenId) - .setNftIds(List.of( - nftTokenId.nft(nftSerials.get(0)), - nftTokenId.nft(nftSerials.get(1)), - nftTokenId.nft(nftSerials.get(2)), - nftTokenId.nft(nftSerials.get(3)), - nftTokenId.nft(nftSerials.get(4)), - nftTokenId.nft(nftSerials.get(5)), - nftTokenId.nft(nftSerials.get(6)), - nftTokenId.nft(nftSerials.get(7)), - nftTokenId.nft(nftSerials.get(8)), - nftTokenId.nft(nftSerials.get(9)) - )) - .freezeWith(testEnv.client) - .sign(receiverAccountKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining("TOKEN_REFERENCE_LIST_SIZE_LIMIT_EXCEEDED"); - - new TokenDeleteTransaction() - .setTokenId(ftTokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenDeleteTransaction() - .setTokenId(nftTokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(receiverAccountId, receiverAccountKey); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var ftTokenId = EntityHelper.createFungibleToken(testEnv, 18); + var receiverAccountKey = PrivateKey.generateED25519(); + var receiverAccountId = EntityHelper.createAccount(testEnv, receiverAccountKey, -1); + var nftTokenId = EntityHelper.createNft(testEnv); + + var mintReceipt = new TokenMintTransaction() + .setTokenId(nftTokenId) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + var nftSerials = mintReceipt.serials; + + // transfer the tokens to the receiver + new TransferTransaction() + .addTokenTransfer(ftTokenId, testEnv.operatorId, -10) + .addTokenTransfer(ftTokenId, receiverAccountId, 10) + .addNftTransfer(nftTokenId.nft(nftSerials.get(0)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(nftTokenId.nft(nftSerials.get(1)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(nftTokenId.nft(nftSerials.get(2)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(nftTokenId.nft(nftSerials.get(3)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(nftTokenId.nft(nftSerials.get(4)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(nftTokenId.nft(nftSerials.get(5)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(nftTokenId.nft(nftSerials.get(6)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(nftTokenId.nft(nftSerials.get(7)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(nftTokenId.nft(nftSerials.get(8)), testEnv.operatorId, receiverAccountId) + .addNftTransfer(nftTokenId.nft(nftSerials.get(9)), testEnv.operatorId, receiverAccountId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // reject the token with 11 token references - should fail with TOKEN_REFERENCE_LIST_SIZE_LIMIT_EXCEEDED + assertThatExceptionOfType(Exception.class).isThrownBy(() -> { + new TokenRejectTransaction() + .setOwnerId(receiverAccountId) + .addTokenId(ftTokenId) + .setNftIds(List.of( + nftTokenId.nft(nftSerials.get(0)), + nftTokenId.nft(nftSerials.get(1)), + nftTokenId.nft(nftSerials.get(2)), + nftTokenId.nft(nftSerials.get(3)), + nftTokenId.nft(nftSerials.get(4)), + nftTokenId.nft(nftSerials.get(5)), + nftTokenId.nft(nftSerials.get(6)), + nftTokenId.nft(nftSerials.get(7)), + nftTokenId.nft(nftSerials.get(8)), + nftTokenId.nft(nftSerials.get(9)) + )) + .freezeWith(testEnv.client) + .sign(receiverAccountKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining("TOKEN_REFERENCE_LIST_SIZE_LIMIT_EXCEEDED"); + + new TokenDeleteTransaction() + .setTokenId(ftTokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenDeleteTransaction() + .setTokenId(nftTokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenRevokeKycIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenRevokeKycIntegrationTest.java index 063343e44..31c57e6aa 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenRevokeKycIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenRevokeKycIntegrationTest.java @@ -40,131 +40,88 @@ class TokenRevokeKycIntegrationTest { @Test @DisplayName("Can revoke kyc to account with token") void canRevokeKycAccountWithToken() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var key = PrivateKey.generateED25519(); - - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); - - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - new TokenAssociateTransaction() - .setAccountId(accountId) - .setTokenIds(Collections.singletonList(tokenId)) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenRevokeKycTransaction() - .setAccountId(accountId) - .setTokenId(tokenId) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(tokenId, accountId, key); - } - - @Test - @DisplayName("Cannot revoke kyc to account on token when token ID is not set") - void cannotRevokeKycToAccountOnTokenWhenTokenIDIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var key = PrivateKey.generateED25519(); - - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); - - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenRevokeKycTransaction() + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var key = PrivateKey.generateED25519(); + + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); + + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + new TokenAssociateTransaction() .setAccountId(accountId) + .setTokenIds(Collections.singletonList(tokenId)) .freezeWith(testEnv.client) .sign(key) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_TOKEN_ID.toString()); - testEnv.close(accountId, key); - } - - @Test - @DisplayName("Cannot revoke kyc to account on token when account ID is not set") - void cannotRevokeKycToAccountOnTokenWhenAccountIDIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var key = PrivateKey.generateED25519(); - - var response = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client); - - var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); - - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { new TokenRevokeKycTransaction() + .setAccountId(accountId) .setTokenId(tokenId) .freezeWith(testEnv.client) .sign(key) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_ACCOUNT_ID.toString()); - testEnv.close(tokenId); + } } @Test - @DisplayName("Cannot revoke kyc to account on token when account was not associated with") - void cannotRevokeKycToAccountOnTokenWhenAccountWasNotAssociatedWith() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + @DisplayName("Cannot revoke kyc to account on token when token ID is not set") + void cannotRevokeKycToAccountOnTokenWhenTokenIDIsNotSet() throws Exception { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var key = PrivateKey.generateED25519(); - var key = PrivateKey.generateED25519(); + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenRevokeKycTransaction() + .setAccountId(accountId) + .freezeWith(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_TOKEN_ID.toString()); + + } + } + + @Test + @DisplayName("Cannot revoke kyc to account on token when account ID is not set") + void cannotRevokeKycToAccountOnTokenWhenAccountIDIsNotSet() throws Exception { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + var key = PrivateKey.generateED25519(); - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() + var response = new TokenCreateTransaction() .setTokenName("ffff") .setTokenSymbol("F") .setDecimals(3) @@ -176,21 +133,64 @@ void cannotRevokeKycToAccountOnTokenWhenAccountWasNotAssociatedWith() throws Exc .setKycKey(testEnv.operatorKey) .setSupplyKey(testEnv.operatorKey) .setFreezeDefault(false) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); + .execute(testEnv.client); - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenRevokeKycTransaction() - .setAccountId(accountId) - .setTokenId(tokenId) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.TOKEN_NOT_ASSOCIATED_TO_ACCOUNT.toString()); + var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenRevokeKycTransaction() + .setTokenId(tokenId) + .freezeWith(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_ACCOUNT_ID.toString()); + + } + } - testEnv.close(tokenId, accountId, key); + @Test + @DisplayName("Cannot revoke kyc to account on token when account was not associated with") + void cannotRevokeKycToAccountOnTokenWhenAccountWasNotAssociatedWith() throws Exception { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var key = PrivateKey.generateED25519(); + + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); + + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenRevokeKycTransaction() + .setAccountId(accountId) + .setTokenId(tokenId) + .freezeWith(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.TOKEN_NOT_ASSOCIATED_TO_ACCOUNT.toString()); + + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenTransferIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenTransferIntegrationTest.java index bafd071f0..b830879a5 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenTransferIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenTransferIntegrationTest.java @@ -45,134 +45,130 @@ class TokenTransferIntegrationTest { @Test @DisplayName("Can transfer tokens") void tokenTransferTest() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var key = PrivateKey.generateED25519(); - - @Var TransactionResponse response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); - - var accountId = response.getReceipt(testEnv.client).accountId; - assertThat(accountId).isNotNull(); - - response = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client); - - var tokenId = response.getReceipt(testEnv.client).tokenId; - assertThat(tokenId).isNotNull(); - - new TokenAssociateTransaction() - .setAccountId(accountId) - .setTokenIds(Collections.singletonList(tokenId)) - .freezeWith(testEnv.client) - .signWithOperator(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenGrantKycTransaction() - .setAccountId(accountId) - .setTokenId(tokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TransferTransaction() - .addTokenTransfer(tokenId, testEnv.operatorId, -10) - .addTokenTransfer(tokenId, accountId, 10) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(tokenId, accountId, key); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var key = PrivateKey.generateED25519(); + + @Var TransactionResponse response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); + + var accountId = response.getReceipt(testEnv.client).accountId; + assertThat(accountId).isNotNull(); + + response = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client); + + var tokenId = response.getReceipt(testEnv.client).tokenId; + assertThat(tokenId).isNotNull(); + + new TokenAssociateTransaction() + .setAccountId(accountId) + .setTokenIds(Collections.singletonList(tokenId)) + .freezeWith(testEnv.client) + .signWithOperator(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenGrantKycTransaction() + .setAccountId(accountId) + .setTokenId(tokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TransferTransaction() + .addTokenTransfer(tokenId, testEnv.operatorId, -10) + .addTokenTransfer(tokenId, accountId, 10) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } @Test @DisplayName("Cannot transfer tokens if balance is insufficient to pay fee") void insufficientBalanceForFee() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - PrivateKey key1 = PrivateKey.generateED25519(); - PrivateKey key2 = PrivateKey.generateED25519(); - var accountId1 = new AccountCreateTransaction() - .setKey(key1) - .setInitialBalance(new Hbar(2)) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .accountId; - var accountId2 = new AccountCreateTransaction() - .setKey(key2) - .setInitialBalance(new Hbar(2)) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .accountId; - - var tokenId = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setInitialSupply(1) - .setCustomFees(Collections.singletonList(new CustomFixedFee() - .setAmount(5000_000_000L) - .setFeeCollectorAccountId(testEnv.operatorId))) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFeeScheduleKey(testEnv.operatorKey) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId; - - new TokenAssociateTransaction() - .setAccountId(accountId1) - .setTokenIds(Collections.singletonList(tokenId)) - .freezeWith(testEnv.client) - .sign(key1) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenAssociateTransaction() - .setAccountId(accountId2) - .setTokenIds(Collections.singletonList(tokenId)) - .freezeWith(testEnv.client) - .sign(key2) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TransferTransaction() - .addTokenTransfer(tokenId, testEnv.operatorId, -1) - .addTokenTransfer(tokenId, accountId1, 1) - .freezeWith(testEnv.client) - .sign(key1) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TransferTransaction() - .addTokenTransfer(tokenId, accountId1, -1) - .addTokenTransfer(tokenId, accountId2, 1) + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + PrivateKey key1 = PrivateKey.generateED25519(); + PrivateKey key2 = PrivateKey.generateED25519(); + var accountId1 = new AccountCreateTransaction() + .setKey(key1) + .setInitialBalance(new Hbar(2)) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .accountId; + var accountId2 = new AccountCreateTransaction() + .setKey(key2) + .setInitialBalance(new Hbar(2)) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .accountId; + + var tokenId = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setInitialSupply(1) + .setCustomFees(Collections.singletonList(new CustomFixedFee() + .setAmount(5000_000_000L) + .setFeeCollectorAccountId(testEnv.operatorId))) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFeeScheduleKey(testEnv.operatorKey) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId; + + new TokenAssociateTransaction() + .setAccountId(accountId1) + .setTokenIds(Collections.singletonList(tokenId)) .freezeWith(testEnv.client) .sign(key1) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenAssociateTransaction() + .setAccountId(accountId2) + .setTokenIds(Collections.singletonList(tokenId)) + .freezeWith(testEnv.client) .sign(key2) .execute(testEnv.client) .getReceipt(testEnv.client); - }).satisfies(error -> assertThat(error.getMessage()).containsAnyOf( - Status.INSUFFICIENT_SENDER_ACCOUNT_BALANCE_FOR_CUSTOM_FEE.toString(), - Status.INSUFFICIENT_PAYER_BALANCE_FOR_CUSTOM_FEE.toString() - )); - testEnv.wipeAccountHbars(accountId1, key1); - testEnv.wipeAccountHbars(accountId2, key2); + new TransferTransaction() + .addTokenTransfer(tokenId, testEnv.operatorId, -1) + .addTokenTransfer(tokenId, accountId1, 1) + .freezeWith(testEnv.client) + .sign(key1) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TransferTransaction() + .addTokenTransfer(tokenId, accountId1, -1) + .addTokenTransfer(tokenId, accountId2, 1) + .freezeWith(testEnv.client) + .sign(key1) + .sign(key2) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).satisfies(error -> assertThat(error.getMessage()).containsAnyOf( + Status.INSUFFICIENT_SENDER_ACCOUNT_BALANCE_FOR_CUSTOM_FEE.toString(), + Status.INSUFFICIENT_PAYER_BALANCE_FOR_CUSTOM_FEE.toString() + )); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenUnfreezeIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenUnfreezeIntegrationTest.java index da19a243e..678c49687 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenUnfreezeIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenUnfreezeIntegrationTest.java @@ -40,131 +40,88 @@ class TokenUnfreezeIntegrationTest { @Test @DisplayName("Can unfreeze account with token") void canUnfreezeAccountWithToken() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var key = PrivateKey.generateED25519(); - - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); - - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - new TokenAssociateTransaction() - .setAccountId(accountId) - .setTokenIds(Collections.singletonList(tokenId)) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenUnfreezeTransaction() - .setAccountId(accountId) - .setTokenId(tokenId) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(tokenId, accountId, key); - } - - @Test - @DisplayName("Cannot unfreeze account on token when token ID is not set") - void cannotUnfreezeAccountOnTokenWhenTokenIDIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var key = PrivateKey.generateED25519(); - - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); - - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenUnfreezeTransaction() + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var key = PrivateKey.generateED25519(); + + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); + + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + new TokenAssociateTransaction() .setAccountId(accountId) + .setTokenIds(Collections.singletonList(tokenId)) .freezeWith(testEnv.client) .sign(key) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_TOKEN_ID.toString()); - testEnv.close(accountId, key); - } - - @Test - @DisplayName("Cannot unfreeze account on token when account ID is not set") - void cannotUnfreezeAccountOnTokenWhenAccountIDIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var key = PrivateKey.generateED25519(); - - var response = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client); - - var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); - - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { new TokenUnfreezeTransaction() + .setAccountId(accountId) .setTokenId(tokenId) .freezeWith(testEnv.client) .sign(key) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_ACCOUNT_ID.toString()); - testEnv.close(tokenId); + } } @Test - @DisplayName("Cannot unfreeze account on token when account was not associated with") - void cannotUnfreezeAccountOnTokenWhenAccountWasNotAssociatedWith() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + @DisplayName("Cannot unfreeze account on token when token ID is not set") + void cannotUnfreezeAccountOnTokenWhenTokenIDIsNotSet() throws Exception { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var key = PrivateKey.generateED25519(); - var key = PrivateKey.generateED25519(); + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenUnfreezeTransaction() + .setAccountId(accountId) + .freezeWith(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_TOKEN_ID.toString()); + + } + } + + @Test + @DisplayName("Cannot unfreeze account on token when account ID is not set") + void cannotUnfreezeAccountOnTokenWhenAccountIDIsNotSet() throws Exception { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + var key = PrivateKey.generateED25519(); - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() + var response = new TokenCreateTransaction() .setTokenName("ffff") .setTokenSymbol("F") .setDecimals(3) @@ -176,21 +133,64 @@ void cannotUnfreezeAccountOnTokenWhenAccountWasNotAssociatedWith() throws Except .setKycKey(testEnv.operatorKey) .setSupplyKey(testEnv.operatorKey) .setFreezeDefault(false) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); + .execute(testEnv.client); - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUnfreezeTransaction() - .setAccountId(accountId) - .setTokenId(tokenId) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.TOKEN_NOT_ASSOCIATED_TO_ACCOUNT.toString()); + var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenUnfreezeTransaction() + .setTokenId(tokenId) + .freezeWith(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_ACCOUNT_ID.toString()); + + } + } - testEnv.close(tokenId, accountId, key); + @Test + @DisplayName("Cannot unfreeze account on token when account was not associated with") + void cannotUnfreezeAccountOnTokenWhenAccountWasNotAssociatedWith() throws Exception { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var key = PrivateKey.generateED25519(); + + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); + + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUnfreezeTransaction() + .setAccountId(accountId) + .setTokenId(tokenId) + .freezeWith(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.TOKEN_NOT_ASSOCIATED_TO_ACCOUNT.toString()); + + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenUnpauseIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenUnpauseIntegrationTest.java index d4a8ff3bd..7c0d037c2 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenUnpauseIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenUnpauseIntegrationTest.java @@ -41,47 +41,48 @@ public class TokenUnpauseIntegrationTest { @Test @DisplayName("Can execute token unpause transaction") void canExecuteTokenUnpauseTransaction() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var accountKey = PrivateKey.generateED25519(); - var testTokenAmount = 10; - var accountId = new AccountCreateTransaction().setKey(accountKey).setInitialBalance(new Hbar(2)) - .execute(testEnv.client).getReceipt(testEnv.client).accountId; + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { - var tokenId = new TokenCreateTransaction().setTokenName("ffff").setTokenSymbol("F").setInitialSupply(1000000) - .setDecimals(3).setTreasuryAccountId(testEnv.operatorId).setAdminKey(testEnv.operatorKey) - .setPauseKey(testEnv.operatorKey).setWipeKey(testEnv.operatorKey).setFreezeDefault(false) - .execute(testEnv.client).getReceipt(testEnv.client).tokenId; + var accountKey = PrivateKey.generateED25519(); + var testTokenAmount = 10; + var accountId = new AccountCreateTransaction().setKey(accountKey).setInitialBalance(new Hbar(2)) + .execute(testEnv.client).getReceipt(testEnv.client).accountId; - new TokenAssociateTransaction().setAccountId(accountId).setTokenIds(Collections.singletonList(tokenId)) - .freezeWith(testEnv.client).sign(accountKey).execute(testEnv.client).getReceipt(testEnv.client); + var tokenId = new TokenCreateTransaction().setTokenName("ffff").setTokenSymbol("F").setInitialSupply(1000000) + .setDecimals(3).setTreasuryAccountId(testEnv.operatorId).setAdminKey(testEnv.operatorKey) + .setPauseKey(testEnv.operatorKey).setWipeKey(testEnv.operatorKey).setFreezeDefault(false) + .execute(testEnv.client).getReceipt(testEnv.client).tokenId; - new TokenUnpauseTransaction().setTokenId(tokenId).freezeWith(testEnv.client).execute(testEnv.client) - .getReceipt(testEnv.client); + new TokenAssociateTransaction().setAccountId(accountId).setTokenIds(Collections.singletonList(tokenId)) + .freezeWith(testEnv.client).sign(accountKey).execute(testEnv.client).getReceipt(testEnv.client); - new TransferTransaction().addTokenTransfer(tokenId, accountId, testTokenAmount) - .addTokenTransfer(tokenId, testEnv.operatorId, -testTokenAmount).execute(testEnv.client) - .getReceipt(testEnv.client); + new TokenUnpauseTransaction().setTokenId(tokenId).freezeWith(testEnv.client).execute(testEnv.client) + .getReceipt(testEnv.client); - new TokenWipeTransaction().setTokenId(tokenId).setAccountId(accountId).setAmount(testTokenAmount) - .execute(testEnv.client).getReceipt(testEnv.client); + new TransferTransaction().addTokenTransfer(tokenId, accountId, testTokenAmount) + .addTokenTransfer(tokenId, testEnv.operatorId, -testTokenAmount).execute(testEnv.client) + .getReceipt(testEnv.client); - new TokenDeleteTransaction().setTokenId(tokenId).execute(testEnv.client).getReceipt(testEnv.client); + new TokenWipeTransaction().setTokenId(tokenId).setAccountId(accountId).setAmount(testTokenAmount) + .execute(testEnv.client).getReceipt(testEnv.client); - new AccountDeleteTransaction().setTransferAccountId(testEnv.operatorId).setAccountId(accountId) - .freezeWith(testEnv.client).sign(accountKey).execute(testEnv.client).getReceipt(testEnv.client); + new TokenDeleteTransaction().setTokenId(tokenId).execute(testEnv.client).getReceipt(testEnv.client); - testEnv.close(); + new AccountDeleteTransaction().setTransferAccountId(testEnv.operatorId).setAccountId(accountId) + .freezeWith(testEnv.client).sign(accountKey).execute(testEnv.client).getReceipt(testEnv.client); + + } } @Test @DisplayName("Cannot unpause with no token ID") void cannotUnpauseWithNoTokenId() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { - assertThrows(PrecheckStatusException.class, () -> { - new TokenUnpauseTransaction().execute(testEnv.client).getReceipt(testEnv.client); - }); + assertThrows(PrecheckStatusException.class, () -> { + new TokenUnpauseTransaction().execute(testEnv.client).getReceipt(testEnv.client); + }); - testEnv.close(); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenUpdateIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenUpdateIntegrationTest.java index 9d7640c3f..acd3e5100 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenUpdateIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenUpdateIntegrationTest.java @@ -43,110 +43,110 @@ class TokenUpdateIntegrationTest { @Test @DisplayName("Can update token") void canUpdateToken() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var response = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setPauseKey(testEnv.operatorKey) - .setMetadataKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client); - - var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); - - @Var var info = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(info.tokenId).isEqualTo(tokenId); - assertThat(info.name).isEqualTo("ffff"); - assertThat(info.symbol).isEqualTo("F"); - assertThat(info.decimals).isEqualTo(3); - assertThat(info.treasuryAccountId).isEqualTo(testEnv.operatorId); - assertThat(info.adminKey).isNotNull(); - assertThat(info.freezeKey).isNotNull(); - assertThat(info.wipeKey).isNotNull(); - assertThat(info.kycKey).isNotNull(); - assertThat(info.supplyKey).isNotNull(); - assertThat(info.adminKey.toString()).isEqualTo(testEnv.operatorKey.toString()); - assertThat(info.freezeKey.toString()).isEqualTo(testEnv.operatorKey.toString()); - assertThat(info.wipeKey.toString()).isEqualTo(testEnv.operatorKey.toString()); - assertThat(info.kycKey.toString()).isEqualTo(testEnv.operatorKey.toString()); - assertThat(info.supplyKey.toString()).isEqualTo(testEnv.operatorKey.toString()); - assertThat(info.pauseKey.toString()).isEqualTo(testEnv.operatorKey.toString()); - assertThat(info.metadataKey.toString()).isEqualTo(testEnv.operatorKey.toString()); - assertThat(info.defaultFreezeStatus).isNotNull().isFalse(); - assertThat(info.defaultKycStatus).isNotNull().isFalse(); - - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setTokenName("aaaa") - .setTokenSymbol("A") - .execute(testEnv.client) - .getReceipt(testEnv.client); - - info = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(info.tokenId).isEqualTo(tokenId); - assertThat(info.name).isEqualTo("aaaa"); - assertThat(info.symbol).isEqualTo("A"); - assertThat(info.decimals).isEqualTo(3); - assertThat(info.treasuryAccountId).isEqualTo(testEnv.operatorId); - assertThat(info.adminKey).isNotNull(); - assertThat(info.freezeKey).isNotNull(); - assertThat(info.wipeKey).isNotNull(); - assertThat(info.kycKey).isNotNull(); - assertThat(info.supplyKey).isNotNull(); - assertThat(info.adminKey.toString()).isEqualTo(testEnv.operatorKey.toString()); - assertThat(info.freezeKey.toString()).isEqualTo(testEnv.operatorKey.toString()); - assertThat(info.wipeKey.toString()).isEqualTo(testEnv.operatorKey.toString()); - assertThat(info.kycKey.toString()).isEqualTo(testEnv.operatorKey.toString()); - assertThat(info.supplyKey.toString()).isEqualTo(testEnv.operatorKey.toString()); - assertThat(info.pauseKey.toString()).isEqualTo(testEnv.operatorKey.toString()); - assertThat(info.metadataKey.toString()).isEqualTo(testEnv.operatorKey.toString()); - assertThat(info.defaultFreezeStatus).isNotNull(); - assertThat(info.defaultFreezeStatus).isFalse(); - assertThat(info.defaultKycStatus).isNotNull(); - assertThat(info.defaultKycStatus).isFalse(); - - testEnv.close(tokenId); - } - - @Test - @DisplayName("Cannot update immutable token") - void cannotUpdateImmutableToken() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var response = new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTreasuryAccountId(testEnv.operatorId) - .setFreezeDefault(false) - .execute(testEnv.client); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ - var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); + var response = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setPauseKey(testEnv.operatorKey) + .setMetadataKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client); + + var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); + + @Var var info = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(info.tokenId).isEqualTo(tokenId); + assertThat(info.name).isEqualTo("ffff"); + assertThat(info.symbol).isEqualTo("F"); + assertThat(info.decimals).isEqualTo(3); + assertThat(info.treasuryAccountId).isEqualTo(testEnv.operatorId); + assertThat(info.adminKey).isNotNull(); + assertThat(info.freezeKey).isNotNull(); + assertThat(info.wipeKey).isNotNull(); + assertThat(info.kycKey).isNotNull(); + assertThat(info.supplyKey).isNotNull(); + assertThat(info.adminKey.toString()).isEqualTo(testEnv.operatorKey.toString()); + assertThat(info.freezeKey.toString()).isEqualTo(testEnv.operatorKey.toString()); + assertThat(info.wipeKey.toString()).isEqualTo(testEnv.operatorKey.toString()); + assertThat(info.kycKey.toString()).isEqualTo(testEnv.operatorKey.toString()); + assertThat(info.supplyKey.toString()).isEqualTo(testEnv.operatorKey.toString()); + assertThat(info.pauseKey.toString()).isEqualTo(testEnv.operatorKey.toString()); + assertThat(info.metadataKey.toString()).isEqualTo(testEnv.operatorKey.toString()); + assertThat(info.defaultFreezeStatus).isNotNull().isFalse(); + assertThat(info.defaultKycStatus).isNotNull().isFalse(); - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { new TokenUpdateTransaction() .setTokenId(tokenId) .setTokenName("aaaa") .setTokenSymbol("A") .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.TOKEN_IS_IMMUTABLE.toString()); - testEnv.close(); + info = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(info.tokenId).isEqualTo(tokenId); + assertThat(info.name).isEqualTo("aaaa"); + assertThat(info.symbol).isEqualTo("A"); + assertThat(info.decimals).isEqualTo(3); + assertThat(info.treasuryAccountId).isEqualTo(testEnv.operatorId); + assertThat(info.adminKey).isNotNull(); + assertThat(info.freezeKey).isNotNull(); + assertThat(info.wipeKey).isNotNull(); + assertThat(info.kycKey).isNotNull(); + assertThat(info.supplyKey).isNotNull(); + assertThat(info.adminKey.toString()).isEqualTo(testEnv.operatorKey.toString()); + assertThat(info.freezeKey.toString()).isEqualTo(testEnv.operatorKey.toString()); + assertThat(info.wipeKey.toString()).isEqualTo(testEnv.operatorKey.toString()); + assertThat(info.kycKey.toString()).isEqualTo(testEnv.operatorKey.toString()); + assertThat(info.supplyKey.toString()).isEqualTo(testEnv.operatorKey.toString()); + assertThat(info.pauseKey.toString()).isEqualTo(testEnv.operatorKey.toString()); + assertThat(info.metadataKey.toString()).isEqualTo(testEnv.operatorKey.toString()); + assertThat(info.defaultFreezeStatus).isNotNull(); + assertThat(info.defaultFreezeStatus).isFalse(); + assertThat(info.defaultKycStatus).isNotNull(); + assertThat(info.defaultKycStatus).isFalse(); + + } + } + + @Test + @DisplayName("Cannot update immutable token") + void cannotUpdateImmutableToken() throws Exception { + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + var response = new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTreasuryAccountId(testEnv.operatorId) + .setFreezeDefault(false) + .execute(testEnv.client); + + var tokenId = Objects.requireNonNull(response.getReceipt(testEnv.client).tokenId); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setTokenName("aaaa") + .setTokenSymbol("A") + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.TOKEN_IS_IMMUTABLE.toString()); + + } } /** @@ -156,47 +156,47 @@ void cannotUpdateImmutableToken() throws Exception { @Test @DisplayName("Can update a fungible token's metadata") void canUpdateFungibleTokenMetadata() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var initialTokenMetadata = new byte[]{1, 1, 1, 1, 1}; - var updatedTokenMetadata = new byte[]{2, 2, 2, 2, 2}; + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var initialTokenMetadata = new byte[]{1, 1, 1, 1, 1}; + var updatedTokenMetadata = new byte[]{2, 2, 2, 2, 2}; + + // create a fungible token with metadata + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenMetadata(initialTokenMetadata) + .setTokenType(TokenType.FUNGIBLE_COMMON) + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var tokenInfoAfterCreation = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoAfterCreation.metadata).isEqualTo(initialTokenMetadata); + + // update token's metadata + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setTokenMetadata(updatedTokenMetadata) + .execute(testEnv.client) + .getReceipt(testEnv.client); - // create a fungible token with metadata - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenMetadata(initialTokenMetadata) - .setTokenType(TokenType.FUNGIBLE_COMMON) - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var tokenInfoAfterCreation = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoAfterCreation.metadata).isEqualTo(initialTokenMetadata); - - // update token's metadata - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setTokenMetadata(updatedTokenMetadata) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var tokenInfoAfterMetadataUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoAfterMetadataUpdate.metadata).isEqualTo(updatedTokenMetadata); - - testEnv.close(tokenId); + var tokenInfoAfterMetadataUpdate = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoAfterMetadataUpdate.metadata).isEqualTo(updatedTokenMetadata); + + } } /** @@ -206,46 +206,46 @@ void canUpdateFungibleTokenMetadata() throws Exception { @Test @DisplayName("Can update a non fungible token's metadata") void canUpdateNonFungibleTokenMetadata() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var initialTokenMetadata = new byte[]{1, 1, 1, 1, 1}; - var updatedTokenMetadata = new byte[]{2, 2, 2, 2, 2}; + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var initialTokenMetadata = new byte[]{1, 1, 1, 1, 1}; + var updatedTokenMetadata = new byte[]{2, 2, 2, 2, 2}; + + // create a non fungible token with metadata + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenMetadata(initialTokenMetadata) + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var tokenInfoAfterCreation = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoAfterCreation.metadata).isEqualTo(initialTokenMetadata); + + // update token's metadata + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setTokenMetadata(updatedTokenMetadata) + .execute(testEnv.client) + .getReceipt(testEnv.client); - // create a non fungible token with metadata - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenMetadata(initialTokenMetadata) - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var tokenInfoAfterCreation = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoAfterCreation.metadata).isEqualTo(initialTokenMetadata); - - // update token's metadata - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setTokenMetadata(updatedTokenMetadata) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var tokenInfoAfterMetadataUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoAfterMetadataUpdate.metadata).isEqualTo(updatedTokenMetadata); - - testEnv.close(tokenId); + var tokenInfoAfterMetadataUpdate = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoAfterMetadataUpdate.metadata).isEqualTo(updatedTokenMetadata); + + } } /** @@ -255,51 +255,51 @@ void canUpdateNonFungibleTokenMetadata() throws Exception { @Test @DisplayName("Can update an immutable fungible token's metadata") void canUpdateImmutableFungibleTokenMetadata() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var initialTokenMetadata = new byte[]{1, 1, 1, 1, 1}; - var updatedTokenMetadata = new byte[]{2, 2, 2, 2, 2}; - var metadataKey = PrivateKey.generateED25519(); - - // create a fungible token with metadata and metadata key - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenMetadata(initialTokenMetadata) - .setTokenType(TokenType.FUNGIBLE_COMMON) - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setMetadataKey(metadataKey) - .setFreezeDefault(false) + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var initialTokenMetadata = new byte[]{1, 1, 1, 1, 1}; + var updatedTokenMetadata = new byte[]{2, 2, 2, 2, 2}; + var metadataKey = PrivateKey.generateED25519(); + + // create a fungible token with metadata and metadata key + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenMetadata(initialTokenMetadata) + .setTokenType(TokenType.FUNGIBLE_COMMON) + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setMetadataKey(metadataKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var tokenInfoAfterCreation = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoAfterCreation.metadata).isEqualTo(initialTokenMetadata); + assertThat(tokenInfoAfterCreation.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); + + // update token's metadata + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setTokenMetadata(updatedTokenMetadata) + .freezeWith(testEnv.client) + .sign(metadataKey) .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var tokenInfoAfterCreation = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoAfterCreation.metadata).isEqualTo(initialTokenMetadata); - assertThat(tokenInfoAfterCreation.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); - - // update token's metadata - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setTokenMetadata(updatedTokenMetadata) - .freezeWith(testEnv.client) - .sign(metadataKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); + .getReceipt(testEnv.client); - var tokenInfoAfterMetadataUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); + var tokenInfoAfterMetadataUpdate = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); - assertThat(tokenInfoAfterMetadataUpdate.metadata).isEqualTo(updatedTokenMetadata); + assertThat(tokenInfoAfterMetadataUpdate.metadata).isEqualTo(updatedTokenMetadata); - testEnv.close(tokenId); + } } /** @@ -309,50 +309,50 @@ void canUpdateImmutableFungibleTokenMetadata() throws Exception { @Test @DisplayName("Can update an immutable non fungible token's metadata") void canUpdateImmutableNonFungibleTokenMetadata() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var initialTokenMetadata = new byte[]{1, 1, 1, 1, 1}; - var updatedTokenMetadata = new byte[]{2, 2, 2, 2, 2}; - var metadataKey = PrivateKey.generateED25519(); - - // create a non fungible token with metadata and metadata key - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenMetadata(initialTokenMetadata) - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setSupplyKey(testEnv.operatorKey) - .setMetadataKey(metadataKey) - .setFreezeDefault(false) + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var initialTokenMetadata = new byte[]{1, 1, 1, 1, 1}; + var updatedTokenMetadata = new byte[]{2, 2, 2, 2, 2}; + var metadataKey = PrivateKey.generateED25519(); + + // create a non fungible token with metadata and metadata key + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenMetadata(initialTokenMetadata) + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setSupplyKey(testEnv.operatorKey) + .setMetadataKey(metadataKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var tokenInfoAfterCreation = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoAfterCreation.metadata).isEqualTo(initialTokenMetadata); + assertThat(tokenInfoAfterCreation.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); + + // update token's metadata + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setTokenMetadata(updatedTokenMetadata) + .freezeWith(testEnv.client) + .sign(metadataKey) .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var tokenInfoAfterCreation = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoAfterCreation.metadata).isEqualTo(initialTokenMetadata); - assertThat(tokenInfoAfterCreation.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); - - // update token's metadata - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setTokenMetadata(updatedTokenMetadata) - .freezeWith(testEnv.client) - .sign(metadataKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); + .getReceipt(testEnv.client); - var tokenInfoAfterMetadataUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); + var tokenInfoAfterMetadataUpdate = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); - assertThat(tokenInfoAfterMetadataUpdate.metadata).isEqualTo(updatedTokenMetadata); + assertThat(tokenInfoAfterMetadataUpdate.metadata).isEqualTo(updatedTokenMetadata); - testEnv.close(tokenId); + } } /** @@ -362,46 +362,46 @@ void canUpdateImmutableNonFungibleTokenMetadata() throws Exception { @Test @DisplayName("Cannot update a fungible token with metadata when it is not set") void cannotUpdateFungibleTokenMetadataWhenItsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var initialTokenMetadata = new byte[]{1, 1, 1, 1, 1}; - - // create a fungible token with metadata - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenMetadata(initialTokenMetadata) - .setTokenType(TokenType.FUNGIBLE_COMMON) - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeDefault(false) + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var initialTokenMetadata = new byte[]{1, 1, 1, 1, 1}; + + // create a fungible token with metadata + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenMetadata(initialTokenMetadata) + .setTokenType(TokenType.FUNGIBLE_COMMON) + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var tokenInfoAfterCreation = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoAfterCreation.metadata).isEqualTo(initialTokenMetadata); + + // update token, but don't update metadata + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setTokenMemo("abc") .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var tokenInfoAfterCreation = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoAfterCreation.metadata).isEqualTo(initialTokenMetadata); - - // update token, but don't update metadata - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setTokenMemo("abc") - .execute(testEnv.client) - .getReceipt(testEnv.client); + .getReceipt(testEnv.client); - var tokenInfoAfterMemoUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); + var tokenInfoAfterMemoUpdate = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); - assertThat(tokenInfoAfterMemoUpdate.metadata).isEqualTo(initialTokenMetadata); + assertThat(tokenInfoAfterMemoUpdate.metadata).isEqualTo(initialTokenMetadata); - testEnv.close(tokenId); + } } /** @@ -411,45 +411,45 @@ void cannotUpdateFungibleTokenMetadataWhenItsNotSet() throws Exception { @Test @DisplayName("Cannot update a non fungible token with metadata when it is not set") void cannotUpdateNonFungibleTokenMetadataWhenItsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var initialTokenMetadata = new byte[]{1, 1, 1, 1, 1}; + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var initialTokenMetadata = new byte[]{1, 1, 1, 1, 1}; - // create a non fungible token with metadata - var tokenId = Objects.requireNonNull( + // create a non fungible token with metadata + var tokenId = Objects.requireNonNull( new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenMetadata(initialTokenMetadata) - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenMetadata(initialTokenMetadata) + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var tokenInfoAfterCreation = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoAfterCreation.metadata).isEqualTo(initialTokenMetadata); + + // update token, but don't update metadata + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setTokenMemo("abc") .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var tokenInfoAfterCreation = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoAfterCreation.metadata).isEqualTo(initialTokenMetadata); - - // update token, but don't update metadata - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setTokenMemo("abc") - .execute(testEnv.client) - .getReceipt(testEnv.client); + .getReceipt(testEnv.client); - var tokenInfoAfterMemoUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); + var tokenInfoAfterMemoUpdate = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); - assertThat(tokenInfoAfterMemoUpdate.metadata).isEqualTo(initialTokenMetadata); + assertThat(tokenInfoAfterMemoUpdate.metadata).isEqualTo(initialTokenMetadata); - testEnv.close(tokenId); + } } /** @@ -459,47 +459,47 @@ void cannotUpdateNonFungibleTokenMetadataWhenItsNotSet() throws Exception { @Test @DisplayName("Can erase fungible token metadata") void canEraseFungibleTokenMetadata() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var initialTokenMetadata = new byte[]{1, 1, 1, 1, 1}; - var emptyTokenMetadata = new byte[]{}; - - // create a fungible token with metadata - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenMetadata(initialTokenMetadata) - .setTokenType(TokenType.FUNGIBLE_COMMON) - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var tokenInfoAfterCreation = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoAfterCreation.metadata).isEqualTo(initialTokenMetadata); - - // erase token metadata (update token with empty metadata) - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setTokenMetadata(emptyTokenMetadata) - .execute(testEnv.client) - .getReceipt(testEnv.client); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var initialTokenMetadata = new byte[]{1, 1, 1, 1, 1}; + var emptyTokenMetadata = new byte[]{}; + + // create a fungible token with metadata + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenMetadata(initialTokenMetadata) + .setTokenType(TokenType.FUNGIBLE_COMMON) + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var tokenInfoAfterCreation = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoAfterCreation.metadata).isEqualTo(initialTokenMetadata); + + // erase token metadata (update token with empty metadata) + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setTokenMetadata(emptyTokenMetadata) + .execute(testEnv.client) + .getReceipt(testEnv.client); - var tokenInfoAfterSettingEmptyMetadata = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); + var tokenInfoAfterSettingEmptyMetadata = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); - assertThat(tokenInfoAfterSettingEmptyMetadata.metadata).isEqualTo(emptyTokenMetadata); + assertThat(tokenInfoAfterSettingEmptyMetadata.metadata).isEqualTo(emptyTokenMetadata); - testEnv.close(tokenId); + } } /** @@ -509,46 +509,46 @@ void canEraseFungibleTokenMetadata() throws Exception { @Test @DisplayName("Can erase non fungible token metadata") void canEraseNonFungibleTokenMetadata() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var initialTokenMetadata = new byte[]{1, 1, 1, 1, 1}; - var emptyTokenMetadata = new byte[]{}; + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var initialTokenMetadata = new byte[]{1, 1, 1, 1, 1}; + var emptyTokenMetadata = new byte[]{}; - // create a non fungible token with metadata - var tokenId = Objects.requireNonNull( + // create a non fungible token with metadata + var tokenId = Objects.requireNonNull( new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenMetadata(initialTokenMetadata) - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenMetadata(initialTokenMetadata) + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var tokenInfoAfterCreation = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoAfterCreation.metadata).isEqualTo(initialTokenMetadata); + + // erase token metadata (update token with empty metadata) + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setTokenMetadata(emptyTokenMetadata) .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var tokenInfoAfterCreation = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoAfterCreation.metadata).isEqualTo(initialTokenMetadata); - - // erase token metadata (update token with empty metadata) - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setTokenMetadata(emptyTokenMetadata) - .execute(testEnv.client) - .getReceipt(testEnv.client); + .getReceipt(testEnv.client); - var tokenInfoAfterSettingEmptyMetadata = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); + var tokenInfoAfterSettingEmptyMetadata = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); - assertThat(tokenInfoAfterSettingEmptyMetadata.metadata).isEqualTo(emptyTokenMetadata); + assertThat(tokenInfoAfterSettingEmptyMetadata.metadata).isEqualTo(emptyTokenMetadata); - testEnv.close(tokenId); + } } /** @@ -558,40 +558,41 @@ void canEraseNonFungibleTokenMetadata() throws Exception { @Test @DisplayName("Cannot update a fungible token with metadata when transaction is not signed with an admin or a metadata key") void cannotUpdateFungibleTokenMetadataWhenTransactionIsNotSignedWithMetadataKey() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var initialTokenMetadata = new byte[]{1, 1, 1, 1, 1}; - var updatedTokenMetadata = new byte[]{2, 2, 2, 2, 2}; - var adminKey = PrivateKey.generateED25519(); - var metadataKey = PrivateKey.generateED25519(); - - // create a fungible token with metadata and metadata key - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenMetadata(initialTokenMetadata) - .setTokenType(TokenType.FUNGIBLE_COMMON) - .setTreasuryAccountId(testEnv.operatorId) - .setDecimals(3) - .setInitialSupply(1000000) - .setAdminKey(adminKey) - .setMetadataKey(metadataKey) - .freezeWith(testEnv.client) - .sign(adminKey) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setTokenMetadata(updatedTokenMetadata) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - testEnv.close(); + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()) { + + var initialTokenMetadata = new byte[]{1, 1, 1, 1, 1}; + var updatedTokenMetadata = new byte[]{2, 2, 2, 2, 2}; + var adminKey = PrivateKey.generateED25519(); + var metadataKey = PrivateKey.generateED25519(); + + // create a fungible token with metadata and metadata key + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenMetadata(initialTokenMetadata) + .setTokenType(TokenType.FUNGIBLE_COMMON) + .setTreasuryAccountId(testEnv.operatorId) + .setDecimals(3) + .setInitialSupply(1000000) + .setAdminKey(adminKey) + .setMetadataKey(metadataKey) + .freezeWith(testEnv.client) + .sign(adminKey) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setTokenMetadata(updatedTokenMetadata) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + } } /** @@ -601,39 +602,39 @@ void cannotUpdateFungibleTokenMetadataWhenTransactionIsNotSignedWithMetadataKey( @Test @DisplayName("Cannot update a non fungible token with metadata when transaction is not signed with an admin or a metadata key") void cannotUpdateNonFungibleTokenMetadataWhenTransactionIsNotSignedWithMetadataKey() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var initialTokenMetadata = new byte[]{1, 1, 1, 1, 1}; - var updatedTokenMetadata = new byte[]{2, 2, 2, 2, 2}; - var adminKey = PrivateKey.generateED25519(); - var metadataKey = PrivateKey.generateED25519(); - - // create a non fungible token with metadata and metadata key - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenMetadata(initialTokenMetadata) - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(adminKey) - .setSupplyKey(testEnv.operatorKey) - .setMetadataKey(metadataKey) - .freezeWith(testEnv.client) - .sign(adminKey) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setTokenMetadata(updatedTokenMetadata) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - testEnv.close(tokenId); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var initialTokenMetadata = new byte[]{1, 1, 1, 1, 1}; + var updatedTokenMetadata = new byte[]{2, 2, 2, 2, 2}; + var adminKey = PrivateKey.generateED25519(); + var metadataKey = PrivateKey.generateED25519(); + + // create a non fungible token with metadata and metadata key + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenMetadata(initialTokenMetadata) + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(adminKey) + .setSupplyKey(testEnv.operatorKey) + .setMetadataKey(metadataKey) + .freezeWith(testEnv.client) + .sign(adminKey) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setTokenMetadata(updatedTokenMetadata) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + } } /** @@ -643,34 +644,34 @@ void cannotUpdateNonFungibleTokenMetadataWhenTransactionIsNotSignedWithMetadataK @Test @DisplayName("Cannot update a fungible token with metadata when admin and metadata keys are not set") void cannotUpdateFungibleTokenMetadataWhenMetadataKeyNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var initialTokenMetadata = new byte[]{1, 1, 1, 1, 1}; - var updatedTokenMetadata = new byte[]{2, 2, 2, 2, 2}; - - // create a fungible token with metadata and without a metadata key and admin key - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenMetadata(initialTokenMetadata) - .setTokenType(TokenType.FUNGIBLE_COMMON) - .setTreasuryAccountId(testEnv.operatorId) - .setDecimals(3) - .setInitialSupply(1000000) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setTokenMetadata(updatedTokenMetadata) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.TOKEN_IS_IMMUTABLE.toString()); - - testEnv.close(tokenId); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var initialTokenMetadata = new byte[]{1, 1, 1, 1, 1}; + var updatedTokenMetadata = new byte[]{2, 2, 2, 2, 2}; + + // create a fungible token with metadata and without a metadata key and admin key + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenMetadata(initialTokenMetadata) + .setTokenType(TokenType.FUNGIBLE_COMMON) + .setTreasuryAccountId(testEnv.operatorId) + .setDecimals(3) + .setInitialSupply(1000000) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setTokenMetadata(updatedTokenMetadata) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.TOKEN_IS_IMMUTABLE.toString()); + + } } /** @@ -680,34 +681,33 @@ void cannotUpdateFungibleTokenMetadataWhenMetadataKeyNotSet() throws Exception { @Test @DisplayName("Cannot update a non fungible token with metadata when admin and metadata keys are not set") void cannotUpdateNonFungibleTokenMetadataWhenMetadataKeyNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - var initialTokenMetadata = new byte[]{1, 1, 1, 1, 1}; - var updatedTokenMetadata = new byte[]{2, 2, 2, 2, 2}; - - // create a non fungible token with metadata and without a metadata key and admin key - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenMetadata(initialTokenMetadata) - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setSupplyKey(testEnv.operatorKey) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setTokenMetadata(updatedTokenMetadata) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.TOKEN_IS_IMMUTABLE.toString()); - - - testEnv.close(tokenId); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + var initialTokenMetadata = new byte[]{1, 1, 1, 1, 1}; + var updatedTokenMetadata = new byte[]{2, 2, 2, 2, 2}; + + // create a non fungible token with metadata and without a metadata key and admin key + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenMetadata(initialTokenMetadata) + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setSupplyKey(testEnv.operatorKey) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setTokenMetadata(updatedTokenMetadata) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.TOKEN_IS_IMMUTABLE.toString()); + + } } /** @@ -717,87 +717,87 @@ void cannotUpdateNonFungibleTokenMetadataWhenMetadataKeyNotSet() throws Exceptio @Test @DisplayName("Can make a token immutable when updating keys to an empty KeyList, signing with an Admin Key, and setting the key verification mode to NO_VALIDATION") void canMakeTokenImmutableWhenUpdatingKeysToEmptyKeyListSigningWithAdminKeyWithKeyVerificationSetToNoValidation() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // Admin, Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys - var adminKey = PrivateKey.generateED25519(); - var wipeKey = PrivateKey.generateED25519(); - var kycKey = PrivateKey.generateED25519(); - var freezeKey = PrivateKey.generateED25519(); - var pauseKey = PrivateKey.generateED25519(); - var supplyKey = PrivateKey.generateED25519(); - var feeScheduleKey = PrivateKey.generateED25519(); - var metadataKey = PrivateKey.generateED25519(); - - // Create a non-fungible token - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("Test NFT") - .setTokenSymbol("TNFT") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(adminKey.getPublicKey()) - .setWipeKey(wipeKey.getPublicKey()) - .setKycKey(kycKey.getPublicKey()) - .setFreezeKey(freezeKey.getPublicKey()) - .setPauseKey(pauseKey.getPublicKey()) - .setSupplyKey(supplyKey.getPublicKey()) - .setFeeScheduleKey(feeScheduleKey.getPublicKey()) - .setMetadataKey(metadataKey.getPublicKey()) + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + // Admin, Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys + var adminKey = PrivateKey.generateED25519(); + var wipeKey = PrivateKey.generateED25519(); + var kycKey = PrivateKey.generateED25519(); + var freezeKey = PrivateKey.generateED25519(); + var pauseKey = PrivateKey.generateED25519(); + var supplyKey = PrivateKey.generateED25519(); + var feeScheduleKey = PrivateKey.generateED25519(); + var metadataKey = PrivateKey.generateED25519(); + + // Create a non-fungible token + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("Test NFT") + .setTokenSymbol("TNFT") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(adminKey.getPublicKey()) + .setWipeKey(wipeKey.getPublicKey()) + .setKycKey(kycKey.getPublicKey()) + .setFreezeKey(freezeKey.getPublicKey()) + .setPauseKey(pauseKey.getPublicKey()) + .setSupplyKey(supplyKey.getPublicKey()) + .setFeeScheduleKey(feeScheduleKey.getPublicKey()) + .setMetadataKey(metadataKey.getPublicKey()) + .freezeWith(testEnv.client) + .sign(adminKey) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var tokenInfoBeforeUpdate = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoBeforeUpdate.adminKey.toString()).isEqualTo(adminKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); + + var emptyKeyList = new KeyList(); + + // Make a token immutable by removing all of its keys when updating them to an empty KeyList, + // signing with an Admin Key, and setting the key verification mode to NO_VALIDATION + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setWipeKey(emptyKeyList) + .setKycKey(emptyKeyList) + .setFreezeKey(emptyKeyList) + .setPauseKey(emptyKeyList) + .setSupplyKey(emptyKeyList) + .setFeeScheduleKey(emptyKeyList) + .setMetadataKey(emptyKeyList) + .setAdminKey(emptyKeyList) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) .freezeWith(testEnv.client) .sign(adminKey) .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var tokenInfoBeforeUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoBeforeUpdate.adminKey.toString()).isEqualTo(adminKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); - - var emptyKeyList = new KeyList(); - - // Make a token immutable by removing all of its keys when updating them to an empty KeyList, - // signing with an Admin Key, and setting the key verification mode to NO_VALIDATION - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setWipeKey(emptyKeyList) - .setKycKey(emptyKeyList) - .setFreezeKey(emptyKeyList) - .setPauseKey(emptyKeyList) - .setSupplyKey(emptyKeyList) - .setFeeScheduleKey(emptyKeyList) - .setMetadataKey(emptyKeyList) - .setAdminKey(emptyKeyList) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .freezeWith(testEnv.client) - .sign(adminKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var tokenInfoAfterUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoAfterUpdate.adminKey).isNull(); - assertThat(tokenInfoAfterUpdate.wipeKey).isNull(); - assertThat(tokenInfoAfterUpdate.kycKey).isNull(); - assertThat(tokenInfoAfterUpdate.freezeKey).isNull(); - assertThat(tokenInfoAfterUpdate.pauseKey).isNull(); - assertThat(tokenInfoAfterUpdate.supplyKey).isNull(); - assertThat(tokenInfoAfterUpdate.feeScheduleKey).isNull(); - assertThat(tokenInfoAfterUpdate.metadataKey).isNull(); - - testEnv.close(tokenId); + .getReceipt(testEnv.client); + + var tokenInfoAfterUpdate = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoAfterUpdate.adminKey).isNull(); + assertThat(tokenInfoAfterUpdate.wipeKey).isNull(); + assertThat(tokenInfoAfterUpdate.kycKey).isNull(); + assertThat(tokenInfoAfterUpdate.freezeKey).isNull(); + assertThat(tokenInfoAfterUpdate.pauseKey).isNull(); + assertThat(tokenInfoAfterUpdate.supplyKey).isNull(); + assertThat(tokenInfoAfterUpdate.feeScheduleKey).isNull(); + assertThat(tokenInfoAfterUpdate.metadataKey).isNull(); + + } } /** @@ -807,85 +807,85 @@ void canMakeTokenImmutableWhenUpdatingKeysToEmptyKeyListSigningWithAdminKeyWithK @Test @DisplayName("Can remove all of token’s lower-privilege keys when updating keys to an empty KeyList, signing with an Admin Key, and setting the key verification mode to FULL_VALIDATION") void canRemoveAllLowerPrivilegeKeysWhenUpdatingKeysToEmptyKeyListSigningWithAdminKeyWithKeyVerificationSetToFullValidation() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // Admin, Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys - var adminKey = PrivateKey.generateED25519(); - var wipeKey = PrivateKey.generateED25519(); - var kycKey = PrivateKey.generateED25519(); - var freezeKey = PrivateKey.generateED25519(); - var pauseKey = PrivateKey.generateED25519(); - var supplyKey = PrivateKey.generateED25519(); - var feeScheduleKey = PrivateKey.generateED25519(); - var metadataKey = PrivateKey.generateED25519(); - - // Create a non-fungible token - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("Test NFT") - .setTokenSymbol("TNFT") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(adminKey.getPublicKey()) - .setWipeKey(wipeKey.getPublicKey()) - .setKycKey(kycKey.getPublicKey()) - .setFreezeKey(freezeKey.getPublicKey()) - .setPauseKey(pauseKey.getPublicKey()) - .setSupplyKey(supplyKey.getPublicKey()) - .setFeeScheduleKey(feeScheduleKey.getPublicKey()) - .setMetadataKey(metadataKey.getPublicKey()) + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + // Admin, Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys + var adminKey = PrivateKey.generateED25519(); + var wipeKey = PrivateKey.generateED25519(); + var kycKey = PrivateKey.generateED25519(); + var freezeKey = PrivateKey.generateED25519(); + var pauseKey = PrivateKey.generateED25519(); + var supplyKey = PrivateKey.generateED25519(); + var feeScheduleKey = PrivateKey.generateED25519(); + var metadataKey = PrivateKey.generateED25519(); + + // Create a non-fungible token + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("Test NFT") + .setTokenSymbol("TNFT") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(adminKey.getPublicKey()) + .setWipeKey(wipeKey.getPublicKey()) + .setKycKey(kycKey.getPublicKey()) + .setFreezeKey(freezeKey.getPublicKey()) + .setPauseKey(pauseKey.getPublicKey()) + .setSupplyKey(supplyKey.getPublicKey()) + .setFeeScheduleKey(feeScheduleKey.getPublicKey()) + .setMetadataKey(metadataKey.getPublicKey()) + .freezeWith(testEnv.client) + .sign(adminKey) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var tokenInfoBeforeUpdate = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoBeforeUpdate.adminKey.toString()).isEqualTo(adminKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); + + var emptyKeyList = new KeyList(); + + // Remove all of token’s lower-privilege keys when updating them to an empty KeyList, + // signing with an Admin Key, and setting the key verification mode to FULL_VALIDATION + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setWipeKey(emptyKeyList) + .setKycKey(emptyKeyList) + .setFreezeKey(emptyKeyList) + .setPauseKey(emptyKeyList) + .setSupplyKey(emptyKeyList) + .setFeeScheduleKey(emptyKeyList) + .setMetadataKey(emptyKeyList) + .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) .freezeWith(testEnv.client) .sign(adminKey) .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var tokenInfoBeforeUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoBeforeUpdate.adminKey.toString()).isEqualTo(adminKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); - - var emptyKeyList = new KeyList(); - - // Remove all of token’s lower-privilege keys when updating them to an empty KeyList, - // signing with an Admin Key, and setting the key verification mode to FULL_VALIDATION - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setWipeKey(emptyKeyList) - .setKycKey(emptyKeyList) - .setFreezeKey(emptyKeyList) - .setPauseKey(emptyKeyList) - .setSupplyKey(emptyKeyList) - .setFeeScheduleKey(emptyKeyList) - .setMetadataKey(emptyKeyList) - .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) - .freezeWith(testEnv.client) - .sign(adminKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var tokenInfoAfterUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoAfterUpdate.wipeKey).isNull(); - assertThat(tokenInfoAfterUpdate.kycKey).isNull(); - assertThat(tokenInfoAfterUpdate.freezeKey).isNull(); - assertThat(tokenInfoAfterUpdate.pauseKey).isNull(); - assertThat(tokenInfoAfterUpdate.supplyKey).isNull(); - assertThat(tokenInfoAfterUpdate.feeScheduleKey).isNull(); - assertThat(tokenInfoAfterUpdate.metadataKey).isNull(); - - testEnv.close(tokenId); + .getReceipt(testEnv.client); + + var tokenInfoAfterUpdate = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoAfterUpdate.wipeKey).isNull(); + assertThat(tokenInfoAfterUpdate.kycKey).isNull(); + assertThat(tokenInfoAfterUpdate.freezeKey).isNull(); + assertThat(tokenInfoAfterUpdate.pauseKey).isNull(); + assertThat(tokenInfoAfterUpdate.supplyKey).isNull(); + assertThat(tokenInfoAfterUpdate.feeScheduleKey).isNull(); + assertThat(tokenInfoAfterUpdate.metadataKey).isNull(); + + } } /** @@ -895,151 +895,86 @@ void canRemoveAllLowerPrivilegeKeysWhenUpdatingKeysToEmptyKeyListSigningWithAdmi @Test @DisplayName("Can update all of token’s lower-privilege keys to an unusable key (i.e. all-zeros key), when signing with an Admin Key, and setting the key verification mode to FULL_VALIDATION, and then revert previous keys") void canUpdateAllLowerPrivilegeKeysToUnusableKeyWhenSigningWithAdminKeyWithKeyVerificationSetToFullValidationAndThenRevertPreviousKeys() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // Admin, Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys - var adminKey = PrivateKey.generateED25519(); - var wipeKey = PrivateKey.generateED25519(); - var kycKey = PrivateKey.generateED25519(); - var freezeKey = PrivateKey.generateED25519(); - var pauseKey = PrivateKey.generateED25519(); - var supplyKey = PrivateKey.generateED25519(); - var feeScheduleKey = PrivateKey.generateED25519(); - var metadataKey = PrivateKey.generateED25519(); - - // Create a non-fungible token - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("Test NFT") - .setTokenSymbol("TNFT") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(adminKey.getPublicKey()) - .setWipeKey(wipeKey.getPublicKey()) - .setKycKey(kycKey.getPublicKey()) - .setFreezeKey(freezeKey.getPublicKey()) - .setPauseKey(pauseKey.getPublicKey()) - .setSupplyKey(supplyKey.getPublicKey()) - .setFeeScheduleKey(feeScheduleKey.getPublicKey()) - .setMetadataKey(metadataKey.getPublicKey()) + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + // Admin, Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys + var adminKey = PrivateKey.generateED25519(); + var wipeKey = PrivateKey.generateED25519(); + var kycKey = PrivateKey.generateED25519(); + var freezeKey = PrivateKey.generateED25519(); + var pauseKey = PrivateKey.generateED25519(); + var supplyKey = PrivateKey.generateED25519(); + var feeScheduleKey = PrivateKey.generateED25519(); + var metadataKey = PrivateKey.generateED25519(); + + // Create a non-fungible token + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("Test NFT") + .setTokenSymbol("TNFT") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(adminKey.getPublicKey()) + .setWipeKey(wipeKey.getPublicKey()) + .setKycKey(kycKey.getPublicKey()) + .setFreezeKey(freezeKey.getPublicKey()) + .setPauseKey(pauseKey.getPublicKey()) + .setSupplyKey(supplyKey.getPublicKey()) + .setFeeScheduleKey(feeScheduleKey.getPublicKey()) + .setMetadataKey(metadataKey.getPublicKey()) + .freezeWith(testEnv.client) + .sign(adminKey) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var tokenInfoBeforeUpdate = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoBeforeUpdate.adminKey.toString()).isEqualTo(adminKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); + + // Update all of token’s lower-privilege keys to an unusable key (i.e., all-zeros key), + // signing with an Admin Key, and setting the key verification mode to FULL_VALIDATION + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setWipeKey(PublicKey.unusableKey()) + .setKycKey(PublicKey.unusableKey()) + .setFreezeKey(PublicKey.unusableKey()) + .setPauseKey(PublicKey.unusableKey()) + .setSupplyKey(PublicKey.unusableKey()) + .setFeeScheduleKey(PublicKey.unusableKey()) + .setMetadataKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) .freezeWith(testEnv.client) .sign(adminKey) .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var tokenInfoBeforeUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoBeforeUpdate.adminKey.toString()).isEqualTo(adminKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); - - // Update all of token’s lower-privilege keys to an unusable key (i.e., all-zeros key), - // signing with an Admin Key, and setting the key verification mode to FULL_VALIDATION - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setWipeKey(PublicKey.unusableKey()) - .setKycKey(PublicKey.unusableKey()) - .setFreezeKey(PublicKey.unusableKey()) - .setPauseKey(PublicKey.unusableKey()) - .setSupplyKey(PublicKey.unusableKey()) - .setFeeScheduleKey(PublicKey.unusableKey()) - .setMetadataKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) - .freezeWith(testEnv.client) - .sign(adminKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var tokenInfoAfterUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoAfterUpdate.wipeKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); - assertThat(tokenInfoAfterUpdate.kycKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); - assertThat(tokenInfoAfterUpdate.freezeKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); - assertThat(tokenInfoAfterUpdate.pauseKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); - assertThat(tokenInfoAfterUpdate.supplyKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); - assertThat(tokenInfoAfterUpdate.feeScheduleKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); - assertThat(tokenInfoAfterUpdate.metadataKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); - - // Set all lower-privilege keys back by signing with an Admin Key, - // and setting key verification mode to NO_VALIDATION - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setWipeKey(wipeKey.getPublicKey()) - .setKycKey(kycKey.getPublicKey()) - .setFreezeKey(freezeKey.getPublicKey()) - .setPauseKey(pauseKey.getPublicKey()) - .setSupplyKey(supplyKey.getPublicKey()) - .setFeeScheduleKey(feeScheduleKey.getPublicKey()) - .setMetadataKey(metadataKey.getPublicKey()) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .freezeWith(testEnv.client) - .sign(adminKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var tokenInfoAfterRevert = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoAfterRevert.adminKey.toString()).isEqualTo(adminKey.getPublicKey().toString()); - assertThat(tokenInfoAfterRevert.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); - assertThat(tokenInfoAfterRevert.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); - assertThat(tokenInfoAfterRevert.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); - assertThat(tokenInfoAfterRevert.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); - assertThat(tokenInfoAfterRevert.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); - assertThat(tokenInfoAfterRevert.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); - assertThat(tokenInfoAfterRevert.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); - - testEnv.close(tokenId); - } + .getReceipt(testEnv.client); - /** - * @notice E2E-HIP-540 - * @url https://hips.hedera.com/hip/hip-540 - */ - @Test - @DisplayName("Can update all of token’s lower-privilege keys when signing with an Admin Key and new respective lower-privilege key, and setting key verification mode to FULL_VALIDATION") - void canUpdateAllLowerPrivilegeKeysWhenSigningWithAdminKeyAndNewLowerPrivilegeKeyWithKeyVerificationSetToFullValidation() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // Admin, Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys - var adminKey = PrivateKey.generateED25519(); - var wipeKey = PrivateKey.generateED25519(); - var kycKey = PrivateKey.generateED25519(); - var freezeKey = PrivateKey.generateED25519(); - var pauseKey = PrivateKey.generateED25519(); - var supplyKey = PrivateKey.generateED25519(); - var feeScheduleKey = PrivateKey.generateED25519(); - var metadataKey = PrivateKey.generateED25519(); - - // New Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys - var newWipeKey = PrivateKey.generateED25519(); - var newKycKey = PrivateKey.generateED25519(); - var newFreezeKey = PrivateKey.generateED25519(); - var newPauseKey = PrivateKey.generateED25519(); - var newSupplyKey = PrivateKey.generateED25519(); - var newFeeScheduleKey = PrivateKey.generateED25519(); - var newMetadataKey = PrivateKey.generateED25519(); - - // Create a non-fungible token - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("Test NFT") - .setTokenSymbol("TNFT") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(adminKey.getPublicKey()) + var tokenInfoAfterUpdate = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoAfterUpdate.wipeKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); + assertThat(tokenInfoAfterUpdate.kycKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); + assertThat(tokenInfoAfterUpdate.freezeKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); + assertThat(tokenInfoAfterUpdate.pauseKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); + assertThat(tokenInfoAfterUpdate.supplyKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); + assertThat(tokenInfoAfterUpdate.feeScheduleKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); + assertThat(tokenInfoAfterUpdate.metadataKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); + + // Set all lower-privilege keys back by signing with an Admin Key, + // and setting key verification mode to NO_VALIDATION + new TokenUpdateTransaction() + .setTokenId(tokenId) .setWipeKey(wipeKey.getPublicKey()) .setKycKey(kycKey.getPublicKey()) .setFreezeKey(freezeKey.getPublicKey()) @@ -1047,61 +982,26 @@ void canUpdateAllLowerPrivilegeKeysWhenSigningWithAdminKeyAndNewLowerPrivilegeKe .setSupplyKey(supplyKey.getPublicKey()) .setFeeScheduleKey(feeScheduleKey.getPublicKey()) .setMetadataKey(metadataKey.getPublicKey()) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) .freezeWith(testEnv.client) .sign(adminKey) .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var tokenInfoBeforeUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoBeforeUpdate.adminKey.toString()).isEqualTo(adminKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); - - // Update all of token’s lower-privilege keys when signing with an Admin Key and new respective lower-privilege key, - // and setting key verification mode to FULL_VALIDATION - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setWipeKey(newWipeKey.getPublicKey()) - .setKycKey(newKycKey.getPublicKey()) - .setFreezeKey(newFreezeKey.getPublicKey()) - .setPauseKey(newPauseKey.getPublicKey()) - .setSupplyKey(newSupplyKey.getPublicKey()) - .setFeeScheduleKey(newFeeScheduleKey.getPublicKey()) - .setMetadataKey(newMetadataKey.getPublicKey()) - .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) - .freezeWith(testEnv.client) - .sign(adminKey) - .sign(newWipeKey) - .sign(newKycKey) - .sign(newFreezeKey) - .sign(newPauseKey) - .sign(newSupplyKey) - .sign(newFeeScheduleKey) - .sign(newMetadataKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var tokenInfoAfterUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoAfterUpdate.wipeKey.toString()).isEqualTo(newWipeKey.getPublicKey().toString()); - assertThat(tokenInfoAfterUpdate.kycKey.toString()).isEqualTo(newKycKey.getPublicKey().toString()); - assertThat(tokenInfoAfterUpdate.freezeKey.toString()).isEqualTo(newFreezeKey.getPublicKey().toString()); - assertThat(tokenInfoAfterUpdate.pauseKey.toString()).isEqualTo(newPauseKey.getPublicKey().toString()); - assertThat(tokenInfoAfterUpdate.supplyKey.toString()).isEqualTo(newSupplyKey.getPublicKey().toString()); - assertThat(tokenInfoAfterUpdate.feeScheduleKey.toString()).isEqualTo(newFeeScheduleKey.getPublicKey().toString()); - assertThat(tokenInfoAfterUpdate.metadataKey.toString()).isEqualTo(newMetadataKey.getPublicKey().toString()); + .getReceipt(testEnv.client); + + var tokenInfoAfterRevert = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoAfterRevert.adminKey.toString()).isEqualTo(adminKey.getPublicKey().toString()); + assertThat(tokenInfoAfterRevert.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); + assertThat(tokenInfoAfterRevert.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); + assertThat(tokenInfoAfterRevert.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); + assertThat(tokenInfoAfterRevert.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); + assertThat(tokenInfoAfterRevert.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); + assertThat(tokenInfoAfterRevert.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); + assertThat(tokenInfoAfterRevert.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); + + } } /** @@ -1109,132 +1009,236 @@ void canUpdateAllLowerPrivilegeKeysWhenSigningWithAdminKeyAndNewLowerPrivilegeKe * @url https://hips.hedera.com/hip/hip-540 */ @Test - @DisplayName("Cannot make a token immutable when updating keys to an empty KeyList, signing with a key that is different from an Admin Key, and setting the key verification mode to NO_VALIDATION") - void cannotMakeTokenImmutableWhenUpdatingKeysToEmptyKeyListSigningWithDifferentKeyWithKeyVerificationSetToNoValidation() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // Admin, Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys - var adminKey = PrivateKey.generateED25519(); - var wipeKey = PrivateKey.generateED25519(); - var kycKey = PrivateKey.generateED25519(); - var freezeKey = PrivateKey.generateED25519(); - var pauseKey = PrivateKey.generateED25519(); - var supplyKey = PrivateKey.generateED25519(); - var feeScheduleKey = PrivateKey.generateED25519(); - var metadataKey = PrivateKey.generateED25519(); - - // Create a non-fungible token - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("Test NFT") - .setTokenSymbol("TNFT") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(adminKey.getPublicKey()) - .setWipeKey(wipeKey.getPublicKey()) - .setKycKey(kycKey.getPublicKey()) - .setFreezeKey(freezeKey.getPublicKey()) - .setPauseKey(pauseKey.getPublicKey()) - .setSupplyKey(supplyKey.getPublicKey()) - .setFeeScheduleKey(feeScheduleKey.getPublicKey()) - .setMetadataKey(metadataKey.getPublicKey()) - .freezeWith(testEnv.client) - .sign(adminKey) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var tokenInfoBeforeUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoBeforeUpdate.adminKey.toString()).isEqualTo(adminKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); - - var emptyKeyList = new KeyList(); - - // Make the token immutable when updating all of its keys to an empty KeyList - // (trying to remove keys one by one to check all errors), - // signing with a key that is different from an Admin Key (implicitly with an operator key), - // and setting the key verification mode to NO_VALIDATION - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setWipeKey(emptyKeyList) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setKycKey(emptyKeyList) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setFreezeKey(emptyKeyList) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + @DisplayName("Can update all of token’s lower-privilege keys when signing with an Admin Key and new respective lower-privilege key, and setting key verification mode to FULL_VALIDATION") + void canUpdateAllLowerPrivilegeKeysWhenSigningWithAdminKeyAndNewLowerPrivilegeKeyWithKeyVerificationSetToFullValidation() throws Exception { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + // Admin, Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys + var adminKey = PrivateKey.generateED25519(); + var wipeKey = PrivateKey.generateED25519(); + var kycKey = PrivateKey.generateED25519(); + var freezeKey = PrivateKey.generateED25519(); + var pauseKey = PrivateKey.generateED25519(); + var supplyKey = PrivateKey.generateED25519(); + var feeScheduleKey = PrivateKey.generateED25519(); + var metadataKey = PrivateKey.generateED25519(); + + // New Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys + var newWipeKey = PrivateKey.generateED25519(); + var newKycKey = PrivateKey.generateED25519(); + var newFreezeKey = PrivateKey.generateED25519(); + var newPauseKey = PrivateKey.generateED25519(); + var newSupplyKey = PrivateKey.generateED25519(); + var newFeeScheduleKey = PrivateKey.generateED25519(); + var newMetadataKey = PrivateKey.generateED25519(); + + // Create a non-fungible token + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("Test NFT") + .setTokenSymbol("TNFT") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(adminKey.getPublicKey()) + .setWipeKey(wipeKey.getPublicKey()) + .setKycKey(kycKey.getPublicKey()) + .setFreezeKey(freezeKey.getPublicKey()) + .setPauseKey(pauseKey.getPublicKey()) + .setSupplyKey(supplyKey.getPublicKey()) + .setFeeScheduleKey(feeScheduleKey.getPublicKey()) + .setMetadataKey(metadataKey.getPublicKey()) + .freezeWith(testEnv.client) + .sign(adminKey) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var tokenInfoBeforeUpdate = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoBeforeUpdate.adminKey.toString()).isEqualTo(adminKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); + + // Update all of token’s lower-privilege keys when signing with an Admin Key and new respective lower-privilege key, + // and setting key verification mode to FULL_VALIDATION new TokenUpdateTransaction() .setTokenId(tokenId) - .setPauseKey(emptyKeyList) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .setWipeKey(newWipeKey.getPublicKey()) + .setKycKey(newKycKey.getPublicKey()) + .setFreezeKey(newFreezeKey.getPublicKey()) + .setPauseKey(newPauseKey.getPublicKey()) + .setSupplyKey(newSupplyKey.getPublicKey()) + .setFeeScheduleKey(newFeeScheduleKey.getPublicKey()) + .setMetadataKey(newMetadataKey.getPublicKey()) + .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) + .freezeWith(testEnv.client) + .sign(adminKey) + .sign(newWipeKey) + .sign(newKycKey) + .sign(newFreezeKey) + .sign(newPauseKey) + .sign(newSupplyKey) + .sign(newFeeScheduleKey) + .sign(newMetadataKey) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() + var tokenInfoAfterUpdate = new TokenInfoQuery() .setTokenId(tokenId) - .setSupplyKey(emptyKeyList) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + .execute(testEnv.client); - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setFeeScheduleKey(emptyKeyList) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + assertThat(tokenInfoAfterUpdate.wipeKey.toString()).isEqualTo(newWipeKey.getPublicKey().toString()); + assertThat(tokenInfoAfterUpdate.kycKey.toString()).isEqualTo(newKycKey.getPublicKey().toString()); + assertThat(tokenInfoAfterUpdate.freezeKey.toString()).isEqualTo(newFreezeKey.getPublicKey().toString()); + assertThat(tokenInfoAfterUpdate.pauseKey.toString()).isEqualTo(newPauseKey.getPublicKey().toString()); + assertThat(tokenInfoAfterUpdate.supplyKey.toString()).isEqualTo(newSupplyKey.getPublicKey().toString()); + assertThat(tokenInfoAfterUpdate.feeScheduleKey.toString()).isEqualTo(newFeeScheduleKey.getPublicKey().toString()); + assertThat(tokenInfoAfterUpdate.metadataKey.toString()).isEqualTo(newMetadataKey.getPublicKey().toString()); - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setMetadataKey(emptyKeyList) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + } + } - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setAdminKey(emptyKeyList) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + /** + * @notice E2E-HIP-540 + * @url https://hips.hedera.com/hip/hip-540 + */ + @Test + @DisplayName("Cannot make a token immutable when updating keys to an empty KeyList, signing with a key that is different from an Admin Key, and setting the key verification mode to NO_VALIDATION") + void cannotMakeTokenImmutableWhenUpdatingKeysToEmptyKeyListSigningWithDifferentKeyWithKeyVerificationSetToNoValidation() throws Exception { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + // Admin, Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys + var adminKey = PrivateKey.generateED25519(); + var wipeKey = PrivateKey.generateED25519(); + var kycKey = PrivateKey.generateED25519(); + var freezeKey = PrivateKey.generateED25519(); + var pauseKey = PrivateKey.generateED25519(); + var supplyKey = PrivateKey.generateED25519(); + var feeScheduleKey = PrivateKey.generateED25519(); + var metadataKey = PrivateKey.generateED25519(); + + // Create a non-fungible token + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("Test NFT") + .setTokenSymbol("TNFT") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(adminKey.getPublicKey()) + .setWipeKey(wipeKey.getPublicKey()) + .setKycKey(kycKey.getPublicKey()) + .setFreezeKey(freezeKey.getPublicKey()) + .setPauseKey(pauseKey.getPublicKey()) + .setSupplyKey(supplyKey.getPublicKey()) + .setFeeScheduleKey(feeScheduleKey.getPublicKey()) + .setMetadataKey(metadataKey.getPublicKey()) + .freezeWith(testEnv.client) + .sign(adminKey) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var tokenInfoBeforeUpdate = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoBeforeUpdate.adminKey.toString()).isEqualTo(adminKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); + + var emptyKeyList = new KeyList(); + + // Make the token immutable when updating all of its keys to an empty KeyList + // (trying to remove keys one by one to check all errors), + // signing with a key that is different from an Admin Key (implicitly with an operator key), + // and setting the key verification mode to NO_VALIDATION + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setWipeKey(emptyKeyList) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setKycKey(emptyKeyList) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setFreezeKey(emptyKeyList) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setPauseKey(emptyKeyList) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setSupplyKey(emptyKeyList) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setFeeScheduleKey(emptyKeyList) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setMetadataKey(emptyKeyList) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setAdminKey(emptyKeyList) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + } } /** @@ -1244,128 +1248,269 @@ void cannotMakeTokenImmutableWhenUpdatingKeysToEmptyKeyListSigningWithDifferentK @Test @DisplayName("Cannot make a token immutable when updating keys to an unusable key (i.e. all-zeros key), signing with a key that is different from an Admin Key, and setting the key verification mode to NO_VALIDATION") void cannotMakeTokenImmutableWhenUpdatingKeysToUnusableKeySigningWithDifferentKeyWithKeyVerificationSetToNoValidation() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // Admin, Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys - var adminKey = PrivateKey.generateED25519(); - var wipeKey = PrivateKey.generateED25519(); - var kycKey = PrivateKey.generateED25519(); - var freezeKey = PrivateKey.generateED25519(); - var pauseKey = PrivateKey.generateED25519(); - var supplyKey = PrivateKey.generateED25519(); - var feeScheduleKey = PrivateKey.generateED25519(); - var metadataKey = PrivateKey.generateED25519(); - - // Create a non-fungible token - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("Test NFT") - .setTokenSymbol("TNFT") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(adminKey.getPublicKey()) - .setWipeKey(wipeKey.getPublicKey()) - .setKycKey(kycKey.getPublicKey()) - .setFreezeKey(freezeKey.getPublicKey()) - .setPauseKey(pauseKey.getPublicKey()) - .setSupplyKey(supplyKey.getPublicKey()) - .setFeeScheduleKey(feeScheduleKey.getPublicKey()) - .setMetadataKey(metadataKey.getPublicKey()) - .freezeWith(testEnv.client) - .sign(adminKey) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var tokenInfoBeforeUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoBeforeUpdate.adminKey.toString()).isEqualTo(adminKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); - - // Make the token immutable when updating all of its keys to an unusable key (i.e. all-zeros key) - // (trying to remove keys one by one to check all errors), - // signing with a key that is different from an Admin Key (implicitly with an operator key), - // and setting the key verification mode to NO_VALIDATION - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setWipeKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + // Admin, Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys + var adminKey = PrivateKey.generateED25519(); + var wipeKey = PrivateKey.generateED25519(); + var kycKey = PrivateKey.generateED25519(); + var freezeKey = PrivateKey.generateED25519(); + var pauseKey = PrivateKey.generateED25519(); + var supplyKey = PrivateKey.generateED25519(); + var feeScheduleKey = PrivateKey.generateED25519(); + var metadataKey = PrivateKey.generateED25519(); + + // Create a non-fungible token + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("Test NFT") + .setTokenSymbol("TNFT") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(adminKey.getPublicKey()) + .setWipeKey(wipeKey.getPublicKey()) + .setKycKey(kycKey.getPublicKey()) + .setFreezeKey(freezeKey.getPublicKey()) + .setPauseKey(pauseKey.getPublicKey()) + .setSupplyKey(supplyKey.getPublicKey()) + .setFeeScheduleKey(feeScheduleKey.getPublicKey()) + .setMetadataKey(metadataKey.getPublicKey()) + .freezeWith(testEnv.client) + .sign(adminKey) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var tokenInfoBeforeUpdate = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoBeforeUpdate.adminKey.toString()).isEqualTo(adminKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); + + // Make the token immutable when updating all of its keys to an unusable key (i.e. all-zeros key) + // (trying to remove keys one by one to check all errors), + // signing with a key that is different from an Admin Key (implicitly with an operator key), + // and setting the key verification mode to NO_VALIDATION + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setWipeKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setKycKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setFreezeKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setPauseKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setSupplyKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setFeeScheduleKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setMetadataKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setAdminKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + } + } - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setKycKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + /** + * @notice E2E-HIP-540 + * @url https://hips.hedera.com/hip/hip-540 + */ + @Test + @DisplayName("Cannot update the Admin Key to an unusable key (i.e. all-zeros key), signing with an Admin Key, and setting the key verification mode to NO_VALIDATION") + void cannotUpdateAdminKeyToUnusableKeySigningWithAdminKeyWithKeyVerificationSetToNoValidation() throws Exception { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + // Admin and supply keys + var adminKey = PrivateKey.generateED25519(); + var supplyKey = PrivateKey.generateED25519(); + + // Create a non-fungible token + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("Test NFT") + .setTokenSymbol("TNFT") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(adminKey.getPublicKey()) + .setSupplyKey(supplyKey.getPublicKey()) + .freezeWith(testEnv.client) + .sign(adminKey) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var tokenInfoBeforeUpdate = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoBeforeUpdate.adminKey.toString()).isEqualTo(adminKey.getPublicKey().toString()); + + // Update the Admin Key to an unusable key (i.e., all-zeros key), + // signing with an Admin Key, and setting the key verification mode to NO_VALIDATION + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setAdminKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .freezeWith(testEnv.client) + .sign(adminKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + } + } - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + /** + * @notice E2E-HIP-540 + * @url https://hips.hedera.com/hip/hip-540 + */ + @Test + @DisplayName("Can update all of token’s lower-privilege keys to an unusable key (i.e. all-zeros key), when signing with a respective lower-privilege key, and setting the key verification mode to NO_VALIDATION") + void canUpdateAllLowerPrivilegeKeysToUnusableKeyWhenSigningWithRespectiveLowerPrivilegeKeyWithKeyVerificationSetToNoValidation() throws Exception { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + // Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys + var wipeKey = PrivateKey.generateED25519(); + var kycKey = PrivateKey.generateED25519(); + var freezeKey = PrivateKey.generateED25519(); + var pauseKey = PrivateKey.generateED25519(); + var supplyKey = PrivateKey.generateED25519(); + var feeScheduleKey = PrivateKey.generateED25519(); + var metadataKey = PrivateKey.generateED25519(); + + // Create a non-fungible token + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("Test NFT") + .setTokenSymbol("TNFT") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setWipeKey(wipeKey.getPublicKey()) + .setKycKey(kycKey.getPublicKey()) + .setFreezeKey(freezeKey.getPublicKey()) + .setPauseKey(pauseKey.getPublicKey()) + .setSupplyKey(supplyKey.getPublicKey()) + .setFeeScheduleKey(feeScheduleKey.getPublicKey()) + .setMetadataKey(metadataKey.getPublicKey()) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var tokenInfoBeforeUpdate = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); + + // Update all of token’s lower-privilege keys to an unusable key (i.e., all-zeros key), + // when signing with a respective lower-privilege key, + // and setting the key verification mode to NO_VALIDATION new TokenUpdateTransaction() .setTokenId(tokenId) + .setWipeKey(PublicKey.unusableKey()) + .setKycKey(PublicKey.unusableKey()) .setFreezeKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) .setPauseKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) .setSupplyKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) .setFeeScheduleKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) .setMetadataKey(PublicKey.unusableKey()) .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .freezeWith(testEnv.client) + .sign(wipeKey) + .sign(kycKey) + .sign(freezeKey) + .sign(pauseKey) + .sign(supplyKey) + .sign(feeScheduleKey) + .sign(metadataKey) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() + var tokenInfoAfterUpdate = new TokenInfoQuery() .setTokenId(tokenId) - .setAdminKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + .execute(testEnv.client); + + assertThat(tokenInfoAfterUpdate.wipeKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); + assertThat(tokenInfoAfterUpdate.kycKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); + assertThat(tokenInfoAfterUpdate.freezeKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); + assertThat(tokenInfoAfterUpdate.pauseKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); + assertThat(tokenInfoAfterUpdate.supplyKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); + assertThat(tokenInfoAfterUpdate.feeScheduleKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); + assertThat(tokenInfoAfterUpdate.metadataKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); + + } } /** @@ -1373,50 +1518,198 @@ void cannotMakeTokenImmutableWhenUpdatingKeysToUnusableKeySigningWithDifferentKe * @url https://hips.hedera.com/hip/hip-540 */ @Test - @DisplayName("Cannot update the Admin Key to an unusable key (i.e. all-zeros key), signing with an Admin Key, and setting the key verification mode to NO_VALIDATION") - void cannotUpdateAdminKeyToUnusableKeySigningWithAdminKeyWithKeyVerificationSetToNoValidation() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // Admin and supply keys - var adminKey = PrivateKey.generateED25519(); - var supplyKey = PrivateKey.generateED25519(); - - // Create a non-fungible token - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("Test NFT") - .setTokenSymbol("TNFT") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(adminKey.getPublicKey()) - .setSupplyKey(supplyKey.getPublicKey()) + @DisplayName("Can update all of token’s lower-privilege keys when signing with an old lower-privilege key and with a new lower-privilege key, and setting key verification mode to FULL_VALIDATION") + void canUpdateAllLowerPrivilegeKeysWhenSigningWithOldLowerPrivilegeKeyAndNewLowerPrivilegeKeyWithKeyVerificationSetToFulValidation() throws Exception { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + // Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys + var wipeKey = PrivateKey.generateED25519(); + var kycKey = PrivateKey.generateED25519(); + var freezeKey = PrivateKey.generateED25519(); + var pauseKey = PrivateKey.generateED25519(); + var supplyKey = PrivateKey.generateED25519(); + var feeScheduleKey = PrivateKey.generateED25519(); + var metadataKey = PrivateKey.generateED25519(); + + // New Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys + var newWipeKey = PrivateKey.generateED25519(); + var newKycKey = PrivateKey.generateED25519(); + var newFreezeKey = PrivateKey.generateED25519(); + var newPauseKey = PrivateKey.generateED25519(); + var newSupplyKey = PrivateKey.generateED25519(); + var newFeeScheduleKey = PrivateKey.generateED25519(); + var newMetadataKey = PrivateKey.generateED25519(); + + // Create a non-fungible token + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("Test NFT") + .setTokenSymbol("TNFT") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setWipeKey(wipeKey.getPublicKey()) + .setKycKey(kycKey.getPublicKey()) + .setFreezeKey(freezeKey.getPublicKey()) + .setPauseKey(pauseKey.getPublicKey()) + .setSupplyKey(supplyKey.getPublicKey()) + .setFeeScheduleKey(feeScheduleKey.getPublicKey()) + .setMetadataKey(metadataKey.getPublicKey()) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var tokenInfoBeforeUpdate = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); + + // Update all of token’s lower-privilege keys when signing with an old respective lower-privilege key, + // and setting key verification mode to NO_VALIDATION + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setWipeKey(newWipeKey.getPublicKey()) + .setKycKey(newKycKey.getPublicKey()) + .setFreezeKey(newFreezeKey.getPublicKey()) + .setPauseKey(newPauseKey.getPublicKey()) + .setSupplyKey(newSupplyKey.getPublicKey()) + .setFeeScheduleKey(newFeeScheduleKey.getPublicKey()) + .setMetadataKey(newMetadataKey.getPublicKey()) + .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) .freezeWith(testEnv.client) - .sign(adminKey) + .sign(wipeKey) + .sign(newWipeKey) + .sign(kycKey) + .sign(newKycKey) + .sign(freezeKey) + .sign(newFreezeKey) + .sign(pauseKey) + .sign(newPauseKey) + .sign(supplyKey) + .sign(newSupplyKey) + .sign(feeScheduleKey) + .sign(newFeeScheduleKey) + .sign(metadataKey) + .sign(newMetadataKey) .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); + .getReceipt(testEnv.client); + + var tokenInfoAfterUpdate = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); - var tokenInfoBeforeUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); + assertThat(tokenInfoAfterUpdate.wipeKey.toString()).isEqualTo(newWipeKey.getPublicKey().toString()); + assertThat(tokenInfoAfterUpdate.kycKey.toString()).isEqualTo(newKycKey.getPublicKey().toString()); + assertThat(tokenInfoAfterUpdate.freezeKey.toString()).isEqualTo(newFreezeKey.getPublicKey().toString()); + assertThat(tokenInfoAfterUpdate.pauseKey.toString()).isEqualTo(newPauseKey.getPublicKey().toString()); + assertThat(tokenInfoAfterUpdate.supplyKey.toString()).isEqualTo(newSupplyKey.getPublicKey().toString()); + assertThat(tokenInfoAfterUpdate.feeScheduleKey.toString()).isEqualTo(newFeeScheduleKey.getPublicKey().toString()); + assertThat(tokenInfoAfterUpdate.metadataKey.toString()).isEqualTo(newMetadataKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.adminKey.toString()).isEqualTo(adminKey.getPublicKey().toString()); + } + } - // Update the Admin Key to an unusable key (i.e., all-zeros key), - // signing with an Admin Key, and setting the key verification mode to NO_VALIDATION - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + /** + * @notice E2E-HIP-540 + * @url https://hips.hedera.com/hip/hip-540 + */ + @Test + @DisplayName("Can update all of token’s lower-privilege keys when signing ONLY with an old lower-privilege key, and setting key verification mode to NO_VALIDATION") + void canUpdateAllLowerPrivilegeKeysWhenSigningOnlyWithOldLowerPrivilegeKeyWithKeyVerificationSetToNoValidation() throws Exception { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + // Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys + var wipeKey = PrivateKey.generateED25519(); + var kycKey = PrivateKey.generateED25519(); + var freezeKey = PrivateKey.generateED25519(); + var pauseKey = PrivateKey.generateED25519(); + var supplyKey = PrivateKey.generateED25519(); + var feeScheduleKey = PrivateKey.generateED25519(); + var metadataKey = PrivateKey.generateED25519(); + + // New Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys + var newWipeKey = PrivateKey.generateED25519(); + var newKycKey = PrivateKey.generateED25519(); + var newFreezeKey = PrivateKey.generateED25519(); + var newPauseKey = PrivateKey.generateED25519(); + var newSupplyKey = PrivateKey.generateED25519(); + var newFeeScheduleKey = PrivateKey.generateED25519(); + var newMetadataKey = PrivateKey.generateED25519(); + + // Create a non-fungible token + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("Test NFT") + .setTokenSymbol("TNFT") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setWipeKey(wipeKey.getPublicKey()) + .setKycKey(kycKey.getPublicKey()) + .setFreezeKey(freezeKey.getPublicKey()) + .setPauseKey(pauseKey.getPublicKey()) + .setSupplyKey(supplyKey.getPublicKey()) + .setFeeScheduleKey(feeScheduleKey.getPublicKey()) + .setMetadataKey(metadataKey.getPublicKey()) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var tokenInfoBeforeUpdate = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); + + // Update all of token’s lower-privilege keys when signing with an old respective lower-privilege key, + // and setting key verification mode to NO_VALIDATION new TokenUpdateTransaction() .setTokenId(tokenId) - .setAdminKey(PublicKey.unusableKey()) + .setWipeKey(newWipeKey.getPublicKey()) + .setKycKey(newKycKey.getPublicKey()) + .setFreezeKey(newFreezeKey.getPublicKey()) + .setPauseKey(newPauseKey.getPublicKey()) + .setSupplyKey(newSupplyKey.getPublicKey()) + .setFeeScheduleKey(newFeeScheduleKey.getPublicKey()) + .setMetadataKey(newMetadataKey.getPublicKey()) .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) .freezeWith(testEnv.client) - .sign(adminKey) + .sign(wipeKey) + .sign(kycKey) + .sign(freezeKey) + .sign(pauseKey) + .sign(supplyKey) + .sign(feeScheduleKey) + .sign(metadataKey) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - testEnv.close(tokenId); + var tokenInfoAfterUpdate = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoAfterUpdate.wipeKey.toString()).isEqualTo(newWipeKey.getPublicKey().toString()); + assertThat(tokenInfoAfterUpdate.kycKey.toString()).isEqualTo(newKycKey.getPublicKey().toString()); + assertThat(tokenInfoAfterUpdate.freezeKey.toString()).isEqualTo(newFreezeKey.getPublicKey().toString()); + assertThat(tokenInfoAfterUpdate.pauseKey.toString()).isEqualTo(newPauseKey.getPublicKey().toString()); + assertThat(tokenInfoAfterUpdate.supplyKey.toString()).isEqualTo(newSupplyKey.getPublicKey().toString()); + assertThat(tokenInfoAfterUpdate.feeScheduleKey.toString()).isEqualTo(newFeeScheduleKey.getPublicKey().toString()); + assertThat(tokenInfoAfterUpdate.metadataKey.toString()).isEqualTo(newMetadataKey.getPublicKey().toString()); + + } } /** @@ -1424,415 +1717,134 @@ void cannotUpdateAdminKeyToUnusableKeySigningWithAdminKeyWithKeyVerificationSetT * @url https://hips.hedera.com/hip/hip-540 */ @Test - @DisplayName("Can update all of token’s lower-privilege keys to an unusable key (i.e. all-zeros key), when signing with a respective lower-privilege key, and setting the key verification mode to NO_VALIDATION") - void canUpdateAllLowerPrivilegeKeysToUnusableKeyWhenSigningWithRespectiveLowerPrivilegeKeyWithKeyVerificationSetToNoValidation() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys - var wipeKey = PrivateKey.generateED25519(); - var kycKey = PrivateKey.generateED25519(); - var freezeKey = PrivateKey.generateED25519(); - var pauseKey = PrivateKey.generateED25519(); - var supplyKey = PrivateKey.generateED25519(); - var feeScheduleKey = PrivateKey.generateED25519(); - var metadataKey = PrivateKey.generateED25519(); - - // Create a non-fungible token - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("Test NFT") - .setTokenSymbol("TNFT") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setWipeKey(wipeKey.getPublicKey()) - .setKycKey(kycKey.getPublicKey()) - .setFreezeKey(freezeKey.getPublicKey()) - .setPauseKey(pauseKey.getPublicKey()) - .setSupplyKey(supplyKey.getPublicKey()) - .setFeeScheduleKey(feeScheduleKey.getPublicKey()) - .setMetadataKey(metadataKey.getPublicKey()) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var tokenInfoBeforeUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); - - // Update all of token’s lower-privilege keys to an unusable key (i.e., all-zeros key), - // when signing with a respective lower-privilege key, - // and setting the key verification mode to NO_VALIDATION - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setWipeKey(PublicKey.unusableKey()) - .setKycKey(PublicKey.unusableKey()) - .setFreezeKey(PublicKey.unusableKey()) - .setPauseKey(PublicKey.unusableKey()) - .setSupplyKey(PublicKey.unusableKey()) - .setFeeScheduleKey(PublicKey.unusableKey()) - .setMetadataKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .freezeWith(testEnv.client) - .sign(wipeKey) - .sign(kycKey) - .sign(freezeKey) - .sign(pauseKey) - .sign(supplyKey) - .sign(feeScheduleKey) - .sign(metadataKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var tokenInfoAfterUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoAfterUpdate.wipeKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); - assertThat(tokenInfoAfterUpdate.kycKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); - assertThat(tokenInfoAfterUpdate.freezeKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); - assertThat(tokenInfoAfterUpdate.pauseKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); - assertThat(tokenInfoAfterUpdate.supplyKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); - assertThat(tokenInfoAfterUpdate.feeScheduleKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); - assertThat(tokenInfoAfterUpdate.metadataKey.toString()).isEqualTo(PublicKey.unusableKey().toString()); - - testEnv.close(tokenId); - } - - /** - * @notice E2E-HIP-540 - * @url https://hips.hedera.com/hip/hip-540 - */ - @Test - @DisplayName("Can update all of token’s lower-privilege keys when signing with an old lower-privilege key and with a new lower-privilege key, and setting key verification mode to FULL_VALIDATION") - void canUpdateAllLowerPrivilegeKeysWhenSigningWithOldLowerPrivilegeKeyAndNewLowerPrivilegeKeyWithKeyVerificationSetToFulValidation() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys - var wipeKey = PrivateKey.generateED25519(); - var kycKey = PrivateKey.generateED25519(); - var freezeKey = PrivateKey.generateED25519(); - var pauseKey = PrivateKey.generateED25519(); - var supplyKey = PrivateKey.generateED25519(); - var feeScheduleKey = PrivateKey.generateED25519(); - var metadataKey = PrivateKey.generateED25519(); - - // New Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys - var newWipeKey = PrivateKey.generateED25519(); - var newKycKey = PrivateKey.generateED25519(); - var newFreezeKey = PrivateKey.generateED25519(); - var newPauseKey = PrivateKey.generateED25519(); - var newSupplyKey = PrivateKey.generateED25519(); - var newFeeScheduleKey = PrivateKey.generateED25519(); - var newMetadataKey = PrivateKey.generateED25519(); - - // Create a non-fungible token - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("Test NFT") - .setTokenSymbol("TNFT") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setWipeKey(wipeKey.getPublicKey()) - .setKycKey(kycKey.getPublicKey()) - .setFreezeKey(freezeKey.getPublicKey()) - .setPauseKey(pauseKey.getPublicKey()) - .setSupplyKey(supplyKey.getPublicKey()) - .setFeeScheduleKey(feeScheduleKey.getPublicKey()) - .setMetadataKey(metadataKey.getPublicKey()) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var tokenInfoBeforeUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); - - // Update all of token’s lower-privilege keys when signing with an old respective lower-privilege key, - // and setting key verification mode to NO_VALIDATION - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setWipeKey(newWipeKey.getPublicKey()) - .setKycKey(newKycKey.getPublicKey()) - .setFreezeKey(newFreezeKey.getPublicKey()) - .setPauseKey(newPauseKey.getPublicKey()) - .setSupplyKey(newSupplyKey.getPublicKey()) - .setFeeScheduleKey(newFeeScheduleKey.getPublicKey()) - .setMetadataKey(newMetadataKey.getPublicKey()) - .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) - .freezeWith(testEnv.client) - .sign(wipeKey) - .sign(newWipeKey) - .sign(kycKey) - .sign(newKycKey) - .sign(freezeKey) - .sign(newFreezeKey) - .sign(pauseKey) - .sign(newPauseKey) - .sign(supplyKey) - .sign(newSupplyKey) - .sign(feeScheduleKey) - .sign(newFeeScheduleKey) - .sign(metadataKey) - .sign(newMetadataKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var tokenInfoAfterUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoAfterUpdate.wipeKey.toString()).isEqualTo(newWipeKey.getPublicKey().toString()); - assertThat(tokenInfoAfterUpdate.kycKey.toString()).isEqualTo(newKycKey.getPublicKey().toString()); - assertThat(tokenInfoAfterUpdate.freezeKey.toString()).isEqualTo(newFreezeKey.getPublicKey().toString()); - assertThat(tokenInfoAfterUpdate.pauseKey.toString()).isEqualTo(newPauseKey.getPublicKey().toString()); - assertThat(tokenInfoAfterUpdate.supplyKey.toString()).isEqualTo(newSupplyKey.getPublicKey().toString()); - assertThat(tokenInfoAfterUpdate.feeScheduleKey.toString()).isEqualTo(newFeeScheduleKey.getPublicKey().toString()); - assertThat(tokenInfoAfterUpdate.metadataKey.toString()).isEqualTo(newMetadataKey.getPublicKey().toString()); - } - - /** - * @notice E2E-HIP-540 - * @url https://hips.hedera.com/hip/hip-540 - */ - @Test - @DisplayName("Can update all of token’s lower-privilege keys when signing ONLY with an old lower-privilege key, and setting key verification mode to NO_VALIDATION") - void canUpdateAllLowerPrivilegeKeysWhenSigningOnlyWithOldLowerPrivilegeKeyWithKeyVerificationSetToNoValidation() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys - var wipeKey = PrivateKey.generateED25519(); - var kycKey = PrivateKey.generateED25519(); - var freezeKey = PrivateKey.generateED25519(); - var pauseKey = PrivateKey.generateED25519(); - var supplyKey = PrivateKey.generateED25519(); - var feeScheduleKey = PrivateKey.generateED25519(); - var metadataKey = PrivateKey.generateED25519(); - - // New Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys - var newWipeKey = PrivateKey.generateED25519(); - var newKycKey = PrivateKey.generateED25519(); - var newFreezeKey = PrivateKey.generateED25519(); - var newPauseKey = PrivateKey.generateED25519(); - var newSupplyKey = PrivateKey.generateED25519(); - var newFeeScheduleKey = PrivateKey.generateED25519(); - var newMetadataKey = PrivateKey.generateED25519(); - - // Create a non-fungible token - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("Test NFT") - .setTokenSymbol("TNFT") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setWipeKey(wipeKey.getPublicKey()) - .setKycKey(kycKey.getPublicKey()) - .setFreezeKey(freezeKey.getPublicKey()) - .setPauseKey(pauseKey.getPublicKey()) - .setSupplyKey(supplyKey.getPublicKey()) - .setFeeScheduleKey(feeScheduleKey.getPublicKey()) - .setMetadataKey(metadataKey.getPublicKey()) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var tokenInfoBeforeUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); - - // Update all of token’s lower-privilege keys when signing with an old respective lower-privilege key, - // and setting key verification mode to NO_VALIDATION - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setWipeKey(newWipeKey.getPublicKey()) - .setKycKey(newKycKey.getPublicKey()) - .setFreezeKey(newFreezeKey.getPublicKey()) - .setPauseKey(newPauseKey.getPublicKey()) - .setSupplyKey(newSupplyKey.getPublicKey()) - .setFeeScheduleKey(newFeeScheduleKey.getPublicKey()) - .setMetadataKey(newMetadataKey.getPublicKey()) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .freezeWith(testEnv.client) - .sign(wipeKey) - .sign(kycKey) - .sign(freezeKey) - .sign(pauseKey) - .sign(supplyKey) - .sign(feeScheduleKey) - .sign(metadataKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var tokenInfoAfterUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoAfterUpdate.wipeKey.toString()).isEqualTo(newWipeKey.getPublicKey().toString()); - assertThat(tokenInfoAfterUpdate.kycKey.toString()).isEqualTo(newKycKey.getPublicKey().toString()); - assertThat(tokenInfoAfterUpdate.freezeKey.toString()).isEqualTo(newFreezeKey.getPublicKey().toString()); - assertThat(tokenInfoAfterUpdate.pauseKey.toString()).isEqualTo(newPauseKey.getPublicKey().toString()); - assertThat(tokenInfoAfterUpdate.supplyKey.toString()).isEqualTo(newSupplyKey.getPublicKey().toString()); - assertThat(tokenInfoAfterUpdate.feeScheduleKey.toString()).isEqualTo(newFeeScheduleKey.getPublicKey().toString()); - assertThat(tokenInfoAfterUpdate.metadataKey.toString()).isEqualTo(newMetadataKey.getPublicKey().toString()); - } - - /** - * @notice E2E-HIP-540 - * @url https://hips.hedera.com/hip/hip-540 - */ - @Test - @DisplayName("Cannot remove all of token’s lower-privilege keys when updating them to an empty KeyList, signing with a respective lower-privilege key, and setting the key verification mode to NO_VALIDATION") - void cannotRemoveAllLowerPrivilegeKeysWhenUpdatingKeysToEmptyKeyListSigningWithRespectiveLowerPrivilegeKeyWithKeyVerificationSetToNoValidation() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys - var wipeKey = PrivateKey.generateED25519(); - var kycKey = PrivateKey.generateED25519(); - var freezeKey = PrivateKey.generateED25519(); - var pauseKey = PrivateKey.generateED25519(); - var supplyKey = PrivateKey.generateED25519(); - var feeScheduleKey = PrivateKey.generateED25519(); - var metadataKey = PrivateKey.generateED25519(); - - // Create a non-fungible token - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("Test NFT") - .setTokenSymbol("TNFT") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setWipeKey(wipeKey.getPublicKey()) - .setKycKey(kycKey.getPublicKey()) - .setFreezeKey(freezeKey.getPublicKey()) - .setPauseKey(pauseKey.getPublicKey()) - .setSupplyKey(supplyKey.getPublicKey()) - .setFeeScheduleKey(feeScheduleKey.getPublicKey()) - .setMetadataKey(metadataKey.getPublicKey()) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var tokenInfoBeforeUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); - - var emptyKeyList = new KeyList(); - - // Remove all of token’s lower-privilege keys - // when updating them to an empty KeyList (trying to remove keys one by one to check all errors), - // signing with a respective lower-privilege key, - // and setting the key verification mode to NO_VALIDATION - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setWipeKey(emptyKeyList) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .freezeWith(testEnv.client) - .sign(wipeKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.TOKEN_IS_IMMUTABLE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setKycKey(emptyKeyList) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .freezeWith(testEnv.client) - .sign(kycKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.TOKEN_IS_IMMUTABLE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setFreezeKey(emptyKeyList) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .freezeWith(testEnv.client) - .sign(freezeKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.TOKEN_IS_IMMUTABLE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setPauseKey(emptyKeyList) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .freezeWith(testEnv.client) - .sign(pauseKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.TOKEN_IS_IMMUTABLE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setSupplyKey(emptyKeyList) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .freezeWith(testEnv.client) - .sign(supplyKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.TOKEN_IS_IMMUTABLE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setFeeScheduleKey(emptyKeyList) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .freezeWith(testEnv.client) - .sign(feeScheduleKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.TOKEN_IS_IMMUTABLE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setMetadataKey(emptyKeyList) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .freezeWith(testEnv.client) - .sign(metadataKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.TOKEN_IS_IMMUTABLE.toString()); + @DisplayName("Cannot remove all of token’s lower-privilege keys when updating them to an empty KeyList, signing with a respective lower-privilege key, and setting the key verification mode to NO_VALIDATION") + void cannotRemoveAllLowerPrivilegeKeysWhenUpdatingKeysToEmptyKeyListSigningWithRespectiveLowerPrivilegeKeyWithKeyVerificationSetToNoValidation() throws Exception { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + // Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys + var wipeKey = PrivateKey.generateED25519(); + var kycKey = PrivateKey.generateED25519(); + var freezeKey = PrivateKey.generateED25519(); + var pauseKey = PrivateKey.generateED25519(); + var supplyKey = PrivateKey.generateED25519(); + var feeScheduleKey = PrivateKey.generateED25519(); + var metadataKey = PrivateKey.generateED25519(); + + // Create a non-fungible token + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("Test NFT") + .setTokenSymbol("TNFT") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setWipeKey(wipeKey.getPublicKey()) + .setKycKey(kycKey.getPublicKey()) + .setFreezeKey(freezeKey.getPublicKey()) + .setPauseKey(pauseKey.getPublicKey()) + .setSupplyKey(supplyKey.getPublicKey()) + .setFeeScheduleKey(feeScheduleKey.getPublicKey()) + .setMetadataKey(metadataKey.getPublicKey()) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var tokenInfoBeforeUpdate = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); + + var emptyKeyList = new KeyList(); + + // Remove all of token’s lower-privilege keys + // when updating them to an empty KeyList (trying to remove keys one by one to check all errors), + // signing with a respective lower-privilege key, + // and setting the key verification mode to NO_VALIDATION + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setWipeKey(emptyKeyList) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .freezeWith(testEnv.client) + .sign(wipeKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.TOKEN_IS_IMMUTABLE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setKycKey(emptyKeyList) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .freezeWith(testEnv.client) + .sign(kycKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.TOKEN_IS_IMMUTABLE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setFreezeKey(emptyKeyList) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .freezeWith(testEnv.client) + .sign(freezeKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.TOKEN_IS_IMMUTABLE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setPauseKey(emptyKeyList) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .freezeWith(testEnv.client) + .sign(pauseKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.TOKEN_IS_IMMUTABLE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setSupplyKey(emptyKeyList) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .freezeWith(testEnv.client) + .sign(supplyKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.TOKEN_IS_IMMUTABLE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setFeeScheduleKey(emptyKeyList) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .freezeWith(testEnv.client) + .sign(feeScheduleKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.TOKEN_IS_IMMUTABLE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setMetadataKey(emptyKeyList) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .freezeWith(testEnv.client) + .sign(metadataKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.TOKEN_IS_IMMUTABLE.toString()); + + } } /** @@ -1842,114 +1854,116 @@ void cannotRemoveAllLowerPrivilegeKeysWhenUpdatingKeysToEmptyKeyListSigningWithR @Test @DisplayName("Cannot update all of token’s lower-privilege keys to an unusable key (i.e. all-zeros key), when signing with a key that is different from a respective lower-privilege key, and setting the key verification mode to NO_VALIDATION") void cannotUpdateAllLowerPrivilegeKeysToUnusableKeyWhenSigningWithDifferentKeyWithKeyVerificationSetToNoValidation() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys - var wipeKey = PrivateKey.generateED25519(); - var kycKey = PrivateKey.generateED25519(); - var freezeKey = PrivateKey.generateED25519(); - var pauseKey = PrivateKey.generateED25519(); - var supplyKey = PrivateKey.generateED25519(); - var feeScheduleKey = PrivateKey.generateED25519(); - var metadataKey = PrivateKey.generateED25519(); - - // Create a non-fungible token - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("Test NFT") - .setTokenSymbol("TNFT") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setWipeKey(wipeKey.getPublicKey()) - .setKycKey(kycKey.getPublicKey()) - .setFreezeKey(freezeKey.getPublicKey()) - .setPauseKey(pauseKey.getPublicKey()) - .setSupplyKey(supplyKey.getPublicKey()) - .setFeeScheduleKey(feeScheduleKey.getPublicKey()) - .setMetadataKey(metadataKey.getPublicKey()) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var tokenInfoBeforeUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); - - // Update all of token’s lower-privilege keys to an unusable key (i.e. all-zeros key) - // (trying to remove keys one by one to check all errors), - // signing with a key that is different from a respective lower-privilege key (implicitly with an operator key), - // and setting the key verification mode to NO_VALIDATION - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setWipeKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setKycKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setFreezeKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setPauseKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setSupplyKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setFeeScheduleKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setMetadataKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + // Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys + var wipeKey = PrivateKey.generateED25519(); + var kycKey = PrivateKey.generateED25519(); + var freezeKey = PrivateKey.generateED25519(); + var pauseKey = PrivateKey.generateED25519(); + var supplyKey = PrivateKey.generateED25519(); + var feeScheduleKey = PrivateKey.generateED25519(); + var metadataKey = PrivateKey.generateED25519(); + + // Create a non-fungible token + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("Test NFT") + .setTokenSymbol("TNFT") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setWipeKey(wipeKey.getPublicKey()) + .setKycKey(kycKey.getPublicKey()) + .setFreezeKey(freezeKey.getPublicKey()) + .setPauseKey(pauseKey.getPublicKey()) + .setSupplyKey(supplyKey.getPublicKey()) + .setFeeScheduleKey(feeScheduleKey.getPublicKey()) + .setMetadataKey(metadataKey.getPublicKey()) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var tokenInfoBeforeUpdate = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); + + // Update all of token’s lower-privilege keys to an unusable key (i.e. all-zeros key) + // (trying to remove keys one by one to check all errors), + // signing with a key that is different from a respective lower-privilege key (implicitly with an operator key), + // and setting the key verification mode to NO_VALIDATION + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setWipeKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setKycKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setFreezeKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setPauseKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setSupplyKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setFeeScheduleKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setMetadataKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + } } /** @@ -1959,128 +1973,130 @@ void cannotUpdateAllLowerPrivilegeKeysToUnusableKeyWhenSigningWithDifferentKeyWi @Test @DisplayName("Cannot update all of token’s lower-privilege keys to an unusable key (i.e. all-zeros key), when signing ONLY with an old respective lower-privilege key, and setting the key verification mode to FULL_VALIDATION") void cannotUpdateAllLowerPrivilegeKeysToUnusableKeyWhenSigningOnlyWithOldRespectiveLowerPrivilegeKeyWithKeyVerificationSetToFullValidation() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys - var wipeKey = PrivateKey.generateED25519(); - var kycKey = PrivateKey.generateED25519(); - var freezeKey = PrivateKey.generateED25519(); - var pauseKey = PrivateKey.generateED25519(); - var supplyKey = PrivateKey.generateED25519(); - var feeScheduleKey = PrivateKey.generateED25519(); - var metadataKey = PrivateKey.generateED25519(); - - // Create a non-fungible token - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("Test NFT") - .setTokenSymbol("TNFT") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setWipeKey(wipeKey.getPublicKey()) - .setKycKey(kycKey.getPublicKey()) - .setFreezeKey(freezeKey.getPublicKey()) - .setPauseKey(pauseKey.getPublicKey()) - .setSupplyKey(supplyKey.getPublicKey()) - .setFeeScheduleKey(feeScheduleKey.getPublicKey()) - .setMetadataKey(metadataKey.getPublicKey()) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var tokenInfoBeforeUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); - - // Update all of token’s lower-privilege keys to an unusable key (i.e., all-zeros key) - // (trying to remove keys one by one to check all errors), - // signing ONLY with an old respective lower-privilege key, - // and setting the key verification mode to FULL_VALIDATION - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setWipeKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) - .freezeWith(testEnv.client) - .sign(wipeKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setKycKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) - .freezeWith(testEnv.client) - .sign(kycKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setFreezeKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) - .freezeWith(testEnv.client) - .sign(freezeKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setPauseKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) - .freezeWith(testEnv.client) - .sign(pauseKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setSupplyKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) - .freezeWith(testEnv.client) - .sign(supplyKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setFeeScheduleKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) - .freezeWith(testEnv.client) - .sign(feeScheduleKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setMetadataKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) - .freezeWith(testEnv.client) - .sign(metadataKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + // Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys + var wipeKey = PrivateKey.generateED25519(); + var kycKey = PrivateKey.generateED25519(); + var freezeKey = PrivateKey.generateED25519(); + var pauseKey = PrivateKey.generateED25519(); + var supplyKey = PrivateKey.generateED25519(); + var feeScheduleKey = PrivateKey.generateED25519(); + var metadataKey = PrivateKey.generateED25519(); + + // Create a non-fungible token + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("Test NFT") + .setTokenSymbol("TNFT") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setWipeKey(wipeKey.getPublicKey()) + .setKycKey(kycKey.getPublicKey()) + .setFreezeKey(freezeKey.getPublicKey()) + .setPauseKey(pauseKey.getPublicKey()) + .setSupplyKey(supplyKey.getPublicKey()) + .setFeeScheduleKey(feeScheduleKey.getPublicKey()) + .setMetadataKey(metadataKey.getPublicKey()) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var tokenInfoBeforeUpdate = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); + + // Update all of token’s lower-privilege keys to an unusable key (i.e., all-zeros key) + // (trying to remove keys one by one to check all errors), + // signing ONLY with an old respective lower-privilege key, + // and setting the key verification mode to FULL_VALIDATION + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setWipeKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) + .freezeWith(testEnv.client) + .sign(wipeKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setKycKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) + .freezeWith(testEnv.client) + .sign(kycKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setFreezeKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) + .freezeWith(testEnv.client) + .sign(freezeKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setPauseKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) + .freezeWith(testEnv.client) + .sign(pauseKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setSupplyKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) + .freezeWith(testEnv.client) + .sign(supplyKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setFeeScheduleKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) + .freezeWith(testEnv.client) + .sign(feeScheduleKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setMetadataKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) + .freezeWith(testEnv.client) + .sign(metadataKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + } } /** @@ -2090,144 +2106,146 @@ void cannotUpdateAllLowerPrivilegeKeysToUnusableKeyWhenSigningOnlyWithOldRespect @Test @DisplayName("Cannot update all of token’s lower-privilege keys to an unusable key (i.e. all-zeros key), when signing with an old respective lower-privilege key and new respective lower-privilege key, and setting the key verification mode to FULL_VALIDATION") void cannotUpdateAllLowerPrivilegeKeysToUnusableKeyWhenSigningWithOldRespectiveLowerPrivilegeKeyAndNewRespectiveLowerPrivilegeKeyWithKeyVerificationSetToFullValidation() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys - var wipeKey = PrivateKey.generateED25519(); - var kycKey = PrivateKey.generateED25519(); - var freezeKey = PrivateKey.generateED25519(); - var pauseKey = PrivateKey.generateED25519(); - var supplyKey = PrivateKey.generateED25519(); - var feeScheduleKey = PrivateKey.generateED25519(); - var metadataKey = PrivateKey.generateED25519(); - - // New Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys - var newWipeKey = PrivateKey.generateED25519(); - var newKycKey = PrivateKey.generateED25519(); - var newFreezeKey = PrivateKey.generateED25519(); - var newPauseKey = PrivateKey.generateED25519(); - var newSupplyKey = PrivateKey.generateED25519(); - var newFeeScheduleKey = PrivateKey.generateED25519(); - var newMetadataKey = PrivateKey.generateED25519(); - - // Create a non-fungible token - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("Test NFT") - .setTokenSymbol("TNFT") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setWipeKey(wipeKey.getPublicKey()) - .setKycKey(kycKey.getPublicKey()) - .setFreezeKey(freezeKey.getPublicKey()) - .setPauseKey(pauseKey.getPublicKey()) - .setSupplyKey(supplyKey.getPublicKey()) - .setFeeScheduleKey(feeScheduleKey.getPublicKey()) - .setMetadataKey(metadataKey.getPublicKey()) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var tokenInfoBeforeUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); - - // Update all of token’s lower-privilege keys to an unusable key (i.e., all-zeros key) - // (trying to remove keys one by one to check all errors), - // signing with an old respective lower-privilege key and new respective lower-privilege key, - // and setting the key verification mode to FULL_VALIDATION - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setWipeKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) - .freezeWith(testEnv.client) - .sign(wipeKey) - .sign(newWipeKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setKycKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) - .freezeWith(testEnv.client) - .sign(kycKey) - .sign(newKycKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setFreezeKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) - .freezeWith(testEnv.client) - .sign(freezeKey) - .sign(newFreezeKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setPauseKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) - .freezeWith(testEnv.client) - .sign(pauseKey) - .sign(newPauseKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setSupplyKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) - .freezeWith(testEnv.client) - .sign(supplyKey) - .sign(newSupplyKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setFeeScheduleKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) - .freezeWith(testEnv.client) - .sign(feeScheduleKey) - .sign(newFeeScheduleKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setMetadataKey(PublicKey.unusableKey()) - .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) - .freezeWith(testEnv.client) - .sign(metadataKey) - .sign(newMetadataKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + // Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys + var wipeKey = PrivateKey.generateED25519(); + var kycKey = PrivateKey.generateED25519(); + var freezeKey = PrivateKey.generateED25519(); + var pauseKey = PrivateKey.generateED25519(); + var supplyKey = PrivateKey.generateED25519(); + var feeScheduleKey = PrivateKey.generateED25519(); + var metadataKey = PrivateKey.generateED25519(); + + // New Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys + var newWipeKey = PrivateKey.generateED25519(); + var newKycKey = PrivateKey.generateED25519(); + var newFreezeKey = PrivateKey.generateED25519(); + var newPauseKey = PrivateKey.generateED25519(); + var newSupplyKey = PrivateKey.generateED25519(); + var newFeeScheduleKey = PrivateKey.generateED25519(); + var newMetadataKey = PrivateKey.generateED25519(); + + // Create a non-fungible token + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("Test NFT") + .setTokenSymbol("TNFT") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setWipeKey(wipeKey.getPublicKey()) + .setKycKey(kycKey.getPublicKey()) + .setFreezeKey(freezeKey.getPublicKey()) + .setPauseKey(pauseKey.getPublicKey()) + .setSupplyKey(supplyKey.getPublicKey()) + .setFeeScheduleKey(feeScheduleKey.getPublicKey()) + .setMetadataKey(metadataKey.getPublicKey()) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var tokenInfoBeforeUpdate = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); + + // Update all of token’s lower-privilege keys to an unusable key (i.e., all-zeros key) + // (trying to remove keys one by one to check all errors), + // signing with an old respective lower-privilege key and new respective lower-privilege key, + // and setting the key verification mode to FULL_VALIDATION + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setWipeKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) + .freezeWith(testEnv.client) + .sign(wipeKey) + .sign(newWipeKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setKycKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) + .freezeWith(testEnv.client) + .sign(kycKey) + .sign(newKycKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setFreezeKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) + .freezeWith(testEnv.client) + .sign(freezeKey) + .sign(newFreezeKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setPauseKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) + .freezeWith(testEnv.client) + .sign(pauseKey) + .sign(newPauseKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setSupplyKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) + .freezeWith(testEnv.client) + .sign(supplyKey) + .sign(newSupplyKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setFeeScheduleKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) + .freezeWith(testEnv.client) + .sign(feeScheduleKey) + .sign(newFeeScheduleKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setMetadataKey(PublicKey.unusableKey()) + .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) + .freezeWith(testEnv.client) + .sign(metadataKey) + .sign(newMetadataKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + } } /** @@ -2237,137 +2255,139 @@ void cannotUpdateAllLowerPrivilegeKeysToUnusableKeyWhenSigningWithOldRespectiveL @Test @DisplayName("Cannot update all of token’s lower-privilege keys, when signing ONLY with an old respective lower-privilege key, and setting the key verification mode to FULL_VALIDATION") void cannotUpdateAllLowerPrivilegeKeysWhenSigningOnlyWithOldRespectiveLowerPrivilegeKeyWithKeyVerificationSetToFullValidation() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys - var wipeKey = PrivateKey.generateED25519(); - var kycKey = PrivateKey.generateED25519(); - var freezeKey = PrivateKey.generateED25519(); - var pauseKey = PrivateKey.generateED25519(); - var supplyKey = PrivateKey.generateED25519(); - var feeScheduleKey = PrivateKey.generateED25519(); - var metadataKey = PrivateKey.generateED25519(); - - // New Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys - var newWipeKey = PrivateKey.generateED25519(); - var newKycKey = PrivateKey.generateED25519(); - var newFreezeKey = PrivateKey.generateED25519(); - var newPauseKey = PrivateKey.generateED25519(); - var newSupplyKey = PrivateKey.generateED25519(); - var newFeeScheduleKey = PrivateKey.generateED25519(); - var newMetadataKey = PrivateKey.generateED25519(); - - // Create a non-fungible token - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("Test NFT") - .setTokenSymbol("TNFT") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setWipeKey(wipeKey.getPublicKey()) - .setKycKey(kycKey.getPublicKey()) - .setFreezeKey(freezeKey.getPublicKey()) - .setPauseKey(pauseKey.getPublicKey()) - .setSupplyKey(supplyKey.getPublicKey()) - .setFeeScheduleKey(feeScheduleKey.getPublicKey()) - .setMetadataKey(metadataKey.getPublicKey()) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var tokenInfoBeforeUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); - - // Update all of token’s lower-privilege keys - // (trying to update keys one by one to check all errors), - // signing ONLY with an old respective lower-privilege key, - // and setting the key verification mode to FULL_VALIDATION - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setWipeKey(newWipeKey) - .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) - .freezeWith(testEnv.client) - .sign(wipeKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setKycKey(newKycKey) - .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) - .freezeWith(testEnv.client) - .sign(kycKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setFreezeKey(newFreezeKey) - .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) - .freezeWith(testEnv.client) - .sign(freezeKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setPauseKey(newPauseKey) - .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) - .freezeWith(testEnv.client) - .sign(pauseKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setSupplyKey(newSupplyKey) - .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) - .freezeWith(testEnv.client) - .sign(supplyKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setFeeScheduleKey(newFeeScheduleKey) - .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) - .freezeWith(testEnv.client) - .sign(feeScheduleKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setMetadataKey(newMetadataKey) - .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) - .freezeWith(testEnv.client) - .sign(metadataKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + // Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys + var wipeKey = PrivateKey.generateED25519(); + var kycKey = PrivateKey.generateED25519(); + var freezeKey = PrivateKey.generateED25519(); + var pauseKey = PrivateKey.generateED25519(); + var supplyKey = PrivateKey.generateED25519(); + var feeScheduleKey = PrivateKey.generateED25519(); + var metadataKey = PrivateKey.generateED25519(); + + // New Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys + var newWipeKey = PrivateKey.generateED25519(); + var newKycKey = PrivateKey.generateED25519(); + var newFreezeKey = PrivateKey.generateED25519(); + var newPauseKey = PrivateKey.generateED25519(); + var newSupplyKey = PrivateKey.generateED25519(); + var newFeeScheduleKey = PrivateKey.generateED25519(); + var newMetadataKey = PrivateKey.generateED25519(); + + // Create a non-fungible token + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("Test NFT") + .setTokenSymbol("TNFT") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setWipeKey(wipeKey.getPublicKey()) + .setKycKey(kycKey.getPublicKey()) + .setFreezeKey(freezeKey.getPublicKey()) + .setPauseKey(pauseKey.getPublicKey()) + .setSupplyKey(supplyKey.getPublicKey()) + .setFeeScheduleKey(feeScheduleKey.getPublicKey()) + .setMetadataKey(metadataKey.getPublicKey()) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var tokenInfoBeforeUpdate = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); + + // Update all of token’s lower-privilege keys + // (trying to update keys one by one to check all errors), + // signing ONLY with an old respective lower-privilege key, + // and setting the key verification mode to FULL_VALIDATION + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setWipeKey(newWipeKey) + .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) + .freezeWith(testEnv.client) + .sign(wipeKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setKycKey(newKycKey) + .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) + .freezeWith(testEnv.client) + .sign(kycKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setFreezeKey(newFreezeKey) + .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) + .freezeWith(testEnv.client) + .sign(freezeKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setPauseKey(newPauseKey) + .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) + .freezeWith(testEnv.client) + .sign(pauseKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setSupplyKey(newSupplyKey) + .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) + .freezeWith(testEnv.client) + .sign(supplyKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setFeeScheduleKey(newFeeScheduleKey) + .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) + .freezeWith(testEnv.client) + .sign(feeScheduleKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setMetadataKey(newMetadataKey) + .setKeyVerificationMode(TokenKeyValidation.FULL_VALIDATION) + .freezeWith(testEnv.client) + .sign(metadataKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + } } /** @@ -2377,130 +2397,132 @@ void cannotUpdateAllLowerPrivilegeKeysWhenSigningOnlyWithOldRespectiveLowerPrivi @Test @DisplayName("Cannot update all of token’s lower-privilege keys when updating them to a keys with an invalid structure and signing with an old respective lower-privilege and setting key verification mode to NO_VALIDATION") void cannotUpdateAllLowerPrivilegeKeysWhenUpdatingKeysToStructurallyInvalidKeysSigningOnlyWithOldRespectiveLowerPrivilegeKeyWithKeyVerificationSetToNoValidation() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - // Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys - var wipeKey = PrivateKey.generateED25519(); - var kycKey = PrivateKey.generateED25519(); - var freezeKey = PrivateKey.generateED25519(); - var pauseKey = PrivateKey.generateED25519(); - var supplyKey = PrivateKey.generateED25519(); - var feeScheduleKey = PrivateKey.generateED25519(); - var metadataKey = PrivateKey.generateED25519(); - - // create a non-fungible token - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("Test NFT") - .setTokenSymbol("TNFT") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setWipeKey(wipeKey.getPublicKey()) - .setKycKey(kycKey.getPublicKey()) - .setFreezeKey(freezeKey.getPublicKey()) - .setPauseKey(pauseKey.getPublicKey()) - .setSupplyKey(supplyKey.getPublicKey()) - .setFeeScheduleKey(feeScheduleKey.getPublicKey()) - .setMetadataKey(metadataKey.getPublicKey()) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var tokenInfoBeforeUpdate = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); - assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); - - // This key is truly invalid, as all Ed25519 public keys must be 32 bytes long - var structurallyInvalidKey = PublicKey.fromString("000000000000000000000000000000000000000000000000000000000000000000"); - - // update all of token’s lower-privilege keys - // to a structurally invalid key (trying to update keys one by one to check all errors), - // signing with an old respective lower-privilege - // and setting key verification mode to NO_VALIDATION - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setWipeKey(structurallyInvalidKey) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .freezeWith(testEnv.client) - .sign(wipeKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_WIPE_KEY.toString()); - - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setKycKey(structurallyInvalidKey) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .freezeWith(testEnv.client) - .sign(kycKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_KYC_KEY.toString()); - - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setFreezeKey(structurallyInvalidKey) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .freezeWith(testEnv.client) - .sign(freezeKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_FREEZE_KEY.toString()); - - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setPauseKey(structurallyInvalidKey) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .freezeWith(testEnv.client) - .sign(pauseKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_PAUSE_KEY.toString()); - - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setSupplyKey(structurallyInvalidKey) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .freezeWith(testEnv.client) - .sign(supplyKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SUPPLY_KEY.toString()); - - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setFeeScheduleKey(structurallyInvalidKey) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .freezeWith(testEnv.client) - .sign(feeScheduleKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_CUSTOM_FEE_SCHEDULE_KEY.toString()); - - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenUpdateTransaction() - .setTokenId(tokenId) - .setMetadataKey(structurallyInvalidKey) - .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) - .freezeWith(testEnv.client) - .sign(metadataKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_METADATA_KEY.toString()); + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + // Wipe, KYC, Freeze, Pause, Supply, Fee Schedule, Metadata keys + var wipeKey = PrivateKey.generateED25519(); + var kycKey = PrivateKey.generateED25519(); + var freezeKey = PrivateKey.generateED25519(); + var pauseKey = PrivateKey.generateED25519(); + var supplyKey = PrivateKey.generateED25519(); + var feeScheduleKey = PrivateKey.generateED25519(); + var metadataKey = PrivateKey.generateED25519(); + + // create a non-fungible token + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("Test NFT") + .setTokenSymbol("TNFT") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setWipeKey(wipeKey.getPublicKey()) + .setKycKey(kycKey.getPublicKey()) + .setFreezeKey(freezeKey.getPublicKey()) + .setPauseKey(pauseKey.getPublicKey()) + .setSupplyKey(supplyKey.getPublicKey()) + .setFeeScheduleKey(feeScheduleKey.getPublicKey()) + .setMetadataKey(metadataKey.getPublicKey()) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var tokenInfoBeforeUpdate = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfoBeforeUpdate.wipeKey.toString()).isEqualTo(wipeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.kycKey.toString()).isEqualTo(kycKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.freezeKey.toString()).isEqualTo(freezeKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.pauseKey.toString()).isEqualTo(pauseKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.supplyKey.toString()).isEqualTo(supplyKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.feeScheduleKey.toString()).isEqualTo(feeScheduleKey.getPublicKey().toString()); + assertThat(tokenInfoBeforeUpdate.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); + + // This key is truly invalid, as all Ed25519 public keys must be 32 bytes long + var structurallyInvalidKey = PublicKey.fromString("000000000000000000000000000000000000000000000000000000000000000000"); + + // update all of token’s lower-privilege keys + // to a structurally invalid key (trying to update keys one by one to check all errors), + // signing with an old respective lower-privilege + // and setting key verification mode to NO_VALIDATION + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setWipeKey(structurallyInvalidKey) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .freezeWith(testEnv.client) + .sign(wipeKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_WIPE_KEY.toString()); + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setKycKey(structurallyInvalidKey) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .freezeWith(testEnv.client) + .sign(kycKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_KYC_KEY.toString()); + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setFreezeKey(structurallyInvalidKey) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .freezeWith(testEnv.client) + .sign(freezeKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_FREEZE_KEY.toString()); + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setPauseKey(structurallyInvalidKey) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .freezeWith(testEnv.client) + .sign(pauseKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_PAUSE_KEY.toString()); + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setSupplyKey(structurallyInvalidKey) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .freezeWith(testEnv.client) + .sign(supplyKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SUPPLY_KEY.toString()); + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setFeeScheduleKey(structurallyInvalidKey) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .freezeWith(testEnv.client) + .sign(feeScheduleKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_CUSTOM_FEE_SCHEDULE_KEY.toString()); + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenUpdateTransaction() + .setTokenId(tokenId) + .setMetadataKey(structurallyInvalidKey) + .setKeyVerificationMode(TokenKeyValidation.NO_VALIDATION) + .freezeWith(testEnv.client) + .sign(metadataKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_METADATA_KEY.toString()); + + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenUpdateNftsIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenUpdateNftsIntegrationTest.java index d162e8ae9..5b256e159 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenUpdateNftsIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenUpdateNftsIntegrationTest.java @@ -48,344 +48,344 @@ public class TokenUpdateNftsIntegrationTest { @Test @DisplayName("Can update the metadata of the entire NFT collection") void canUpdateNFTMetadataOfEntireCollection() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var metadataKey = PrivateKey.generateED25519(); - var nftCount = 4; - var initialMetadataList = NftMetadataGenerator.generate(new byte[]{4, 2, 0}, nftCount); - var updatedMetadata = new byte[]{6, 9}; - var updatedMetadataList = NftMetadataGenerator.generate(updatedMetadata, nftCount); - - // create a token with metadata key - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setMetadataKey(metadataKey) + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var metadataKey = PrivateKey.generateED25519(); + var nftCount = 4; + var initialMetadataList = NftMetadataGenerator.generate(new byte[]{4, 2, 0}, nftCount); + var updatedMetadata = new byte[]{6, 9}; + var updatedMetadataList = NftMetadataGenerator.generate(updatedMetadata, nftCount); + + // create a token with metadata key + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setMetadataKey(metadataKey) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + // mint tokens + var tokenMintTransactionReceipt = new TokenMintTransaction() + .setMetadata(initialMetadataList) + .setTokenId(tokenId) .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - // mint tokens - var tokenMintTransactionReceipt = new TokenMintTransaction() - .setMetadata(initialMetadataList) - .setTokenId(tokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // check that metadata was set correctly - var nftSerials = tokenMintTransactionReceipt.serials; - List metadataListAfterMint = getMetadataList(testEnv.client, tokenId, nftSerials); - - assertThat(metadataListAfterMint.toArray()).isEqualTo(initialMetadataList.toArray()); - - // update metadata all minted NFTs - new TokenUpdateNftsTransaction() - .setTokenId(tokenId) - .setSerials(nftSerials) - .setMetadata(updatedMetadata) - .freezeWith(testEnv.client) - .sign(metadataKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // check updated NFTs' metadata - List metadataListAfterUpdate = getMetadataList(testEnv.client, tokenId, nftSerials); - assertThat(metadataListAfterUpdate.toArray()).isEqualTo(updatedMetadataList.toArray()); - - testEnv.close(tokenId); + .getReceipt(testEnv.client); + + // check that metadata was set correctly + var nftSerials = tokenMintTransactionReceipt.serials; + List metadataListAfterMint = getMetadataList(testEnv.client, tokenId, nftSerials); + + assertThat(metadataListAfterMint.toArray()).isEqualTo(initialMetadataList.toArray()); + + // update metadata all minted NFTs + new TokenUpdateNftsTransaction() + .setTokenId(tokenId) + .setSerials(nftSerials) + .setMetadata(updatedMetadata) + .freezeWith(testEnv.client) + .sign(metadataKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + // check updated NFTs' metadata + List metadataListAfterUpdate = getMetadataList(testEnv.client, tokenId, nftSerials); + assertThat(metadataListAfterUpdate.toArray()).isEqualTo(updatedMetadataList.toArray()); + + } } @Test @DisplayName("Can update the metadata of a part of the NFT collection") void canUpdateNFTMetadataOfPartOfCollection() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var metadataKey = PrivateKey.generateED25519(); - var nftCount = 4; - var initialMetadataList = NftMetadataGenerator.generate(new byte[]{4, 2, 0}, nftCount); - var updatedMetadata = new byte[]{6, 9}; - var updatedMetadataList = NftMetadataGenerator.generate(updatedMetadata, nftCount / 2); - - // create a token with metadata key - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setMetadataKey(metadataKey) + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var metadataKey = PrivateKey.generateED25519(); + var nftCount = 4; + var initialMetadataList = NftMetadataGenerator.generate(new byte[]{4, 2, 0}, nftCount); + var updatedMetadata = new byte[]{6, 9}; + var updatedMetadataList = NftMetadataGenerator.generate(updatedMetadata, nftCount / 2); + + // create a token with metadata key + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setMetadataKey(metadataKey) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + // mint tokens + var tokenMintTransactionReceipt = new TokenMintTransaction() + .setMetadata(initialMetadataList) + .setTokenId(tokenId) .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - // mint tokens - var tokenMintTransactionReceipt = new TokenMintTransaction() - .setMetadata(initialMetadataList) - .setTokenId(tokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + .getReceipt(testEnv.client); - // check that metadata was set correctly - var nftSerials = tokenMintTransactionReceipt.serials; - List metadataListAfterMint = getMetadataList(testEnv.client, tokenId, nftSerials); + // check that metadata was set correctly + var nftSerials = tokenMintTransactionReceipt.serials; + List metadataListAfterMint = getMetadataList(testEnv.client, tokenId, nftSerials); - assertThat(metadataListAfterMint.toArray()).isEqualTo(initialMetadataList.toArray()); + assertThat(metadataListAfterMint.toArray()).isEqualTo(initialMetadataList.toArray()); - // update metadata of the first two minted NFTs - var nftSerialsToUpdate = nftSerials.subList(0, nftCount / 2); + // update metadata of the first two minted NFTs + var nftSerialsToUpdate = nftSerials.subList(0, nftCount / 2); - new TokenUpdateNftsTransaction() - .setTokenId(tokenId) - .setSerials(nftSerialsToUpdate) - .setMetadata(updatedMetadata) - .freezeWith(testEnv.client) - .sign(metadataKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TokenUpdateNftsTransaction() + .setTokenId(tokenId) + .setSerials(nftSerialsToUpdate) + .setMetadata(updatedMetadata) + .freezeWith(testEnv.client) + .sign(metadataKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); - // check updated NFTs' metadata - List metadataListAfterUpdate = getMetadataList(testEnv.client, tokenId, nftSerialsToUpdate); + // check updated NFTs' metadata + List metadataListAfterUpdate = getMetadataList(testEnv.client, tokenId, nftSerialsToUpdate); - assertThat(metadataListAfterUpdate.toArray()).isEqualTo(updatedMetadataList.toArray()); + assertThat(metadataListAfterUpdate.toArray()).isEqualTo(updatedMetadataList.toArray()); - // check that remaining NFTs were not updated - var nftSerialsSame = nftSerials.subList(nftCount / 2, nftCount); - List metadataList = getMetadataList(testEnv.client, tokenId, nftSerialsSame); + // check that remaining NFTs were not updated + var nftSerialsSame = nftSerials.subList(nftCount / 2, nftCount); + List metadataList = getMetadataList(testEnv.client, tokenId, nftSerialsSame); - assertThat(metadataList.toArray()).isEqualTo(initialMetadataList.subList(nftCount / 2, nftCount).toArray()); + assertThat(metadataList.toArray()).isEqualTo(initialMetadataList.subList(nftCount / 2, nftCount).toArray()); - testEnv.close(tokenId); + } } @Test @DisplayName("Cannot update NFTs metadata when it is not set") void cannotUpdateNFTMetadataWhenItsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var metadataKey = PrivateKey.generateED25519(); - var nftCount = 4; - var initialMetadataList = NftMetadataGenerator.generate(new byte[]{4, 2, 0}, nftCount); - - // create a token with metadata key - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setMetadataKey(metadataKey) + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var metadataKey = PrivateKey.generateED25519(); + var nftCount = 4; + var initialMetadataList = NftMetadataGenerator.generate(new byte[]{4, 2, 0}, nftCount); + + // create a token with metadata key + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setMetadataKey(metadataKey) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + // mint tokens + var tokenMintTransactionReceipt = new TokenMintTransaction() + .setMetadata(initialMetadataList) + .setTokenId(tokenId) .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - // mint tokens - var tokenMintTransactionReceipt = new TokenMintTransaction() - .setMetadata(initialMetadataList) - .setTokenId(tokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // check that metadata was set correctly - var nftSerials = tokenMintTransactionReceipt.serials; - List metadataListAfterMint = getMetadataList(testEnv.client, tokenId, nftSerials); - - assertThat(metadataListAfterMint.toArray()).isEqualTo(initialMetadataList.toArray()); - - // run `TokenUpdateNftsTransaction` without `setMetadata` - new TokenUpdateNftsTransaction() - .setTokenId(tokenId) - .setSerials(nftSerials) - .freezeWith(testEnv.client) - .sign(metadataKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // check that NFTs' metadata was not updated - List metadataListAfterUpdate = getMetadataList(testEnv.client, tokenId, nftSerials); - assertThat(metadataListAfterUpdate.toArray()).isEqualTo(initialMetadataList.toArray()); - - testEnv.close(tokenId); - } + .getReceipt(testEnv.client); - @Test - @DisplayName("Can erase NFTs metadata") - void canEraseNFTsMetadata() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var metadataKey = PrivateKey.generateED25519(); - var nftCount = 4; - var initialMetadataList = NftMetadataGenerator.generate(new byte[]{4, 2, 0}, nftCount); - var emptyMetadata = new byte[]{}; - var emptyMetadataList = NftMetadataGenerator.generate(emptyMetadata, nftCount); - - // create a token with metadata key - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setMetadataKey(metadataKey) + // check that metadata was set correctly + var nftSerials = tokenMintTransactionReceipt.serials; + List metadataListAfterMint = getMetadataList(testEnv.client, tokenId, nftSerials); + + assertThat(metadataListAfterMint.toArray()).isEqualTo(initialMetadataList.toArray()); + + // run `TokenUpdateNftsTransaction` without `setMetadata` + new TokenUpdateNftsTransaction() + .setTokenId(tokenId) + .setSerials(nftSerials) + .freezeWith(testEnv.client) + .sign(metadataKey) .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - // mint tokens - var tokenMintTransactionReceipt = new TokenMintTransaction() - .setMetadata(initialMetadataList) - .setTokenId(tokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // check that metadata was set correctly - var nftSerials = tokenMintTransactionReceipt.serials; - List metadataListAfterMint = getMetadataList(testEnv.client, tokenId, nftSerials); - - assertThat(metadataListAfterMint.toArray()).isEqualTo(initialMetadataList.toArray()); - - // erase metadata all minted NFTs (update to an empty byte array) - new TokenUpdateNftsTransaction() - .setTokenId(tokenId) - .setSerials(nftSerials) - .setMetadata(emptyMetadata) - .freezeWith(testEnv.client) - .sign(metadataKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - // check that NFTs' metadata was erased - List metadataListAfterUpdate = getMetadataList(testEnv.client, tokenId, nftSerials); - assertThat(metadataListAfterUpdate.toArray()).isEqualTo(emptyMetadataList.toArray()); - - testEnv.close(tokenId); + .getReceipt(testEnv.client); + + // check that NFTs' metadata was not updated + List metadataListAfterUpdate = getMetadataList(testEnv.client, tokenId, nftSerials); + assertThat(metadataListAfterUpdate.toArray()).isEqualTo(initialMetadataList.toArray()); + + } } @Test - @DisplayName("Cannot update NFT metadata when transaction is not signed with metadata key") - void cannotUpdateNFTMetadataWhenTransactionIsNotSignedWithMetadataKey() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var supplyKey = PrivateKey.generateED25519(); - var metadataKey = PrivateKey.generateED25519(); - var nftCount = 4; - var initialMetadataList = NftMetadataGenerator.generate(new byte[]{4, 2, 0}, nftCount); - var updatedMetadata = new byte[]{6, 9}; - - // create a token with a metadata key and check it - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setSupplyKey(supplyKey) - .setMetadataKey(metadataKey) + @DisplayName("Can erase NFTs metadata") + void canEraseNFTsMetadata() throws Exception { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var metadataKey = PrivateKey.generateED25519(); + var nftCount = 4; + var initialMetadataList = NftMetadataGenerator.generate(new byte[]{4, 2, 0}, nftCount); + var emptyMetadata = new byte[]{}; + var emptyMetadataList = NftMetadataGenerator.generate(emptyMetadata, nftCount); + + // create a token with metadata key + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setMetadataKey(metadataKey) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + // mint tokens + var tokenMintTransactionReceipt = new TokenMintTransaction() + .setMetadata(initialMetadataList) + .setTokenId(tokenId) .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var tokenInfo = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); - - assertThat(tokenInfo.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); + .getReceipt(testEnv.client); - // mint tokens - var tokenMintTransactionReceipt = new TokenMintTransaction() - .setMetadata(initialMetadataList) - .setTokenId(tokenId) - .freezeWith(testEnv.client) - .sign(supplyKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); + // check that metadata was set correctly + var nftSerials = tokenMintTransactionReceipt.serials; + List metadataListAfterMint = getMetadataList(testEnv.client, tokenId, nftSerials); - var nftSerials = tokenMintTransactionReceipt.serials; + assertThat(metadataListAfterMint.toArray()).isEqualTo(initialMetadataList.toArray()); - // update nfts without signing - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + // erase metadata all minted NFTs (update to an empty byte array) new TokenUpdateNftsTransaction() .setTokenId(tokenId) .setSerials(nftSerials) - .setMetadata(updatedMetadata) + .setMetadata(emptyMetadata) + .freezeWith(testEnv.client) + .sign(metadataKey) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - testEnv.close(tokenId); + // check that NFTs' metadata was erased + List metadataListAfterUpdate = getMetadataList(testEnv.client, tokenId, nftSerials); + assertThat(metadataListAfterUpdate.toArray()).isEqualTo(emptyMetadataList.toArray()); + + } } @Test - @DisplayName("Cannot update NFT metadata when metadata key is not set") - void cannotUpdateNFTMetadataWhenMetadataKeyNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var supplyKey = PrivateKey.generateED25519(); - var metadataKey = PrivateKey.generateED25519(); - var nftCount = 4; - var initialMetadataList = NftMetadataGenerator.generate(new byte[]{4, 2, 0}, nftCount); - var updatedMetadata = new byte[]{6, 9}; - - // create a token without a metadata key and check it - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setSupplyKey(supplyKey) + @DisplayName("Cannot update NFT metadata when transaction is not signed with metadata key") + void cannotUpdateNFTMetadataWhenTransactionIsNotSignedWithMetadataKey() throws Exception { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var supplyKey = PrivateKey.generateED25519(); + var metadataKey = PrivateKey.generateED25519(); + var nftCount = 4; + var initialMetadataList = NftMetadataGenerator.generate(new byte[]{4, 2, 0}, nftCount); + var updatedMetadata = new byte[]{6, 9}; + + // create a token with a metadata key and check it + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setSupplyKey(supplyKey) + .setMetadataKey(metadataKey) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var tokenInfo = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); + + assertThat(tokenInfo.metadataKey.toString()).isEqualTo(metadataKey.getPublicKey().toString()); + + // mint tokens + var tokenMintTransactionReceipt = new TokenMintTransaction() + .setMetadata(initialMetadataList) + .setTokenId(tokenId) + .freezeWith(testEnv.client) + .sign(supplyKey) .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); + .getReceipt(testEnv.client); + + var nftSerials = tokenMintTransactionReceipt.serials; - var tokenInfo = new TokenInfoQuery() - .setTokenId(tokenId) - .execute(testEnv.client); + // update nfts without signing + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateNftsTransaction() + .setTokenId(tokenId) + .setSerials(nftSerials) + .setMetadata(updatedMetadata) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - assertThat(tokenInfo.metadataKey).isNull(); + } + } - // mint tokens - var tokenMintTransactionReceipt = new TokenMintTransaction() - .setMetadata(initialMetadataList) - .setTokenId(tokenId) - .freezeWith(testEnv.client) - .sign(supplyKey) - .execute(testEnv.client) - .getReceipt(testEnv.client); + @Test + @DisplayName("Cannot update NFT metadata when metadata key is not set") + void cannotUpdateNFTMetadataWhenMetadataKeyNotSet() throws Exception { + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var supplyKey = PrivateKey.generateED25519(); + var metadataKey = PrivateKey.generateED25519(); + var nftCount = 4; + var initialMetadataList = NftMetadataGenerator.generate(new byte[]{4, 2, 0}, nftCount); + var updatedMetadata = new byte[]{6, 9}; + + // create a token without a metadata key and check it + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setSupplyKey(supplyKey) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var tokenInfo = new TokenInfoQuery() + .setTokenId(tokenId) + .execute(testEnv.client); - var nftSerials = tokenMintTransactionReceipt.serials; + assertThat(tokenInfo.metadataKey).isNull(); - // check NFTs' metadata can't be updated when a metadata key is not set - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenUpdateNftsTransaction() + // mint tokens + var tokenMintTransactionReceipt = new TokenMintTransaction() + .setMetadata(initialMetadataList) .setTokenId(tokenId) - .setSerials(nftSerials) - .setMetadata(updatedMetadata) .freezeWith(testEnv.client) - .sign(metadataKey) + .sign(supplyKey) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); - testEnv.close(tokenId); + var nftSerials = tokenMintTransactionReceipt.serials; + + // check NFTs' metadata can't be updated when a metadata key is not set + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenUpdateNftsTransaction() + .setTokenId(tokenId) + .setSerials(nftSerials) + .setMetadata(updatedMetadata) + .freezeWith(testEnv.client) + .sign(metadataKey) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_SIGNATURE.toString()); + + } } /** diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenWipeIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenWipeIntegrationTest.java index 3f7483e21..2eeb3d1c4 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenWipeIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TokenWipeIntegrationTest.java @@ -45,388 +45,388 @@ class TokenWipeIntegrationTest { @Test @DisplayName("Can wipe accounts balance") void canWipeAccountsBalance() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var key = PrivateKey.generateED25519(); - - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); - - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) + try (var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var key = PrivateKey.generateED25519(); + + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); + + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + new TokenAssociateTransaction() + .setAccountId(accountId) + .setTokenIds(Collections.singletonList(tokenId)) + .freezeWith(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenGrantKycTransaction() + .setAccountId(accountId) + .setTokenId(tokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TransferTransaction() + .addTokenTransfer(tokenId, testEnv.operatorId, -10) + .addTokenTransfer(tokenId, accountId, 10) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenWipeTransaction() + .setTokenId(tokenId) + .setAccountId(accountId) + .setAmount(10) .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - new TokenAssociateTransaction() - .setAccountId(accountId) - .setTokenIds(Collections.singletonList(tokenId)) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenGrantKycTransaction() - .setAccountId(accountId) - .setTokenId(tokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TransferTransaction() - .addTokenTransfer(tokenId, testEnv.operatorId, -10) - .addTokenTransfer(tokenId, accountId, 10) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenWipeTransaction() - .setTokenId(tokenId) - .setAccountId(accountId) - .setAmount(10) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(tokenId, accountId, key); + .getReceipt(testEnv.client); + + } } @Test @DisplayName("Can wipe accounts NFTs") void canWipeAccountsNfts() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var key = PrivateKey.generateED25519(); - - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); - - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var key = PrivateKey.generateED25519(); + + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); + + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var mintReceipt = new TokenMintTransaction() + .setTokenId(tokenId) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var mintReceipt = new TokenMintTransaction() - .setTokenId(tokenId) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenAssociateTransaction() - .setAccountId(accountId) - .setTokenIds(Collections.singletonList(tokenId)) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenGrantKycTransaction() - .setAccountId(accountId) - .setTokenId(tokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var serialsToTransfer = mintReceipt.serials.subList(0, 4); - var transfer = new TransferTransaction(); - for (var serial : serialsToTransfer) { - transfer.addNftTransfer(tokenId.nft(serial), testEnv.operatorId, accountId); - } - transfer.execute(testEnv.client).getReceipt(testEnv.client); + .getReceipt(testEnv.client); - new TokenWipeTransaction() - .setTokenId(tokenId) - .setAccountId(accountId) - .setSerials(serialsToTransfer) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TokenAssociateTransaction() + .setAccountId(accountId) + .setTokenIds(Collections.singletonList(tokenId)) + .freezeWith(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenGrantKycTransaction() + .setAccountId(accountId) + .setTokenId(tokenId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(tokenId, accountId, key); + var serialsToTransfer = mintReceipt.serials.subList(0, 4); + var transfer = new TransferTransaction(); + for (var serial : serialsToTransfer) { + transfer.addNftTransfer(tokenId.nft(serial), testEnv.operatorId, accountId); + } + transfer.execute(testEnv.client).getReceipt(testEnv.client); + + new TokenWipeTransaction() + .setTokenId(tokenId) + .setAccountId(accountId) + .setSerials(serialsToTransfer) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + } } @Test @DisplayName("Cannot wipe accounts NFTs if the account doesn't own them") void cannotWipeAccountsNftsIfNotOwned() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var key = PrivateKey.generateED25519(); - - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); - - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) - .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - var mintReceipt = new TokenMintTransaction() - .setTokenId(tokenId) - .setMetadata(NftMetadataGenerator.generate((byte) 10)) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenAssociateTransaction() - .setAccountId(accountId) - .setTokenIds(Collections.singletonList(tokenId)) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenGrantKycTransaction() - .setAccountId(accountId) - .setTokenId(tokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - var serialsToTransfer = mintReceipt.serials.subList(0, 4); - // don't transfer them - - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TokenWipeTransaction() + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var key = PrivateKey.generateED25519(); + + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); + + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setTokenType(TokenType.NON_FUNGIBLE_UNIQUE) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + var mintReceipt = new TokenMintTransaction() .setTokenId(tokenId) + .setMetadata(NftMetadataGenerator.generate((byte) 10)) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenAssociateTransaction() .setAccountId(accountId) - .setSerials(serialsToTransfer) + .setTokenIds(Collections.singletonList(tokenId)) + .freezeWith(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenGrantKycTransaction() + .setAccountId(accountId) + .setTokenId(tokenId) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.ACCOUNT_DOES_NOT_OWN_WIPED_NFT.toString()); - testEnv.close(tokenId, accountId, key); + var serialsToTransfer = mintReceipt.serials.subList(0, 4); + // don't transfer them + + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TokenWipeTransaction() + .setTokenId(tokenId) + .setAccountId(accountId) + .setSerials(serialsToTransfer) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.ACCOUNT_DOES_NOT_OWN_WIPED_NFT.toString()); + + } } @Test @DisplayName("Cannot wipe accounts balance when account ID is not set") void cannotWipeAccountsBalanceWhenAccountIDIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var key = PrivateKey.generateED25519(); - - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); - - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var key = PrivateKey.generateED25519(); + + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); + + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + new TokenAssociateTransaction() + .setAccountId(accountId) + .setTokenIds(Collections.singletonList(tokenId)) + .freezeWith(testEnv.client) + .sign(key) .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - new TokenAssociateTransaction() - .setAccountId(accountId) - .setTokenIds(Collections.singletonList(tokenId)) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenGrantKycTransaction() - .setAccountId(accountId) - .setTokenId(tokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TransferTransaction() - .addTokenTransfer(tokenId, testEnv.operatorId, -10) - .addTokenTransfer(tokenId, accountId, 10) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenWipeTransaction() + .getReceipt(testEnv.client); + + new TokenGrantKycTransaction() + .setAccountId(accountId) .setTokenId(tokenId) - .setAmount(10) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_ACCOUNT_ID.toString()); - testEnv.close(tokenId, accountId, key); + new TransferTransaction() + .addTokenTransfer(tokenId, testEnv.operatorId, -10) + .addTokenTransfer(tokenId, accountId, 10) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenWipeTransaction() + .setTokenId(tokenId) + .setAmount(10) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_ACCOUNT_ID.toString()); + + } } @Test @DisplayName("Cannot wipe accounts balance when token ID is not set") void cannotWipeAccountsBalanceWhenTokenIDIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var key = PrivateKey.generateED25519(); - - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); - - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var key = PrivateKey.generateED25519(); + + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); + + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + new TokenAssociateTransaction() + .setAccountId(accountId) + .setTokenIds(Collections.singletonList(tokenId)) + .freezeWith(testEnv.client) + .sign(key) .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - new TokenAssociateTransaction() - .setAccountId(accountId) - .setTokenIds(Collections.singletonList(tokenId)) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenGrantKycTransaction() - .setAccountId(accountId) - .setTokenId(tokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TransferTransaction() - .addTokenTransfer(tokenId, testEnv.operatorId, -10) - .addTokenTransfer(tokenId, accountId, 10) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TokenWipeTransaction() + .getReceipt(testEnv.client); + + new TokenGrantKycTransaction() .setAccountId(accountId) - .setAmount(10) + .setTokenId(tokenId) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_TOKEN_ID.toString()); - testEnv.close(tokenId, accountId, key); + new TransferTransaction() + .addTokenTransfer(tokenId, testEnv.operatorId, -10) + .addTokenTransfer(tokenId, accountId, 10) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TokenWipeTransaction() + .setAccountId(accountId) + .setAmount(10) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_TOKEN_ID.toString()); + + } } @Test @DisplayName("Can wipe accounts balance when amount is not set") void canWipeAccountsBalanceWhenAmountIsNotSet() throws Exception { - var testEnv = new IntegrationTestEnv(1).useThrowawayAccount(); - - var key = PrivateKey.generateED25519(); - - var response = new AccountCreateTransaction() - .setKey(key) - .setInitialBalance(new Hbar(1)) - .execute(testEnv.client); - - var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); - - var tokenId = Objects.requireNonNull( - new TokenCreateTransaction() - .setTokenName("ffff") - .setTokenSymbol("F") - .setDecimals(3) - .setInitialSupply(1000000) - .setTreasuryAccountId(testEnv.operatorId) - .setAdminKey(testEnv.operatorKey) - .setFreezeKey(testEnv.operatorKey) - .setWipeKey(testEnv.operatorKey) - .setKycKey(testEnv.operatorKey) - .setSupplyKey(testEnv.operatorKey) - .setFreezeDefault(false) + try(var testEnv = new IntegrationTestEnv(1).useThrowawayAccount()){ + + var key = PrivateKey.generateED25519(); + + var response = new AccountCreateTransaction() + .setKey(key) + .setInitialBalance(new Hbar(1)) + .execute(testEnv.client); + + var accountId = Objects.requireNonNull(response.getReceipt(testEnv.client).accountId); + + var tokenId = Objects.requireNonNull( + new TokenCreateTransaction() + .setTokenName("ffff") + .setTokenSymbol("F") + .setDecimals(3) + .setInitialSupply(1000000) + .setTreasuryAccountId(testEnv.operatorId) + .setAdminKey(testEnv.operatorKey) + .setFreezeKey(testEnv.operatorKey) + .setWipeKey(testEnv.operatorKey) + .setKycKey(testEnv.operatorKey) + .setSupplyKey(testEnv.operatorKey) + .setFreezeDefault(false) + .execute(testEnv.client) + .getReceipt(testEnv.client) + .tokenId + ); + + new TokenAssociateTransaction() + .setAccountId(accountId) + .setTokenIds(Collections.singletonList(tokenId)) + .freezeWith(testEnv.client) + .sign(key) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + new TokenGrantKycTransaction() + .setAccountId(accountId) + .setTokenId(tokenId) .execute(testEnv.client) - .getReceipt(testEnv.client) - .tokenId - ); - - new TokenAssociateTransaction() - .setAccountId(accountId) - .setTokenIds(Collections.singletonList(tokenId)) - .freezeWith(testEnv.client) - .sign(key) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TokenGrantKycTransaction() - .setAccountId(accountId) - .setTokenId(tokenId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - new TransferTransaction() - .addTokenTransfer(tokenId, testEnv.operatorId, -10) - .addTokenTransfer(tokenId, accountId, 10) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - - var receipt = new TokenWipeTransaction() - .setTokenId(tokenId) - .setAccountId(accountId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - assertThat(receipt.status).isEqualTo(Status.SUCCESS); - - testEnv.close(tokenId, accountId, key); + .getReceipt(testEnv.client); + + new TransferTransaction() + .addTokenTransfer(tokenId, testEnv.operatorId, -10) + .addTokenTransfer(tokenId, accountId, 10) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + + var receipt = new TokenWipeTransaction() + .setTokenId(tokenId) + .setAccountId(accountId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + + assertThat(receipt.status).isEqualTo(Status.SUCCESS); + + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TopicCreateIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TopicCreateIntegrationTest.java index 9292ebb1e..375f7ee13 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TopicCreateIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TopicCreateIntegrationTest.java @@ -32,32 +32,32 @@ public class TopicCreateIntegrationTest { @Test @DisplayName("Can create topic") void canCreateTopic() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var response = new TopicCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setTopicMemo("[e2e::TopicCreateTransaction]") - .execute(testEnv.client); + var response = new TopicCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setTopicMemo("[e2e::TopicCreateTransaction]") + .execute(testEnv.client); - var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); + var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); - new TopicDeleteTransaction() - .setTopicId(topicId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TopicDeleteTransaction() + .setTopicId(topicId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } @Test @DisplayName("Can create topic with no field set") void canCreateTopicWithNoFieldsSet() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var response = new TopicCreateTransaction() - .execute(testEnv.client); - assertThat(response.getReceipt(testEnv.client).topicId).isNotNull(); + var response = new TopicCreateTransaction() + .execute(testEnv.client); + assertThat(response.getReceipt(testEnv.client).topicId).isNotNull(); - testEnv.close(); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TopicDeleteIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TopicDeleteIntegrationTest.java index b93155547..6a33a35b1 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TopicDeleteIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TopicDeleteIntegrationTest.java @@ -34,40 +34,40 @@ public class TopicDeleteIntegrationTest { @Test @DisplayName("Can delete topic") void canDeleteTopic() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var response = new TopicCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setTopicMemo("[e2e::TopicCreateTransaction]") - .execute(testEnv.client); + var response = new TopicCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setTopicMemo("[e2e::TopicCreateTransaction]") + .execute(testEnv.client); - var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); + var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); - new TopicDeleteTransaction() - .setTopicId(topicId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TopicDeleteTransaction() + .setTopicId(topicId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } @Test @DisplayName("Cannot delete immutable topic") void cannotDeleteImmutableTopic() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var response = new TopicCreateTransaction() - .execute(testEnv.client); + var response = new TopicCreateTransaction() + .execute(testEnv.client); - var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); + var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); - assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { - new TopicDeleteTransaction() - .setTopicId(topicId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.UNAUTHORIZED.toString()); + assertThatExceptionOfType(ReceiptStatusException.class).isThrownBy(() -> { + new TopicDeleteTransaction() + .setTopicId(topicId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.UNAUTHORIZED.toString()); - testEnv.close(); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TopicInfoIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TopicInfoIntegrationTest.java index a7bfa76a5..014f40399 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TopicInfoIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TopicInfoIntegrationTest.java @@ -38,150 +38,149 @@ public class TopicInfoIntegrationTest { @Test @DisplayName("Can query topic info") void canQueryTopicInfo() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var response = new TopicCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setTopicMemo("[e2e::TopicCreateTransaction]") - .execute(testEnv.client); + var response = new TopicCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setTopicMemo("[e2e::TopicCreateTransaction]") + .execute(testEnv.client); - var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); + var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); - var info = new TopicInfoQuery() - .setTopicId(topicId) - .execute(testEnv.client); + var info = new TopicInfoQuery() + .setTopicId(topicId) + .execute(testEnv.client); - assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); + assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); - new TopicDeleteTransaction() - .setTopicId(topicId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TopicDeleteTransaction() + .setTopicId(topicId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } @Test @DisplayName("Can get cost for topic info query") void getCostQueryTopicInfo() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var response = new TopicCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setTopicMemo("[e2e::TopicCreateTransaction]") - .execute(testEnv.client); + var response = new TopicCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setTopicMemo("[e2e::TopicCreateTransaction]") + .execute(testEnv.client); - var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); + var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); - var infoQuery = new TopicInfoQuery() - .setTopicId(topicId); + var infoQuery = new TopicInfoQuery() + .setTopicId(topicId); - var cost = infoQuery.getCost(testEnv.client); + var cost = infoQuery.getCost(testEnv.client); - assertThat(cost).isNotNull(); + assertThat(cost).isNotNull(); - var info = infoQuery.execute(testEnv.client); + var info = infoQuery.execute(testEnv.client); - assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); + assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); - new TopicDeleteTransaction() - .setTopicId(topicId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TopicDeleteTransaction() + .setTopicId(topicId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } @Test @DisplayName("Can get cost for topic info query") void getCostBigMaxQueryTopicInfo() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var response = new TopicCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setTopicMemo("[e2e::TopicCreateTransaction]") - .execute(testEnv.client); + var response = new TopicCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setTopicMemo("[e2e::TopicCreateTransaction]") + .execute(testEnv.client); - var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); + var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); - var infoQuery = new TopicInfoQuery() - .setTopicId(topicId) - .setMaxQueryPayment(new Hbar(1000)); + var infoQuery = new TopicInfoQuery() + .setTopicId(topicId) + .setMaxQueryPayment(new Hbar(1000)); - var cost = infoQuery.getCost(testEnv.client); + var cost = infoQuery.getCost(testEnv.client); - assertThat(cost).isNotNull(); + assertThat(cost).isNotNull(); - var info = infoQuery.execute(testEnv.client); + var info = infoQuery.execute(testEnv.client); - assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); + assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); - new TopicDeleteTransaction() - .setTopicId(topicId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TopicDeleteTransaction() + .setTopicId(topicId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } @Test @DisplayName("Can get cost for topic info query") void getCostSmallMaxQueryTopicInfo() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var response = new TopicCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setTopicMemo("[e2e::TopicCreateTransaction]") - .execute(testEnv.client); + var response = new TopicCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setTopicMemo("[e2e::TopicCreateTransaction]") + .execute(testEnv.client); - var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); + var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); - var infoQuery = new TopicInfoQuery() - .setTopicId(topicId) - .setMaxQueryPayment(Hbar.fromTinybars(1)); + var infoQuery = new TopicInfoQuery() + .setTopicId(topicId) + .setMaxQueryPayment(Hbar.fromTinybars(1)); - assertThatExceptionOfType(MaxQueryPaymentExceededException.class).isThrownBy(() -> { - infoQuery.execute(testEnv.client); - }); + assertThatExceptionOfType(MaxQueryPaymentExceededException.class).isThrownBy(() -> { + infoQuery.execute(testEnv.client); + }); - new TopicDeleteTransaction() - .setTopicId(topicId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TopicDeleteTransaction() + .setTopicId(topicId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } @Test @DisplayName("Can get cost for topic info query") void getCostInsufficientTxFeeQueryTopicInfo() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var response = new TopicCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setTopicMemo("[e2e::TopicCreateTransaction]") - .execute(testEnv.client); + var response = new TopicCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setTopicMemo("[e2e::TopicCreateTransaction]") + .execute(testEnv.client); - var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); + var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); - var infoQuery = new TopicInfoQuery() - .setTopicId(topicId); + var infoQuery = new TopicInfoQuery() + .setTopicId(topicId); - var cost = infoQuery.getCost(testEnv.client); + var cost = infoQuery.getCost(testEnv.client); - assertThat(cost).isNotNull(); + assertThat(cost).isNotNull(); - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - infoQuery.setQueryPayment(Hbar.fromTinybars(1)).execute(testEnv.client); - }).satisfies(error -> assertThat(error.status.toString()).isEqualTo("INSUFFICIENT_TX_FEE")); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + infoQuery.setQueryPayment(Hbar.fromTinybars(1)).execute(testEnv.client); + }).satisfies(error -> assertThat(error.status.toString()).isEqualTo("INSUFFICIENT_TX_FEE")); - new TopicDeleteTransaction() - .setTopicId(topicId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TopicDeleteTransaction() + .setTopicId(topicId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } - } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TopicMessageIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TopicMessageIntegrationTest.java index a318ac407..a8369b4ed 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TopicMessageIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TopicMessageIntegrationTest.java @@ -34,116 +34,116 @@ public class TopicMessageIntegrationTest { @Test @DisplayName("Can receive a topic message") void canReceiveATopicMessage() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var response = new TopicCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setTopicMemo("[e2e::TopicCreateTransaction]") - .execute(testEnv.client); + var response = new TopicCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setTopicMemo("[e2e::TopicCreateTransaction]") + .execute(testEnv.client); - var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); + var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); - var info = new TopicInfoQuery() - .setTopicId(topicId) - .execute(testEnv.client); + var info = new TopicInfoQuery() + .setTopicId(topicId) + .execute(testEnv.client); - assertThat(info.topicId).isEqualTo(topicId); - assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); - assertThat(info.sequenceNumber).isEqualTo(0); - assertThat(info.adminKey).isEqualTo(testEnv.operatorKey); + assertThat(info.topicId).isEqualTo(topicId); + assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); + assertThat(info.sequenceNumber).isEqualTo(0); + assertThat(info.adminKey).isEqualTo(testEnv.operatorKey); - Thread.sleep(3000); + Thread.sleep(3000); - var receivedMessage = new boolean[]{false}; - var start = Instant.now(); + var receivedMessage = new boolean[]{false}; + var start = Instant.now(); - var handle = new TopicMessageQuery() - .setTopicId(topicId) - .setStartTime(Instant.EPOCH) - .subscribe(testEnv.client, (message) -> { - receivedMessage[0] = new String(message.contents, StandardCharsets.UTF_8).equals("Hello, from HCS!"); - }); + var handle = new TopicMessageQuery() + .setTopicId(topicId) + .setStartTime(Instant.EPOCH) + .subscribe(testEnv.client, (message) -> { + receivedMessage[0] = new String(message.contents, StandardCharsets.UTF_8).equals("Hello, from HCS!"); + }); - Thread.sleep(3000); + Thread.sleep(3000); - new TopicMessageSubmitTransaction() - .setTopicId(topicId) - .setMessage("Hello, from HCS!") - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TopicMessageSubmitTransaction() + .setTopicId(topicId) + .setMessage("Hello, from HCS!") + .execute(testEnv.client) + .getReceipt(testEnv.client); - while (!receivedMessage[0]) { - if (Duration.between(start, Instant.now()).compareTo(Duration.ofSeconds(60)) > 0) { - throw new Exception("TopicMessage was not received in 60 seconds or less"); - } + while (!receivedMessage[0]) { + if (Duration.between(start, Instant.now()).compareTo(Duration.ofSeconds(60)) > 0) { + throw new Exception("TopicMessage was not received in 60 seconds or less"); + } - Thread.sleep(2000); - } + Thread.sleep(2000); + } - new TopicDeleteTransaction() - .setTopicId(topicId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TopicDeleteTransaction() + .setTopicId(topicId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } @Test @DisplayName("Can receive a large topic message") void canReceiveALargeTopicMessage() throws Exception { - var testEnv = new IntegrationTestEnv(2); + try (var testEnv = new IntegrationTestEnv(1)) { - // Skip if using local node. - // Note: this check should be removed once the local node is supporting multiple nodes. - testEnv.assumeNotLocalNode(); + // Skip if using local node. + // Note: this check should be removed once the local node is supporting multiple nodes. + testEnv.assumeNotLocalNode(); - var response = new TopicCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setTopicMemo("[e2e::TopicCreateTransaction]") - .execute(testEnv.client); + var response = new TopicCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setTopicMemo("[e2e::TopicCreateTransaction]") + .execute(testEnv.client); - var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); + var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); - Thread.sleep(5000); + Thread.sleep(5000); - var info = new TopicInfoQuery() - .setTopicId(topicId) - .execute(testEnv.client); + var info = new TopicInfoQuery() + .setTopicId(topicId) + .execute(testEnv.client); - assertThat(info.topicId).isEqualTo(topicId); - assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); - assertThat(info.sequenceNumber).isEqualTo(0); - assertThat(info.adminKey).isEqualTo(testEnv.operatorKey); + assertThat(info.topicId).isEqualTo(topicId); + assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); + assertThat(info.sequenceNumber).isEqualTo(0); + assertThat(info.adminKey).isEqualTo(testEnv.operatorKey); - var receivedMessage = new boolean[]{false}; - var start = Instant.now(); + var receivedMessage = new boolean[]{false}; + var start = Instant.now(); - var handle = new TopicMessageQuery() - .setTopicId(topicId) - .setStartTime(Instant.EPOCH) - .subscribe(testEnv.client, (message) -> { - receivedMessage[0] = new String(message.contents, StandardCharsets.UTF_8).equals(Contents.BIG_CONTENTS); - }); + var handle = new TopicMessageQuery() + .setTopicId(topicId) + .setStartTime(Instant.EPOCH) + .subscribe(testEnv.client, (message) -> { + receivedMessage[0] = new String(message.contents, StandardCharsets.UTF_8).equals(Contents.BIG_CONTENTS); + }); - new TopicMessageSubmitTransaction() - .setTopicId(topicId) - .setMessage(Contents.BIG_CONTENTS) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TopicMessageSubmitTransaction() + .setTopicId(topicId) + .setMessage(Contents.BIG_CONTENTS) + .execute(testEnv.client) + .getReceipt(testEnv.client); - while (!receivedMessage[0]) { - if (Duration.between(start, Instant.now()).compareTo(Duration.ofSeconds(60)) > 0) { - throw new Exception("TopicMessage was not received in 60 seconds or less"); - } + while (!receivedMessage[0]) { + if (Duration.between(start, Instant.now()).compareTo(Duration.ofSeconds(60)) > 0) { + throw new Exception("TopicMessage was not received in 60 seconds or less"); + } - Thread.sleep(1000); - } + Thread.sleep(1000); + } - new TopicDeleteTransaction() - .setTopicId(topicId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TopicDeleteTransaction() + .setTopicId(topicId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TopicMessageSubmitIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TopicMessageSubmitIntegrationTest.java index 9f0e78835..d646e61cd 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TopicMessageSubmitIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TopicMessageSubmitIntegrationTest.java @@ -43,45 +43,45 @@ public class TopicMessageSubmitIntegrationTest { @Test @DisplayName("Can submit a topic message") void canSubmitATopicMessage() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var response = new TopicCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setTopicMemo("[e2e::TopicCreateTransaction]") - .execute(testEnv.client); + var response = new TopicCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setTopicMemo("[e2e::TopicCreateTransaction]") + .execute(testEnv.client); - var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); + var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); - @Var var info = new TopicInfoQuery() - .setTopicId(topicId) - .execute(testEnv.client); + @Var var info = new TopicInfoQuery() + .setTopicId(topicId) + .execute(testEnv.client); - assertThat(info.topicId).isEqualTo(topicId); - assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); - assertThat(info.sequenceNumber).isEqualTo(0); - assertThat(info.adminKey).isEqualTo(testEnv.operatorKey); + assertThat(info.topicId).isEqualTo(topicId); + assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); + assertThat(info.sequenceNumber).isEqualTo(0); + assertThat(info.adminKey).isEqualTo(testEnv.operatorKey); - new TopicMessageSubmitTransaction() - .setTopicId(topicId) - .setMessage("Hello, from HCS!") - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TopicMessageSubmitTransaction() + .setTopicId(topicId) + .setMessage("Hello, from HCS!") + .execute(testEnv.client) + .getReceipt(testEnv.client); - info = new TopicInfoQuery() - .setTopicId(topicId) - .execute(testEnv.client); + info = new TopicInfoQuery() + .setTopicId(topicId) + .execute(testEnv.client); - assertThat(info.topicId).isEqualTo(topicId); - assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); - assertThat(info.sequenceNumber).isEqualTo(1); - assertThat(info.adminKey).isEqualTo(testEnv.operatorKey); + assertThat(info.topicId).isEqualTo(topicId); + assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); + assertThat(info.sequenceNumber).isEqualTo(1); + assertThat(info.adminKey).isEqualTo(testEnv.operatorKey); - new TopicDeleteTransaction() - .setTopicId(topicId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TopicDeleteTransaction() + .setTopicId(topicId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } @Test @@ -91,51 +91,51 @@ void canSubmitALargeTopicMessage() { Assumptions.assumeTrue(!System.getProperty("HEDERA_NETWORK").equals("previewnet")); assertThatNoException().isThrownBy(() -> { - var testEnv = new IntegrationTestEnv(2); + try (var testEnv = new IntegrationTestEnv(1)) { - var response = new TopicCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setTopicMemo("[e2e::TopicCreateTransaction]") - .execute(testEnv.client); + var response = new TopicCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setTopicMemo("[e2e::TopicCreateTransaction]") + .execute(testEnv.client); - var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); + var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); - Thread.sleep(5000); + Thread.sleep(5000); - @Var var info = new TopicInfoQuery() - .setTopicId(topicId) - .execute(testEnv.client); + @Var var info = new TopicInfoQuery() + .setTopicId(topicId) + .execute(testEnv.client); - assertThat(info.topicId).isEqualTo(topicId); - assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); - assertThat(info.sequenceNumber).isEqualTo(0); - assertThat(info.adminKey).isEqualTo(testEnv.operatorKey); + assertThat(info.topicId).isEqualTo(topicId); + assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); + assertThat(info.sequenceNumber).isEqualTo(0); + assertThat(info.adminKey).isEqualTo(testEnv.operatorKey); - var responses = new TopicMessageSubmitTransaction() - .setTopicId(topicId) - .setMaxChunks(15) - .setMessage(Contents.BIG_CONTENTS) - .executeAll(testEnv.client); + var responses = new TopicMessageSubmitTransaction() + .setTopicId(topicId) + .setMaxChunks(15) + .setMessage(Contents.BIG_CONTENTS) + .executeAll(testEnv.client); - for (var resp : responses) { - resp.getReceipt(testEnv.client); - } + for (var resp : responses) { + resp.getReceipt(testEnv.client); + } - info = new TopicInfoQuery() - .setTopicId(topicId) - .execute(testEnv.client); + info = new TopicInfoQuery() + .setTopicId(topicId) + .execute(testEnv.client); - assertThat(info.topicId).isEqualTo(topicId); - assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); - assertThat(info.sequenceNumber).isEqualTo(14); - assertThat(info.adminKey).isEqualTo(testEnv.operatorKey); + assertThat(info.topicId).isEqualTo(topicId); + assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); + assertThat(info.sequenceNumber).isEqualTo(14); + assertThat(info.adminKey).isEqualTo(testEnv.operatorKey); - new TopicDeleteTransaction() - .setTopicId(topicId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TopicDeleteTransaction() + .setTopicId(topicId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } }); } @@ -146,29 +146,29 @@ void cannotSubmitMessageWhenTopicIDIsNotSet() { Assumptions.assumeTrue(!System.getProperty("HEDERA_NETWORK").equals("previewnet")); assertThatNoException().isThrownBy(() -> { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var response = new TopicCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setTopicMemo("[e2e::TopicCreateTransaction]") - .execute(testEnv.client); + var response = new TopicCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setTopicMemo("[e2e::TopicCreateTransaction]") + .execute(testEnv.client); - var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); + var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TopicMessageSubmitTransaction() - .setMessage(Contents.BIG_CONTENTS) - .setMaxChunks(15) - .execute(testEnv.client) - .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_TOPIC_ID.toString()); + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TopicMessageSubmitTransaction() + .setMessage(Contents.BIG_CONTENTS) + .setMaxChunks(15) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_TOPIC_ID.toString()); - new TopicDeleteTransaction() - .setTopicId(topicId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TopicDeleteTransaction() + .setTopicId(topicId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } }); } @@ -179,28 +179,28 @@ void cannotSubmitMessageWhenMessageIsNotSet() { Assumptions.assumeTrue(!System.getProperty("HEDERA_NETWORK").equals("previewnet")); assertThatNoException().isThrownBy(() -> { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var response = new TopicCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setTopicMemo("[e2e::TopicCreateTransaction]") - .execute(testEnv.client); + var response = new TopicCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setTopicMemo("[e2e::TopicCreateTransaction]") + .execute(testEnv.client); - var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); + var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); + + assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { + new TopicMessageSubmitTransaction() + .setTopicId(topicId) + .execute(testEnv.client) + .getReceipt(testEnv.client); + }).withMessageContaining(Status.INVALID_TOPIC_MESSAGE.toString()); - assertThatExceptionOfType(PrecheckStatusException.class).isThrownBy(() -> { - new TopicMessageSubmitTransaction() + new TopicDeleteTransaction() .setTopicId(topicId) .execute(testEnv.client) .getReceipt(testEnv.client); - }).withMessageContaining(Status.INVALID_TOPIC_MESSAGE.toString()); - new TopicDeleteTransaction() - .setTopicId(topicId) - .execute(testEnv.client) - .getReceipt(testEnv.client); - - testEnv.close(); + } }); } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TopicUpdateIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TopicUpdateIntegrationTest.java index 3a5658909..ad5ae1ef6 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TopicUpdateIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TopicUpdateIntegrationTest.java @@ -34,35 +34,35 @@ public class TopicUpdateIntegrationTest { @Test @DisplayName("Can update topic") void canUpdateTopic() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var response = new TopicCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setAutoRenewAccountId(testEnv.operatorId) - .setTopicMemo("[e2e::TopicCreateTransaction]") - .execute(testEnv.client); + var response = new TopicCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setAutoRenewAccountId(testEnv.operatorId) + .setTopicMemo("[e2e::TopicCreateTransaction]") + .execute(testEnv.client); - var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); + var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); - new TopicUpdateTransaction() - .clearAutoRenewAccountId() - .setTopicMemo("hello") - .setTopicId(topicId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TopicUpdateTransaction() + .clearAutoRenewAccountId() + .setTopicMemo("hello") + .setTopicId(topicId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - var topicInfo = new TopicInfoQuery() - .setTopicId(topicId) - .execute(testEnv.client); + var topicInfo = new TopicInfoQuery() + .setTopicId(topicId) + .execute(testEnv.client); - assertThat(topicInfo.topicMemo).isEqualTo("hello"); - assertThat(topicInfo.autoRenewAccountId).isNull(); + assertThat(topicInfo.topicMemo).isEqualTo("hello"); + assertThat(topicInfo.autoRenewAccountId).isNull(); - new TopicDeleteTransaction() - .setTopicId(topicId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TopicDeleteTransaction() + .setTopicId(topicId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TransactionIntegrationTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TransactionIntegrationTest.java index 0bf812856..ed44db327 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TransactionIntegrationTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TransactionIntegrationTest.java @@ -67,33 +67,33 @@ public class TransactionIntegrationTest { @Test @DisplayName("transaction hash in transaction record is equal to the derived transaction hash") void transactionHashInTransactionRecordIsEqualToTheDerivedTransactionHash() throws Exception { - var testEnv = new IntegrationTestEnv(1); - var key = PrivateKey.generateED25519(); + try (var testEnv = new IntegrationTestEnv(1)) { + var key = PrivateKey.generateED25519(); - var transaction = new AccountCreateTransaction() - .setKey(key) - .freezeWith(testEnv.client) - .signWithOperator(testEnv.client); + var transaction = new AccountCreateTransaction() + .setKey(key) + .freezeWith(testEnv.client) + .signWithOperator(testEnv.client); - var expectedHash = transaction.getTransactionHashPerNode(); + var expectedHash = transaction.getTransactionHashPerNode(); - var response = transaction.execute(testEnv.client); + var response = transaction.execute(testEnv.client); - var record = response.getRecord(testEnv.client); + var record = response.getRecord(testEnv.client); - assertThat(expectedHash.get(response.nodeId)).containsExactly(record.transactionHash.toByteArray()); + assertThat(expectedHash.get(response.nodeId)).containsExactly(record.transactionHash.toByteArray()); - var accountId = record.receipt.accountId; - assertThat(accountId).isNotNull(); + var accountId = record.receipt.accountId; + assertThat(accountId).isNotNull(); - var transactionId = transaction.getTransactionId(); - assertThat(transactionId.getReceipt(testEnv.client)).isNotNull(); - assertThat(transactionId.getReceiptAsync(testEnv.client).get()).isNotNull(); - assertThat(transactionId.getRecord(testEnv.client)).isNotNull(); - assertThat(transactionId.getRecordAsync(testEnv.client).get()).isNotNull(); + var transactionId = transaction.getTransactionId(); + assertThat(transactionId.getReceipt(testEnv.client)).isNotNull(); + assertThat(transactionId.getReceiptAsync(testEnv.client).get()).isNotNull(); + assertThat(transactionId.getRecord(testEnv.client)).isNotNull(); + assertThat(transactionId.getRecordAsync(testEnv.client).get()).isNotNull(); + } - testEnv.close(accountId, key); } /** @@ -103,27 +103,28 @@ var record = response.getRecord(testEnv.client); @Test @DisplayName("incomplete transaction can be serialized into bytes, deserialized and be equal to the original one") void canSerializeDeserializeCompareFields() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var adminKey = PrivateKey.generateECDSA(); - var publicKey = adminKey.getPublicKey(); + var adminKey = PrivateKey.generateECDSA(); + var publicKey = adminKey.getPublicKey(); - var accountCreateTransaction = new AccountCreateTransaction() - .setKey(publicKey) - .setInitialBalance(new Hbar(1L)); + var accountCreateTransaction = new AccountCreateTransaction() + .setKey(publicKey) + .setInitialBalance(new Hbar(1L)); - var expectedNodeAccountIds = accountCreateTransaction.getNodeAccountIds(); - var expectedBalance = new Hbar(1L); + var expectedNodeAccountIds = accountCreateTransaction.getNodeAccountIds(); + var expectedBalance = new Hbar(1L); - var transactionBytesSerialized = accountCreateTransaction.toBytes(); - AccountCreateTransaction accountCreateTransactionDeserialized = (AccountCreateTransaction) Transaction.fromBytes(transactionBytesSerialized); + var transactionBytesSerialized = accountCreateTransaction.toBytes(); + AccountCreateTransaction accountCreateTransactionDeserialized = (AccountCreateTransaction) Transaction + .fromBytes(transactionBytesSerialized); - assertThat(expectedNodeAccountIds).isEqualTo(accountCreateTransactionDeserialized.getNodeAccountIds()); - assertThat(expectedBalance).isEqualTo(accountCreateTransactionDeserialized.getInitialBalance()); - assertThatExceptionOfType(IllegalStateException.class).isThrownBy( - accountCreateTransactionDeserialized::getTransactionId); + assertThat(expectedNodeAccountIds).isEqualTo(accountCreateTransactionDeserialized.getNodeAccountIds()); + assertThat(expectedBalance).isEqualTo(accountCreateTransactionDeserialized.getInitialBalance()); + assertThatExceptionOfType(IllegalStateException.class).isThrownBy( + accountCreateTransactionDeserialized::getTransactionId); - testEnv.close(); + } } /** @@ -133,30 +134,32 @@ void canSerializeDeserializeCompareFields() throws Exception { @Test @DisplayName("incomplete transaction with node account ids can be serialized into bytes, deserialized and be equal to the original one") void canSerializeWithNodeAccountIdsDeserializeCompareFields() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var adminKey = PrivateKey.generateECDSA(); - var publicKey = adminKey.getPublicKey(); + var adminKey = PrivateKey.generateECDSA(); + var publicKey = adminKey.getPublicKey(); - var nodeAccountIds = testEnv.client.getNetwork().values().stream().toList(); + var nodeAccountIds = testEnv.client.getNetwork().values().stream().toList(); - var accountCreateTransaction = new AccountCreateTransaction() - .setNodeAccountIds(nodeAccountIds) - .setKey(publicKey) - .setInitialBalance(new Hbar(1L)); + var accountCreateTransaction = new AccountCreateTransaction() + .setNodeAccountIds(nodeAccountIds) + .setKey(publicKey) + .setInitialBalance(new Hbar(1L)); - var expectedNodeAccountIds = accountCreateTransaction.getNodeAccountIds(); - var expectedBalance = new Hbar(1L); + var expectedNodeAccountIds = accountCreateTransaction.getNodeAccountIds(); + var expectedBalance = new Hbar(1L); - var transactionBytesSerialized = accountCreateTransaction.toBytes(); - AccountCreateTransaction accountCreateTransactionDeserialized = (AccountCreateTransaction) Transaction.fromBytes(transactionBytesSerialized); + var transactionBytesSerialized = accountCreateTransaction.toBytes(); + AccountCreateTransaction accountCreateTransactionDeserialized = (AccountCreateTransaction) Transaction + .fromBytes(transactionBytesSerialized); - assertThat(expectedNodeAccountIds.size()).isEqualTo(accountCreateTransactionDeserialized.getNodeAccountIds().size()); - assertThat(expectedBalance).isEqualTo(accountCreateTransactionDeserialized.getInitialBalance()); - assertThatExceptionOfType(IllegalStateException.class).isThrownBy( - accountCreateTransactionDeserialized::getTransactionId); + assertThat(expectedNodeAccountIds.size()) + .isEqualTo(accountCreateTransactionDeserialized.getNodeAccountIds().size()); + assertThat(expectedBalance).isEqualTo(accountCreateTransactionDeserialized.getInitialBalance()); + assertThatExceptionOfType(IllegalStateException.class).isThrownBy( + accountCreateTransactionDeserialized::getTransactionId); - testEnv.close(); + } } /** @@ -166,31 +169,32 @@ void canSerializeWithNodeAccountIdsDeserializeCompareFields() throws Exception { @Test @DisplayName("incomplete transaction can be serialized into bytes, deserialized and executed") void canSerializeDeserializeAndExecuteIncompleteTransaction() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var adminKey = PrivateKey.generateECDSA(); - var publicKey = adminKey.getPublicKey(); + var adminKey = PrivateKey.generateECDSA(); + var publicKey = adminKey.getPublicKey(); - var accountCreateTransaction = new AccountCreateTransaction() - .setKey(publicKey) - .setInitialBalance(new Hbar(1L)); + var accountCreateTransaction = new AccountCreateTransaction() + .setKey(publicKey) + .setInitialBalance(new Hbar(1L)); - var transactionBytesSerialized = accountCreateTransaction.toBytes(); - AccountCreateTransaction accountCreateTransactionDeserialized = (AccountCreateTransaction) Transaction.fromBytes( - transactionBytesSerialized); + var transactionBytesSerialized = accountCreateTransaction.toBytes(); + AccountCreateTransaction accountCreateTransactionDeserialized = (AccountCreateTransaction) Transaction + .fromBytes( + transactionBytesSerialized); - var txReceipt = accountCreateTransactionDeserialized - .execute(testEnv.client) - .getReceipt(testEnv.client); + var txReceipt = accountCreateTransactionDeserialized + .execute(testEnv.client) + .getReceipt(testEnv.client); - new AccountDeleteTransaction() - .setAccountId(txReceipt.accountId) - .setTransferAccountId(testEnv.client.getOperatorAccountId()) - .freezeWith(testEnv.client) - .sign(adminKey) - .execute(testEnv.client); + new AccountDeleteTransaction() + .setAccountId(txReceipt.accountId) + .setTransferAccountId(testEnv.client.getOperatorAccountId()) + .freezeWith(testEnv.client) + .sign(adminKey) + .execute(testEnv.client); - testEnv.close(); + } } /** @@ -200,34 +204,35 @@ void canSerializeDeserializeAndExecuteIncompleteTransaction() throws Exception { @Test @DisplayName("incomplete transaction with node account ids can be serialized into bytes, deserialized and executed") void canSerializeDeserializeAndExecuteIncompleteTransactionWithNodeAccountIds() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var adminKey = PrivateKey.generateECDSA(); - var publicKey = adminKey.getPublicKey(); + var adminKey = PrivateKey.generateECDSA(); + var publicKey = adminKey.getPublicKey(); - var nodeAccountIds = testEnv.client.getNetwork().values().stream().toList(); + var nodeAccountIds = testEnv.client.getNetwork().values().stream().toList(); - var accountCreateTransaction = new AccountCreateTransaction() - .setNodeAccountIds(nodeAccountIds) - .setKey(publicKey) - .setInitialBalance(new Hbar(1L)); + var accountCreateTransaction = new AccountCreateTransaction() + .setNodeAccountIds(nodeAccountIds) + .setKey(publicKey) + .setInitialBalance(new Hbar(1L)); - var transactionBytesSerialized = accountCreateTransaction.toBytes(); - AccountCreateTransaction accountCreateTransactionDeserialized = (AccountCreateTransaction) Transaction.fromBytes( - transactionBytesSerialized); + var transactionBytesSerialized = accountCreateTransaction.toBytes(); + AccountCreateTransaction accountCreateTransactionDeserialized = (AccountCreateTransaction) Transaction + .fromBytes( + transactionBytesSerialized); - var txReceipt = accountCreateTransactionDeserialized - .execute(testEnv.client) - .getReceipt(testEnv.client); + var txReceipt = accountCreateTransactionDeserialized + .execute(testEnv.client) + .getReceipt(testEnv.client); - new AccountDeleteTransaction() - .setAccountId(txReceipt.accountId) - .setTransferAccountId(testEnv.client.getOperatorAccountId()) - .freezeWith(testEnv.client) - .sign(adminKey) - .execute(testEnv.client); + new AccountDeleteTransaction() + .setAccountId(txReceipt.accountId) + .setTransferAccountId(testEnv.client.getOperatorAccountId()) + .freezeWith(testEnv.client) + .sign(adminKey) + .execute(testEnv.client); - testEnv.close(); + } } /** @@ -237,37 +242,38 @@ void canSerializeDeserializeAndExecuteIncompleteTransactionWithNodeAccountIds() @Test @DisplayName("incomplete transaction can be serialized into bytes, deserialized, edited and executed") void canSerializeDeserializeEditExecuteCompareFields() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var adminKey = PrivateKey.generateECDSA(); - var publicKey = adminKey.getPublicKey(); + var adminKey = PrivateKey.generateECDSA(); + var publicKey = adminKey.getPublicKey(); - var accountCreateTransaction = new AccountCreateTransaction() - .setKey(publicKey); + var accountCreateTransaction = new AccountCreateTransaction() + .setKey(publicKey); - var expectedBalance = new Hbar(1L); - var nodeAccountIds = testEnv.client.getNetwork().values().stream().toList(); + var expectedBalance = new Hbar(1L); + var nodeAccountIds = testEnv.client.getNetwork().values().stream().toList(); - var transactionBytesSerialized = accountCreateTransaction.toBytes(); - AccountCreateTransaction accountCreateTransactionDeserialized = (AccountCreateTransaction) Transaction.fromBytes(transactionBytesSerialized); + var transactionBytesSerialized = accountCreateTransaction.toBytes(); + AccountCreateTransaction accountCreateTransactionDeserialized = (AccountCreateTransaction) Transaction + .fromBytes(transactionBytesSerialized); - var txReceipt = accountCreateTransactionDeserialized - .setInitialBalance(new Hbar(1L)) - .setNodeAccountIds(nodeAccountIds) - .setTransactionId(TransactionId.generate(testEnv.client.getOperatorAccountId())) - .execute(testEnv.client) - .getReceipt(testEnv.client); + var txReceipt = accountCreateTransactionDeserialized + .setInitialBalance(new Hbar(1L)) + .setNodeAccountIds(nodeAccountIds) + .setTransactionId(TransactionId.generate(testEnv.client.getOperatorAccountId())) + .execute(testEnv.client) + .getReceipt(testEnv.client); - assertThat(expectedBalance).isEqualTo(accountCreateTransactionDeserialized.getInitialBalance()); + assertThat(expectedBalance).isEqualTo(accountCreateTransactionDeserialized.getInitialBalance()); - new AccountDeleteTransaction() - .setAccountId(txReceipt.accountId) - .setTransferAccountId(testEnv.client.getOperatorAccountId()) - .freezeWith(testEnv.client) - .sign(adminKey) - .execute(testEnv.client); + new AccountDeleteTransaction() + .setAccountId(txReceipt.accountId) + .setTransferAccountId(testEnv.client.getOperatorAccountId()) + .freezeWith(testEnv.client) + .sign(adminKey) + .execute(testEnv.client); - testEnv.close(); + } } /** @@ -277,38 +283,39 @@ void canSerializeDeserializeEditExecuteCompareFields() throws Exception { @Test @DisplayName("incomplete transaction with node account ids can be serialized into bytes, deserialized, edited and executed") void canSerializeDeserializeEditExecuteCompareFieldsIncompleteTransactionWithNodeAccountIds() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var adminKey = PrivateKey.generateECDSA(); - var publicKey = adminKey.getPublicKey(); + var adminKey = PrivateKey.generateECDSA(); + var publicKey = adminKey.getPublicKey(); - var nodeAccountIds = testEnv.client.getNetwork().values().stream().toList(); + var nodeAccountIds = testEnv.client.getNetwork().values().stream().toList(); - var accountCreateTransaction = new AccountCreateTransaction() - .setNodeAccountIds(nodeAccountIds) - .setKey(publicKey); + var accountCreateTransaction = new AccountCreateTransaction() + .setNodeAccountIds(nodeAccountIds) + .setKey(publicKey); - var expectedBalance = new Hbar(1L); + var expectedBalance = new Hbar(1L); - var transactionBytesSerialized = accountCreateTransaction.toBytes(); - AccountCreateTransaction accountCreateTransactionDeserialized = (AccountCreateTransaction) Transaction.fromBytes(transactionBytesSerialized); + var transactionBytesSerialized = accountCreateTransaction.toBytes(); + AccountCreateTransaction accountCreateTransactionDeserialized = (AccountCreateTransaction) Transaction + .fromBytes(transactionBytesSerialized); - var txReceipt = accountCreateTransactionDeserialized - .setInitialBalance(new Hbar(1L)) - .setTransactionId(TransactionId.generate(testEnv.client.getOperatorAccountId())) - .execute(testEnv.client) - .getReceipt(testEnv.client); + var txReceipt = accountCreateTransactionDeserialized + .setInitialBalance(new Hbar(1L)) + .setTransactionId(TransactionId.generate(testEnv.client.getOperatorAccountId())) + .execute(testEnv.client) + .getReceipt(testEnv.client); - assertThat(expectedBalance).isEqualTo(accountCreateTransactionDeserialized.getInitialBalance()); + assertThat(expectedBalance).isEqualTo(accountCreateTransactionDeserialized.getInitialBalance()); - new AccountDeleteTransaction() - .setAccountId(txReceipt.accountId) - .setTransferAccountId(testEnv.client.getOperatorAccountId()) - .freezeWith(testEnv.client) - .sign(adminKey) - .execute(testEnv.client); + new AccountDeleteTransaction() + .setAccountId(txReceipt.accountId) + .setTransferAccountId(testEnv.client.getOperatorAccountId()) + .freezeWith(testEnv.client) + .sign(adminKey) + .execute(testEnv.client); - testEnv.close(); + } } /** @@ -318,90 +325,93 @@ void canSerializeDeserializeEditExecuteCompareFieldsIncompleteTransactionWithNod @Test @DisplayName("complete frozen and signed transaction can be serialized into bytes, deserialized (x2) and executed") void canFreezeSignSerializeDeserializeReserializeAndExecute() throws Exception { - var testEnv = new IntegrationTestEnv(1); - - var adminKey = PrivateKey.generateECDSA(); - var publicKey = adminKey.getPublicKey(); - - var evmAddress = publicKey.toEvmAddress(); - var initialBalance = new Hbar(1L); - var autoRenewPeriod = java.time.Duration.ofSeconds(2592000); - var memo = "test account memo"; - var maxAutomaticTokenAssociations = 4; + try (var testEnv = new IntegrationTestEnv(1)) { + + var adminKey = PrivateKey.generateECDSA(); + var publicKey = adminKey.getPublicKey(); + + var evmAddress = publicKey.toEvmAddress(); + var initialBalance = new Hbar(1L); + var autoRenewPeriod = java.time.Duration.ofSeconds(2592000); + var memo = "test account memo"; + var maxAutomaticTokenAssociations = 4; + + var accountCreateTransaction = new AccountCreateTransaction() + .setKey(publicKey) + .setInitialBalance(initialBalance) + .setReceiverSignatureRequired(true) + .setAutoRenewPeriod(autoRenewPeriod) + .setAccountMemo(memo) + .setMaxAutomaticTokenAssociations(maxAutomaticTokenAssociations) + .setDeclineStakingReward(true) + .setAlias(evmAddress) + .freezeWith(testEnv.client) + .sign(adminKey); + + var transactionBytesSerialized = accountCreateTransaction.toBytes(); + AccountCreateTransaction accountCreateTransactionDeserialized = (AccountCreateTransaction) Transaction + .fromBytes(transactionBytesSerialized); + + var transactionBytesReserialized = accountCreateTransactionDeserialized.toBytes(); + assertThat(transactionBytesSerialized).isEqualTo(transactionBytesReserialized); + + AccountCreateTransaction accountCreateTransactionReserialized = (AccountCreateTransaction) Transaction + .fromBytes(transactionBytesReserialized); + + var txResponse = accountCreateTransactionReserialized.execute(testEnv.client); + + var accountId = txResponse.getReceipt(testEnv.client).accountId; + + new AccountDeleteTransaction() + .setAccountId(accountId) + .setTransferAccountId(testEnv.client.getOperatorAccountId()) + .freezeWith(testEnv.client) + .sign(adminKey) + .execute(testEnv.client); - var accountCreateTransaction = new AccountCreateTransaction() - .setKey(publicKey) - .setInitialBalance(initialBalance) - .setReceiverSignatureRequired(true) - .setAutoRenewPeriod(autoRenewPeriod) - .setAccountMemo(memo) - .setMaxAutomaticTokenAssociations(maxAutomaticTokenAssociations) - .setDeclineStakingReward(true) - .setAlias(evmAddress) - .freezeWith(testEnv.client) - .sign(adminKey); - - var transactionBytesSerialized = accountCreateTransaction.toBytes(); - AccountCreateTransaction accountCreateTransactionDeserialized = (AccountCreateTransaction) Transaction.fromBytes(transactionBytesSerialized); - - var transactionBytesReserialized = accountCreateTransactionDeserialized.toBytes(); - assertThat(transactionBytesSerialized).isEqualTo(transactionBytesReserialized); - - AccountCreateTransaction accountCreateTransactionReserialized = (AccountCreateTransaction) Transaction.fromBytes(transactionBytesReserialized); - - var txResponse = accountCreateTransactionReserialized.execute(testEnv.client); - - var accountId = txResponse.getReceipt(testEnv.client).accountId; - - new AccountDeleteTransaction() - .setAccountId(accountId) - .setTransferAccountId(testEnv.client.getOperatorAccountId()) - .freezeWith(testEnv.client) - .sign(adminKey) - .execute(testEnv.client); - - testEnv.close(); + } } @Test @DisplayName("complete frozen transaction can be serialized into bytes, deserialized, signature added and executed") void canFreezeSerializeDeserializeAddSignatureAndExecute() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var key = PrivateKey.generateED25519(); + var key = PrivateKey.generateED25519(); - var transaction = new AccountCreateTransaction() - .setKey(key) - .freezeWith(testEnv.client) - .signWithOperator(testEnv.client); + var transaction = new AccountCreateTransaction() + .setKey(key) + .freezeWith(testEnv.client) + .signWithOperator(testEnv.client); - var expectedHash = transaction.getTransactionHashPerNode(); + var expectedHash = transaction.getTransactionHashPerNode(); - @Var var response = transaction.execute(testEnv.client); + @Var + var response = transaction.execute(testEnv.client); - var record = response.getRecord(testEnv.client); + var record = response.getRecord(testEnv.client); - assertThat(expectedHash.get(response.nodeId)).containsExactly(record.transactionHash.toByteArray()); + assertThat(expectedHash.get(response.nodeId)).containsExactly(record.transactionHash.toByteArray()); - var accountId = record.receipt.accountId; - assertThat(accountId).isNotNull(); + var accountId = record.receipt.accountId; + assertThat(accountId).isNotNull(); - var deleteTransaction = new AccountDeleteTransaction() - .setAccountId(accountId) - .setTransferAccountId(testEnv.operatorId) - .freezeWith(testEnv.client); + var deleteTransaction = new AccountDeleteTransaction() + .setAccountId(accountId) + .setTransferAccountId(testEnv.operatorId) + .freezeWith(testEnv.client); - var updateBytes = deleteTransaction.toBytes(); + var updateBytes = deleteTransaction.toBytes(); - var sig1 = key.signTransaction(deleteTransaction); + var sig1 = key.signTransaction(deleteTransaction); - var deleteTransaction2 = Transaction.fromBytes(updateBytes); + var deleteTransaction2 = Transaction.fromBytes(updateBytes); - deleteTransaction2 - .addSignature(key.getPublicKey(), sig1) - .execute(testEnv.client); + deleteTransaction2 + .addSignature(key.getPublicKey(), sig1) + .execute(testEnv.client); - testEnv.close(); + } } /** @@ -411,43 +421,45 @@ var record = response.getRecord(testEnv.client); @Test @DisplayName("file append chunked transaction can be frozen, signed, serialized into bytes, deserialized and be equal to the original one") void canFreezeSignSerializeDeserializeAndCompareFileAppendChunkedTransaction() throws Exception { - var testEnv = new IntegrationTestEnv(2); + try (var testEnv = new IntegrationTestEnv(1)) { - var privateKey = PrivateKey.generateED25519(); + var privateKey = PrivateKey.generateED25519(); - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents("[e2e::FileCreateTransaction]") - .execute(testEnv.client); + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents("[e2e::FileCreateTransaction]") + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - Thread.sleep(5000); + Thread.sleep(5000); - @Var var info = new FileInfoQuery() - .setFileId(fileId) - .execute(testEnv.client); + @Var + var info = new FileInfoQuery() + .setFileId(fileId) + .execute(testEnv.client); - assertThat(info.fileId).isEqualTo(fileId); - assertThat(info.size).isEqualTo(28); - assertThat(info.isDeleted).isFalse(); - assertThat(info.keys).isNotNull(); - assertThat(info.keys.getThreshold()).isNull(); - assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); + assertThat(info.fileId).isEqualTo(fileId); + assertThat(info.size).isEqualTo(28); + assertThat(info.isDeleted).isFalse(); + assertThat(info.keys).isNotNull(); + assertThat(info.keys.getThreshold()).isNull(); + assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); - var fileAppendTransaction = new FileAppendTransaction() - .setFileId(fileId) - .setContents(Contents.BIG_CONTENTS) - .freezeWith(testEnv.client) - .sign(privateKey); + var fileAppendTransaction = new FileAppendTransaction() + .setFileId(fileId) + .setContents(Contents.BIG_CONTENTS) + .freezeWith(testEnv.client) + .sign(privateKey); - var transactionBytesSerialized = fileAppendTransaction.toBytes(); - FileAppendTransaction fileAppendTransactionDeserialized = (FileAppendTransaction) Transaction.fromBytes(transactionBytesSerialized); + var transactionBytesSerialized = fileAppendTransaction.toBytes(); + FileAppendTransaction fileAppendTransactionDeserialized = (FileAppendTransaction) Transaction + .fromBytes(transactionBytesSerialized); - var transactionBytesReserialized = fileAppendTransactionDeserialized.toBytes(); - assertThat(transactionBytesSerialized).isEqualTo(transactionBytesReserialized); + var transactionBytesReserialized = fileAppendTransactionDeserialized.toBytes(); + assertThat(transactionBytesSerialized).isEqualTo(transactionBytesReserialized); - testEnv.close(); + } } /** @@ -457,62 +469,64 @@ void canFreezeSignSerializeDeserializeAndCompareFileAppendChunkedTransaction() t @Test @DisplayName("incomplete file append chunked transaction can be serialized into bytes, deserialized, edited and executed") void canSerializeDeserializeExecuteFileAppendChunkedTransaction() throws Exception { - var testEnv = new IntegrationTestEnv(2); + try (var testEnv = new IntegrationTestEnv(1)) { - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents("[e2e::FileCreateTransaction]") - .execute(testEnv.client); + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents("[e2e::FileCreateTransaction]") + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - Thread.sleep(5000); + Thread.sleep(5000); - @Var var info = new FileInfoQuery() - .setFileId(fileId) - .execute(testEnv.client); + @Var + var info = new FileInfoQuery() + .setFileId(fileId) + .execute(testEnv.client); - assertThat(info.fileId).isEqualTo(fileId); - assertThat(info.size).isEqualTo(28); - assertThat(info.isDeleted).isFalse(); - assertThat(info.keys).isNotNull(); - assertThat(info.keys.getThreshold()).isNull(); - assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); + assertThat(info.fileId).isEqualTo(fileId); + assertThat(info.size).isEqualTo(28); + assertThat(info.isDeleted).isFalse(); + assertThat(info.keys).isNotNull(); + assertThat(info.keys.getThreshold()).isNull(); + assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); - var fileAppendTransaction = new FileAppendTransaction() - .setFileId(fileId) - .setContents(Contents.BIG_CONTENTS); + var fileAppendTransaction = new FileAppendTransaction() + .setFileId(fileId) + .setContents(Contents.BIG_CONTENTS); - var transactionBytesSerialized = fileAppendTransaction.toBytes(); - FileAppendTransaction fileAppendTransactionDeserialized = (FileAppendTransaction) Transaction.fromBytes(transactionBytesSerialized); + var transactionBytesSerialized = fileAppendTransaction.toBytes(); + FileAppendTransaction fileAppendTransactionDeserialized = (FileAppendTransaction) Transaction + .fromBytes(transactionBytesSerialized); - fileAppendTransactionDeserialized - .execute(testEnv.client) - .getReceipt(testEnv.client); + fileAppendTransactionDeserialized + .execute(testEnv.client) + .getReceipt(testEnv.client); - var contents = new FileContentsQuery() - .setFileId(fileId) - .execute(testEnv.client); + var contents = new FileContentsQuery() + .setFileId(fileId) + .execute(testEnv.client); - assertThat(contents.toStringUtf8()).isEqualTo("[e2e::FileCreateTransaction]" + Contents.BIG_CONTENTS); + assertThat(contents.toStringUtf8()).isEqualTo("[e2e::FileCreateTransaction]" + Contents.BIG_CONTENTS); - info = new FileInfoQuery() - .setFileId(fileId) - .execute(testEnv.client); + info = new FileInfoQuery() + .setFileId(fileId) + .execute(testEnv.client); - assertThat(info.fileId).isEqualTo(fileId); - assertThat(info.size).isEqualTo(13522); - assertThat(info.isDeleted).isFalse(); - assertThat(info.keys).isNotNull(); - assertThat(info.keys.getThreshold()).isNull(); - assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); + assertThat(info.fileId).isEqualTo(fileId); + assertThat(info.size).isEqualTo(13522); + assertThat(info.isDeleted).isFalse(); + assertThat(info.keys).isNotNull(); + assertThat(info.keys.getThreshold()).isNull(); + assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } /** @@ -522,66 +536,68 @@ void canSerializeDeserializeExecuteFileAppendChunkedTransaction() throws Excepti @Test @DisplayName("incomplete file append chunked transaction with node account ids can be serialized into bytes, deserialized, edited and executed") void canSerializeDeserializeExecuteIncompleteFileAppendChunkedTransactionWithNodeAccountIds() throws Exception { - var testEnv = new IntegrationTestEnv(2); + try (var testEnv = new IntegrationTestEnv(1)) { - var nodeAccountIds = testEnv.client.getNetwork().values().stream().toList(); + var nodeAccountIds = testEnv.client.getNetwork().values().stream().toList(); - var response = new FileCreateTransaction() - .setKeys(testEnv.operatorKey) - .setContents("[e2e::FileCreateTransaction]") - .execute(testEnv.client); + var response = new FileCreateTransaction() + .setKeys(testEnv.operatorKey) + .setContents("[e2e::FileCreateTransaction]") + .execute(testEnv.client); - var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); + var fileId = Objects.requireNonNull(response.getReceipt(testEnv.client).fileId); - Thread.sleep(5000); + Thread.sleep(5000); - @Var var info = new FileInfoQuery() - .setFileId(fileId) - .execute(testEnv.client); + @Var + var info = new FileInfoQuery() + .setFileId(fileId) + .execute(testEnv.client); - assertThat(info.fileId).isEqualTo(fileId); - assertThat(info.size).isEqualTo(28); - assertThat(info.isDeleted).isFalse(); - assertThat(info.keys).isNotNull(); - assertThat(info.keys.getThreshold()).isNull(); - assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); + assertThat(info.fileId).isEqualTo(fileId); + assertThat(info.size).isEqualTo(28); + assertThat(info.isDeleted).isFalse(); + assertThat(info.keys).isNotNull(); + assertThat(info.keys.getThreshold()).isNull(); + assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); - var fileAppendTransaction = new FileAppendTransaction() - .setNodeAccountIds(nodeAccountIds) - .setFileId(fileId) - .setContents(Contents.BIG_CONTENTS); + var fileAppendTransaction = new FileAppendTransaction() + .setNodeAccountIds(nodeAccountIds) + .setFileId(fileId) + .setContents(Contents.BIG_CONTENTS); - var transactionBytesSerialized = fileAppendTransaction.toBytes(); - FileAppendTransaction fileAppendTransactionDeserialized = (FileAppendTransaction) Transaction.fromBytes(transactionBytesSerialized); + var transactionBytesSerialized = fileAppendTransaction.toBytes(); + FileAppendTransaction fileAppendTransactionDeserialized = (FileAppendTransaction) Transaction + .fromBytes(transactionBytesSerialized); - fileAppendTransactionDeserialized - .setTransactionId(TransactionId.generate(testEnv.client.getOperatorAccountId())) - .execute(testEnv.client) - .getReceipt(testEnv.client); + fileAppendTransactionDeserialized + .setTransactionId(TransactionId.generate(testEnv.client.getOperatorAccountId())) + .execute(testEnv.client) + .getReceipt(testEnv.client); - var contents = new FileContentsQuery() - .setFileId(fileId) - .execute(testEnv.client); + var contents = new FileContentsQuery() + .setFileId(fileId) + .execute(testEnv.client); - assertThat(contents.toStringUtf8()).isEqualTo("[e2e::FileCreateTransaction]" + Contents.BIG_CONTENTS); + assertThat(contents.toStringUtf8()).isEqualTo("[e2e::FileCreateTransaction]" + Contents.BIG_CONTENTS); - info = new FileInfoQuery() - .setFileId(fileId) - .execute(testEnv.client); + info = new FileInfoQuery() + .setFileId(fileId) + .execute(testEnv.client); - assertThat(info.fileId).isEqualTo(fileId); - assertThat(info.size).isEqualTo(13522); - assertThat(info.isDeleted).isFalse(); - assertThat(info.keys).isNotNull(); - assertThat(info.keys.getThreshold()).isNull(); - assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); + assertThat(info.fileId).isEqualTo(fileId); + assertThat(info.size).isEqualTo(13522); + assertThat(info.isDeleted).isFalse(); + assertThat(info.keys).isNotNull(); + assertThat(info.keys.getThreshold()).isNull(); + assertThat(info.keys).isEqualTo(KeyList.of(testEnv.operatorKey)); - new FileDeleteTransaction() - .setFileId(fileId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new FileDeleteTransaction() + .setFileId(fileId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } /** @@ -591,47 +607,49 @@ void canSerializeDeserializeExecuteIncompleteFileAppendChunkedTransactionWithNod @Test @DisplayName("topic message submit chunked transaction can be frozen, signed, serialized into bytes, deserialized and be equal to the original one") void canFreezeSignSerializeDeserializeAndCompareTopicMessageSubmitChunkedTransaction() throws Exception { - var testEnv = new IntegrationTestEnv(2); + try (var testEnv = new IntegrationTestEnv(1)) { - var privateKey = PrivateKey.generateED25519(); + var privateKey = PrivateKey.generateED25519(); - var response = new TopicCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setTopicMemo("[e2e::TopicCreateTransaction]") - .execute(testEnv.client); + var response = new TopicCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setTopicMemo("[e2e::TopicCreateTransaction]") + .execute(testEnv.client); - var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); + var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); - Thread.sleep(5000); + Thread.sleep(5000); - @Var var info = new TopicInfoQuery() - .setTopicId(topicId) - .execute(testEnv.client); + @Var + var info = new TopicInfoQuery() + .setTopicId(topicId) + .execute(testEnv.client); - assertThat(info.topicId).isEqualTo(topicId); - assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); - assertThat(info.sequenceNumber).isEqualTo(0); - assertThat(info.adminKey).isEqualTo(testEnv.operatorKey); + assertThat(info.topicId).isEqualTo(topicId); + assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); + assertThat(info.sequenceNumber).isEqualTo(0); + assertThat(info.adminKey).isEqualTo(testEnv.operatorKey); - var topicMessageSubmitTransaction = new TopicMessageSubmitTransaction() - .setTopicId(topicId) - .setMaxChunks(15) - .setMessage(Contents.BIG_CONTENTS) - .freezeWith(testEnv.client) - .sign(privateKey); + var topicMessageSubmitTransaction = new TopicMessageSubmitTransaction() + .setTopicId(topicId) + .setMaxChunks(15) + .setMessage(Contents.BIG_CONTENTS) + .freezeWith(testEnv.client) + .sign(privateKey); - var transactionBytesSerialized = topicMessageSubmitTransaction.toBytes(); - TopicMessageSubmitTransaction fileAppendTransactionDeserialized = (TopicMessageSubmitTransaction) Transaction.fromBytes(transactionBytesSerialized); + var transactionBytesSerialized = topicMessageSubmitTransaction.toBytes(); + TopicMessageSubmitTransaction fileAppendTransactionDeserialized = (TopicMessageSubmitTransaction) Transaction + .fromBytes(transactionBytesSerialized); - var transactionBytesReserialized = fileAppendTransactionDeserialized.toBytes(); - assertThat(transactionBytesSerialized).isEqualTo(transactionBytesReserialized); + var transactionBytesReserialized = fileAppendTransactionDeserialized.toBytes(); + assertThat(transactionBytesSerialized).isEqualTo(transactionBytesReserialized); - new TopicDeleteTransaction() - .setTopicId(topicId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TopicDeleteTransaction() + .setTopicId(topicId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } /** @@ -641,55 +659,57 @@ void canFreezeSignSerializeDeserializeAndCompareTopicMessageSubmitChunkedTransac @Test @DisplayName("incomplete topic message submit chunked transaction can be serialized into bytes, deserialized, edited and executed") void canSerializeDeserializeExecuteIncompleteTopicMessageSubmitChunkedTransaction() throws Exception { - var testEnv = new IntegrationTestEnv(2); + try (var testEnv = new IntegrationTestEnv(1)) { - var response = new TopicCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setTopicMemo("[e2e::TopicCreateTransaction]") - .execute(testEnv.client); + var response = new TopicCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setTopicMemo("[e2e::TopicCreateTransaction]") + .execute(testEnv.client); - var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); + var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); - Thread.sleep(5000); + Thread.sleep(5000); - @Var var info = new TopicInfoQuery() - .setTopicId(topicId) - .execute(testEnv.client); + @Var + var info = new TopicInfoQuery() + .setTopicId(topicId) + .execute(testEnv.client); - assertThat(info.topicId).isEqualTo(topicId); - assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); - assertThat(info.sequenceNumber).isEqualTo(0); - assertThat(info.adminKey).isEqualTo(testEnv.operatorKey); + assertThat(info.topicId).isEqualTo(topicId); + assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); + assertThat(info.sequenceNumber).isEqualTo(0); + assertThat(info.adminKey).isEqualTo(testEnv.operatorKey); - var topicMessageSubmitTransaction = new TopicMessageSubmitTransaction() - .setTopicId(topicId) - .setMaxChunks(15) - .setMessage(Contents.BIG_CONTENTS); + var topicMessageSubmitTransaction = new TopicMessageSubmitTransaction() + .setTopicId(topicId) + .setMaxChunks(15) + .setMessage(Contents.BIG_CONTENTS); - var transactionBytesSerialized = topicMessageSubmitTransaction.toBytes(); - TopicMessageSubmitTransaction topicMessageSubmitTransactionDeserialized = (TopicMessageSubmitTransaction) Transaction.fromBytes(transactionBytesSerialized); + var transactionBytesSerialized = topicMessageSubmitTransaction.toBytes(); + TopicMessageSubmitTransaction topicMessageSubmitTransactionDeserialized = (TopicMessageSubmitTransaction) Transaction + .fromBytes(transactionBytesSerialized); - var responses = topicMessageSubmitTransactionDeserialized.executeAll(testEnv.client); + var responses = topicMessageSubmitTransactionDeserialized.executeAll(testEnv.client); - for (var resp : responses) { - resp.getReceipt(testEnv.client); - } + for (var resp : responses) { + resp.getReceipt(testEnv.client); + } - info = new TopicInfoQuery() - .setTopicId(topicId) - .execute(testEnv.client); + info = new TopicInfoQuery() + .setTopicId(topicId) + .execute(testEnv.client); - assertThat(info.topicId).isEqualTo(topicId); - assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); - assertThat(info.sequenceNumber).isEqualTo(14); - assertThat(info.adminKey).isEqualTo(testEnv.operatorKey); + assertThat(info.topicId).isEqualTo(topicId); + assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); + assertThat(info.sequenceNumber).isEqualTo(14); + assertThat(info.adminKey).isEqualTo(testEnv.operatorKey); - new TopicDeleteTransaction() - .setTopicId(topicId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TopicDeleteTransaction() + .setTopicId(topicId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } /** @@ -699,63 +719,66 @@ void canSerializeDeserializeExecuteIncompleteTopicMessageSubmitChunkedTransactio @Test @DisplayName("incomplete topic message submit chunked transaction with node account ids can be serialized into bytes, deserialized, edited and executed") void canSerializeDeserializeExecuteIncompleteTopicMessageSubmitChunkedTransactionWithNodeAccountIds() - throws Exception { - var testEnv = new IntegrationTestEnv(2); + throws Exception { + try (var testEnv = new IntegrationTestEnv(1)) { - var nodeAccountIds = testEnv.client.getNetwork().values().stream().toList(); + var nodeAccountIds = testEnv.client.getNetwork().values().stream().toList(); - var response = new TopicCreateTransaction() - .setAdminKey(testEnv.operatorKey) - .setTopicMemo("[e2e::TopicCreateTransaction]") - .execute(testEnv.client); + var response = new TopicCreateTransaction() + .setAdminKey(testEnv.operatorKey) + .setTopicMemo("[e2e::TopicCreateTransaction]") + .execute(testEnv.client); - var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); + var topicId = Objects.requireNonNull(response.getReceipt(testEnv.client).topicId); - Thread.sleep(5000); + Thread.sleep(5000); - @Var var info = new TopicInfoQuery() - .setTopicId(topicId) - .execute(testEnv.client); + @Var + var info = new TopicInfoQuery() + .setTopicId(topicId) + .execute(testEnv.client); - assertThat(info.topicId).isEqualTo(topicId); - assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); - assertThat(info.sequenceNumber).isEqualTo(0); - assertThat(info.adminKey).isEqualTo(testEnv.operatorKey); + assertThat(info.topicId).isEqualTo(topicId); + assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); + assertThat(info.sequenceNumber).isEqualTo(0); + assertThat(info.adminKey).isEqualTo(testEnv.operatorKey); - var topicMessageSubmitTransaction = new TopicMessageSubmitTransaction() - .setNodeAccountIds(nodeAccountIds) - .setTopicId(topicId) - .setMaxChunks(15) - .setMessage(Contents.BIG_CONTENTS); + var topicMessageSubmitTransaction = new TopicMessageSubmitTransaction() + .setNodeAccountIds(nodeAccountIds) + .setTopicId(topicId) + .setMaxChunks(15) + .setMessage(Contents.BIG_CONTENTS); - var transactionBytesSerialized = topicMessageSubmitTransaction.toBytes(); - TopicMessageSubmitTransaction topicMessageSubmitTransactionDeserialized = (TopicMessageSubmitTransaction) Transaction.fromBytes(transactionBytesSerialized); + var transactionBytesSerialized = topicMessageSubmitTransaction.toBytes(); + TopicMessageSubmitTransaction topicMessageSubmitTransactionDeserialized = (TopicMessageSubmitTransaction) Transaction + .fromBytes(transactionBytesSerialized); - var responses = topicMessageSubmitTransactionDeserialized.executeAll(testEnv.client); + var responses = topicMessageSubmitTransactionDeserialized.executeAll(testEnv.client); - for (var resp : responses) { - resp.getReceipt(testEnv.client); - } + for (var resp : responses) { + resp.getReceipt(testEnv.client); + } - info = new TopicInfoQuery() - .setTopicId(topicId) - .execute(testEnv.client); + info = new TopicInfoQuery() + .setTopicId(topicId) + .execute(testEnv.client); - assertThat(info.topicId).isEqualTo(topicId); - assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); - assertThat(info.sequenceNumber).isEqualTo(14); - assertThat(info.adminKey).isEqualTo(testEnv.operatorKey); + assertThat(info.topicId).isEqualTo(topicId); + assertThat(info.topicMemo).isEqualTo("[e2e::TopicCreateTransaction]"); + assertThat(info.sequenceNumber).isEqualTo(14); + assertThat(info.adminKey).isEqualTo(testEnv.operatorKey); - new TopicDeleteTransaction() - .setTopicId(topicId) - .execute(testEnv.client) - .getReceipt(testEnv.client); + new TopicDeleteTransaction() + .setTopicId(topicId) + .execute(testEnv.client) + .getReceipt(testEnv.client); - testEnv.close(); + } } - // TODO: this test has a bunch of things hard-coded into it, which is kinda dumb, but it's a good idea for a test. - // Any way to fix it and bring it back? + // TODO: this test has a bunch of things hard-coded into it, which is kinda + // dumb, but it's a good idea for a test. + // Any way to fix it and bring it back? @Disabled @Test @DisplayName("transaction can be serialized into bytes, deserialized, signature added and executed") @@ -765,59 +788,62 @@ void transactionFromToBytes2() { var transactionBodyBuilder = TransactionBody.newBuilder(); transactionBodyBuilder - .setTransactionID(TransactionID.newBuilder() - .setTransactionValidStart(Timestamp.newBuilder() - .setNanos(id.validStart.getNano()) - .setSeconds(id.validStart.getEpochSecond()) - .build()) - .setAccountID(AccountID.newBuilder() - .setAccountNum(542348) - .setRealmNum(0) - .setShardNum(0) - .build()) - .build()) - .setNodeAccountID(AccountID.newBuilder() - .setAccountNum(3) - .setRealmNum(0) - .setShardNum(0) - .build() - ) - .setTransactionFee(200_000_000) - .setTransactionValidDuration( - Duration.newBuilder() - .setSeconds(120) - .build() - ) - .setGenerateRecord(false) - .setMemo("") - .setCryptoTransfer( - CryptoTransferTransactionBody.newBuilder() - .setTransfers(TransferList.newBuilder() - .addAccountAmounts(AccountAmount.newBuilder() - .setAccountID(AccountID.newBuilder() - .setAccountNum(47439) - .setRealmNum(0) - .setShardNum(0) + .setTransactionID(TransactionID.newBuilder() + .setTransactionValidStart(Timestamp.newBuilder() + .setNanos(id.validStart.getNano()) + .setSeconds(id.validStart.getEpochSecond()) .build()) - .setAmount(10) - .build()) - .addAccountAmounts(AccountAmount.newBuilder() - .setAccountID(AccountID.newBuilder() + .setAccountID(AccountID.newBuilder() .setAccountNum(542348) .setRealmNum(0) .setShardNum(0) .build()) - .setAmount(-10) - .build()) .build()) - .build()); + .setNodeAccountID(AccountID.newBuilder() + .setAccountNum(3) + .setRealmNum(0) + .setShardNum(0) + .build()) + .setTransactionFee(200_000_000) + .setTransactionValidDuration( + Duration.newBuilder() + .setSeconds(120) + .build()) + .setGenerateRecord(false) + .setMemo("") + .setCryptoTransfer( + CryptoTransferTransactionBody.newBuilder() + .setTransfers(TransferList.newBuilder() + .addAccountAmounts(AccountAmount.newBuilder() + .setAccountID(AccountID.newBuilder() + .setAccountNum(47439) + .setRealmNum(0) + .setShardNum(0) + .build()) + .setAmount(10) + .build()) + .addAccountAmounts(AccountAmount.newBuilder() + .setAccountID(AccountID.newBuilder() + .setAccountNum(542348) + .setRealmNum(0) + .setShardNum(0) + .build()) + .setAmount(-10) + .build()) + .build()) + .build()); var bodyBytes = transactionBodyBuilder.build().toByteString(); - var key1 = PrivateKey.fromString("302e020100300506032b6570042204203e7fda6dde63c3cdb3cb5ecf5264324c5faad7c9847b6db093c088838b35a110"); - var key2 = PrivateKey.fromString("302e020100300506032b65700422042032d3d5a32e9d06776976b39c09a31fbda4a4a0208223da761c26a2ae560c1755"); - var key3 = PrivateKey.fromString("302e020100300506032b657004220420195a919056d1d698f632c228dbf248bbbc3955adf8a80347032076832b8299f9"); - var key4 = PrivateKey.fromString("302e020100300506032b657004220420b9962f17f94ffce73a23649718a11638cac4b47095a7a6520e88c7563865be62"); - var key5 = PrivateKey.fromString("302e020100300506032b657004220420fef68591819080cd9d48b0cbaa10f65f919752abb50ffb3e7411ac66ab22692e"); + var key1 = PrivateKey.fromString( + "302e020100300506032b6570042204203e7fda6dde63c3cdb3cb5ecf5264324c5faad7c9847b6db093c088838b35a110"); + var key2 = PrivateKey.fromString( + "302e020100300506032b65700422042032d3d5a32e9d06776976b39c09a31fbda4a4a0208223da761c26a2ae560c1755"); + var key3 = PrivateKey.fromString( + "302e020100300506032b657004220420195a919056d1d698f632c228dbf248bbbc3955adf8a80347032076832b8299f9"); + var key4 = PrivateKey.fromString( + "302e020100300506032b657004220420b9962f17f94ffce73a23649718a11638cac4b47095a7a6520e88c7563865be62"); + var key5 = PrivateKey.fromString( + "302e020100300506032b657004220420fef68591819080cd9d48b0cbaa10f65f919752abb50ffb3e7411ac66ab22692e"); var publicKey1 = key1.getPublicKey(); var publicKey2 = key2.getPublicKey(); @@ -833,60 +859,65 @@ void transactionFromToBytes2() { var signedBuilder = SignedTransaction.newBuilder(); signedBuilder - .setBodyBytes(bodyBytes) - .setSigMap(SignatureMap.newBuilder() - .addSigPair(SignaturePair.newBuilder() - .setEd25519(ByteString.copyFrom(signature1)) - .setPubKeyPrefix(ByteString.copyFrom(publicKey1.toBytes())) - .build()) - .addSigPair(SignaturePair.newBuilder() - .setEd25519(ByteString.copyFrom(signature2)) - .setPubKeyPrefix(ByteString.copyFrom(publicKey2.toBytes())) - .build()) - .addSigPair(SignaturePair.newBuilder() - .setEd25519(ByteString.copyFrom(signature3)) - .setPubKeyPrefix(ByteString.copyFrom(publicKey3.toBytes())) - .build()) - .addSigPair(SignaturePair.newBuilder() - .setEd25519(ByteString.copyFrom(signature4)) - .setPubKeyPrefix(ByteString.copyFrom(publicKey4.toBytes())) - .build()) - .addSigPair(SignaturePair.newBuilder() - .setEd25519(ByteString.copyFrom(signature5)) - .setPubKeyPrefix(ByteString.copyFrom(publicKey5.toBytes())) - .build()) - ); - @Var var byts = signedBuilder.build().toByteString(); + .setBodyBytes(bodyBytes) + .setSigMap(SignatureMap.newBuilder() + .addSigPair(SignaturePair.newBuilder() + .setEd25519(ByteString.copyFrom(signature1)) + .setPubKeyPrefix(ByteString.copyFrom(publicKey1.toBytes())) + .build()) + .addSigPair(SignaturePair.newBuilder() + .setEd25519(ByteString.copyFrom(signature2)) + .setPubKeyPrefix(ByteString.copyFrom(publicKey2.toBytes())) + .build()) + .addSigPair(SignaturePair.newBuilder() + .setEd25519(ByteString.copyFrom(signature3)) + .setPubKeyPrefix(ByteString.copyFrom(publicKey3.toBytes())) + .build()) + .addSigPair(SignaturePair.newBuilder() + .setEd25519(ByteString.copyFrom(signature4)) + .setPubKeyPrefix(ByteString.copyFrom(publicKey4.toBytes())) + .build()) + .addSigPair(SignaturePair.newBuilder() + .setEd25519(ByteString.copyFrom(signature5)) + .setPubKeyPrefix(ByteString.copyFrom(publicKey5.toBytes())) + .build())); + @Var + var byts = signedBuilder.build().toByteString(); byts = TransactionList.newBuilder() - .addTransactionList(com.hedera.hashgraph.sdk.proto.Transaction.newBuilder() - .setSignedTransactionBytes(byts) - .build()) - .build().toByteString(); + .addTransactionList(com.hedera.hashgraph.sdk.proto.Transaction.newBuilder() + .setSignedTransactionBytes(byts) + .build()) + .build().toByteString(); var tx = (TransferTransaction) Transaction.fromBytes(byts.toByteArray()); - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - assertThat(tx.getHbarTransfers().get(new AccountId(542348)).toTinybars()).isEqualTo(-10); - assertThat(tx.getHbarTransfers().get(new AccountId(47439)).toTinybars()).isEqualTo(10); + assertThat(tx.getHbarTransfers().get(new AccountId(542348)).toTinybars()).isEqualTo(-10); + assertThat(tx.getHbarTransfers().get(new AccountId(47439)).toTinybars()).isEqualTo(10); - assertThat(tx.getNodeAccountIds()).isNotNull(); - assertThat(tx.getNodeAccountIds().size()).isEqualTo(1); - assertThat(tx.getNodeAccountIds().get(0)).isEqualTo(new AccountId(3)); + assertThat(tx.getNodeAccountIds()).isNotNull(); + assertThat(tx.getNodeAccountIds().size()).isEqualTo(1); + assertThat(tx.getNodeAccountIds().get(0)).isEqualTo(new AccountId(3)); - var signatures = tx.getSignatures(); - assertThat(Arrays.toString(signatures.get(new AccountId(3)).get(publicKey1))).isEqualTo(Arrays.toString(signature1)); - assertThat(Arrays.toString(signatures.get(new AccountId(3)).get(publicKey2))).isEqualTo(Arrays.toString(signature2)); - assertThat(Arrays.toString(signatures.get(new AccountId(3)).get(publicKey3))).isEqualTo(Arrays.toString(signature3)); - assertThat(Arrays.toString(signatures.get(new AccountId(3)).get(publicKey4))).isEqualTo(Arrays.toString(signature4)); - assertThat(Arrays.toString(signatures.get(new AccountId(3)).get(publicKey5))).isEqualTo(Arrays.toString(signature5)); + var signatures = tx.getSignatures(); + assertThat(Arrays.toString(signatures.get(new AccountId(3)).get(publicKey1))) + .isEqualTo(Arrays.toString(signature1)); + assertThat(Arrays.toString(signatures.get(new AccountId(3)).get(publicKey2))) + .isEqualTo(Arrays.toString(signature2)); + assertThat(Arrays.toString(signatures.get(new AccountId(3)).get(publicKey3))) + .isEqualTo(Arrays.toString(signature3)); + assertThat(Arrays.toString(signatures.get(new AccountId(3)).get(publicKey4))) + .isEqualTo(Arrays.toString(signature4)); + assertThat(Arrays.toString(signatures.get(new AccountId(3)).get(publicKey5))) + .isEqualTo(Arrays.toString(signature5)); - var resp = tx.execute(testEnv.client); + var resp = tx.execute(testEnv.client); - resp.getReceipt(testEnv.client); + resp.getReceipt(testEnv.client); - testEnv.close(); + } }); } } diff --git a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TransactionResponseTest.java b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TransactionResponseTest.java index f8e1fb37a..ab85d144d 100644 --- a/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TransactionResponseTest.java +++ b/sdk/src/testIntegration/java/com/hedera/hashgraph/sdk/test/integration/TransactionResponseTest.java @@ -30,22 +30,22 @@ public class TransactionResponseTest { @Test @DisplayName("transaction hash in transaction record is equal to the transaction response transaction hash") void transactionHashInTransactionRecordIsEqualToTheTransactionResponseTransactionHash() throws Exception { - var testEnv = new IntegrationTestEnv(1); + try (var testEnv = new IntegrationTestEnv(1)) { - var key = PrivateKey.generateED25519(); + var key = PrivateKey.generateED25519(); - var transaction = new AccountCreateTransaction() - .setKey(key) - .execute(testEnv.client); + var transaction = new AccountCreateTransaction() + .setKey(key) + .execute(testEnv.client); - var record = transaction.getRecord(testEnv.client); + var record = transaction.getRecord(testEnv.client); - assertThat(record.transactionHash.toByteArray()).containsExactly(transaction.transactionHash); + assertThat(record.transactionHash.toByteArray()).containsExactly(transaction.transactionHash); - var accountId = record.receipt.accountId; - assertThat(accountId).isNotNull(); + var accountId = record.receipt.accountId; + assertThat(accountId).isNotNull(); - testEnv.close(accountId, key); + } } } From 470193a6f54ea32a82db91f68b2490511ec89786 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Thu, 10 Oct 2024 10:42:28 +0300 Subject: [PATCH 8/8] chore(deps): bump actions/checkout from 4.1.7 to 4.2.1 (#2029) Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: Ivan Ivanov Signed-off-by: Jeffery Orazulike --- .github/workflows/build.yml | 8 ++++---- .github/workflows/pages.yml | 2 +- .github/workflows/release-artifacts.yml | 4 ++-- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 832094d1e..ffe2229e2 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -36,7 +36,7 @@ jobs: egress-policy: audit - name: Checkout Code - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7 + uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4.2.1 - name: Setup Java uses: actions/setup-java@b36c23c0d998641eff861008f374ee103c25ac73 # v4.4.0 @@ -64,7 +64,7 @@ jobs: egress-policy: audit - name: Checkout Code - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7 + uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4.2.1 with: fetch-depth: 0 # Shallow clones should be disabled for a better relevancy of analysis @@ -128,7 +128,7 @@ jobs: egress-policy: audit - name: Checkout Code - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7 + uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4.2.1 - name: Setup NodeJS uses: actions/setup-node@0a44ba7841725637a19e28fa30b79a866c81b0a6 # v4.0.4 @@ -178,7 +178,7 @@ jobs: - build steps: - name: Checkout Code - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7 + uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4.2.1 with: fetch-depth: 0 # Shallow clones should be disabled for a better relevancy of analysis diff --git a/.github/workflows/pages.yml b/.github/workflows/pages.yml index 2c36e1b5e..d570da5f4 100644 --- a/.github/workflows/pages.yml +++ b/.github/workflows/pages.yml @@ -29,7 +29,7 @@ jobs: egress-policy: audit - name: Checkout Code - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7 + uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4.2.1 - name: Setup Java uses: actions/setup-java@b36c23c0d998641eff861008f374ee103c25ac73 # v4.4.0 diff --git a/.github/workflows/release-artifacts.yml b/.github/workflows/release-artifacts.yml index a892413c2..7f6078a32 100644 --- a/.github/workflows/release-artifacts.yml +++ b/.github/workflows/release-artifacts.yml @@ -35,7 +35,7 @@ jobs: egress-policy: audit - name: Checkout Code - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7 + uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4.2.1 - name: Retrieve Tag Version if: ${{ github.event_name == 'push' }} @@ -85,7 +85,7 @@ jobs: egress-policy: audit - name: Checkout Code - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7 + uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4.2.1 - name: Install GnuPG Tools run: |