From 39cb27707ad6a91669abc515725ec3556d22ea8f Mon Sep 17 00:00:00 2001 From: JeffreyDallas <39912573+JeffreyDallas@users.noreply.github.com> Date: Thu, 14 Dec 2023 21:27:59 -0600 Subject: [PATCH 01/13] chore: Disable some reconnect and upgrade tests for coming hedera modularization (#10492) --- .../node-flow-fsts-daily-interval-04.yaml | 46 ++++----- .../node-flow-fsts-daily-regression.yaml | 98 +++++++++---------- 2 files changed, 72 insertions(+), 72 deletions(-) diff --git a/.github/workflows/node-flow-fsts-daily-interval-04.yaml b/.github/workflows/node-flow-fsts-daily-interval-04.yaml index 2fb9fbd44e3f..fb5c3abd83d2 100644 --- a/.github/workflows/node-flow-fsts-daily-interval-04.yaml +++ b/.github/workflows/node-flow-fsts-daily-interval-04.yaml @@ -42,11 +42,11 @@ concurrency: # "configs/services/suites/daily/GCP-Daily-Services-Comp-3NReconnect-15N-4C.json" ---- 90m # "configs/services/suites/daily/GCP-Daily-Services-Global-3NReconnect-15N-4C.json" ---- 90m -# TOTAL RUN TIME: 180 minutes, 3 hours +# TOTAL RUN TIME: 90 minutes, 1.5 hours # # Parallel job(s): # -# comp-3nreconnect-15n-4c -> global-3nreconnect-15n-4c +# comp-3nreconnect-15n-4c jobs: @@ -71,24 +71,24 @@ jobs: if: ${{ !cancelled() && always() }} - global-3nreconnect-15n-4c: - name: Global-3NReconnect-15N-4C - uses: ./.github/workflows/zxc-jrs-regression.yaml - with: - ref: ${{ github.event.inputs.ref }} - branch-name: ${{ github.event.inputs.branch-name }} - hedera-tests-enabled: true - use-branch-for-slack-channel: true - panel-config: "configs/services/suites/daily/GCP-Daily-Services-Global-3NReconnect-15N-4C.json" - secrets: - access-token: ${{ secrets.PLATFORM_GH_ACCESS_TOKEN }} - jrs-ssh-user-name: ${{ secrets.PLATFORM_JRS_SSH_USER_NAME }} - jrs-ssh-key-file: ${{ secrets.PLATFORM_JRS_SSH_KEY_FILE }} - gcp-project-number: ${{ secrets.PLATFORM_GCP_PROJECT_NUMBER }} - gcp-sa-key-contents: ${{ secrets.PLATFORM_GCP_KEY_FILE }} - slack-api-token: ${{ secrets.PLATFORM_SLACK_API_TOKEN }} - gradle-cache-username: ${{ secrets.GRADLE_CACHE_USERNAME }} - gradle-cache-password: ${{ secrets.GRADLE_CACHE_PASSWORD }} - needs: - - comp-3nreconnect-15n-4c - if: ${{ !cancelled() && always() }} +# global-3nreconnect-15n-4c: +# name: Global-3NReconnect-15N-4C +# uses: ./.github/workflows/zxc-jrs-regression.yaml +# with: +# ref: ${{ github.event.inputs.ref }} +# branch-name: ${{ github.event.inputs.branch-name }} +# hedera-tests-enabled: true +# use-branch-for-slack-channel: true +# panel-config: "configs/services/suites/daily/GCP-Daily-Services-Global-3NReconnect-15N-4C.json" +# secrets: +# access-token: ${{ secrets.PLATFORM_GH_ACCESS_TOKEN }} +# jrs-ssh-user-name: ${{ secrets.PLATFORM_JRS_SSH_USER_NAME }} +# jrs-ssh-key-file: ${{ secrets.PLATFORM_JRS_SSH_KEY_FILE }} +# gcp-project-number: ${{ secrets.PLATFORM_GCP_PROJECT_NUMBER }} +# gcp-sa-key-contents: ${{ secrets.PLATFORM_GCP_KEY_FILE }} +# slack-api-token: ${{ secrets.PLATFORM_SLACK_API_TOKEN }} +# gradle-cache-username: ${{ secrets.GRADLE_CACHE_USERNAME }} +# gradle-cache-password: ${{ secrets.GRADLE_CACHE_PASSWORD }} +# needs: +# - comp-3nreconnect-15n-4c +# if: ${{ !cancelled() && always() }} diff --git a/.github/workflows/node-flow-fsts-daily-regression.yaml b/.github/workflows/node-flow-fsts-daily-regression.yaml index 2f3b8a7ce695..4f95c65df8cc 100644 --- a/.github/workflows/node-flow-fsts-daily-regression.yaml +++ b/.github/workflows/node-flow-fsts-daily-regression.yaml @@ -43,37 +43,37 @@ jobs: secrets: access-token: ${{ secrets.PLATFORM_GH_ACCESS_TOKEN }} - interval-02: - name: Interval 2 - uses: ./.github/workflows/platform-zxc-launch-jrs-workflow.yaml - needs: - - interval-01 - with: - ref: ${{ github.event.inputs.ref || github.sha }} - branch-name: ${{ github.event.inputs.branch-name || github.ref_name }} - workflow-file: node-flow-fsts-daily-interval-02.yaml - concurrency-group: ${{ github.event.inputs.ref || github.sha }}-node-flow-fsts-daily-group-02 - secrets: - access-token: ${{ secrets.PLATFORM_GH_ACCESS_TOKEN }} +# interval-02: +# name: Interval 2 +# uses: ./.github/workflows/platform-zxc-launch-jrs-workflow.yaml +# needs: +# - interval-01 +# with: +# ref: ${{ github.event.inputs.ref || github.sha }} +# branch-name: ${{ github.event.inputs.branch-name || github.ref_name }} +# workflow-file: node-flow-fsts-daily-interval-02.yaml +# concurrency-group: ${{ github.event.inputs.ref || github.sha }}-node-flow-fsts-daily-group-02 +# secrets: +# access-token: ${{ secrets.PLATFORM_GH_ACCESS_TOKEN }} - interval-03: - name: Interval 3 - uses: ./.github/workflows/platform-zxc-launch-jrs-workflow.yaml - needs: - - interval-02 - with: - ref: ${{ github.event.inputs.ref || github.sha }} - branch-name: ${{ github.event.inputs.branch-name || github.ref_name }} - workflow-file: node-flow-fsts-daily-interval-03.yaml - concurrency-group: ${{ github.event.inputs.ref || github.sha }}-node-flow-fsts-daily-group-03 - secrets: - access-token: ${{ secrets.PLATFORM_GH_ACCESS_TOKEN }} +# interval-03: +# name: Interval 3 +# uses: ./.github/workflows/platform-zxc-launch-jrs-workflow.yaml +# needs: +# - interval-02 +# with: +# ref: ${{ github.event.inputs.ref || github.sha }} +# branch-name: ${{ github.event.inputs.branch-name || github.ref_name }} +# workflow-file: node-flow-fsts-daily-interval-03.yaml +# concurrency-group: ${{ github.event.inputs.ref || github.sha }}-node-flow-fsts-daily-group-03 +# secrets: +# access-token: ${{ secrets.PLATFORM_GH_ACCESS_TOKEN }} interval-04: name: Interval 4 uses: ./.github/workflows/platform-zxc-launch-jrs-workflow.yaml needs: - - interval-03 + - interval-01 with: ref: ${{ github.event.inputs.ref || github.sha }} branch-name: ${{ github.event.inputs.branch-name || github.ref_name }} @@ -82,28 +82,28 @@ jobs: secrets: access-token: ${{ secrets.PLATFORM_GH_ACCESS_TOKEN }} - interval-05: - name: Interval 5 - uses: ./.github/workflows/platform-zxc-launch-jrs-workflow.yaml - needs: - - interval-04 - with: - ref: ${{ github.event.inputs.ref || github.sha }} - branch-name: ${{ github.event.inputs.branch-name || github.ref_name }} - workflow-file: node-flow-fsts-daily-interval-05.yaml - concurrency-group: ${{ github.event.inputs.ref || github.sha }}-node-flow-fsts-daily-group-05 - secrets: - access-token: ${{ secrets.PLATFORM_GH_ACCESS_TOKEN }} +# interval-05: +# name: Interval 5 +# uses: ./.github/workflows/platform-zxc-launch-jrs-workflow.yaml +# needs: +# - interval-04 +# with: +# ref: ${{ github.event.inputs.ref || github.sha }} +# branch-name: ${{ github.event.inputs.branch-name || github.ref_name }} +# workflow-file: node-flow-fsts-daily-interval-05.yaml +# concurrency-group: ${{ github.event.inputs.ref || github.sha }}-node-flow-fsts-daily-group-05 +# secrets: +# access-token: ${{ secrets.PLATFORM_GH_ACCESS_TOKEN }} - interval-06: - name: Interval 6 - uses: ./.github/workflows/platform-zxc-launch-jrs-workflow.yaml - needs: - - interval-05 - with: - ref: ${{ github.event.inputs.ref || github.sha }} - branch-name: ${{ github.event.inputs.branch-name || github.ref_name }} - workflow-file: node-flow-fsts-daily-interval-06.yaml - concurrency-group: ${{ github.event.inputs.ref || github.sha }}-node-flow-fsts-daily-group-06 - secrets: - access-token: ${{ secrets.PLATFORM_GH_ACCESS_TOKEN }} +# interval-06: +# name: Interval 6 +# uses: ./.github/workflows/platform-zxc-launch-jrs-workflow.yaml +# needs: +# - interval-05 +# with: +# ref: ${{ github.event.inputs.ref || github.sha }} +# branch-name: ${{ github.event.inputs.branch-name || github.ref_name }} +# workflow-file: node-flow-fsts-daily-interval-06.yaml +# concurrency-group: ${{ github.event.inputs.ref || github.sha }}-node-flow-fsts-daily-group-06 +# secrets: +# access-token: ${{ secrets.PLATFORM_GH_ACCESS_TOKEN }} From e49cc5a320ae33a011426ddb00a925f3ef0519de Mon Sep 17 00:00:00 2001 From: Valentin Valkanov Date: Fri, 15 Dec 2023 11:26:15 +0200 Subject: [PATCH 02/13] fix: add record list checkpoint, so following & preceding child records are reverted correctly (#10137) Signed-off-by: Valentin Valkanov --- .../node/app/spi/workflows/HandleContext.java | 30 ++- .../record/RecordListCheckPoint.java | 23 ++ .../workflows/handle/HandleContextImpl.java | 25 ++- .../handle/record/RecordListBuilder.java | 37 ++++ .../handle/HandleContextImplTest.java | 63 ++++++ .../handle/record/RecordListBuilderTest.java | 205 +++++++++++++++++- .../CustomMessageCallProcessor.java | 3 +- .../exec/scope/HandleHederaOperations.java | 10 +- .../impl/exec/scope/HederaOperations.java | 12 +- .../exec/scope/QueryHederaOperations.java | 9 +- .../impl/hevm/HederaWorldUpdater.java | 2 +- .../impl/state/ProxyWorldUpdater.java | 16 +- .../scope/HandleHederaOperationsTest.java | 15 ++ .../opcodes/Create2OperationSuite.java | 2 +- .../suites/leaky/LeakyContractTestsSuite.java | 2 + 15 files changed, 435 insertions(+), 19 deletions(-) create mode 100644 hedera-node/hedera-app-spi/src/main/java/com/hedera/node/app/spi/workflows/record/RecordListCheckPoint.java diff --git a/hedera-node/hedera-app-spi/src/main/java/com/hedera/node/app/spi/workflows/HandleContext.java b/hedera-node/hedera-app-spi/src/main/java/com/hedera/node/app/spi/workflows/HandleContext.java index 7b40dccb3bbd..9f090c0d8528 100644 --- a/hedera-node/hedera-app-spi/src/main/java/com/hedera/node/app/spi/workflows/HandleContext.java +++ b/hedera-node/hedera-app-spi/src/main/java/com/hedera/node/app/spi/workflows/HandleContext.java @@ -37,6 +37,7 @@ import com.hedera.node.app.spi.validation.AttributeValidator; import com.hedera.node.app.spi.validation.ExpiryValidator; import com.hedera.node.app.spi.workflows.record.ExternalizedRecordCustomizer; +import com.hedera.node.app.spi.workflows.record.RecordListCheckPoint; import com.hedera.pbj.runtime.io.buffer.Bytes; import com.swirlds.config.api.Configuration; import edu.umd.cs.findbugs.annotations.NonNull; @@ -396,7 +397,9 @@ T dispatchPrecedingTransaction( * @throws IllegalArgumentException if the transaction body did not have an id */ default T dispatchPrecedingTransaction( - @NonNull TransactionBody txBody, @NonNull Class recordBuilderClass, @NonNull Predicate verifier) { + @NonNull final TransactionBody txBody, + @NonNull final Class recordBuilderClass, + @NonNull final Predicate verifier) { throwIfMissingPayerId(txBody); return dispatchPrecedingTransaction( txBody, @@ -478,7 +481,9 @@ T dispatchRemovablePrecedingTransaction( * @throws IllegalArgumentException if the transaction body did not have an id */ default T dispatchReversiblePrecedingTransaction( - @NonNull TransactionBody txBody, @NonNull Class recordBuilderClass, @NonNull Predicate verifier) { + @NonNull final TransactionBody txBody, + @NonNull final Class recordBuilderClass, + @NonNull final Predicate verifier) { throwIfMissingPayerId(txBody); return dispatchReversiblePrecedingTransaction( txBody, @@ -536,7 +541,9 @@ T dispatchChildTransaction( */ @NonNull default T dispatchScheduledChildTransaction( - @NonNull TransactionBody txBody, @NonNull Class recordBuilderClass, @NonNull Predicate callback) { + @NonNull final TransactionBody txBody, + @NonNull final Class recordBuilderClass, + @NonNull final Predicate callback) { throwIfMissingPayerId(txBody); return dispatchChildTransaction( txBody, @@ -588,7 +595,9 @@ T dispatchRemovableChildTransaction( */ @NonNull default T dispatchRemovableChildTransaction( - @NonNull TransactionBody txBody, @NonNull Class recordBuilderClass, @NonNull Predicate callback) { + @NonNull final TransactionBody txBody, + @NonNull final Class recordBuilderClass, + @NonNull final Predicate callback) { throwIfMissingPayerId(txBody); return dispatchRemovableChildTransaction( txBody, @@ -647,9 +656,18 @@ default T dispatchRemovableChildTransaction( SavepointStack savepointStack(); /** - * Revert all child records in RecordListBuilder. + * Revert the childRecords from the checkpoint. */ - void revertChildRecords(); + void revertRecordsFrom(@NonNull RecordListCheckPoint recordListCheckPoint); + + /** + * Create a checkpoint for the current childRecords. + * + * @return the checkpoint for the current childRecords, containing the first preceding record and the last following + * record. + */ + @NonNull + RecordListCheckPoint createRecordListCheckPoint(); /** * A stack of savepoints. diff --git a/hedera-node/hedera-app-spi/src/main/java/com/hedera/node/app/spi/workflows/record/RecordListCheckPoint.java b/hedera-node/hedera-app-spi/src/main/java/com/hedera/node/app/spi/workflows/record/RecordListCheckPoint.java new file mode 100644 index 000000000000..96df06164e17 --- /dev/null +++ b/hedera-node/hedera-app-spi/src/main/java/com/hedera/node/app/spi/workflows/record/RecordListCheckPoint.java @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2023 Hedera Hashgraph, LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.hedera.node.app.spi.workflows.record; + +import edu.umd.cs.findbugs.annotations.Nullable; + +public record RecordListCheckPoint( + @Nullable SingleTransactionRecordBuilder firstPrecedingRecord, + @Nullable SingleTransactionRecordBuilder lastFollowingRecord) {} diff --git a/hedera-node/hedera-app/src/main/java/com/hedera/node/app/workflows/handle/HandleContextImpl.java b/hedera-node/hedera-app/src/main/java/com/hedera/node/app/workflows/handle/HandleContextImpl.java index c3e4aa2cc76f..e5672489556b 100644 --- a/hedera-node/hedera-app/src/main/java/com/hedera/node/app/workflows/handle/HandleContextImpl.java +++ b/hedera-node/hedera-app/src/main/java/com/hedera/node/app/workflows/handle/HandleContextImpl.java @@ -71,6 +71,8 @@ import com.hedera.node.app.spi.workflows.PreCheckException; import com.hedera.node.app.spi.workflows.TransactionKeys; import com.hedera.node.app.spi.workflows.record.ExternalizedRecordCustomizer; +import com.hedera.node.app.spi.workflows.record.RecordListCheckPoint; +import com.hedera.node.app.spi.workflows.record.SingleTransactionRecordBuilder; import com.hedera.node.app.state.HederaRecordCache; import com.hedera.node.app.state.WrappedHederaState; import com.hedera.node.app.workflows.SolvencyPreCheck; @@ -835,8 +837,27 @@ public SavepointStack savepointStack() { } @Override - public void revertChildRecords() { - recordListBuilder.revertChildrenOf(recordBuilder); + public void revertRecordsFrom(@NonNull final RecordListCheckPoint checkpoint) { + recordListBuilder.revertChildrenFrom(checkpoint); + } + + @NonNull + @Override + public RecordListCheckPoint createRecordListCheckPoint() { + final var precedingRecordBuilders = recordListBuilder.precedingRecordBuilders(); + final var childRecordBuilders = recordListBuilder.childRecordBuilders(); + + SingleTransactionRecordBuilder lastFollowing = null; + SingleTransactionRecordBuilder firstPreceding = null; + + if (!precedingRecordBuilders.isEmpty()) { + firstPreceding = precedingRecordBuilders.get(precedingRecordBuilders.size() - 1); + } + if (!childRecordBuilders.isEmpty()) { + lastFollowing = childRecordBuilders.get(childRecordBuilders.size() - 1); + } + + return new RecordListCheckPoint(firstPreceding, lastFollowing); } public enum PrecedingTransactionCategory { diff --git a/hedera-node/hedera-app/src/main/java/com/hedera/node/app/workflows/handle/record/RecordListBuilder.java b/hedera-node/hedera-app/src/main/java/com/hedera/node/app/workflows/handle/record/RecordListBuilder.java index 8291ae04647a..974fca772924 100644 --- a/hedera-node/hedera-app/src/main/java/com/hedera/node/app/workflows/handle/record/RecordListBuilder.java +++ b/hedera-node/hedera-app/src/main/java/com/hedera/node/app/workflows/handle/record/RecordListBuilder.java @@ -28,6 +28,7 @@ import com.hedera.node.app.spi.workflows.HandleContext.TransactionCategory; import com.hedera.node.app.spi.workflows.HandleException; import com.hedera.node.app.spi.workflows.record.ExternalizedRecordCustomizer; +import com.hedera.node.app.spi.workflows.record.RecordListCheckPoint; import com.hedera.node.app.state.SingleTransactionRecord; import com.hedera.node.app.workflows.handle.HandleContextImpl; import com.hedera.node.app.workflows.handle.record.SingleTransactionRecordBuilderImpl.ReversingBehavior; @@ -395,6 +396,42 @@ public void revertChildrenOf(@NonNull final SingleTransactionRecordBuilderImpl r } } + /** + * Reverts or removes all child transactions after the given checkpoint. + * If there are no following records in the checkpoint, it means that the revert was executed on the user transaction. + */ + public void revertChildrenFrom(@NonNull final RecordListCheckPoint checkPoint) { + requireNonNull(checkPoint, "the record checkpoint must not be null"); + // The revert was executed on the user transaction + if (checkPoint.lastFollowingRecord() == null) { + revertChildrenOf(userTxnRecordBuilder); + return; + } + + // We get to here when the revert was executed on a child transaction + // We need to revert all children that were added after the child transaction that was reverted + revertChildrenOf((SingleTransactionRecordBuilderImpl) checkPoint.lastFollowingRecord()); + + // We also need to revert all preceding transactions that were added after the first preceding transaction + var firstPrecedingRecord = (SingleTransactionRecordBuilderImpl) checkPoint.firstPrecedingRecord(); + if (firstPrecedingRecord != null) { + final var indexOf = precedingTxnRecordBuilders.indexOf(firstPrecedingRecord) + 1; + if (indexOf == 0) { + // This should never happen since the firstPrecedingRecord is not null + throw new IllegalArgumentException("Preceding recordBuilder not found"); + } + for (int i = indexOf; i < precedingTxnRecordBuilders.size(); i++) { + final var preceding = precedingTxnRecordBuilders.get(i); + if (preceding.reversingBehavior() == ReversingBehavior.REVERSIBLE + && SUCCESSES.contains(preceding.status())) { + preceding.status(ResponseCodeEnum.REVERTED_SUCCESS); + } else if (preceding.reversingBehavior() == ReversingBehavior.REMOVABLE) { + precedingTxnRecordBuilders.set(i, null); + } + } + } + } + /** * Builds a list of all records. Assigns transactions IDs as needed. * diff --git a/hedera-node/hedera-app/src/test/java/com/hedera/node/app/workflows/handle/HandleContextImplTest.java b/hedera-node/hedera-app/src/test/java/com/hedera/node/app/workflows/handle/HandleContextImplTest.java index ef1642f64138..0cac4d464e59 100644 --- a/hedera-node/hedera-app/src/test/java/com/hedera/node/app/workflows/handle/HandleContextImplTest.java +++ b/hedera-node/hedera-app/src/test/java/com/hedera/node/app/workflows/handle/HandleContextImplTest.java @@ -85,6 +85,7 @@ import com.hedera.node.app.spi.workflows.HandleException; import com.hedera.node.app.spi.workflows.PreCheckException; import com.hedera.node.app.spi.workflows.PreHandleContext; +import com.hedera.node.app.spi.workflows.record.RecordListCheckPoint; import com.hedera.node.app.spi.workflows.record.SingleTransactionRecordBuilder; import com.hedera.node.app.state.HederaRecordCache; import com.hedera.node.app.state.HederaState; @@ -278,6 +279,68 @@ void testConstructorWithInvalidArguments() { } } + @Nested + @DisplayName("Handling of record list checkpoint creation") + final class RevertRecordFromCheckPointTest { + + private HandleContextImpl subject; + + @BeforeEach + void setUp() { + when(stack.createWritableStates(TokenService.NAME)) + .thenReturn(MapWritableStates.builder() + .state(MapWritableKVState.builder("ACCOUNTS").build()) + .state(MapWritableKVState.builder("ALIASES").build()) + .build()); + subject = createContext(defaultTransactionBody()); + } + + @Test + void success_createRecordListCheckPoint() { + // given + var precedingRecord = createRecordBuilder(); + var childRecord = createRecordBuilder(); + given(recordListBuilder.precedingRecordBuilders()).willReturn(List.of(precedingRecord)); + given(recordListBuilder.childRecordBuilders()).willReturn(List.of(childRecord)); + + // when + final var actual = subject.createRecordListCheckPoint(); + + // then + assertThat(actual).isEqualTo(new RecordListCheckPoint(precedingRecord, childRecord)); + } + + @Test + void success_createRecordListCheckPoint_MultipleRecords() { + // given + var precedingRecord = createRecordBuilder(); + var precedingRecord1 = createRecordBuilder(); + var childRecord = createRecordBuilder(); + var childRecord1 = createRecordBuilder(); + + given(recordListBuilder.precedingRecordBuilders()).willReturn(List.of(precedingRecord, precedingRecord1)); + given(recordListBuilder.childRecordBuilders()).willReturn(List.of(childRecord, childRecord1)); + + // when + final var actual = subject.createRecordListCheckPoint(); + + // then + assertThat(actual).isEqualTo(new RecordListCheckPoint(precedingRecord1, childRecord1)); + } + + @Test + void success_createRecordListCheckPoint_null_values() { + // when + final var actual = subject.createRecordListCheckPoint(); + // then + assertThat(actual).isEqualTo(new RecordListCheckPoint(null, null)); + } + + private static SingleTransactionRecordBuilderImpl createRecordBuilder() { + return new SingleTransactionRecordBuilderImpl(Instant.EPOCH); + } + } + @Nested @DisplayName("Handling new EntityNumber") final class EntityIdNumTest { diff --git a/hedera-node/hedera-app/src/test/java/com/hedera/node/app/workflows/handle/record/RecordListBuilderTest.java b/hedera-node/hedera-app/src/test/java/com/hedera/node/app/workflows/handle/record/RecordListBuilderTest.java index dc8313b6ff9c..1bea9c0f3524 100644 --- a/hedera-node/hedera-app/src/test/java/com/hedera/node/app/workflows/handle/record/RecordListBuilderTest.java +++ b/hedera-node/hedera-app/src/test/java/com/hedera/node/app/workflows/handle/record/RecordListBuilderTest.java @@ -24,6 +24,7 @@ import static com.hedera.node.app.workflows.handle.HandleContextImpl.PrecedingTransactionCategory.LIMITED_CHILD_RECORDS; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.api.Assertions.assertThrows; import com.hedera.hapi.node.base.ResponseCodeEnum; import com.hedera.hapi.node.base.Timestamp; @@ -31,6 +32,7 @@ import com.hedera.hapi.node.base.TransactionID; import com.hedera.node.app.AppTestBase; import com.hedera.node.app.spi.workflows.HandleException; +import com.hedera.node.app.spi.workflows.record.RecordListCheckPoint; import com.hedera.node.app.state.SingleTransactionRecord; import com.hedera.node.config.data.ConsensusConfig; import com.hedera.node.config.testfixtures.HederaTestConfigBuilder; @@ -858,7 +860,206 @@ void testRevertMultipleMixedChildren() { .hasParent(result.userTransactionRecord()); } - private SingleTransactionRecordBuilderImpl addUserTransaction(RecordListBuilder builder) { + @Test + void revertChildrenFrom_NullCheckpoint_ShouldThrowException() { + final var builder = new RecordListBuilder(Instant.now()); + assertThrows(NullPointerException.class, () -> builder.revertChildrenFrom(null)); + } + + @Test + void revertChildrenFrom_CheckpointWithNoChildren_ShouldUseUserTransactionRecord() { + // given + final var recordListBuilder = new RecordListBuilder(Instant.now()); + final var checkpoint = new RecordListCheckPoint(null, null); + addUserTransaction(recordListBuilder); + + // when + recordListBuilder.revertChildrenFrom(checkpoint); + + // then + final var result = recordListBuilder.build(); + assertThat(result.records()).hasSize(1); + assertThat(result.records().get(0)).isSameAs(result.userTransactionRecord()); + } + + @Test + void revertChildrenFrom_NotFound_PrecedingInList() { + // given + final var consensusTime = Instant.now(); + final var recordListBuilder = new RecordListBuilder(consensusTime); + addUserTransaction(recordListBuilder); + + // When + final var followingChild = + recordListBuilder.addChild(CONFIGURATION, CHILD).transaction(simpleCryptoTransfer()); + final var nonExistentPreceding = new SingleTransactionRecordBuilderImpl(Instant.EPOCH); + final var recordListCheckPoint = new RecordListCheckPoint(nonExistentPreceding, followingChild); + + // then + assertThatThrownBy(() -> recordListBuilder.revertChildrenFrom(recordListCheckPoint)) + .isInstanceOf(IllegalArgumentException.class); + } + + @Test + void revertChildrenFrom_Correctly_Revert_ChildrenBothWays() { + // Given + final var consensusTime = Instant.now(); + final var recordListBuilder = new RecordListBuilder(consensusTime); + final var builder = addUserTransaction(recordListBuilder); + final var txnId = builder.transactionID(); + + final var first = simpleCryptoTransferWithNonce(txnId, 2); + final var second = simpleCryptoTransferWithNonce(txnId, 1); + final var third = simpleCryptoTransferWithNonce(txnId, 3); + final var fourth = simpleCryptoTransferWithNonce(txnId, 4); + // mixing up preceding vs. following, but within which, in order + var following = recordListBuilder.addChild(CONFIGURATION, CHILD).transaction(third); + var preceding = recordListBuilder + .addPreceding(CONFIGURATION, LIMITED_CHILD_RECORDS) + .transaction(first); + recordListBuilder.addPreceding(CONFIGURATION, LIMITED_CHILD_RECORDS).transaction(second); + recordListBuilder.addChild(CONFIGURATION, CHILD).transaction(fourth); + + final var recordListCheckPoint = new RecordListCheckPoint(preceding, following); + + // When + recordListBuilder.revertChildrenFrom(recordListCheckPoint); + final var result = recordListBuilder.build(); + final var records = result.records(); + + // Then + assertThat(records).hasSize(5); + assertThat(records.get(2)).isSameAs(result.userTransactionRecord()); + assertCreatedRecord(records.get(0)) + .nanosBefore(2, result.userTransactionRecord()) + .hasNonce(2) + .hasNoParent() + .hasTransaction(first); + assertCreatedRecord(records.get(1)) + .nanosBefore(1, result.userTransactionRecord()) + .hasNonce(1) + .hasNoParent() + .hasTransaction(second); + assertCreatedRecord(records.get(2)).hasNonce(0).hasNoParent(); + assertCreatedRecord(records.get(3)) + .nanosAfter(1, result.userTransactionRecord()) + .hasNonce(3) + .hasParent(result.userTransactionRecord()) + .hasTransaction(third); + assertCreatedRecord(records.get(4)) + .nanosAfter(2, result.userTransactionRecord()) + .hasNonce(4) + .hasResponseCode(REVERTED_SUCCESS) + .hasParent(result.userTransactionRecord()) + .hasTransaction(fourth); + } + + @Test + void revertChildrenFrom_Correctly_Revert_FollowingChild() { + // Given + final var consensusTime = Instant.now(); + final var recordListBuilder = new RecordListBuilder(consensusTime); + + addUserTransaction(recordListBuilder); + final var followingChild = + recordListBuilder.addChild(CONFIGURATION, CHILD).transaction(simpleCryptoTransfer()); + recordListBuilder.addChild(CONFIGURATION, CHILD).transaction(simpleCryptoTransfer()); + final var recordListCheckPoint = new RecordListCheckPoint(null, followingChild); + + // When + recordListBuilder.revertChildrenFrom(recordListCheckPoint); + final var result = recordListBuilder.build(); + final var records = result.records(); + + // Then the following child should be reverted + assertThat(records).hasSize(3); + assertThat(records.get(0)).isSameAs(result.userTransactionRecord()); + assertCreatedRecord(records.get(0)).hasNonce(0).hasResponseCode(OK).hasNoParent(); + assertCreatedRecord(records.get(1)) + .nanosAfter(1, result.userTransactionRecord()) + .hasNonce(1) + .hasResponseCode(OK) + .hasParent(result.userTransactionRecord()); + assertCreatedRecord(records.get(2)) + .nanosAfter(2, result.userTransactionRecord()) + .hasNonce(2) + .hasResponseCode(REVERTED_SUCCESS) + .hasParent(result.userTransactionRecord()); + } + + @Test + void revertChildrenFrom_Correctly_Revert_RemovableFollowingChild() { + // Given + final var consensusTime = Instant.now(); + final var recordListBuilder = new RecordListBuilder(consensusTime); + + addUserTransaction(recordListBuilder); + final var followingChild = + recordListBuilder.addRemovableChild(CONFIGURATION).transaction(simpleCryptoTransfer()); + recordListBuilder.addRemovableChild(CONFIGURATION).transaction(simpleCryptoTransfer()); + final var recordListCheckPoint = new RecordListCheckPoint(null, followingChild); + + // When + recordListBuilder.revertChildrenFrom(recordListCheckPoint); + final var result = recordListBuilder.build(); + final var records = result.records(); + + // Then the following child should have been removed from the list + assertThat(records).hasSize(2); + assertThat(records.get(0)).isSameAs(result.userTransactionRecord()); + assertCreatedRecord(records.get(0)).hasNonce(0).hasResponseCode(OK).hasNoParent(); + assertCreatedRecord(records.get(1)).hasResponseCode(OK).hasParent(result.userTransactionRecord()); + } + + @Test + void revertChildrenFrom_Correctly_Revert_RemovablePrecedingChild() { + // Given + final var consensusTime = Instant.now(); + final var recordListBuilder = new RecordListBuilder(consensusTime); + final var builder = addUserTransaction(recordListBuilder); + final var txnId = builder.transactionID(); + + final var first = simpleCryptoTransferWithNonce(txnId, 2); + final var second = simpleCryptoTransferWithNonce(txnId, 1); + final var third = simpleCryptoTransferWithNonce(txnId, 3); + + // mixing up preceding vs. following, but within which, in order + var preceding = recordListBuilder + .addPreceding(CONFIGURATION, LIMITED_CHILD_RECORDS) + .transaction(first); + recordListBuilder.addReversiblePreceding(CONFIGURATION).transaction(second); + var following = recordListBuilder.addChild(CONFIGURATION, CHILD).transaction(third); + + final var recordListCheckPoint = new RecordListCheckPoint(preceding, following); + + // When + recordListBuilder.revertChildrenFrom(recordListCheckPoint); + final var result = recordListBuilder.build(); + final var records = result.records(); + + // Then + assertThat(records).hasSize(4); + assertThat(records.get(2)).isSameAs(result.userTransactionRecord()); + assertCreatedRecord(records.get(0)) + .nanosBefore(2, result.userTransactionRecord()) + .hasNonce(2) + .hasResponseCode(REVERTED_SUCCESS) + .hasNoParent() + .hasTransaction(first); + assertCreatedRecord(records.get(1)) + .nanosBefore(1, result.userTransactionRecord()) + .hasNonce(1) + .hasNoParent() + .hasTransaction(second); + assertCreatedRecord(records.get(2)).hasNonce(0).hasNoParent(); + assertCreatedRecord(records.get(3)) + .nanosAfter(1, result.userTransactionRecord()) + .hasNonce(3) + .hasParent(result.userTransactionRecord()) + .hasTransaction(third); + } + + private SingleTransactionRecordBuilderImpl addUserTransaction(final RecordListBuilder builder) { final var start = Instant.now().minusSeconds(60); final var txnId = TransactionID.newBuilder() .accountID(ALICE.accountID()) @@ -869,7 +1070,7 @@ private SingleTransactionRecordBuilderImpl addUserTransaction(RecordListBuilder .transactionID(txnId); } - private TransactionRecordAssertions assertCreatedRecord(SingleTransactionRecord record) { + private TransactionRecordAssertions assertCreatedRecord(final SingleTransactionRecord record) { return new TransactionRecordAssertions(record); } diff --git a/hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/exec/processors/CustomMessageCallProcessor.java b/hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/exec/processors/CustomMessageCallProcessor.java index b95c2599eb72..18242a281b00 100644 --- a/hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/exec/processors/CustomMessageCallProcessor.java +++ b/hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/exec/processors/CustomMessageCallProcessor.java @@ -278,9 +278,10 @@ private void doHalt( } } + @Override protected void revert(final MessageFrame frame) { super.revert(frame); - // clear child records form any succeeded operations when revert + // Clear the childRecords from the record builder checkpoint in ProxyWorldUpdater, when revert() is called ((HederaWorldUpdater) frame.getWorldUpdater()).revertChildRecords(); } } diff --git a/hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/exec/scope/HandleHederaOperations.java b/hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/exec/scope/HandleHederaOperations.java index de6500d1f0e4..1f09325ff1ee 100644 --- a/hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/exec/scope/HandleHederaOperations.java +++ b/hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/exec/scope/HandleHederaOperations.java @@ -46,6 +46,7 @@ import com.hedera.node.app.service.token.api.TokenServiceApi; import com.hedera.node.app.spi.workflows.HandleContext; import com.hedera.node.app.spi.workflows.record.ExternalizedRecordCustomizer; +import com.hedera.node.app.spi.workflows.record.RecordListCheckPoint; import com.hedera.node.config.data.ContractsConfig; import com.hedera.node.config.data.HederaConfig; import com.hedera.node.config.data.LedgerConfig; @@ -133,8 +134,8 @@ public void revert() { * {@inheritDoc} */ @Override - public void revertChildRecords() { - context.revertChildRecords(); + public void revertRecordsFrom(RecordListCheckPoint checkpoint) { + context.revertRecordsFrom(checkpoint); } /** @@ -370,6 +371,11 @@ public ContractID shardAndRealmValidated(@NonNull final ContractID contractId) { return configValidated(contractId, hederaConfig); } + @Override + public RecordListCheckPoint createRecordListCheckPoint() { + return context.createRecordListCheckPoint(); + } + private void dispatchAndMarkCreation( final long number, @NonNull final CryptoCreateTransactionBody bodyToDispatch, diff --git a/hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/exec/scope/HederaOperations.java b/hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/exec/scope/HederaOperations.java index e75601780be0..fa4c9b3702a7 100644 --- a/hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/exec/scope/HederaOperations.java +++ b/hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/exec/scope/HederaOperations.java @@ -27,6 +27,7 @@ import com.hedera.node.app.service.contract.impl.state.ProxyWorldUpdater; import com.hedera.node.app.service.token.api.ContractChangeSummary; import com.hedera.node.app.spi.state.WritableStates; +import com.hedera.node.app.spi.workflows.record.RecordListCheckPoint; import com.hedera.node.config.data.HederaConfig; import com.hedera.pbj.runtime.io.buffer.Bytes; import edu.umd.cs.findbugs.annotations.NonNull; @@ -66,9 +67,9 @@ public interface HederaOperations { void revert(); /** - * Revert child records. + * Revert child records from the given {@link RecordListCheckPoint}. */ - void revertChildRecords(); + void revertRecordsFrom(RecordListCheckPoint checkpoint); /** * Returns the {@link WritableStates} the {@code ContractService} can use to update @@ -259,6 +260,13 @@ public interface HederaOperations { */ ContractID shardAndRealmValidated(@NonNull ContractID contractId); + /** + * Creates a {@link RecordListCheckPoint} that can be used to revert records from a given point. + * + * @return a {@link RecordListCheckPoint} + */ + RecordListCheckPoint createRecordListCheckPoint(); + /** * Given a {@link ContractID} and the current Hedera config, returns the given id if its shard and realm * match the config; otherwise, returns {@link #MISSING_CONTRACT_ID}. diff --git a/hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/exec/scope/QueryHederaOperations.java b/hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/exec/scope/QueryHederaOperations.java index df5d95b8a42b..a1cf10d4808b 100644 --- a/hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/exec/scope/QueryHederaOperations.java +++ b/hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/exec/scope/QueryHederaOperations.java @@ -25,6 +25,7 @@ import com.hedera.node.app.service.contract.impl.state.ContractStateStore; import com.hedera.node.app.service.token.api.ContractChangeSummary; import com.hedera.node.app.spi.workflows.QueryContext; +import com.hedera.node.app.spi.workflows.record.RecordListCheckPoint; import com.hedera.node.config.data.HederaConfig; import com.hedera.pbj.runtime.io.buffer.Bytes; import edu.umd.cs.findbugs.annotations.NonNull; @@ -77,7 +78,7 @@ public void revert() { } @Override - public void revertChildRecords() { + public void revertRecordsFrom(RecordListCheckPoint checkpoint) { // No-op } @@ -261,6 +262,12 @@ public ContractID shardAndRealmValidated(@NonNull ContractID contractId) { return configValidated(contractId, hederaConfig); } + @Override + public RecordListCheckPoint createRecordListCheckPoint() { + // no op + return null; + } + public void externalizeHollowAccountMerge(@NonNull ContractID contractId, @Nullable Bytes evmAddress) { throw new UnsupportedOperationException("Queries cannot create accounts"); } diff --git a/hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/hevm/HederaWorldUpdater.java b/hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/hevm/HederaWorldUpdater.java index db63ea892413..8ded1f4521a5 100644 --- a/hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/hevm/HederaWorldUpdater.java +++ b/hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/hevm/HederaWorldUpdater.java @@ -281,7 +281,7 @@ void externalizeSystemContractResults( ExchangeRate currentExchangeRate(); /** - * Revert child records. + * Revert the last child record. */ void revertChildRecords(); } diff --git a/hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/state/ProxyWorldUpdater.java b/hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/state/ProxyWorldUpdater.java index ac47e1ef3fa8..6bdf1f079434 100644 --- a/hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/state/ProxyWorldUpdater.java +++ b/hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/state/ProxyWorldUpdater.java @@ -36,6 +36,7 @@ import com.hedera.node.app.service.contract.impl.exec.scope.HandleHederaOperations; import com.hedera.node.app.service.contract.impl.hevm.HederaWorldUpdater; import com.hedera.node.app.spi.workflows.ResourceExhaustedException; +import com.hedera.node.app.spi.workflows.record.RecordListCheckPoint; import edu.umd.cs.findbugs.annotations.NonNull; import edu.umd.cs.findbugs.annotations.Nullable; import java.util.ArrayList; @@ -76,6 +77,12 @@ public class ProxyWorldUpdater implements HederaWorldUpdater { */ @Nullable private final WorldUpdater parent; + + /** + * The current checkpoint of the child records for this ProxyWorldUpdater. + */ + private final RecordListCheckPoint recordListCheckPoint; + /** * The {@link EvmFrameState} managing this {@code ProxyWorldUpdater}'s state. */ @@ -118,6 +125,11 @@ public ProxyWorldUpdater( this.enhancement = requireNonNull(enhancement); this.evmFrameStateFactory = requireNonNull(evmFrameStateFactory); this.evmFrameState = evmFrameStateFactory.get(); + // Everytime we create a new child updater, we need to create a new record list checkpoint containing the + // last preceding record and the first following record, so that we can revert the child records from the + // checkpoint + // when revert() operation is called. + this.recordListCheckPoint = enhancement.operations().createRecordListCheckPoint(); } /** @@ -380,7 +392,9 @@ public void revert() { */ @Override public void revertChildRecords() { - enhancement.operations().revertChildRecords(); + if (recordListCheckPoint != null) { + enhancement.operations().revertRecordsFrom(recordListCheckPoint); + } } /** diff --git a/hedera-node/hedera-smart-contract-service-impl/src/test/java/com/hedera/node/app/service/contract/impl/test/exec/scope/HandleHederaOperationsTest.java b/hedera-node/hedera-smart-contract-service-impl/src/test/java/com/hedera/node/app/service/contract/impl/test/exec/scope/HandleHederaOperationsTest.java index 79e4b904628e..0adbc317aeb5 100644 --- a/hedera-node/hedera-smart-contract-service-impl/src/test/java/com/hedera/node/app/service/contract/impl/test/exec/scope/HandleHederaOperationsTest.java +++ b/hedera-node/hedera-smart-contract-service-impl/src/test/java/com/hedera/node/app/service/contract/impl/test/exec/scope/HandleHederaOperationsTest.java @@ -53,6 +53,7 @@ import com.hedera.node.app.spi.records.BlockRecordInfo; import com.hedera.node.app.spi.workflows.HandleContext; import com.hedera.node.app.spi.workflows.record.ExternalizedRecordCustomizer; +import com.hedera.node.app.spi.workflows.record.RecordListCheckPoint; import com.hedera.pbj.runtime.io.buffer.Bytes; import edu.umd.cs.findbugs.annotations.NonNull; import java.io.IOException; @@ -198,6 +199,20 @@ void useNumberUsesContext() { assertEquals(123L, subject.useNextEntityNumber()); } + @Test + void createRecordListCheckPointUsesContext() { + var recordListCheckPoint = new RecordListCheckPoint(null, null); + given(context.createRecordListCheckPoint()).willReturn(recordListCheckPoint); + assertEquals(recordListCheckPoint, subject.createRecordListCheckPoint()); + } + + @Test + void revertRecordsFromUsesContext() { + var recordListCheckPoint = new RecordListCheckPoint(null, null); + subject.revertRecordsFrom(recordListCheckPoint); + verify(context).revertRecordsFrom(recordListCheckPoint); + } + @Test void commitIsNoopUntilSavepointExposesIt() { given(context.savepointStack()).willReturn(savepointStack); diff --git a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/contract/opcodes/Create2OperationSuite.java b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/contract/opcodes/Create2OperationSuite.java index 9f3a8b81ef15..8fa3b73e5982 100644 --- a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/contract/opcodes/Create2OperationSuite.java +++ b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/contract/opcodes/Create2OperationSuite.java @@ -837,7 +837,7 @@ final HapiSpec eip1014AliasIsPriorityInErcOwnerPrecompile() { } @SuppressWarnings("java:S5669") - // Missing creation record + @HapiTest final HapiSpec canUseAliasesInPrecompilesAndContractKeys() { final var creation2 = CREATE_2_TXN; final var contract = "Create2PrecompileUser"; diff --git a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/leaky/LeakyContractTestsSuite.java b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/leaky/LeakyContractTestsSuite.java index 8592d8c1e621..3c3d2b8df22c 100644 --- a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/leaky/LeakyContractTestsSuite.java +++ b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/leaky/LeakyContractTestsSuite.java @@ -1490,6 +1490,7 @@ final HapiSpec createMinChargeIsTXGasUsedByContractCreate() { resetToDefault(CONTRACTS_MAX_REFUND_PERCENT_OF_GAS_LIMIT1)); } + @HapiTest HapiSpec propagatesNestedCreations() { final var call = "callTxn"; final var creation = "createTxn"; @@ -1719,6 +1720,7 @@ final HapiSpec lazyCreateThroughPrecompileNotSupportedWhenFlagDisabled() { .then(); } + @HapiTest final HapiSpec evmLazyCreateViaSolidityCall() { final var LAZY_CREATE_CONTRACT = "NestedLazyCreateContract"; final var ECDSA_KEY = "ECDSAKey"; From 3a99e37378d8bf037f36a424eab534e24ac4c58f Mon Sep 17 00:00:00 2001 From: Georgi Lazarov Date: Fri, 15 Dec 2023 13:54:18 +0200 Subject: [PATCH 03/13] fix: Correct payer account on `Issue1744Spec` (#10510) This PR adds a civilian payer account for the only test in the Issue1744Spec. This is needed, because some part of the test depends on the fees payed by the first crypto transfer. However previously it depended on account 0.0.2 to be charged, which can't happen Signed-off-by: georgi-l95 Co-authored-by: Michael Tinker --- .../hedera/services/bdd/suites/issues/Issue1744Suite.java | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/issues/Issue1744Suite.java b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/issues/Issue1744Suite.java index df083b329185..decc2c6a4638 100644 --- a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/issues/Issue1744Suite.java +++ b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/issues/Issue1744Suite.java @@ -23,6 +23,7 @@ import static com.hedera.services.bdd.spec.transactions.crypto.HapiCryptoTransfer.tinyBarsFromTo; import static com.hedera.services.bdd.spec.utilops.CustomSpecAssert.allRunFor; +import com.hedera.services.bdd.junit.HapiTest; import com.hedera.services.bdd.junit.HapiTestSuite; import com.hedera.services.bdd.spec.HapiSpec; import com.hedera.services.bdd.spec.queries.meta.HapiGetTxnRecord; @@ -47,11 +48,14 @@ public List getSpecsInSuite() { return List.of(keepsRecordOfPayerIBE()); } - // @HapiTest This will pass after NetworkGetTransactionRecordHandler fee is implemented + @HapiTest public HapiSpec keepsRecordOfPayerIBE() { return defaultHapiSpec("KeepsRecordOfPayerIBE") .given( - cryptoTransfer(tinyBarsFromTo(GENESIS, FUNDING, 1L)).via("referenceTxn"), + cryptoCreate(CIVILIAN_PAYER), + cryptoTransfer(tinyBarsFromTo(GENESIS, FUNDING, 1L)) + .payingWith(CIVILIAN_PAYER) + .via("referenceTxn"), UtilVerbs.withOpContext((spec, ctxLog) -> { HapiGetTxnRecord subOp = getTxnRecord("referenceTxn"); allRunFor(spec, subOp); From e727601b1d85a0795b650f0d763f363b3ba6c8b5 Mon Sep 17 00:00:00 2001 From: Lazar Petrovic Date: Fri, 15 Dec 2023 15:15:47 +0100 Subject: [PATCH 04/13] chore: move saved state controller invocation (#10505) Signed-off-by: Lazar Petrovic --- .../com/swirlds/platform/SwirldsPlatform.java | 14 +++-- .../components/SavedStateController.java | 54 +++++++------------ .../DefaultStateManagementComponent.java | 46 ++++++---------- .../platform/SignedStateFileManagerTests.java | 8 ++- .../state/StateManagementComponentTests.java | 29 +--------- .../state/TestSavedStateController.java | 12 ++--- 6 files changed, 53 insertions(+), 110 deletions(-) diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/SwirldsPlatform.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/SwirldsPlatform.java index 2f0a85390b35..a25c0d1295ee 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/SwirldsPlatform.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/SwirldsPlatform.java @@ -350,6 +350,8 @@ public class SwirldsPlatform implements Platform { /** Manages emergency recovery */ private final EmergencyRecoveryManager emergencyRecoveryManager; + /** Controls which states are saved to disk */ + private final SavedStateController savedStateController; /** * Encapsulated wiring for the platform. @@ -532,8 +534,7 @@ public class SwirldsPlatform implements Platform { final LatestCompleteStateNexus latestCompleteState = new LatestCompleteStateNexus(stateConfig, platformContext.getMetrics()); - final SavedStateController savedStateController = - new SavedStateController(stateConfig, platformWiring.getSaveStateToDiskInput()::offer); + savedStateController = new SavedStateController(stateConfig); final NewLatestCompleteStateConsumer newLatestCompleteStateConsumer = ss -> { // the app comm component will reserve the state, this should be done by the wiring in the future appCommunicationComponent.newLatestCompleteStateEvent(ss); @@ -548,7 +549,7 @@ public class SwirldsPlatform implements Platform { dispatchBuilder, newLatestCompleteStateConsumer, this::handleFatalError, - savedStateController, + platformWiring.getSaveStateToDiskInput()::put, platformWiring.getSignStateInput()::put); // Load the minimum generation into the pre-consensus event writer @@ -625,6 +626,7 @@ public class SwirldsPlatform implements Platform { final InterruptableConsumer newSignedStateFromTransactionsConsumer = rs -> { latestImmutableState.setState(rs.getAndReserve("newSignedStateFromTransactionsConsumer")); latestCompleteState.newIncompleteState(rs.get().getRound()); + savedStateController.markSavedState(rs.getAndReserve("savedStateController.markSavedState")); stateManagementComponent.newSignedStateFromTransactions(rs); }; @@ -858,6 +860,7 @@ public class SwirldsPlatform implements Platform { initialState.getState().getPlatformState().getPlatformData().getMinimumGenerationNonAncient(); latestImmutableState.setState(initialState.reserve("set latest immutable to initial state")); stateManagementComponent.stateToLoad(initialState, SourceOfSignedState.DISK); + savedStateController.registerSignedStateFromDisk(initialState); consensusRoundHandler.loadDataFromSignedState(initialState, false); loadStateIntoConsensus(initialState); @@ -1111,6 +1114,9 @@ private void loadReconnectState(final SignedState signedState) { platformStatusManager.submitStatusAction(new ReconnectCompleteAction(signedState.getRound())); latestImmutableState.setState(signedState.reserve("set latest immutable to reconnect state")); stateManagementComponent.stateToLoad(signedState, SourceOfSignedState.RECONNECT); + savedStateController.reconnectStateReceived( + signedState.reserve("savedStateController.reconnectStateReceived")); + platformWiring.getSaveStateToDiskInput().put(signedState.reserve("save reconnect state to disk")); loadStateIntoConsensus(signedState); loadStateIntoEventCreator(signedState); @@ -1304,7 +1310,7 @@ public void performPcesRecovery() { final StateDumpRequest request = StateDumpRequest.create(signedState.reserve("dumping PCES recovery state")); - signedStateFileManager.dumpStateTask(request); + platformWiring.getDumpStateToDiskInput().put(request); request.waitForFinished().run(); } } diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/components/SavedStateController.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/components/SavedStateController.java index 399d44b6e76b..db1963eb064e 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/components/SavedStateController.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/components/SavedStateController.java @@ -16,14 +16,12 @@ package com.swirlds.platform.components; -import static com.swirlds.logging.legacy.LogMarker.EXCEPTION; import static com.swirlds.logging.legacy.LogMarker.STATE_TO_DISK; import static com.swirlds.platform.state.signed.StateToDiskReason.FIRST_ROUND_AFTER_GENESIS; import static com.swirlds.platform.state.signed.StateToDiskReason.FREEZE_STATE; import static com.swirlds.platform.state.signed.StateToDiskReason.PERIODIC_SNAPSHOT; import static com.swirlds.platform.state.signed.StateToDiskReason.RECONNECT; -import com.swirlds.base.function.BooleanFunction; import com.swirlds.common.config.StateConfig; import com.swirlds.platform.state.signed.ReservedSignedState; import com.swirlds.platform.state.signed.SignedState; @@ -47,45 +45,44 @@ public class SavedStateController { private Instant previousSavedStateTimestamp; /** the state config */ private final StateConfig stateConfig; - /** a function that writes a signed state to disk asynchronously */ - private final BooleanFunction stateWrite; /** * Create a new SavedStateController * * @param stateConfig the state config - * @param stateWrite a function that writes a signed state to disk asynchronously */ - public SavedStateController( - @NonNull final StateConfig stateConfig, @NonNull final BooleanFunction stateWrite) { + public SavedStateController(@NonNull final StateConfig stateConfig) { this.stateConfig = Objects.requireNonNull(stateConfig); - this.stateWrite = Objects.requireNonNull(stateWrite); } /** - * Determine if a signed state should be written to disk. If the state should be written, the state will be passed - * on to the writer to be written asynchronously. + * Determine if a signed state should be written to disk. If the state should be written, the state will be marked + * and then written to disk outside the scope of this class. * - * @param signedState the signed state in question + * @param reservedSignedState the signed state in question */ - public synchronized void maybeSaveState(@NonNull final SignedState signedState) { - - final StateToDiskReason reason = shouldSaveToDisk(signedState, previousSavedStateTimestamp); - - if (reason != null) { - saveToDisk(signedState.reserve("saving to disk"), reason); + public synchronized void markSavedState(@NonNull final ReservedSignedState reservedSignedState) { + try (reservedSignedState) { + final SignedState signedState = reservedSignedState.get(); + final StateToDiskReason reason = shouldSaveToDisk(signedState, previousSavedStateTimestamp); + + if (reason != null) { + markSavingToDisk(reservedSignedState, reason); + } + // if a null reason is returned, then there isn't anything to do, since the state shouldn't be saved } - // if a null reason is returned, then there isn't anything to do, since the state shouldn't be saved } /** * Notifies the controller that a signed state was received from another node during reconnect. The controller saves - * its timestamp and pass it on to be written to disk. + * its timestamp and marks it to be written to disk. * - * @param signedState the signed state that was received from another node during reconnect + * @param reservedSignedState the signed state that was received from another node during reconnect */ - public synchronized void reconnectStateReceived(@NonNull final SignedState signedState) { - saveToDisk(signedState.reserve("saving to disk after reconnect"), RECONNECT); + public synchronized void reconnectStateReceived(@NonNull final ReservedSignedState reservedSignedState) { + try (reservedSignedState) { + markSavingToDisk(reservedSignedState, RECONNECT); + } } /** @@ -97,7 +94,7 @@ public synchronized void registerSignedStateFromDisk(@NonNull final SignedState previousSavedStateTimestamp = signedState.getConsensusTimestamp(); } - private void saveToDisk(@NonNull final ReservedSignedState state, @NonNull final StateToDiskReason reason) { + private void markSavingToDisk(@NonNull final ReservedSignedState state, @NonNull final StateToDiskReason reason) { final SignedState signedState = state.get(); logger.info( STATE_TO_DISK.getMarker(), @@ -107,17 +104,6 @@ private void saveToDisk(@NonNull final ReservedSignedState state, @NonNull final previousSavedStateTimestamp = signedState.getConsensusTimestamp(); signedState.markAsStateToSave(reason); - final boolean accepted = stateWrite.apply(state); - - if (!accepted) { - logger.error( - EXCEPTION.getMarker(), - "Unable to save signed state to disk for round {} due to backlog of " - + "operations in the SignedStateManager task queue.", - signedState.getRound()); - - state.close(); - } } /** diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/components/state/DefaultStateManagementComponent.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/components/state/DefaultStateManagementComponent.java index 1b1d0d9eda3e..ae7ebb4dbcd8 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/components/state/DefaultStateManagementComponent.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/components/state/DefaultStateManagementComponent.java @@ -20,7 +20,6 @@ import com.swirlds.common.config.StateConfig; import com.swirlds.common.context.PlatformContext; import com.swirlds.common.threading.manager.ThreadManager; -import com.swirlds.platform.components.SavedStateController; import com.swirlds.platform.components.common.output.FatalErrorConsumer; import com.swirlds.platform.components.state.output.NewLatestCompleteStateConsumer; import com.swirlds.platform.dispatch.DispatchBuilder; @@ -70,7 +69,7 @@ public class DefaultStateManagementComponent implements StateManagementComponent */ private final SignedStateSentinel signedStateSentinel; - private final SavedStateController savedStateController; + private final Consumer stateFileManager; private final Consumer stateSigner; @@ -81,7 +80,7 @@ public class DefaultStateManagementComponent implements StateManagementComponent * with this. * @param newLatestCompleteStateConsumer consumer to invoke when there is a new latest complete signed state * @param fatalErrorConsumer consumer to invoke when a fatal error has occurred - * @param savedStateController controls which states are saved to disk + * @param stateFileManager writes states to disk */ public DefaultStateManagementComponent( @NonNull final PlatformContext platformContext, @@ -89,7 +88,7 @@ public DefaultStateManagementComponent( @NonNull final DispatchBuilder dispatchBuilder, @NonNull final NewLatestCompleteStateConsumer newLatestCompleteStateConsumer, @NonNull final FatalErrorConsumer fatalErrorConsumer, - @NonNull final SavedStateController savedStateController, + @NonNull final Consumer stateFileManager, @NonNull final Consumer stateSigner) { Objects.requireNonNull(platformContext); @@ -101,7 +100,7 @@ public DefaultStateManagementComponent( final SignedStateMetrics signedStateMetrics = new SignedStateMetrics(platformContext.getMetrics()); this.signedStateGarbageCollector = new SignedStateGarbageCollector(threadManager, signedStateMetrics); this.signedStateSentinel = new SignedStateSentinel(platformContext, threadManager, Time.getCurrent()); - this.savedStateController = Objects.requireNonNull(savedStateController); + this.stateFileManager = Objects.requireNonNull(stateFileManager); this.stateSigner = Objects.requireNonNull(stateSigner); hashLogger = @@ -115,38 +114,23 @@ public DefaultStateManagementComponent( platformContext.getConfiguration().getConfigData(StateConfig.class), signedStateMetrics, newLatestCompleteStateConsumer, - this::stateHasEnoughSignatures, - this::stateLacksSignatures); + this::signatureCollectionDone, + this::signatureCollectionDone); } /** - * Handles a signed state that is now complete by saving it to disk, if it should be saved. + * Signature for a signed state is now done. We should save it to disk, if it should be saved. The state may or may + * not have all its signatures collected. * * @param signedState the newly complete signed state */ - private void stateHasEnoughSignatures(@NonNull final SignedState signedState) { - savedStateController.maybeSaveState(signedState); - } - - /** - * Handles a signed state that did not collect enough signatures before being ejected from memory. - * - * @param signedState the signed state that lacks signatures - */ - private void stateLacksSignatures(@NonNull final SignedState signedState) { - savedStateController.maybeSaveState(signedState); - } - - private void newSignedStateBeingTracked(final SignedState signedState, final SourceOfSignedState source) { - // When we begin tracking a new signed state, "introduce" the state to the SignedStateFileManager - if (source == SourceOfSignedState.DISK) { - savedStateController.registerSignedStateFromDisk(signedState); - } - if (source == SourceOfSignedState.RECONNECT) { - // a state received from reconnect should be saved to disk - savedStateController.reconnectStateReceived(signedState); + private void signatureCollectionDone(@NonNull final SignedState signedState) { + if (signedState.isStateToSave()) { + stateFileManager.accept(signedState.reserve("save to disk")); } + } + private void logHashes(final SignedState signedState) { if (signedState.getState().getHash() != null) { hashLogger.logHashes(signedState); } @@ -158,7 +142,7 @@ public void newSignedStateFromTransactions(@NonNull final ReservedSignedState si signedState.get().setGarbageCollector(signedStateGarbageCollector); signedStateHasher.hashState(signedState.get()); - newSignedStateBeingTracked(signedState.get(), SourceOfSignedState.TRANSACTIONS); + logHashes(signedState.get()); stateSigner.accept(signedState.getAndReserve("signing state from transactions")); @@ -180,7 +164,7 @@ public List getSignedStateInfo() { @Override public void stateToLoad(final SignedState signedState, final SourceOfSignedState sourceOfSignedState) { signedState.setGarbageCollector(signedStateGarbageCollector); - newSignedStateBeingTracked(signedState, sourceOfSignedState); + logHashes(signedState); signedStateManager.addState(signedState); } diff --git a/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/SignedStateFileManagerTests.java b/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/SignedStateFileManagerTests.java index 8030619607ff..f0ce79f6bb51 100644 --- a/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/SignedStateFileManagerTests.java +++ b/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/SignedStateFileManagerTests.java @@ -276,10 +276,7 @@ void sequenceOfStatesTest(final boolean startAtGenesis) throws IOException { final SignedStateFileManager manager = new SignedStateFileManager( context, buildMockMetrics(), new FakeTime(), MAIN_CLASS_NAME, SELF_ID, SWIRLD_NAME); final SavedStateController controller = - new SavedStateController(context.getConfiguration().getConfigData(StateConfig.class), (rss) -> { - lastResult.set(manager.saveStateTask(rss)); - return lastResult.get() != null; - }); + new SavedStateController(context.getConfiguration().getConfigData(StateConfig.class)); Instant timestamp; final long firstRound; @@ -317,12 +314,13 @@ void sequenceOfStatesTest(final boolean startAtGenesis) throws IOException { .setRound(round) .build(); - controller.maybeSaveState(signedState); + controller.markSavedState(signedState.reserve("markSavedState")); if (signedState.isStateToSave()) { assertTrue( nextBoundary == null || CompareTo.isGreaterThanOrEqualTo(timestamp, nextBoundary), "timestamp should be after the boundary"); + manager.saveStateTask(signedState.reserve("save to disk")); savedStates.add(signedState); diff --git a/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/components/state/StateManagementComponentTests.java b/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/components/state/StateManagementComponentTests.java index 0bdee0ea49e7..f98cdebe79a2 100644 --- a/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/components/state/StateManagementComponentTests.java +++ b/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/components/state/StateManagementComponentTests.java @@ -18,7 +18,6 @@ import static com.swirlds.platform.state.manager.SignedStateManagerTestUtils.buildFakeSignature; import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.Mockito.mock; @@ -37,7 +36,6 @@ import com.swirlds.platform.state.RandomSignedStateGenerator; import com.swirlds.platform.state.signed.ReservedSignedState; import com.swirlds.platform.state.signed.SignedState; -import com.swirlds.platform.state.signed.SourceOfSignedState; import com.swirlds.platform.system.address.AddressBook; import com.swirlds.platform.system.transaction.StateSignatureTransaction; import com.swirlds.test.framework.config.TestConfigBuilder; @@ -68,13 +66,11 @@ class StateManagementComponentTests { private final TestPrioritySystemTransactionConsumer systemTransactionConsumer = new TestPrioritySystemTransactionConsumer(); private final TestSignedStateWrapperConsumer newLatestCompleteStateConsumer = new TestSignedStateWrapperConsumer(); - private final TestSavedStateController controller = new TestSavedStateController(); @BeforeEach protected void beforeEach() { systemTransactionConsumer.reset(); newLatestCompleteStateConsumer.reset(); - controller.getStatesQueue().clear(); } /** @@ -173,29 +169,6 @@ void stateSignaturesAppliedAndTracked() { component.stop(); } - @Test - @DisplayName("Test that the state is saved to disk when it is received via reconnect") - void testReconnectStateSaved() { - final Random random = RandomUtils.getRandomPrintSeed(); - final DefaultStateManagementComponent component = newStateManagementComponent(); - - component.start(); - - final List majorityWeightNodes = - IntStream.range(0, NUM_NODES - 1).mapToObj(NodeId::new).toList(); - final SignedState signedState = new RandomSignedStateGenerator(random) - .setRound(10) - .setSigningNodeIds(majorityWeightNodes) - .build(); - component.stateToLoad(signedState, SourceOfSignedState.RECONNECT); - final SignedState stateSentForWriting = controller.getStatesQueue().poll(); - assertNotNull(stateSentForWriting, "The state should be saved to disk."); - assertEquals( - stateSentForWriting, signedState, "The state saved to disk should be the same as the state loaded."); - - component.stop(); - } - private void allNodesSign(final SignedState signedState, final DefaultStateManagementComponent component) { final AddressBook addressBook = signedState.getAddressBook(); IntStream.range(0, NUM_NODES).forEach(index -> component @@ -301,7 +274,7 @@ private DefaultStateManagementComponent newStateManagementComponent( dispatchBuilder, newLatestCompleteStateConsumer::consume, (msg, t, code) -> {}, - controller, + rss -> {}, signer); dispatchBuilder.start(); diff --git a/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/components/state/TestSavedStateController.java b/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/components/state/TestSavedStateController.java index c76c35127fd7..9b782eb5ffc5 100644 --- a/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/components/state/TestSavedStateController.java +++ b/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/components/state/TestSavedStateController.java @@ -18,6 +18,7 @@ import com.swirlds.common.config.StateConfig; import com.swirlds.platform.components.SavedStateController; +import com.swirlds.platform.state.signed.ReservedSignedState; import com.swirlds.platform.state.signed.SignedState; import com.swirlds.test.framework.config.TestConfigBuilder; import edu.umd.cs.findbugs.annotations.NonNull; @@ -28,17 +29,12 @@ public class TestSavedStateController extends SavedStateController { private final Deque queue = new LinkedList<>(); public TestSavedStateController() { - super(new TestConfigBuilder().getOrCreateConfig().getConfigData(StateConfig.class), s -> true); + super(new TestConfigBuilder().getOrCreateConfig().getConfigData(StateConfig.class)); } @Override - public synchronized void maybeSaveState(@NonNull final SignedState signedState) { - queue.add(signedState); - } - - @Override - public synchronized void reconnectStateReceived(@NonNull final SignedState signedState) { - queue.add(signedState); + public synchronized void reconnectStateReceived(@NonNull final ReservedSignedState reservedSignedState) { + queue.add(reservedSignedState.get()); } @Override From 9ea6569e87a5de2ba5473ca018baf2daede13f8c Mon Sep 17 00:00:00 2001 From: JeffreyDallas <39912573+JeffreyDallas@users.noreply.github.com> Date: Fri, 15 Dec 2023 09:23:10 -0600 Subject: [PATCH 05/13] ci: change cron job to every 16 hours (#10491) --- .github/workflows/flow-node-performance-tests.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/flow-node-performance-tests.yaml b/.github/workflows/flow-node-performance-tests.yaml index ad009dae9734..7ef567a0591d 100644 --- a/.github/workflows/flow-node-performance-tests.yaml +++ b/.github/workflows/flow-node-performance-tests.yaml @@ -17,7 +17,7 @@ name: "Node: Performance Tests" on: schedule: - - cron: '0 */12 * * *' + - cron: '0 */16 * * *' workflow_dispatch: defaults: From 6f86e02e7d35534225cbf5d08c3a57dc17d0acf9 Mon Sep 17 00:00:00 2001 From: Valentin Tronkov Date: Fri, 15 Dec 2023 17:33:20 +0200 Subject: [PATCH 06/13] test: turn on fuzzy matching on CreatePrecompileSuite (#10318) Signed-off-by: Valentin Tronkov <99957253+vtronkov@users.noreply.github.com> --- .../record-snapshots/CreatePrecompile.json | 232 ++++++++++++++++++ .../precompile/CreatePrecompileSuite.java | 21 +- 2 files changed, 252 insertions(+), 1 deletion(-) create mode 100644 hedera-node/test-clients/record-snapshots/CreatePrecompile.json diff --git a/hedera-node/test-clients/record-snapshots/CreatePrecompile.json b/hedera-node/test-clients/record-snapshots/CreatePrecompile.json new file mode 100644 index 000000000000..287347dc1a5b --- /dev/null +++ b/hedera-node/test-clients/record-snapshots/CreatePrecompile.json @@ -0,0 +1,232 @@ +{ + "specSnapshots": { + "createTokenWithEmptyTokenStruct": { + "placeholderNum": 1001, + "encodedItems": [ + { + "b64Body": "Cg8KCQi48sCrBhD4AxICGAISAhgDGPuV9hQiAgh4MiDDg8Kuw4LCt8ODwrl0RjjDgsKuSsODwovDg8KQw4PCjlozCiISIG90bhIid92Jjms6QAHHQrxz2INynOMzsbzUs7Z1khIuEICA6YOx3hZKBQiAztoD", + "b64Record": "CiUIFhIDGOoHKhwKDAgBEAwaBgiArpmkDxIMCAEQDxoGCICumaQPEjDLU9S8peQRy/4GE+1IeHuRw4qg07OHscpS/4XVZ629gRyA2zPYj/yz+FL5ulOXE+IaDAj08sCrBhDL/+WKAyIPCgkIuPLAqwYQ+AMSAhgCKiDDg8Kuw4LCt8ODwrl0RjjDgsKuSsODwovDg8KQw4PCjlIdCgwKAhgCEP//0YfivC0KDQoDGOoHEICA0ofivC0=" + }, + { + "b64Body": "Cg8KCQi58sCrBhD6AxICGAISAhgDGP7LzSwiAgh4MiDDg8Kuw4LCt8ODwrl0RjjDgsKuSsODwovDg8KQw4PCjooBjwESDAj1wJuvBhDY2dySARptCiISINkxJI4gt+NmyrHXypO5w1cvrCd4Ht1Ga+PddJTOcg7dCiM6IQO4aL/l8mnCy+F/7NY8L2PoNU6zEpTPE91e5taFSVYUoQoiEiCdpMgQ3t4+/LTsoBbqHqYx5Pn8JMD+QlM3OJi3sZOa9SIMSGVsbG8gV29ybGQhKgAyAA==", + "b64Record": "CiUIFhoDGOsHKhwKDAgBEAwaBgiArpmkDxIMCAEQDxoGCICumaQPEjDUTmQrGyYUZtDmqUrLzD/62ar6s84j+EbtNljGd1fTKChoAEptiCVNkulHbu8NNoIaDAj18sCrBhCLhMytASIPCgkIufLAqwYQ+gMSAhgCKiDDg8Kuw4LCt8ODwrl0RjjDgsKuSsODwovDg8KQw4PCjlIA" + }, + { + "b64Body": "Cg8KCQi58sCrBhD+AxICGAISAhgDGIydjj4iAgh4MiDDg8Kuw4LCt8ODwrl0RjjDgsKuSsODwovDg8KQw4PCjpoBiCAKAxjrByKAIDYwYzA2MDQwNTI2MDA5NjA4MDgxOTA1MjY4NzQ2ZjZiNjU2ZTRlNjE2ZDY1NjBiODFiNjBhMDkwODE1MjYyMDAwMDJjOTE2MDAxOTE5MDYyMDAwMGFlNTY1YjUwNjA0MDgwNTE4MDgyMDE5MDkxNTI2MDBiODA4MjUyNmExZDFiZGFkOTViOTRkZTViNTg5YmRiNjBhYTFiNjAyMDkwOTIwMTkxODI1MjYyMDAwMDYxOTE2MDAyOTE2MjAwMDBhZTU2NWI1MDYwNDA4MDUxODA4MjAxOTA5MTUyNjAwNDgwODI1MjYzNmQ2NTZkNmY2MGUwMWI2MDIwOTA5MjAxOTE4MjUyNjIwMDAwOGY5MTYwMDM5MTYyMDAwMGFlNTY1YjUwNjBjODYwMDQ1NTYwMDg2MDA1NTUzNDgwMTU2MjAwMDBhNzU3NjAwMDgwZmQ1YjUwNjIwMDAxOTE1NjViODI4MDU0NjIwMDAwYmM5MDYyMDAwMTU0NTY1YjkwNjAwMDUyNjAyMDYwMDAyMDkwNjAxZjAxNjAyMDkwMDQ4MTAxOTI4MjYyMDAwMGUwNTc2MDAwODU1NTYyMDAwMTJiNTY1YjgyNjAxZjEwNjIwMDAwZmI1NzgwNTE2MGZmMTkxNjgzODAwMTE3ODU1NTYyMDAwMTJiNTY1YjgyODAwMTYwMDEwMTg1NTU4MjE1NjIwMDAxMmI1NzkxODIwMTViODI4MTExMTU2MjAwMDEyYjU3ODI1MTgyNTU5MTYwMjAwMTkxOTA2MDAxMDE5MDYyMDAwMTBlNTY1YjUwNjIwMDAxMzk5MjkxNTA2MjAwMDEzZDU2NWI1MDkwNTY1YjViODA4MjExMTU2MjAwMDEzOTU3NjAwMDgxNTU2MDAxMDE2MjAwMDEzZTU2NWI2MDAxODE4MTFjOTA4MjE2ODA2MjAwMDE2OTU3NjA3ZjgyMTY5MTUwNWI2MDIwODIxMDgxMTQxNTYyMDAwMThiNTc2MzRlNDg3YjcxNjBlMDFiNjAwMDUyNjAyMjYwMDQ1MjYwMjQ2MDAwZmQ1YjUwOTE5MDUwNTY1YjYxNDQyZDgwNjIwMDAxYTE2MDAwMzk2MDAwZjNmZTYwODA2MDQwNTI2MDA0MzYxMDYxMDFlZTU3NjAwMDM1NjBlMDFjODA2MzZmNThiOWQ5MTE2MTAxMGQ1NzgwNjNiYWZjYWY3YTExNjEwMGEwNTc4MDYzZDU3NDQ4YWExMTYxMDA2ZjU3ODA2M2Q1NzQ0OGFhMTQ2MTA0YmE1NzgwNjNkNmZhNDBhZTE0NjEwNGRhNTc4MDYzZTdiMDdjYjYxNDYxMDRlZDU3ODA2M2ZjOGRmMmRhMTQ2MTA1MGQ1NzgwNjNmZTczODZlMTE0NjEwNTIyNTc2MDAwODBmZDViODA2M2JhZmNhZjdhMTQ2MTA0NTI1NzgwNjNjNWNlOWVhNzE0NjEwNDcyNTc4MDYzYzcyZTk3ZjQxNDYxMDQ5MjU3ODA2M2QyMzI0ZGIwMTQ2MTA0YTc1NzYwMDA4MGZkNWI4MDYzOTBlZjc5YzIxMTYxMDBkYzU3ODA2MzkwZWY3OWMyMTQ2MTAzZWE1NzgwNjM5ZDU2MGNiNDE0NjEwM2YyNTc4MDYzYWI4ZDMwZmQxNDYxMDQxMjU3ODA2M2I5MTRiYjc5MTQ2MTA0MzI1NzYwMDA4MGZkNWI4MDYzNmY1OGI5ZDkxNDYxMDNhNzU3ODA2Mzc3ZWQ0YWIyMTQ2MTAzYWY1NzgwNjM4MDFlY2RiZjE0NjEwM2MyNTc4MDYzOGU5M2JjMzMxNDYxMDNjYTU3NjAwMDgwZmQ1YjgwNjMxZmRjODE3ZTExNjEwMTg1NTc4MDYzMzljNDA1MmMxMTYxMDE1NDU3ODA2MzM5YzQwNTJjMTQ2MTAzMzQ1NzgwNjM0NzUzMzdhZDE0NjEwMzU0NTc4MDYzNTUxNjdmMGUxNDYxMDM2NzU3ODA2MzViZTJhMDI2MTQ2MTAzODc1NzYwMDA4MGZkNWI4MDYzMWZkYzgxN2UxNDYxMDJkYjU3ODA2MzI0NTUzMjA2MTQ2MTAyZWU1NzgwNjMyZjNlMGMxMjE0NjEwMzAxNTc4MDYzMzc3YTMyOWYxNDYxMDMxNDU3NjAwMDgwZmQ1YjgwNjMxMmI4OTk0NjExNjEwMWMxNTc4MDYzMTJiODk5NDYxNDYxMDI2ODU3ODA2MzE1MGE5ZmY1MTQ2MTAyODg1NzgwNjMxYzk4NDUwNTE0NjEwMmE4NTc4MDYzMWZhNmE2OTYxNDYxMDJiYjU3NjAwMDgwZmQ1YjgwNjMwOTFjYzg5OTE0NjEwMWYzNTc4MDYzMTE2ODRmNTMxNDYxMDIyMjU3ODA2MzExOTFhMjcyMTQ2MTAyNDI1NzgwNjMxMjk1MTIzYzE0NjEwMjU1NTc1YjYwMDA4MGZkNWI2MTAyMDY2MTAyMDEzNjYwMDQ2MTM1MjY1NjViNjEwNTM3NTY1YjYwNDA1MTYwMDE2MDAxNjBhMDFiMDM5MDkxMTY4MTUyNjAyMDAxNjA0MDUxODA5MTAzOTBmMzViMzQ4MDE1NjEwMjJlNTc2MDAwODBmZDViNTA2MTAyMDY2MTAyM2QzNjYwMDQ2MTM1YWI1NjViNjEwNjA3NTY1YjYxMDIwNjYxMDI1MDM2NjAwNDYxMzVlMjU2NWI2MTA2MzI1NjViNjEwMjA2NjEwMjYzMzY2MDA0NjEzNmI1NTY1YjYxMDdlNzU2NWIzNDgwMTU2MTAyNzQ1NzYwMDA4MGZkNWI1MDYxMDIwNjYxMDI4MzM2NjAwNDYxMzZlYTU2NWI2MTA4NWY1NjViMzQ4MDE1NjEwMjk0NTc2MDAwODBmZDViNTA2MTAyMDY2MTAyYTMzNjYwMDQ2MTM3MzE1NjViNjEwOWQ1NTY1YjYxMDIwNjYxMDJiNjM2NjAwNDYxMzZiNTU2NWI2MTA5ZjU1NjViMzQ4MDE1NjEwMmM3NTc2MDAwODBmZDViNTA2MTAyMDY2MTAyZDYzNjYwMDQ2MTM3OTk1NjViNjEwYWI1NTY1YjYxMDIwNjYxMDJlOTM2NjAwNDYxMzZiNTU2NWI2MTBhZGE1NjViNjEwMjA2NjEwMmZjMzY2MDA0NjEzODE3NTY1YjYxMGI2MzU2NWI2MTAyMDY2MTAzMGYzNjYwMDQ2MTM4NWY1NjViNjEwZWExNTY1YjM0ODAxNTYxMDMyMDU3NjAwMDgwZmQ1YjUwNjEwMjA2NjEwMzJmMzY2MDA0NjEzOGY1NTY1YjYxMGZhYzU2NWIzNDgwMTU2MTAzNDA1NzYwMDA4MGZkNWI1MDYxMDIwNjYxMDM0ZjM2NjAwNDYxMzczMTU2NWI2MTBmY2I1NjViNjEwMjA2NjEwMzYyMzY2MDA0NjEzOTYzNTY1YjYxMGZlNTU2NWIzNDgwMTU2MTAzNzM1NzYwMDA4MGZkNWI1MDYxMDIwNjYxMDM4MjM2NjAwNDYxMzlkNTU2NWI2MTEwMjg1NjViMzQ4MDE1NjEwMzkzNTc2MDAwODBmZDViNTA2MTAyMDY2MTAzYTIzNjYwMDQ2MTNhMmQ1NjViNjExMDQzNTY1YjYxMDIwNjYxMTA1YjU2NWI2MTAyMDY2MTAzYmQzNjYwMDQ2MTNhNWI1NjViNjExMDZkNTY1YjYxMDIwNjYxMTFjYjU2NWIzNDgwMTU2MTAzZDY1NzYwMDA4MGZkNWI1MDYxMDIwNjYxMDNlNTM2NjAwNDYxM2FiNDU2NWI2MTEzMWI1NjViNjEwMjA2NjExMzJiNTY1YjM0ODAxNTYxMDNmZTU3NjAwMDgwZmQ1YjUwNjEwMjA2NjEwNDBkMzY2MDA0NjEzYjExNTY1YjYxMTM0NDU2NWIzNDgwMTU2MTA0MWU1NzYwMDA4MGZkNWI1MDYxMDIwNjYxMDQyZDM2NjAwNDYxM2I1ZTU2NWI2MTEzNTM1NjViMzQ4MDE1NjEwNDNlNTc2MDAwODBmZDViNTA2MTAyMDY2MTA0NGQzNjYwMDQ2MTNiZGE1NjViNjExMzgxNTY1YjM0ODAxNTYxMDQ1ZTU3NjAwMDgwZmQ1YjUwNjEwMjA2NjEwNDZkMzY2MDA0NjEzNWFiNTY1YjYxMTM5YTU2NWIzNDgwMTU2MTA0N2U1NzYwMDA4MGZkNWI1MDYxMDIwNjYxMDQ4ZDM2NjAwNDYxM2MxOTU2NWI2MTEzYjE1NjViMzQ4MDE1NjEwNDllNTc2MDAwODBmZDViNTA2MTAyMDY2MTEzY2U1NjViNjEwMjA2NjEwNGI1MzY2MDA0NjEzODVmNTY1YjYxMTNlMDU2NWIzNDgwMTU2MTA0YzY1NzYwMDA4MGZkNWI1MDYxMDIwNjYxMDRkNTM2NjAwNDYxMzczMTU2NWI2MTE0ZWE1NjViNjEwMjA2NjEwNGU4MzY2MDA0NjEzNmVhNTY1YjYxMTUwMjU2NWIzNDgwMTU2MTA0Zjk1NzYwMDA4MGZkNWI1MDYxMDIwNjYxMDUwODM2NjAwNDYxMzVhYjU2NWI2MTE3YTk1NjViMzQ4MDE1NjEwNTE5NTc2MDAwODBmZDViNTA2MTAyMDY2MTE3YzA1NjViMzQ4MDE1NjEwNTJlNTc2MDAwODBmZDViNTA2MTAyMDY2MTE3ZDI1NjViNjA0MDgwNTE2MDAxODA4MjUyODE4MzAxOTA5MjUyNjAwMDkxODI5MTkwODE2MDIwMDE1YjYxMDU1OTYxMzJmMzU2NWI4MTUyNjAyMDAxOTA2MDAxOTAwMzkwODE2MTA1NTE1NzkwNTA1MDkwNTA2MTA1N2I2MDAwNjAwNDg5NjExN2YzNTY1YjgxNjAwMDgxNTE4MTEwNjEwNThlNTc2MTA1OGU2MTNjNzU1NjViNjAyMDAyNjAyMDAxMDE4MTkwNTI1MDYwMDA2MTA1YTkzMDYwMDA4Nzg3ODY2MTE4Mjg1NjViOTA1MDYwMDA2MTA1Yjk2MDAxODg4YTYxMWEzNTU2NWI5MDUwNjAwMDYxMDVkMDYwMDQ2MDA1NjAwYTYwMWU2MDAxOGU2MTFiMTA1NjViOTA1MDYwMDA4MDYxMDVlNjg1NjAwNDU0NjAwNTU0ODc4NzYxMWI4MDU2NWI5MDkyNTA5MDUwNjAxNjgyMTQ2MTA1Zjg1NzYwMDA4MGZkNWI5YjlhNTA1MDUwNTA1MDUwNTA1MDUwNTA1MDU2NWI2MDAwNjEwNjJiNjEwNjE0NjExY2I0NTY1YjYxMDYxZTg1ODU2MTFkN2E1NjViNjEwNjI2NjExZGUyNTY1YjYxMWUxYjU2NWI5MzkyNTA1MDUwNTY1YjYwNDA4MDUxNjAwNTgwODI1MjYwYzA4MjAxOTA5MjUyNjAwMDkxODI5MTkwODE2MDIwMDE1YjYxMDY1NTYxMzJmMzU2NWI4MTUyNjAyMDAxOTA2MDAxOTA=", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIwTKH4AtxFiPu5vqx+XwwmBrMiDSzeYG37FgTAwRKBCPPuTSXHPwHaBsLJqcenOVbDGgwI9fLAqwYQg72drAMiDwoJCLnywKsGEP4DEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIw9FZkvrwTG1C71YFKOHDal1PKrh6C6KcsyWtF67WtgjLP4jbf5CNZlSC4HdGlcx4WGgwI9vLAqwYQg4fbzQEiDwoJCLrywKsGEIQEEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIwItfp3t0IamwBY/TLvUvwQKFOFaNE/AVjk1qfoTLfb33a2BIbm6TAHwXMaDGr1XRzGgwI9vLAqwYQo/7QswMiDwoJCLrywKsGEIoEEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIwB/Htx5jX1L6lBF5t3Ge4Bz+LO/b/L+ZVAHfFqARCUU8Gf8Fwoyk87zmIyx/YooU0GgwI9/LAqwYQ84yq1AEiDwoJCLvywKsGEJAEEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIwNDIl7PFke9Z/u7SFUPmUmjkO95FfzRsl14xu2TD0ASYa70KEyzVObKpwKDdDCKGRGgwI9/LAqwYQ84mc0wMiDwoJCLvywKsGEJYEEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIwLTd0PY2droVxlsusUIeeNN5BWx7VH6n/XpCte78mc4xAAzoZ7+hTIjUpQqA7xYS+GgwI+PLAqwYQ24Wa2wEiDwoJCLzywKsGEJwEEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIwGojEKCQ6dlJLJhMU2LNQtyTmgxCvjSB1xW/CpR//mFfDTW+UQapz3mLOw1GadXwbGgwI+PLAqwYQ6+WF2gMiDwoJCLzywKsGEKIEEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIwN/X34KmvfLfl6NHX/srrQR9NdsLi3vkqnVdWThyFVKtocwC3RZ6pzGChaMkVeP7EGgwI+fLAqwYQq+LH+wEiDwoJCL3ywKsGEKgEEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIwLRJKmQPbphR4k3n2Wyw2X6AYaQUSgZAvot2+3BttcSRO1hqvv5+PHqN5lM1vigoeGgsI+vLAqwYQs/iXBSIPCgkIvfLAqwYQrgQSAhgCKiDDg8Kuw4LCt8ODwrl0RjjDgsKuSsODwovDg8KQw4PCjlIA" + }, + { + "b64Body": "Cg8KCQi+8sCrBhCwBBICGAISAhgDGJb7rp0CIgIIeDIgw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5CRQoDGOsHGiISIMLu83fFRiyTVvU9v/+VbWKegvUw6iI+EWcyZtWBNgtJIMCEPUIFCIDO2gNSAFoAagtjZWxsYXIgZG9vcg==", + "b64Record": "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" + }, + { + "b64Body": "ChAKCQi/8sCrBhCyBBIDGOoHEgIYAxjAv+0hIgIIeDIgw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo46FQoDGOwHEMCEPRiAqNa5ByIEkO95wg==", + "b64Record": "CiUIISIDGOwHKhwKDAgBEAwaBgiArpmkDxIMCAEQDxoGCICumaQPEjALAz7ZtVbUlbSL6DoySsMu/c4xBFD8bmkLCnkUmxSmHMdjSlmHkwi7IPZ9LXg782IaCwj78sCrBhD79oAmIhAKCQi/8sCrBhCyBBIDGOoHKiDDg8Kuw4LCt8ODwrl0RjjDgsKuSsODwovDg8KQw4PCjjCA5oobOggaAjB4KIDqMFIXCgkKAhhiEIDMlTYKCgoDGOoHEP/LlTY=" + } + ] + }, + "createTokenWithInsufficientValueSent": { + "placeholderNum": 1001, + "encodedItems": [ + { + "b64Body": "Cg8KCQi71cCrBhCcBBICGAISAhgDGPuV9hQiAgh4MiDDg8Kuw4LCt8ODwrl0RjjDgsKuSsODwovDg8KQw4PCjlozCiISICwg9n+Ol3LXC0dlnwCekuBMlICPRGWXSGCcM3yEjxegEICA6YOx3hZKBQiAztoD", + "b64Record": "CiUIFhIDGOoHKhwKDAgBEAwaBgiArpmkDxIMCAEQDxoGCICumaQPEjCex8FrD4yA/8mqDjgUmkAOJjIQ8ruVBeX0MUEY+5yLBuIIIas/HWP9lBux5PfoRwcaDAj31cCrBhD7kpKwAyIPCgkIu9XAqwYQnAQSAhgCKiDDg8Kuw4LCt8ODwrl0RjjDgsKuSsODwovDg8KQw4PCjlIdCgwKAhgCEP//0YfivC0KDQoDGOoHEICA0ofivC0=" + }, + { + "b64Body": "Cg8KCQi81cCrBhCeBBICGAISAhgDGP7LzSwiAgh4MiDDg8Kuw4LCt8ODwrl0RjjDgsKuSsODwovDg8KQw4PCjooBjwESDAj4o5uvBhCAlom9ARptCiISIDfKAinIdKNIc2CY/IBKf4kgtUh4v7m4okdKFFgyKt9vCiM6IQKZHuYj06mDk+joYrPRcf2Rx2WFvtA+AcFsvcDrpF8McgoiEiBr1E0sc43WDBGNO38qtc4lEcoBz/MCcanXuyYfD5NpRCIMSGVsbG8gV29ybGQhKgAyAA==", + "b64Record": "CiUIFhoDGOsHKhwKDAgBEAwaBgiArpmkDxIMCAEQDxoGCICumaQPEjCsW3LmEmdka8k9lD8xMNYEHrOVXUWmt/tYRMKviqeFIRr/m8C4YMCam0kKQFUBsY4aDAj41cCrBhCzu9zTASIPCgkIvNXAqwYQngQSAhgCKiDDg8Kuw4LCt8ODwrl0RjjDgsKuSsODwovDg8KQw4PCjlIA" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIwCuT73dnPI5RLb7VHCX0/PTMiNCE4/60GuHKMqgF3EtjAOslHiHTSRnxRZ6wM+zwoGgwI+NXAqwYQo8DY0wMiDwoJCLzVwKsGEKIEEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIw5ry1+4PVkoxH1GlRYdaKCGh3y9UJKrSg/Y70pO5yERCiI4Dag4XDIE6edGtzsS9bGgwI+dXAqwYQi9399AEiDwoJCL3VwKsGEKgEEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIwqXo9HiEj0/4U8N6qJTVzw0uPbxnAT/pqbL8WF9z20Kg47TfwYoI3yawqv1i7gctpGgsI+tXAqwYQo7zbFiIPCgkIvdXAqwYQrgQSAhgCKiDDg8Kuw4LCt8ODwrl0RjjDgsKuSsODwovDg8KQw4PCjlIA" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIw4dWf2XFdwiMQy1LYElm7m2NbAukF2zz/Jl+UzhWptq9jWulsD+KyQzsYjJV9fqXMGgwI+tXAqwYQk8bT+wEiDwoJCL7VwKsGELQEEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIw1Gjdu8++AJlhxiPjLsNYvFT5Kik4Ot31sfaTKSZdMKPDswYrCEzgXQwKMcNWPuaPGgsI+9XAqwYQm7m3HiIPCgkIv9XAqwYQugQSAhgCKiDDg8Kuw4LCt8ODwrl0RjjDgsKuSsODwovDg8KQw4PCjlIA" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIwlrJ/evO78DevPrmkx9bmNqz2x70yteYxIKDOd/PTRoBciXAuezs+PJPLY6gqCVIeGgwI+9XAqwYQ89ypgwIiDwoJCL/VwKsGEMAEEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIwRqFd06ZNNhDTlOJDU4doy/pzcx92s4y8TermgyIMzrgnW3TYmcTHNS3+6tTowWO4GgsI/NXAqwYQ48KUJiIPCgkIwNXAqwYQxgQSAhgCKiDDg8Kuw4LCt8ODwrl0RjjDgsKuSsODwovDg8KQw4PCjlIA" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIw9YTlT6l0qJF5P3nqXSWGPPG8X7zIDJedTMn5f5/mSFq9fGa98MNd2yGGiltIVdb5GgwI/NXAqwYQw/fmpQIiDwoJCMDVwKsGEMwEEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIw+CcbI0xrd2LmbJw0w1cOKIIrQyPL1fkeBKaQtWw4BuIJlDE39F8vbKqSuSvazAw1GgsI/dXAqwYQw9qrNCIPCgkIwdXAqwYQ0gQSAhgCKiDDg8Kuw4LCt8ODwrl0RjjDgsKuSsODwovDg8KQw4PCjlIA" + }, + { + "b64Body": "Cg8KCQjB1cCrBhDUBBICGAISAhgDGJb7rp0CIgIIeDIgw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5CRQoDGOsHGiISILcSW0mLmdx4SLU5an0gzqREzoysWOtPhNC0qQ3IOSlgIMCEPUIFCIDO2gNSAFoAagtjZWxsYXIgZG9vcg==", + "b64Record": "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" + }, + { + "b64Body": "ChAKCQjC1cCrBhDWBBIDGOoHEgIYAxjAv+0hIgIIeDIgw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo461AEKAxjsBxDAhD0YwIQ9IsQBR1M3rQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD6gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAehIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAsIPZ/jpdy1wtHZZ8AnpLgTJSAj0Rll0hgnDN8hI8XoA==", + "b64Record": "CiUIISIDGOwHKhwKDAgBEAwaBgiArpmkDxIMCAEQDxoGCICumaQPEjCiA3dhvE07X48QTCTpIcQlZDheTQbZbfYSvLaosB4Wio5dJ5juev3oFGLo3jlZhtUaCwj+1cCrBhDzvfBWIhAKCQjC1cCrBhDWBBIDGOoHKiDDg8Kuw4LCt8ODwrl0RjjDgsKuSsODwovDg8KQw4PCjjCA5oobOggaAjB4KIDqMFIXCgkKAhhiEIDMlTYKCgoDGOoHEP/LlTY=" + } + ] + }, + "createTokenWithInvalidExpiry": { + "placeholderNum": 1001, + "encodedItems": [ + { + "b64Body": "Cg8KCQic68CrBhDhBhICGAISAhgDGPuV9hQiAgh4MiDDg8Kuw4LCt8ODwrl0RjjDgsKuSsODwovDg8KQw4PCjlozCiISIE28bWaaWIgiAo32vs4vZYPrfpum2id/9rks51ZKscIUEICA6YOx3hZKBQiAztoD", + "b64Record": "CiUIFhIDGOoHKhwKDAgBEAwaBgiArpmkDxIMCAEQDxoGCICumaQPEjAoKWrkbWiZxJ7G891Rx23bnORBcaHR12/r9I/Z0xbJL7HIzMqrf7GIak+oS7CEXkYaCwjY68CrBhCTgrJZIg8KCQic68CrBhDhBhICGAIqIMODwq7DgsK3w4PCuXRGOMOCwq5Kw4PCi8ODwpDDg8KOUh0KDAoCGAIQ///Rh+K8LQoNCgMY6gcQgIDSh+K8LQ==" + }, + { + "b64Body": "Cg8KCQic68CrBhDjBhICGAISAhgDGP7LzSwiAgh4MiDDg8Kuw4LCt8ODwrl0RjjDgsKuSsODwovDg8KQw4PCjooBjwESDAjYuZuvBhC4oIfKAhptCiISIIhsR5nafbPBB9cKnXf/BpGcQVrLkp3xzHbnx8zbKfmKCiM6IQMUXPUdtjAvAIDRcSbq1W3GJ9ODXN8HX2tkzCjnVWutfQoiEiDA2078rT96Rwl4iNfb5+yQ1F1xznCl37JL8IhwAjQRayIMSGVsbG8gV29ybGQhKgAyAA==", + "b64Record": "CiUIFhoDGOsHKhwKDAgBEAwaBgiArpmkDxIMCAEQDxoGCICumaQPEjD8lFadLAZ+602wlkfK1cn+RiVStwfUFy9LpTrOVAGAXxFUJlRhOy+H4pQlQIsMY0caDAjY68CrBhCDz5bZAiIPCgkInOvAqwYQ4wYSAhgCKiDDg8Kuw4LCt8ODwrl0RjjDgsKuSsODwovDg8KQw4PCjlIA" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIwtExpKG8rCHkjvAngDABF8z92ElOfH6/2p6Y/YANvjk/hq5ahnHqfa9Qa8dtHqG8bGgsI2evAqwYQ+++neyIPCgkInevAqwYQ5wYSAhgCKiDDg8Kuw4LCt8ODwrl0RjjDgsKuSsODwovDg8KQw4PCjlIA" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIwz0eRyFWEMMXlE8XEcnbKzBAa6ztitxSuG4iONafXsn3nsD+URME3DqTyNi/7C+O2GgwI2evAqwYQk/bA+QIiDwoJCJ3rwKsGEO0GEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIwTY1wQ5saujTjs8L2By9KUdqOrUALlLC6nlu/rEHiaWV/gU0TxUFRKCRTSO2tQtMHGgwI2uvAqwYQq57amwEiDwoJCJ7rwKsGEPMGEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIws/c1xYcPj3KbI7+dQMbfOP7CZNsCI/z10pmtod6x4WOBBoSThp2TcWu/pnrYHIx2GgwI2uvAqwYQg6uqgAMiDwoJCJ7rwKsGEPkGEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIw/YmDREHsQx3w94rbgBcWc6sSqihDluV/9L8G+0AWJZEYZK2Xm15fM5x5remoc7NuGgwI2+vAqwYQ68z0ogEiDwoJCJ/rwKsGEP8GEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIwoHWF3QVLCMzA9FgiOH+5GGFSG6fL3mUDYxvvsRSK+xboGkB0hJTL/xD18jX3CDOiGgwI2+vAqwYQq6PbogMiDwoJCJ/rwKsGEIUHEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIwCpWoRluW2SV07axy4GeXMSeRKFGP5M+3KaM5xwp3R08L/H2DIbqK19IviVpw9yIzGgwI3OvAqwYQi8O6rAEiDwoJCKDrwKsGEIsHEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIw7S21jWwqYXjPb95ssyaGOJvHbCqdB0737q1guPr2N0W1cC+yKbKGVPGBpNdsfN0jGgwI3OvAqwYQ05eIqwMiDwoJCKDrwKsGEJEHEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIw7B5tBS04N+n1Dr4WqdqBr0vdy8m0lF6MtNYDwVJytVwobTCJWGTGWa7Xs/KNWqf+GgwI3evAqwYQq6y0tAEiDwoJCKHrwKsGEJcHEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "Cg8KCQih68CrBhCZBxICGAISAhgDGJb7rp0CIgIIeDIgw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5CRQoDGOsHGiISIGG0fB+KL7GcngWUHxAIzqGCix9RzFSNfQUsXer1QW6IIMCEPUIFCIDO2gNSAFoAagtjZWxsYXIgZG9vcg==", + "b64Record": "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" + }, + { + "b64Body": "ChAKCQii68CrBhCbBxIDGOoHEgIYAxjAv+0hIgIIeDIgw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo46VQoDGOwHEMCEPRiAqNa5ByJEH9yBfgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB6EgA=", + "b64Record": "CiUIISIDGOwHKhwKDAgBEAwaBgiArpmkDxIMCAEQDxoGCICumaQPEjDoXaq2B5cnHs1lGhNEHC2XcmzcgFbRYDO8v/yQ4/ZAyr8ifeBGP7DqUJ5k+QGZjPAaDAje68CrBhDjsq3UASIQCgkIouvAqwYQmwcSAxjqByogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo4wgOaKGzoIGgIweCiA6jBSFwoJCgIYYhCAzJU2CgoKAxjqBxD/y5U2" + } + ] + }, + "createTokenWithInvalidTreasury": { + "placeholderNum": 1001, + "encodedItems": [ + { + "b64Body": "Cg8KCQjJy8CrBhCiBxICGAISAhgDGPuV9hQiAgh4MiDDg8Kuw4LCt8ODwrl0RjjDgsKuSsODwovDg8KQw4PCjlozCiISIJL81dr1Pd6jD2AGL5etAk2ZJ6ZBs3ZeCzvSEM60vPx/EICA6YOx3hZKBQiAztoD", + "b64Record": "CiUIFhIDGOoHKhwKDAgBEAwaBgiArpmkDxIMCAEQDxoGCICumaQPEjBxvoMkYKyd+X5XALWJlD/flunqGnNLaazgIqxU1H2oC+QRq7ENl04qNdi4Ig+qvw4aDAiFzMCrBhCL99yNASIPCgkIycvAqwYQogcSAhgCKiDDg8Kuw4LCt8ODwrl0RjjDgsKuSsODwovDg8KQw4PCjlIdCgwKAhgCEP//0YfivC0KDQoDGOoHEICA0ofivC0=" + }, + { + "b64Body": "Cg8KCQjJy8CrBhCkBxICGAISAhgDGP7LzSwiAgh4MiDDg8Kuw4LCt8ODwrl0RjjDgsKuSsODwovDg8KQw4PCjooBjwESDAiFmpuvBhDgm6XyAhptCiISICSRPoiw7baJprO0+zXIR5EKgCBhz834C33AKg+U8VYHCiM6IQKinhEsFSLTylhLZg1w7+04qt/hflDPK6CyrC0y2mkA6goiEiC7DzUgR8FSt7pPZ8E+g7gkt3yapvUtH1IpIRzhryQjPiIMSGVsbG8gV29ybGQhKgAyAA==", + "b64Record": "CiUIFhoDGOsHKhwKDAgBEAwaBgiArpmkDxIMCAEQDxoGCICumaQPEjDOn6kAQtBs9SvRvfXLLMG0BRV8RuDjjB7PTeWsP7++ePaEAldn6rfCKKVUkfGzEb8aDAiFzMCrBhDrtK+MAyIPCgkIycvAqwYQpAcSAhgCKiDDg8Kuw4LCt8ODwrl0RjjDgsKuSsODwovDg8KQw4PCjlIA" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIwrZ8S65hgt7I3EGw+FbHdDI+JyCN4wDGr9L+i9k/025vJxG4v9gkDscZ/F1UjLqlIGgwIhszAqwYQ+7fxrgEiDwoJCMrLwKsGEKgHEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIwlvyxGw00BCiOcwDHgWqMJrct/avI0qmkPeP6tKTYbpvF05755buBaY6DlydHYZEpGgwIhszAqwYQm8m6rgMiDwoJCMrLwKsGEK4HEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIw92om5NdomXvGooVDu0goJAIhCoyBNcReBEd7tBBGGD1QAeZevRqxbR6adNKp67goGgwIh8zAqwYQi4DctgEiDwoJCMvLwKsGELQHEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "Cg8KCQjLy8CrBhC6BxICGAISAhgDGPfR6j4iAgh4MiDDg8Kuw4LCt8ODwrl0RjjDgsKuSsODwovDg8KQw4PCjoIBiCASAxjrByKAIDkwODEwMTYwMWYxOTE2ODIwMTYwNDA1MjYxMTY3NzkxOTA4MTAxOTA2MTNmMTQ1NjViOTA1MDYwMDE2MDQwNTE2MTE2ODg5MTkwNjEzZmJjNTY1YjYwNDA1MTgwOTEwMzkwMjA4MTgwNTE5MDYwMjAwMTIwMTQ2MTE2ZGI1NzYwNDA1MTYyNDYxYmNkNjBlNTFiODE1MjYwMjA2MDA0ODIwMTUyNjAxMzYwMjQ4MjAxNTI3MjEzOTg1YjU5NDgxYTVjYzgxYjliZGQwODE4ZGJkYzljOTk1OGRkNjA2YTFiNjA0NDgyMDE1MjYwNjQwMTYxMGQxYjU2NWI2MDAwODI2MDAxNjAwMTYwYTAxYjAzMTY2Mzk1ZDg5YjQxNjA0MDUxODE2M2ZmZmZmZmZmMTY2MGUwMWI4MTUyNjAwNDAxNjAwMDYwNDA1MTgwODMwMzgxODY1YWZhMTU4MDE1NjExNzFiNTczZDYwMDA4MDNlM2Q2MDAwZmQ1YjUwNTA1MDUwNjA0MDUxM2Q2MDAwODIzZTYwMWYzZDkwODEwMTYwMWYxOTE2ODIwMTYwNDA1MjYxMTc0MzkxOTA4MTAxOTA2MTNmMTQ1NjViOTA1MDYwMDI2MDQwNTE2MTE3NTQ5MTkwNjEzZmJjNTY1YjYwNDA1MTgwOTEwMzkwMjA4MTgwNTE5MDYwMjAwMTIwMTQ2MTBlOTM1NzYwNDA1MTYyNDYxYmNkNjBlNTFiODE1MjYwMjA2MDA0ODIwMTUyNjAxNTYwMjQ4MjAxNTI3NDE0ZGU1YjU4OWJkYjA4MWE1Y2M4MWI5YmRkMDgxOGRiZGM5Yzk5NThkZDYwNWExYjYwNDQ4MjAxNTI2MDY0MDE2MTBkMWI1NjViNjAwMDYxMDYyYjYxMTdiNjYxMWNiNDU2NWI2MTA2MWU4NTg1NjEyYWMyNTY1YjYwMDA2MTEwNjg2MTE3Y2Q2MTFjYjQ1NjViNjEyZGE5NTY1YjYwMDA2MTEwNjg2MTBmYmQ2MDA0NjAwMTYwNDA1MTgwNjAyMDAxNjA0MDUyODA2MDAwODE1MjUwNjEyYTQzNTY1YjYxMTdmYjYxMzJmMzU2NWI2MDQwNTE4MDYwNDAwMTYwNDA1MjgwNjExODBmODY2MTJmY2U1NjViODE1MjYwMjAwMTYxMTgxZTg1ODU2MTMwNjA1NjViOTA1Mjk0OTM1MDUwNTA1MDU2NWI2MTE4MzA2MTMzYjg1NjViNjA0MDgwNTE2MDYwODEwMTgyNTI2M2ZmZmZmZmZmODc4MTE2ODI1MjYwMDE2MDAxNjBhMDFiMDM4NzE2NjAyMDgzMDE1Mjg1MTY5MTgxMDE5MTkwOTE1MjYwMDE4MDU0NjExODY5OTA2MTNmODE1NjViODA2MDFmMDE2MDIwODA5MTA0MDI2MDIwMDE2MDQwNTE5MDgxMDE2MDQwNTI4MDkyOTE5MDgxODE1MjYwMjAwMTgyODA1NDYxMTg5NTkwNjEzZjgxNTY1YjgwMTU2MTE4ZTI1NzgwNjAxZjEwNjExOGI3NTc2MTAxMDA4MDgzNTQwNDAyODM1MjkxNjAyMDAxOTE2MTE4ZTI1NjViODIwMTkxOTA2MDAwNTI2MDIwNjAwMDIwOTA1YjgxNTQ4MTUyOTA2MDAxMDE5MDYwMjAwMTgwODMxMTYxMThjNTU3ODI5MDAzNjAxZjE2ODIwMTkxNWI1MDUwNTA5MTg0NTI1MDUwNjAwMjgwNTQ2MTE4Zjc5MDYxM2Y4MTU2NWI4MDYwMWYwMTYwMjA4MDkxMDQwMjYwMjAwMTYwNDA1MTkwODEwMTYwNDA1MjgwOTI5MTkwODE4MTUyNjAyMDAxODI4MDU0NjExOTIzOTA2MTNmODE1NjViODAxNTYxMTk3MDU3ODA2MDFmMTA2MTE5NDU1NzYxMDEwMDgwODM1NDA0MDI4MzUyOTE2MDIwMDE5MTYxMTk3MDU2NWI4MjAxOTE5MDYwMDA1MjYwMjA2MDAwMjA5MDViODE1NDgxNTI5MDYwMDEwMTkwNjAyMDAxODA4MzExNjExOTUzNTc4MjkwMDM2MDFmMTY4MjAxOTE1YjUwNTA1MDUwNTA2MDIwODMwMTUyNjAwMTYwMDE2MGEwMWIwMzg3MTY2MDQwODMwMTUyNjBlMDgyMDE4MzkwNTI2MTAxMDA4MjAxODE5MDUyNjAwMzgwNTQ2MTE5YTU5MDYxM2Y4MTU2NWI4MDYwMWYwMTYwMjA4MDkxMDQwMjYwMjAwMTYwNDA1MTkwODEwMTYwNDA1MjgwOTI5MTkwODE4MTUyNjAyMDAxODI4MDU0NjExOWQxOTA2MTNmODE1NjViODAxNTYxMWExZTU3ODA2MDFmMTA2MTE5ZjM1NzYxMDEwMDgwODM1NDA0MDI4MzUyOTE2MDIwMDE5MTYxMWExZTU2NWI4MjAxOTE5MDYwMDA1MjYwMjA2MDAwMjA5MDViODE1NDgxNTI5MDYwMDEwMTkwNjAyMDAxODA4MzExNjExYTAxNTc4MjkwMDM2MDFmMTY4MjAxOTE1YjUwNTA1MDUwNTA4MjYwNjAwMTgxOTA1MjUwNTA5NTk0NTA1MDUwNTA1MDU2NWI2MDQwODA1MTYwMDM4MDgyNTI2MDgwODIwMTkwOTI1MjYwNjA5MTgxNjAyMDAxNWI2MTFhNTU2MTMzNTU1NjViODE1MjYwMjAwMTkwNjAwMTkwMDM5MDgxNjExYTRkNTc5MDUwNTA5MDUwNjAwMDYxMWE3Nzg1ODU4NTYxMzBmMzU2NWI5MDUwNjAwMDYxMWE4ZjYxMWE4OTg3NjAwMjYxNDBhNDU2NWI4NTYxMzExZTU2NWI5MDUwNjAwMDYxMWFhNzYxMWFhMTg4NjAwNDYxNDBhNDU2NWI4NjYxMzE0ODU2NWI5MDUwODI4NDYwMDA4MTUxODExMDYxMWFiZDU3NjExYWJkNjEzYzc1NTY1YjYwMjAwMjYwMjAwMTAxODE5MDUyNTA4MTg0NjAwMTgxNTE4MTEwNjExYWRjNTc2MTFhZGM2MTNjNzU1NjViNjAyMDAyNjAyMDAxMDE4MTkwNTI1MDgwODQ2MDAyODE1MTgxMTA2MTFhZmI1NzYxMWFmYjYxM2M3NTU2NWI2MDIwMDI2MDIwMDEwMTgxOTA1MjUwNTA1MDUwOTM5MjUwNTA1MDU2NWI2MDQwODA1MTYwMDE4MDgyNTI4MTgzMDE5MDkyNTI2MDYwOTE4MTYwMjAwMTViNjExYjJmNjEzMzgzNTY1YjgxNTI2MDIwMDE5MDYwMDE5MDAzOTA4MTYxMWIyNzU3OTA1MDUwOTA1MDYwMDA2MTFiNTQ4ODg4ODg4ODg4ODg2MTMxNzI1NjViOTA1MDgwODI2MDAwODE1MTgxMTA2MTFiNmE1NzYxMWI2YTYxM2M3NTU2NWI2MDIwMDI2MDIwMDEwMTgxOTA1MjUwNTA5Njk1NTA1MDUwNTA1MDUwNTY1YjYwMDA4MDg2ODA2MTAxMDAwMTUxNjAwMDAxNTE2M2ZmZmZmZmZmMTY2MDAwMTQ4MDE1NjExYmIwNTc1MDYxMDEwMDgxMDE1MTYwNDAwMTUxNjNmZmZmZmZmZjE2MTU1YjE1NjExYmM2NTc2MTAxMDA4MTAxNTE2Mjc2YTcwMDYwNDA5MDkxMDE1MjViNjAwMDgwNjEwMTY3NjAwMTYwMDE2MGEwMWIwMzE2MzQ2MzRjMzgxYWU3NjBlMDFiOGM4YzhjOGM4YzYwNDA1MTYwMjQwMTYxMWJmNzk1OTQ5MzkyOTE5MDYxNDE0YjU2NWI2MDQwODA1MTYwMWYxOTgxODQwMzAxODE1MjkxODE1MjYwMjA4MjAxODA1MTYwMDE2MDAxNjBlMDFiMDMxNjYwMDE2MDAxNjBlMDFiMDMxOTkwOTQxNjkzOTA5MzE3OTA5MjUyOTA1MTYxMWMzNTkxOTA2MTNlZDM1NjViNjAwMDYwNDA1MTgwODMwMzgxODU4NzVhZjE5MjUwNTA1MDNkODA2MDAwODExNDYxMWM3MjU3NjA0MDUxOTE1MDYwMWYxOTYwM2YzZDAxMTY4MjAxNjA0MDUyM2Q4MjUyM2Q2MDAwNjAyMDg0MDEzZTYxMWM3NzU2NWI2MDYwOTE1MDViNTA5MTUwOTE1MDgxNjExYzhhNTc2MDE1NjAwMDYxMWM5ZTU2NWI4MDgwNjAyMDAxOTA1MTgxMDE5MDYxMWM5ZTkxOTA2MTQyMjI1NjViNjAwMzkxOTA5MTBiOWI5MDlhNTA5ODUwNTA1MDUwNTA1MDUwNTA1MDU2NWI2MDQwODA1MTYwMDI4MDgyNTI2MDYwODI4MTAxOTA5MzUyODE2MDIwMDE1YjYxMWNkMjYxMzJmMzU2NWI4MTUyNjAyMDAxOTA2MDAxOTAwMzkwODE2MTFjY2E1NzkwNTA1MDkwNTA2MTFkMDI2MDAxODA2MDQwNTE4MDYwMjAwMTYwNDA1MjgwNjAwMDgxNTI1MDYxMTdmMzU2NWI4MTYwMDA4MTUxODExMDYxMWQxNTU3NjExZDE1NjEzYzc1NTY1YjYwMjAwMjYwMjAwMTAxODE5MDUyNTA2MDQwNTE4MDYwNDAwMTYwNDA1MjgwNjExZDM3NjAwNDYwMDY2MTMxYjY1NjViODE1MjYwMjAwMTYxMWQ1NjYwMDI2MDQwNTE4MDYwMjAwMTYwNDA1MjgwNjAwMDgxNTI1MDYxMzA2MDU2NWI4MTUyNTA4MTYwMDE4MTUxODExMDYxMWQ2YzU3NjExZDZjNjEzYzc1NTY1YjYwMjAwMjYwMjAwMTAxODE5MDUyNTA5MDU2NWI2MDQwODA1MTYwMDE4MDgyNTI4MTgzMDE5MDkyNTI2MDYwOTE4MTYwMjAwMTViNjExZDk5NjEzMzU1NTY1YjgxNTI2MDIwMDE5MDYwMDE5MDAzOTA4MTYxMWQ5MTU3OTA1MDUwOTA1MDYwMDA2MTFkYmE4NDg0NjEzMTQ4NTY1YjkwNTA4MDgyNjAwMDgxNTE4MTEwNjExZGQwNTc2MTFkZDA2MTNjNzU1NjViNjAyMDAyNjAyMDAxMDE4MTkwNTI1MDUwOTI5MTUwNTA1NjViNjA0MDgwNTE2MDAwODA4MjUyNjAyMDgyMDE5MDkyNTI2MDYwOTE2MTFlMTU1NjViNjExZTAyNjEzMzgzNTY1YjgxNTI2MDIwMDE5MDYwMDE5MDAzOTA4MTYxMWRmYTU3OTA1MDViNTA5MDUwOTA1NjViNjAwMDYxMWUyNTYxMzNiODU2NWI2MDAxODA1NDYxMWUzMjkwNjEzZjgxNTY1YjgwNjAxZjAxNjAyMDgwOTEwNDAyNjAyMDAxNjA0MDUxOTA4MTAxNjA0MDUyODA5MjkxOTA4MTgxNTI2MDIwMDE4MjgwNTQ2MTFlNWU5MDYxM2Y4MTU2NWI=", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIwhBuKXtlUsZtFpS9Hn+2w/OEtER32rw5+stWZZDlgXeLSDu/alaWIXD3F/Ot8fHg8GgwIh8zAqwYQi9iDtgMiDwoJCMvLwKsGELoHEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIwQOqo8jzNGkLAZ/kfAxTEmtUpszSDDOOVmUZfFeJNHimfOKfgAEf57uznEIpctMOaGgwIiMzAqwYQ25Gi1wEiDwoJCMzLwKsGEMAHEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIwkgwUR4xA/7culWTeAhMNCqoXGCFPGEvSMFX8BeN3aDiCEUG4knxXWrqD0zZt48IqGgwIiMzAqwYQq8arvAMiDwoJCMzLwKsGEMYHEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIwrveB//Xa9sY0omWOsU5lTBYYqoS/MrxgzepDxGXGH/TWUj7KCDV2NOoCfmTf7LM0GgwIiczAqwYQg/Ku3gEiDwoJCM3LwKsGEMwHEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "Cg8KCQjNy8CrBhDSBxICGAISAhgDGPbR6j4iAgh4MiDDg8Kuw4LCt8ODwrl0RjjDgsKuSsODwovDg8KQw4PCjoIBiCASAxjrByKAIDM2NjY4MTYxMzRmNTU2NWI5NDUwNjA4MDg5MDEzNTYxMzY3NjgxNjEzNGY1NTY1YjkzNTA2MGEwODkwMTM1NjEzNjg2ODE2MTM0ZjU1NjViOTI1MDYxMzY5NDYwYzA4YTAxNjEzNTBkNTY1YjkxNTA2MGUwODkwMTM1NjEzNmE0ODE2MTM0ZjU1NjViODA5MTUwNTA5Mjk1OTg1MDkyOTU5ODkwOTM5NjUwNTY1YjYwMDA4MDYwNDA4Mzg1MDMxMjE1NjEzNmM4NTc2MDAwODBmZDViODIzNTYxMzZkMzgxNjEzNGY1NTY1YjkxNTA2MTM2ZTE2MDIwODQwMTYxMzUwZDU2NWI5MDUwOTI1MDkyOTA1MDU2NWI2MDAwODA2MDAwNjA2MDg0ODYwMzEyMTU2MTM2ZmY1NzYwMDA4MGZkNWI4MzM1NjEzNzBhODE2MTM0ZjU1NjViOTI1MDYwMjA4NDAxMzU2MTM3MWE4MTYxMzRmNTU2NWI5MTUwNjEzNzI4NjA0MDg1MDE2MTM1MGQ1NjViOTA1MDkyNTA5MjUwOTI1NjViNjAwMDgwNjAwMDYwNjA4NDg2MDMxMjE1NjEzNzQ2NTc2MDAwODBmZDViNjEzNzRmODQ2MTM1MGQ1NjViOTI1MDYwMjA4NDAxMzU2MTM3NWY4MTYxMzRmNTU2NWI5MTUwNjA0MDg0MDEzNTYxMzc2ZjgxNjEzNGY1NTY1YjgwOTE1MDUwOTI1MDkyNTA5MjU2NWI4MDM1NjBmZjgxMTY4MTE0NjEzNTIxNTc2MDAwODBmZDViODAxNTE1ODExNDYxMzUwYTU3NjAwMDgwZmQ1YjYwMDA4MDYwMDA4MDYwMDA4MDYwMDA4MDYxMDEwMDg5OGIwMzEyMTU2MTM3YjY1NzYwMDA4MGZkNWI2MTM3YmY4OTYxMzc3YTU2NWI5NzUwNjEzN2NkNjAyMDhhMDE2MTM3N2E1NjViOTY1MDYxMzdkYjYwNDA4YTAxNjEzNTBkNTY1Yjk1NTA2MTM3ZTk2MDYwOGEwMTYxMzUwZDU2NWI5NDUwNjEzN2Y3NjA4MDhhMDE2MTM1MGQ1NjViOTM1MDYwYTA4OTAxMzU2MTM4MDc4MTYxMzc4YjU2NWI5MjUwNjBjMDg5MDEzNTYxMzY5NDgxNjEzNGY1NTY1YjYwMDA4MDYwMDA2MDYwODQ4NjAzMTIxNTYxMzgyYzU3NjAwMDgwZmQ1YjgzMzU2MDAxNjAwMTYwNDAxYjAzODExMTE1NjEzODQyNTc2MDAwODBmZDViNjEzODRlODY4Mjg3MDE2MTM0OWY1NjViOTM1MDUwNjAyMDg0MDEzNTYxMzcxYTgxNjEzNGY1NTY1YjYwMDA4MDYwMDA4MDYwMDA4MDYwYzA4Nzg5MDMxMjE1NjEzODc4NTc2MDAwODBmZDViODYzNTYxMzg4MzgxNjEzNGY1NTY1Yjk1NTA2MDIwODcwMTM1NjEzODkzODE2MTM0ZjU1NjViOTQ1MDYwNDA4NzAxMzU2MTM4YTM4MTYxMzRmNTU2NWI5MzUwNjA2MDg3MDEzNTYxMzhiMzgxNjEzNGY1NTY1YjkyNTA2MTM4YzE2MDgwODgwMTYxMzUwZDU2NWI5MTUwNjBhMDg3MDEzNTYwMDE2MDAxNjA0MDFiMDM4MTExMTU2MTM4ZGM1NzYwMDA4MGZkNWI2MTM4ZTg4OTgyOGEwMTYxMzQ5ZjU2NWI5MTUwNTA5Mjk1NTA5Mjk1NTA5Mjk1NTY1YjYwMDA4MDYwMDA4MDYwODA4NTg3MDMxMjE1NjEzOTBiNTc2MDAwODBmZDViNjEzOTE0ODU2MTM3N2E1NjViOTM1MDYxMzkyMjYwMjA4NjAxNjEzNzdhNTY1YjkyNTA2MTM5MzA2MDQwODYwMTYxMzc3YTU2NWI5MTUwNjA2MDg1MDEzNTYwMDE2MDAxNjA0MDFiMDM4MTExMTU2MTM5NGI1NzYwMDA4MGZkNWI2MTM5NTc4NzgyODgwMTYxMzQ5ZjU2NWI5MTUwNTA5Mjk1OTE5NDUwOTI1MDU2NWI2MDAwODA2MDAwODA2MDgwODU4NzAzMTIxNTYxMzk3OTU3NjAwMDgwZmQ1Yjg0MzU2MTM5ODQ4MTYxMzRmNTU2NWI5MzUwNjAyMDg1MDEzNTYwMDE2MDAxNjA0MDFiMDM4MTExMTU2MTM5OWY1NzYwMDA4MGZkNWI2MTM5YWI4NzgyODgwMTYxMzQ5ZjU2NWI5MzUwNTA2MDQwODUwMTM1NjEzOWJjODE2MTM0ZjU1NjViOTE1MDYxMzljYTYwNjA4NjAxNjEzNTBkNTY1YjkwNTA5Mjk1OTE5NDUwOTI1MDU2NWI2MDAwODA2MDAwODA2MDgwODU4NzAzMTIxNTYxMzllYjU3NjAwMDgwZmQ1YjYxMzlmNDg1NjEzNTBkNTY1YjkzNTA2MTNhMDI2MDIwODYwMTYxMzUwZDU2NWI5MjUwNjA0MDg1MDEzNTYxM2ExMjgxNjEzNzhiNTY1YjkxNTA2MDYwODUwMTM1NjEzYTIyODE2MTM0ZjU1NjViOTM5NjkyOTU1MDkwOTM1MDUwNTY1YjYwMDA4MDYwMDA2MDYwODQ4NjAzMTIxNTYxM2E0MjU3NjAwMDgwZmQ1YjgzMzU2MTNhNGQ4MTYxMzRmNTU2NWI5MjUwNjEzNzVmNjAyMDg1MDE2MTM1MGQ1NjViNjAwMDgwNjAwMDgwNjA4MDg1ODcwMzEyMTU2MTNhNzE1NzYwMDA4MGZkNWI4NDM1NjAwMTYwMDE2MDQwMWIwMzgxMTExNTYxM2E4NzU3NjAwMDgwZmQ1YjYxM2E5Mzg3ODI4ODAxNjEzNDlmNTY1Yjk0NTA1MDYwMjA4NTAxMzU2MTNhYTQ4MTYxMzRmNTU2NWI5MjUwNjA0MDg1MDEzNTYxMzliYzgxNjEzNGY1NTY1YjYwMDA4MDYwMDA2MDYwODQ4NjAzMTIxNTYxM2FjOTU3NjAwMDgwZmQ1YjYxM2FkMjg0NjEzNzdhNTY1YjkyNTA2MTNhZTA2MDIwODUwMTYxMzc3YTU2NWI5MTUwNjA0MDg0MDEzNTYwMDE2MDAxNjA0MDFiMDM4MTExMTU2MTNhZmI1NzYwMDA4MGZkNWI2MTNiMDc4NjgyODcwMTYxMzQ5ZjU2NWI5MTUwNTA5MjUwOTI1MDkyNTY1YjYwMDA4MDYwNDA4Mzg1MDMxMjE1NjEzYjI0NTc2MDAwODBmZDViNjEzYjJkODM2MTM3N2E1NjViOTE1MDYwMjA4MzAxMzU2MDAxNjAwMTYwNDAxYjAzODExMTE1NjEzYjQ4NTc2MDAwODBmZDViNjEzYjU0ODU4Mjg2MDE2MTM0OWY1NjViOTE1MDUwOTI1MDkyOTA1MDU2NWI2MDAwODA2MDAwODA2MDAwODA2MGMwODc4OTAzMTIxNTYxM2I3NzU3NjAwMDgwZmQ1YjYxM2I4MDg3NjEzNTBkNTY1Yjk1NTA2MTNiOGU2MDIwODgwMTYxMzUwZDU2NWI5NDUwNjEzYjljNjA0MDg4MDE2MTM1MGQ1NjViOTM1MDYwNjA4NzAxMzU2MTNiYWM4MTYxMzc4YjU2NWI5MjUwNjA4MDg3MDEzNTYxM2JiYzgxNjEzNGY1NTY1YjkxNTA2MGEwODcwMTM1NjEzYmNjODE2MTM0ZjU1NjViODA5MTUwNTA5Mjk1NTA5Mjk1NTA5Mjk1NTY1YjYwMDA4MDYwMDA4MDYwODA4NTg3MDMxMjE1NjEzYmYwNTc2MDAwODBmZDViNjEzYmY5ODU2MTM1MGQ1NjViOTM1MDYwMjA4NTAxMzU2MTNjMDk4MTYxMzRmNTU2NWI5MjUwNjA0MDg1MDEzNTYxM2ExMjgxNjEzNGY1NTY1YjYwMDA4MDYwMDA4MDYwMDA4MDYwYzA4Nzg5MDMxMjE1NjEzYzMyNTc2MDAwODBmZDViNjEzYzNiODc2MTM1MGQ1NjViOTU1MDYxM2M0OTYwMjA4ODAxNjEzNTBkNTY1Yjk0NTA2MTNjNTc2MDQwODgwMTYxMzUwZDU2NWI5MzUwNjEzYzY1NjA2MDg4MDE2MTM1MGQ1NjViOTI1MDYwODA4NzAxMzU2MTNiYmM4MTYxMzc4YjU2NWI2MzRlNDg3YjcxNjBlMDFiNjAwMDUyNjAzMjYwMDQ1MjYwMjQ2MDAwZmQ1YjYwMDA1YjgzODExMDE1NjEzY2E2NTc4MTgxMDE1MTgzODIwMTUyNjAyMDAxNjEzYzhlNTY1YjgzODExMTE1NjEzY2I1NTc2MDAwODQ4NDAxNTI1YjUwNTA1MDUwNTY1YjYwMDA4MTUxODA4NDUyNjEzY2QzODE2MDIwODYwMTYwMjA4NjAxNjEzYzhiNTY1YjYwMWYwMTYwMWYxOTE2OTI5MDkyMDE2MDIwMDE5MjkxNTA1MDU2NWI2MDAwODE1MTgwODQ1MjYwMjA4MDg1MDE4MDgxOTY1MDgzNjAwNTFiODEwMTkxNTA4Mjg2MDE2MDAwNWI4NTgxMTAxNTYxM2Q5ZTU3ODI4NDAzODk1MjgxNTE2MDQwODE1MTg2NTI4NjgyMDE1MTkxNTA4MDg3ODcwMTUyODE1MTE1MTU4MTg3MDE1Mjg2ODIwMTUxNjA2MDYwMDE2MDAxNjBhMDFiMDM4MDgzMTY4MjhhMDE1MjgzODUwMTUxOTM1MDYwYTA5MjUwNjA4MDgzODE4YjAxNTI2MTNkNjA2MGUwOGIwMTg2NjEzY2JiNTY1YjkyODYwMTUxOGE4NDAzNjAzZjE5MDE4NThjMDE1MjkyOTQ1MDYxM2Q3Yzg1ODQ2MTNjYmI1NjViOTUwMTUxMTY2MGMwOTg5MDk4MDE5NzkwOTc1MjUwNTA5ODg1MDE5ODkzNTA5MDg0MDE5MDYwMDEwMTYxM2QwNTU2NWI1MDkxOTc5NjUwNTA1MDUwNTA1MDUwNTY1YjYwMDA2MTAxNjA4MjUxODE4NTUyNjEzZGMxODI4NjAxODI2MTNjYmI1NjViOTE1MDUwNjAyMDgzMDE1MTg0ODIwMzYwMjA4NjAxNTI2MTNkZGI4MjgyNjEzY2JiNTY1YjkxNTA1MDYwNDA4MzAxNTE2MTNkZjg2MDQwODYwMTgyNjAwMTYwMDE2MGEwMWIwMzE2OTA1MjU2NWI1MDYwNjA4MzAxNTE4NDgyMDM2MDYwODYwMTUyNjEzZTEwODI4MjYxM2NiYjU2NWI5MTUwNTA2MDgwODMwMTUxNjEzZTI2NjA4MDg2MDE4MjE1MTU5MDUyNTY1YjUwNjBhMDgzMDE1MTYxM2UzZTYwYTA4NjAxODI2M2ZmZmZmZmZmMTY5MDUyNTY1YjUwNjBjMDgzMDE1MTYxM2U1MjYwYzA4NjAxODIxNTE1OTA1MjU2NWI1MDYwZTA4MzAxNTE4NDgyMDM2MGUwODY=", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIwMQNKwN+rWmiEfQu+mRYmuKIDWKn89UsUvtE+5MzSxo5r7hr4tF4XZ893RM7rOGz4GgwIiczAqwYQw52bxQMiDwoJCM3LwKsGENIHEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "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", + "b64Record": "CiAIFiocCgwIARAMGgYIgK6ZpA8SDAgBEA8aBgiArpmkDxIw/ck7UrEopllCR31GDemTRpxOGuZV89/oIe1iAU0zcj/2U1uzZGehwcjLXNqZIGY+GgwIiszAqwYQi9KB5wEiDwoJCM7LwKsGENgHEgIYAiogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5SAA==" + }, + { + "b64Body": "Cg8KCQjOy8CrBhDaBxICGAISAhgDGJb7rp0CIgIIeDIgw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo5CRQoDGOsHGiISIGiRa5HnYwD2A47dz8w5V5SNC9ALX0F/KLaHKvh31SzFIMCEPUIFCIDO2gNSAFoAagtjZWxsYXIgZG9vcg==", + "b64Record": "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" + }, + { + "b64Body": "ChAKCQjPy8CrBhDcBxIDGOoHEgIYAxjAv+0hIgIIeDIgw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo461gEKAxjsBxDAhD0YgKjWuQcixAFHUzetAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADuayf8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB6EgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIJL81dr1Pd6jD2AGL5etAk2ZJ6ZBs3ZeCzvSEM60vPx/", + "b64Record": "CiUIISIDGOwHKhwKDAgBEAwaBgiArpmkDxIMCAEQDxoGCICumaQPEjAHRu5IjqnPeeBmR17EVE8s7tI5Gf/4Mh7FYGfvpIaOv6VZ38LESCIInJAgkQlcCy8aDAiLzMCrBhDL8/uHAiIQCgkIz8vAqwYQ3AcSAxjqByogw4PCrsOCwrfDg8K5dEY4w4LCrkrDg8KLw4PCkMODwo4wgOaKGzoIGgIweCiA6jBSFwoJCgIYYhCAzJU2CgoKAxjqBxD/y5U2" + } + ] + } + } +} \ No newline at end of file diff --git a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/contract/precompile/CreatePrecompileSuite.java b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/contract/precompile/CreatePrecompileSuite.java index e30c1a6efd30..a8af92b79f95 100644 --- a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/contract/precompile/CreatePrecompileSuite.java +++ b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/contract/precompile/CreatePrecompileSuite.java @@ -34,7 +34,11 @@ import static com.hedera.services.bdd.spec.utilops.UtilVerbs.childRecordsCheck; import static com.hedera.services.bdd.spec.utilops.UtilVerbs.emptyChildRecordsCheck; import static com.hedera.services.bdd.spec.utilops.UtilVerbs.newKeyNamed; +import static com.hedera.services.bdd.spec.utilops.UtilVerbs.snapshotMode; import static com.hedera.services.bdd.spec.utilops.UtilVerbs.withOpContext; +import static com.hedera.services.bdd.spec.utilops.records.SnapshotMatchMode.NONDETERMINISTIC_FUNCTION_PARAMETERS; +import static com.hedera.services.bdd.spec.utilops.records.SnapshotMatchMode.NONDETERMINISTIC_TRANSACTION_FEES; +import static com.hedera.services.bdd.spec.utilops.records.SnapshotMode.FUZZY_MATCH_AGAINST_HAPI_TEST_STREAMS; import static com.hedera.services.bdd.suites.contract.Utils.asAddress; import static com.hederahashgraph.api.proto.java.ResponseCodeEnum.CONTRACT_REVERT_EXECUTED; import static com.hederahashgraph.api.proto.java.ResponseCodeEnum.INSUFFICIENT_TX_FEE; @@ -240,7 +244,10 @@ final HapiSpec tokenCreateWithFixedFeeWithMultiplePaymentsReverts() { @HapiTest final HapiSpec createTokenWithEmptyTokenStruct() { return defaultHapiSpec("createTokenWithEmptyTokenStruct") - .given(cryptoCreate(ACCOUNT).balance(ONE_MILLION_HBARS), uploadInitCode(TOKEN_CREATE_CONTRACT)) + .given( + snapshotMode(FUZZY_MATCH_AGAINST_HAPI_TEST_STREAMS, NONDETERMINISTIC_TRANSACTION_FEES), + cryptoCreate(ACCOUNT).balance(ONE_MILLION_HBARS), + uploadInitCode(TOKEN_CREATE_CONTRACT)) .when(withOpContext((spec, opLog) -> allRunFor(spec, contractCreate(TOKEN_CREATE_CONTRACT).gas(GAS_TO_OFFER)))) .then( @@ -289,6 +296,10 @@ final HapiSpec createTokenWithEmptyTokenStruct() { final HapiSpec createTokenWithInvalidExpiry() { return defaultHapiSpec("createTokenWithInvalidExpiry") .given( + snapshotMode( + FUZZY_MATCH_AGAINST_HAPI_TEST_STREAMS, + NONDETERMINISTIC_TRANSACTION_FEES, + NONDETERMINISTIC_FUNCTION_PARAMETERS), newKeyNamed(ECDSA_KEY).shape(SECP256K1), cryptoCreate(ACCOUNT).balance(ONE_MILLION_HBARS), uploadInitCode(TOKEN_CREATE_CONTRACT), @@ -325,6 +336,10 @@ final HapiSpec createTokenWithInvalidExpiry() { final HapiSpec createTokenWithInvalidTreasury() { return defaultHapiSpec("createTokenWithInvalidTreasury") .given( + snapshotMode( + FUZZY_MATCH_AGAINST_HAPI_TEST_STREAMS, + NONDETERMINISTIC_TRANSACTION_FEES, + NONDETERMINISTIC_FUNCTION_PARAMETERS), newKeyNamed(ED25519KEY).shape(ED25519), cryptoCreate(ACCOUNT).balance(ONE_MILLION_HBARS).key(ED25519KEY), uploadInitCode(TOKEN_CREATE_CONTRACT), @@ -368,6 +383,10 @@ final HapiSpec createTokenWithInvalidTreasury() { final HapiSpec createTokenWithInsufficientValueSent() { return defaultHapiSpec("createTokenWithInsufficientValueSent") .given( + snapshotMode( + FUZZY_MATCH_AGAINST_HAPI_TEST_STREAMS, + NONDETERMINISTIC_TRANSACTION_FEES, + NONDETERMINISTIC_FUNCTION_PARAMETERS), newKeyNamed(ED25519KEY).shape(ED25519), cryptoCreate(ACCOUNT).key(ED25519KEY).balance(ONE_MILLION_HBARS), uploadInitCode(TOKEN_CREATE_CONTRACT)) From ae24696084740d1ad32cba60d253177adae11e48 Mon Sep 17 00:00:00 2001 From: Austin Littley <102969658+alittley@users.noreply.github.com> Date: Fri, 15 Dec 2023 11:52:39 -0500 Subject: [PATCH 07/13] feat: Add test setting to force ignore PCES signatures (#10538) Signed-off-by: Austin Littley --- .../java/com/swirlds/platform/SwirldsPlatform.java | 14 +++++++++++++- .../PreconsensusEventStreamConfig.java | 6 +++++- 2 files changed, 18 insertions(+), 2 deletions(-) diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/SwirldsPlatform.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/SwirldsPlatform.java index a25c0d1295ee..082fc9f2db06 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/SwirldsPlatform.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/SwirldsPlatform.java @@ -484,7 +484,19 @@ public class SwirldsPlatform implements Platform { Scratchpad.create(platformContext, selfId, IssScratchpad.class, "platform.iss"); issScratchpad.logContents(); final SerializableLong issRound = issScratchpad.get(IssScratchpad.LAST_ISS_ROUND); - final boolean ignorePreconsensusSignatures = issRound != null && issRound.getValue() >= initialState.getRound(); + + final boolean forceIgnorePcesSignatures = platformContext + .getConfiguration() + .getConfigData(PreconsensusEventStreamConfig.class) + .forceIgnorePcesSignatures(); + + final boolean ignorePreconsensusSignatures; + if (forceIgnorePcesSignatures) { + // this is used FOR TESTING ONLY + ignorePreconsensusSignatures = true; + } else { + ignorePreconsensusSignatures = issRound != null && issRound.getValue() >= initialState.getRound(); + } // A round that we will completely skip ISS detection for. Needed for tests that do janky state modification // without a software upgrade (in production this feature should not be used). diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/PreconsensusEventStreamConfig.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/PreconsensusEventStreamConfig.java index 047628b60ab8..450cb3aea912 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/PreconsensusEventStreamConfig.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/PreconsensusEventStreamConfig.java @@ -97,6 +97,9 @@ * w.r.t. the state snapshot. * @param compactLastFileOnStartup if true, then compact the last file's generational span on * startup. + * @param forceIgnorePcesSignatures if true, then ignore the signatures on preconsensus events. + * Note: This is a TEST ONLY setting. It must never be enabled + * in production. */ @ConfigData("event.preconsensus") public record PreconsensusEventStreamConfig( @@ -115,4 +118,5 @@ public record PreconsensusEventStreamConfig( @ConfigProperty(defaultValue = "1024") int replayQueueSize, @ConfigProperty(defaultValue = "8") int replayHashPoolSize, @ConfigProperty(defaultValue = "true") boolean copyRecentStreamToStateSnapshots, - @ConfigProperty(defaultValue = "true") boolean compactLastFileOnStartup) {} + @ConfigProperty(defaultValue = "true") boolean compactLastFileOnStartup, + @ConfigProperty(defaultValue = "false") boolean forceIgnorePcesSignatures) {} From d65026b682dfd0662232c395f62fb3b01e073376 Mon Sep 17 00:00:00 2001 From: Austin Littley <102969658+alittley@users.noreply.github.com> Date: Fri, 15 Dec 2023 12:02:00 -0500 Subject: [PATCH 08/13] chore: Move sequence number to GossipEvent (#10509) Signed-off-by: Austin Littley --- .../com/swirlds/platform/SwirldsPlatform.java | 4 +- .../swirlds/platform/event/GossipEvent.java | 41 ++++++++ .../AsyncPreconsensusEventWriter.java | 22 ++--- .../NoOpPreconsensusEventWriter.java | 10 +- .../PreconsensusEventStreamSequencer.java | 4 +- .../preconsensus/PreconsensusEventWriter.java | 15 +-- .../SyncPreconsensusEventWriter.java | 28 +++--- .../eventhandling/ConsensusRoundHandler.java | 7 +- .../swirlds/platform/internal/EventImpl.java | 41 -------- .../AsyncPreconsensusEventWriterTests.java | 61 +++++------- .../PreconsensusEventReadWriteTests.java | 96 +++++++++---------- ...PreconsensusEventStreamSequencerTests.java | 14 +-- .../SyncPreconsensusEventWriterTests.java | 56 +++++------ 13 files changed, 195 insertions(+), 204 deletions(-) diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/SwirldsPlatform.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/SwirldsPlatform.java index 082fc9f2db06..802107540cef 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/SwirldsPlatform.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/SwirldsPlatform.java @@ -677,10 +677,10 @@ public class SwirldsPlatform implements Platform { addedEventMetrics, eventIntakeMetrics, (PreConsensusEventObserver) event -> { - sequencer.assignStreamSequenceNumber(event); + sequencer.assignStreamSequenceNumber(event.getBaseEvent()); abortAndThrowIfInterrupted( preconsensusEventWriter::writeEvent, - event, + event.getBaseEvent(), "Interrupted while attempting to enqueue preconsensus event for writing"); }, (ConsensusRoundObserver) round -> { diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/GossipEvent.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/GossipEvent.java index 7836063bb275..e4c860e816a3 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/GossipEvent.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/GossipEvent.java @@ -55,6 +55,22 @@ private static final class ClassVersion { private EventDescriptor descriptor; private Instant timeReceived; + /** + * The sequence number of an event before it is added to the write queue. + */ + public static final long NO_STREAM_SEQUENCE_NUMBER = -1; + + /** + * The sequence number of an event that will never be written to disk because it is stale. + */ + public static final long STALE_EVENT_STREAM_SEQUENCE_NUMBER = -2; + + /** + * Each event is assigned a sequence number as it is written to the preconsensus event stream. This is used to + * signal when events have been made durable. + */ + private long streamSequenceNumber = NO_STREAM_SEQUENCE_NUMBER; + /** * The id of the node which sent us this event *

@@ -79,6 +95,31 @@ public GossipEvent(final BaseEventHashedData hashedData, final BaseEventUnhashed this.senderId = null; } + /** + * Set the sequence number in the preconsensus event stream for this event. + * + * @param streamSequenceNumber the sequence number + */ + public void setStreamSequenceNumber(final long streamSequenceNumber) { + if (this.streamSequenceNumber != NO_STREAM_SEQUENCE_NUMBER + && streamSequenceNumber != STALE_EVENT_STREAM_SEQUENCE_NUMBER) { + throw new IllegalStateException("sequence number already set"); + } + this.streamSequenceNumber = streamSequenceNumber; + } + + /** + * Get the sequence number in the preconsensus event stream for this event. + * + * @return the sequence number + */ + public long getStreamSequenceNumber() { + if (streamSequenceNumber == NO_STREAM_SEQUENCE_NUMBER) { + throw new IllegalStateException("sequence number not set"); + } + return streamSequenceNumber; + } + /** * {@inheritDoc} */ diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/AsyncPreconsensusEventWriter.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/AsyncPreconsensusEventWriter.java index 84e9fdde2779..739aaf9f1f55 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/AsyncPreconsensusEventWriter.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/AsyncPreconsensusEventWriter.java @@ -24,7 +24,7 @@ import com.swirlds.common.threading.framework.config.MultiQueueThreadConfiguration; import com.swirlds.common.threading.framework.config.QueueThreadMetricsConfiguration; import com.swirlds.common.threading.manager.ThreadManager; -import com.swirlds.platform.internal.EventImpl; +import com.swirlds.platform.event.GossipEvent; import edu.umd.cs.findbugs.annotations.NonNull; import java.time.Duration; import java.util.Objects; @@ -56,7 +56,7 @@ public class AsyncPreconsensusEventWriter implements PreconsensusEventWriter { /** * Used to push events onto the handle queue. */ - private final BlockingQueueInserter eventInserter; + private final BlockingQueueInserter eventInserter; /** * This class is used as a flag to indicate where in the queue events start being new (as opposed to being events @@ -130,7 +130,7 @@ public AsyncPreconsensusEventWriter( .setThreadName("event-writer") .setCapacity(config.writeQueueCapacity()) .addHandler(Long.class, this::setMinimumGenerationNonAncientHandler) - .addHandler(EventImpl.class, this::addEventHandler) + .addHandler(GossipEvent.class, this::addEventHandler) .addHandler(BeginStreamingNewEvents.class, this::beginStreamingNewEventsHandler) .addHandler(FlushRequested.class, this::flushRequestedHandler) .addHandler(Discontinuity.class, this::discontinuityHandler) @@ -141,7 +141,7 @@ public AsyncPreconsensusEventWriter( .build(); minimumGenerationNonAncientInserter = handleThread.getInserter(Long.class); - eventInserter = handleThread.getInserter(EventImpl.class); + eventInserter = handleThread.getInserter(GossipEvent.class); beginStreamingNewEventsInserter = handleThread.getInserter(BeginStreamingNewEvents.class); flushRequestedInserter = handleThread.getInserter(FlushRequested.class); discontinuityInserter = handleThread.getInserter(Discontinuity.class); @@ -178,9 +178,9 @@ public void beginStreamingNewEvents() throws InterruptedException { * {@inheritDoc} */ @Override - public void writeEvent(@NonNull final EventImpl event) throws InterruptedException { - if (event.getStreamSequenceNumber() == EventImpl.NO_STREAM_SEQUENCE_NUMBER - || event.getStreamSequenceNumber() == EventImpl.STALE_EVENT_STREAM_SEQUENCE_NUMBER) { + public void writeEvent(@NonNull final GossipEvent event) throws InterruptedException { + if (event.getStreamSequenceNumber() == GossipEvent.NO_STREAM_SEQUENCE_NUMBER + || event.getStreamSequenceNumber() == GossipEvent.STALE_EVENT_STREAM_SEQUENCE_NUMBER) { throw new IllegalStateException("Event must have a valid stream sequence number"); } eventInserter.put(event); @@ -222,7 +222,7 @@ public void setMinimumGenerationToStore(final long minimumGenerationToStore) thr * {@inheritDoc} */ @Override - public boolean isEventDurable(@NonNull final EventImpl event) { + public boolean isEventDurable(@NonNull final GossipEvent event) { return writer.isEventDurable(event); } @@ -230,7 +230,7 @@ public boolean isEventDurable(@NonNull final EventImpl event) { * {@inheritDoc} */ @Override - public void waitUntilDurable(@NonNull final EventImpl event) throws InterruptedException { + public void waitUntilDurable(@NonNull final GossipEvent event) throws InterruptedException { writer.waitUntilDurable(event); } @@ -238,7 +238,7 @@ public void waitUntilDurable(@NonNull final EventImpl event) throws InterruptedE * {@inheritDoc} */ @Override - public boolean waitUntilDurable(@NonNull final EventImpl event, @NonNull final Duration timeToWait) + public boolean waitUntilDurable(@NonNull final GossipEvent event, @NonNull final Duration timeToWait) throws InterruptedException { return writer.waitUntilDurable(event, timeToWait); } @@ -263,7 +263,7 @@ private void setMinimumGenerationNonAncientHandler(@NonNull final Long minimumGe /** * Pass an event to the wrapped writer. */ - private void addEventHandler(@NonNull final EventImpl event) { + private void addEventHandler(@NonNull final GossipEvent event) { try { writer.writeEvent(event); } catch (final InterruptedException e) { diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/NoOpPreconsensusEventWriter.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/NoOpPreconsensusEventWriter.java index e5960700a71a..11ff01458464 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/NoOpPreconsensusEventWriter.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/NoOpPreconsensusEventWriter.java @@ -16,7 +16,7 @@ package com.swirlds.platform.event.preconsensus; -import com.swirlds.platform.internal.EventImpl; +import com.swirlds.platform.event.GossipEvent; import java.time.Duration; /** @@ -56,7 +56,7 @@ public void beginStreamingNewEvents() throws InterruptedException { * {@inheritDoc} */ @Override - public void writeEvent(final EventImpl event) { + public void writeEvent(final GossipEvent event) { // no-op } @@ -88,7 +88,7 @@ public void setMinimumGenerationToStore(final long minimumGenerationToStore) { * {@inheritDoc} */ @Override - public boolean isEventDurable(final EventImpl event) { + public boolean isEventDurable(final GossipEvent event) { // If we are not writing events, then we should never block on events becoming durable. return true; } @@ -97,7 +97,7 @@ public boolean isEventDurable(final EventImpl event) { * {@inheritDoc} */ @Override - public void waitUntilDurable(final EventImpl event) { + public void waitUntilDurable(final GossipEvent event) { // If we are not writing events, then we should never block on events becoming durable. } @@ -105,7 +105,7 @@ public void waitUntilDurable(final EventImpl event) { * {@inheritDoc} */ @Override - public boolean waitUntilDurable(final EventImpl event, final Duration timeToWait) { + public boolean waitUntilDurable(final GossipEvent event, final Duration timeToWait) { // If we are not writing events, then we should never block on events becoming durable. return true; } diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/PreconsensusEventStreamSequencer.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/PreconsensusEventStreamSequencer.java index ae85597ed865..1051f39271ec 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/PreconsensusEventStreamSequencer.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/PreconsensusEventStreamSequencer.java @@ -16,7 +16,7 @@ package com.swirlds.platform.event.preconsensus; -import com.swirlds.platform.internal.EventImpl; +import com.swirlds.platform.event.GossipEvent; /** * Responsible for assigning stream sequence numbers to events. All events that are written @@ -30,7 +30,7 @@ public class PreconsensusEventStreamSequencer { * Set the stream sequence number of an event. * @param event an event that needs a sequence number */ - public void assignStreamSequenceNumber(final EventImpl event) { + public void assignStreamSequenceNumber(final GossipEvent event) { event.setStreamSequenceNumber(nextStreamSequenceNumber++); } } diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/PreconsensusEventWriter.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/PreconsensusEventWriter.java index 0745d7e38558..ef04180e1b5d 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/PreconsensusEventWriter.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/PreconsensusEventWriter.java @@ -20,7 +20,7 @@ import com.swirlds.base.state.Startable; import com.swirlds.base.state.Stoppable; -import com.swirlds.platform.internal.EventImpl; +import com.swirlds.platform.event.GossipEvent; import edu.umd.cs.findbugs.annotations.NonNull; import java.time.Duration; import org.apache.logging.log4j.LogManager; @@ -45,7 +45,7 @@ public interface PreconsensusEventWriter extends Startable, Stoppable { * @param event the event to be written * @throws InterruptedException if interrupted while waiting on queue to drain */ - void writeEvent(@NonNull EventImpl event) throws InterruptedException; + void writeEvent(@NonNull GossipEvent event) throws InterruptedException; /** * Let the event writer know the minimum generation for non-ancient events. Ancient events will be ignored if added @@ -95,21 +95,21 @@ default void setMinimumGenerationToStoreUninterruptably(final long minimumGenera * @param event the event in question * @return true if the event can is guaranteed to be durable */ - boolean isEventDurable(@NonNull EventImpl event); + boolean isEventDurable(@NonNull GossipEvent event); /** * Wait until an event is guaranteed to be durable, i.e. flushed to disk. Prior to blocking on this method, the - * event in question should have been passed to {@link #writeEvent(EventImpl)} and {@link #requestFlush()} should + * event in question should have been passed to {@link #writeEvent(GossipEvent)} and {@link #requestFlush()} should * have been called. Otherwise, this method may block indefinitely. * * @param event the event in question * @throws InterruptedException if interrupted while waiting */ - void waitUntilDurable(@NonNull EventImpl event) throws InterruptedException; + void waitUntilDurable(@NonNull GossipEvent event) throws InterruptedException; /** * Wait until an event is guaranteed to be durable, i.e. flushed to disk. Prior to blocking on this method, the - * event in question should have been passed to {@link #writeEvent(EventImpl)} and {@link #requestFlush()} should + * event in question should have been passed to {@link #writeEvent(GossipEvent)} and {@link #requestFlush()} should * have been called. Otherwise, this method may block until the end of its timeout and return false. * * @param event the event in question @@ -117,5 +117,6 @@ default void setMinimumGenerationToStoreUninterruptably(final long minimumGenera * @return true if the event is durable, false if the time to wait has elapsed * @throws InterruptedException if interrupted while waiting */ - boolean waitUntilDurable(@NonNull EventImpl event, @NonNull final Duration timeToWait) throws InterruptedException; + boolean waitUntilDurable(@NonNull GossipEvent event, @NonNull final Duration timeToWait) + throws InterruptedException; } diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/SyncPreconsensusEventWriter.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/SyncPreconsensusEventWriter.java index 27c35258fd08..2414d1e0d0a9 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/SyncPreconsensusEventWriter.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/SyncPreconsensusEventWriter.java @@ -25,7 +25,7 @@ import com.swirlds.common.context.PlatformContext; import com.swirlds.common.threading.CountUpLatch; import com.swirlds.common.utility.LongRunningAverage; -import com.swirlds.platform.internal.EventImpl; +import com.swirlds.platform.event.GossipEvent; import edu.umd.cs.findbugs.annotations.NonNull; import java.io.IOException; import java.io.UncheckedIOException; @@ -170,7 +170,7 @@ public void beginStreamingNewEvents() { * {@inheritDoc} */ @Override - public void writeEvent(@NonNull final EventImpl event) { + public void writeEvent(@NonNull final GossipEvent event) { validateSequenceNumber(event); if (!streamingNewEvents) { @@ -179,13 +179,13 @@ public void writeEvent(@NonNull final EventImpl event) { } if (event.getGeneration() < minimumGenerationNonAncient) { - event.setStreamSequenceNumber(EventImpl.STALE_EVENT_STREAM_SEQUENCE_NUMBER); + event.setStreamSequenceNumber(GossipEvent.STALE_EVENT_STREAM_SEQUENCE_NUMBER); return; } try { prepareOutputStream(event); - currentMutableFile.writeEvent(event.getBaseEvent()); + currentMutableFile.writeEvent(event); lastWrittenEvent = event.getStreamSequenceNumber(); } catch (final IOException e) { throw new UncheckedIOException(e); @@ -207,9 +207,9 @@ public void registerDiscontinuity(final long newOriginRound) { /** * Make sure that the event has a valid stream sequence number. */ - private static void validateSequenceNumber(@NonNull final EventImpl event) { - if (event.getStreamSequenceNumber() == EventImpl.NO_STREAM_SEQUENCE_NUMBER - || event.getStreamSequenceNumber() == EventImpl.STALE_EVENT_STREAM_SEQUENCE_NUMBER) { + private static void validateSequenceNumber(@NonNull final GossipEvent event) { + if (event.getStreamSequenceNumber() == GossipEvent.NO_STREAM_SEQUENCE_NUMBER + || event.getStreamSequenceNumber() == GossipEvent.STALE_EVENT_STREAM_SEQUENCE_NUMBER) { throw new IllegalStateException("Event must have a valid stream sequence number"); } } @@ -240,9 +240,9 @@ public void setMinimumGenerationToStore(final long minimumGenerationToStore) { * {@inheritDoc} */ @Override - public boolean isEventDurable(@NonNull final EventImpl event) { + public boolean isEventDurable(@NonNull final GossipEvent event) { Objects.requireNonNull(event, "event must not be null"); - if (event.getStreamSequenceNumber() == EventImpl.STALE_EVENT_STREAM_SEQUENCE_NUMBER) { + if (event.getStreamSequenceNumber() == GossipEvent.STALE_EVENT_STREAM_SEQUENCE_NUMBER) { // Stale events are not written to disk. return false; } @@ -253,9 +253,9 @@ public boolean isEventDurable(@NonNull final EventImpl event) { * {@inheritDoc} */ @Override - public void waitUntilDurable(@NonNull final EventImpl event) throws InterruptedException { + public void waitUntilDurable(@NonNull final GossipEvent event) throws InterruptedException { Objects.requireNonNull(event, "event must not be null"); - if (event.getStreamSequenceNumber() == EventImpl.STALE_EVENT_STREAM_SEQUENCE_NUMBER) { + if (event.getStreamSequenceNumber() == GossipEvent.STALE_EVENT_STREAM_SEQUENCE_NUMBER) { throw new IllegalStateException("Event is stale and will never be durable"); } lastFlushedEvent.await(event.getStreamSequenceNumber()); @@ -265,11 +265,11 @@ public void waitUntilDurable(@NonNull final EventImpl event) throws InterruptedE * {@inheritDoc} */ @Override - public boolean waitUntilDurable(@NonNull final EventImpl event, @NonNull final Duration timeToWait) + public boolean waitUntilDurable(@NonNull final GossipEvent event, @NonNull final Duration timeToWait) throws InterruptedException { Objects.requireNonNull(event, "event must not be null"); Objects.requireNonNull(timeToWait, "timeToWait must not be null"); - if (event.getStreamSequenceNumber() == EventImpl.STALE_EVENT_STREAM_SEQUENCE_NUMBER) { + if (event.getStreamSequenceNumber() == GossipEvent.STALE_EVENT_STREAM_SEQUENCE_NUMBER) { throw new IllegalStateException("Event is stale and will never be durable"); } return lastFlushedEvent.await(event.getStreamSequenceNumber(), timeToWait); @@ -369,7 +369,7 @@ private long computeNewFileSpan(final long minimumFileGeneration, final long nex * * @param eventToWrite the event that is about to be written */ - private void prepareOutputStream(@NonNull final EventImpl eventToWrite) throws IOException { + private void prepareOutputStream(@NonNull final GossipEvent eventToWrite) throws IOException { if (currentMutableFile != null) { final boolean fileCanContainEvent = currentMutableFile.canContain(eventToWrite.getGeneration()); final boolean fileIsFull = diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/eventhandling/ConsensusRoundHandler.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/eventhandling/ConsensusRoundHandler.java index 5400f3b678c2..a358a9df02ee 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/eventhandling/ConsensusRoundHandler.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/eventhandling/ConsensusRoundHandler.java @@ -44,6 +44,7 @@ import com.swirlds.common.threading.manager.ThreadManager; import com.swirlds.common.utility.Clearable; import com.swirlds.platform.config.ThreadConfig; +import com.swirlds.platform.event.GossipEvent; import com.swirlds.platform.internal.ConsensusRound; import com.swirlds.platform.internal.EventImpl; import com.swirlds.platform.metrics.ConsensusHandlingMetrics; @@ -133,7 +134,7 @@ public class ConsensusRoundHandler implements ConsensusRoundObserver, Clearable, /** * A method that blocks until an event becomes durable. */ - final CheckedConsumer waitForEventDurability; + final CheckedConsumer waitForEventDurability; /** * The number of non-ancient rounds. @@ -171,7 +172,7 @@ public ConsensusRoundHandler( @NonNull final ConsensusHandlingMetrics consensusHandlingMetrics, @NonNull final EventStreamManager eventStreamManager, @NonNull final BlockingQueue stateHashSignQueue, - @NonNull final CheckedConsumer waitForEventDurability, + @NonNull final CheckedConsumer waitForEventDurability, @NonNull final StatusActionSubmitter statusActionSubmitter, @NonNull final Consumer roundAppliedToStateConsumer, @NonNull final SoftwareVersion softwareVersion) { @@ -362,7 +363,7 @@ private void applyConsensusRoundToState(final ConsensusRound round) throws Inter final CycleTimingStat consensusTimingStat = consensusHandlingMetrics.getConsCycleStat(); consensusTimingStat.startCycle(); - waitForEventDurability.accept(round.getKeystoneEvent()); + waitForEventDurability.accept(round.getKeystoneEvent().getBaseEvent()); consensusTimingStat.setTimePoint(1); diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/internal/EventImpl.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/internal/EventImpl.java index f07d782a6e6b..95f7975e6cd3 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/internal/EventImpl.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/internal/EventImpl.java @@ -112,22 +112,6 @@ public class EventImpl extends EventMetadata /** The number of application transactions in this round */ private int numAppTransactions = 0; - /** - * The sequence number of an event before it is added to the write queue. - */ - public static final long NO_STREAM_SEQUENCE_NUMBER = -1; - - /** - * The sequence number of an event that will never be written to disk because it is stale. - */ - public static final long STALE_EVENT_STREAM_SEQUENCE_NUMBER = -2; - - /** - * Each event is assigned a sequence number as it is written to the preconsensus event stream. This is used to - * signal when events have been made durable. - */ - private long streamSequenceNumber = NO_STREAM_SEQUENCE_NUMBER; // needs to be atomic, thread will mark as stale - /** * This latch counts down when prehandle has been called on all application transactions contained in this event. */ @@ -188,31 +172,6 @@ public EventImpl( findSystemTransactions(); } - /** - * Set the sequence number in the preconsenus event stream for this event. - * - * @param streamSequenceNumber the sequence number - */ - public void setStreamSequenceNumber(final long streamSequenceNumber) { - if (this.streamSequenceNumber != NO_STREAM_SEQUENCE_NUMBER - && streamSequenceNumber != STALE_EVENT_STREAM_SEQUENCE_NUMBER) { - throw new IllegalStateException("sequence number already set"); - } - this.streamSequenceNumber = streamSequenceNumber; - } - - /** - * Get the sequence number in the preconsensus event stream for this event. - * - * @return the sequence number - */ - public long getStreamSequenceNumber() { - if (streamSequenceNumber == NO_STREAM_SEQUENCE_NUMBER) { - throw new IllegalStateException("sequence number not set"); - } - return streamSequenceNumber; - } - /** * Signal that all transactions have been prehandled for this event. */ diff --git a/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/event/preconsensus/AsyncPreconsensusEventWriterTests.java b/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/event/preconsensus/AsyncPreconsensusEventWriterTests.java index 2ad15cfd5f32..a5a1fc9b0783 100644 --- a/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/event/preconsensus/AsyncPreconsensusEventWriterTests.java +++ b/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/event/preconsensus/AsyncPreconsensusEventWriterTests.java @@ -53,7 +53,6 @@ import com.swirlds.platform.event.preconsensus.PreconsensusEventStreamSequencer; import com.swirlds.platform.event.preconsensus.PreconsensusEventWriter; import com.swirlds.platform.event.preconsensus.SyncPreconsensusEventWriter; -import com.swirlds.platform.internal.EventImpl; import com.swirlds.platform.system.transaction.ConsensusTransactionImpl; import com.swirlds.platform.system.transaction.SwirldTransaction; import com.swirlds.platform.test.fixtures.event.generator.StandardGraphGenerator; @@ -150,13 +149,6 @@ static StandardGraphGenerator buildGraphGenerator(final Random random) { new StandardEventSource().setTransactionGenerator(transactionGenerator)); } - /** - * Assert that two events are equal. - */ - public static void assertEventsAreEqual(final EventImpl expected, final GossipEvent actual) { - assertEquals(expected.getBaseEvent(), actual); - } - /** * Perform verification on a stream written by a {@link SyncPreconsensusEventWriter}. * @@ -165,13 +157,13 @@ public static void assertEventsAreEqual(final EventImpl expected, final GossipEv * @param truncatedFileCount the expected number of truncated files */ static void verifyStream( - @NonNull final List events, + @NonNull final List events, @NonNull final PlatformContext platformContext, final int truncatedFileCount) throws IOException { long lastGeneration = Long.MIN_VALUE; - for (final EventImpl event : events) { + for (final GossipEvent event : events) { lastGeneration = Math.max(lastGeneration, event.getGeneration()); } @@ -180,9 +172,9 @@ static void verifyStream( // Verify that the events were written correctly final PreconsensusEventMultiFileIterator eventsIterator = reader.getEventIterator(0); - for (final EventImpl event : events) { + for (final GossipEvent event : events) { assertTrue(eventsIterator.hasNext()); - assertEventsAreEqual(event, eventsIterator.next()); + assertEquals(event, eventsIterator.next()); } assertFalse(eventsIterator.hasNext()); assertEquals(truncatedFileCount, eventsIterator.getTruncatedFileCount()); @@ -190,12 +182,12 @@ static void verifyStream( // Make sure things look good when iterating starting in the middle of the stream that was written final long startingGeneration = lastGeneration / 2; final IOIterator eventsIterator2 = reader.getEventIterator(startingGeneration); - for (final EventImpl event : events) { + for (final GossipEvent event : events) { if (event.getGeneration() < startingGeneration) { continue; } assertTrue(eventsIterator2.hasNext()); - assertEventsAreEqual(event, eventsIterator2.next()); + assertEquals(event, eventsIterator2.next()); } assertFalse(eventsIterator2.hasNext()); @@ -266,9 +258,9 @@ void overflowTest(final boolean artificialPauses) throws IOException, Interrupte final StandardGraphGenerator generator = buildGraphGenerator(random); - final List events = new ArrayList<>(); + final List events = new ArrayList<>(); for (int i = 0; i < numEvents; i++) { - events.add(generator.generateEvent().convertToEventImpl()); + events.add(generator.generateEvent().getBaseEvent()); } final int idleWaitPeriodMs = 10; @@ -287,7 +279,7 @@ void overflowTest(final boolean artificialPauses) throws IOException, Interrupte writer.start(); writer.beginStreamingNewEvents(); - for (final EventImpl event : events) { + for (final GossipEvent event : events) { sequencer.assignStreamSequenceNumber(event); writer.writeEvent(event); @@ -350,9 +342,9 @@ void advanceNonAncientGenerationTest(final AdvanceNonAncientGenerationParams par final StandardGraphGenerator generator = buildGraphGenerator(random); - final List events = new LinkedList<>(); + final List events = new LinkedList<>(); for (int i = 0; i < numEvents; i++) { - events.add(generator.generateEvent().convertToEventImpl()); + events.add(generator.generateEvent().getBaseEvent()); } final int idleWaitPeriodMs = 10; @@ -373,10 +365,10 @@ void advanceNonAncientGenerationTest(final AdvanceNonAncientGenerationParams par writer.start(); writer.beginStreamingNewEvents(); - final Set rejectedEvents = new HashSet<>(); + final Set rejectedEvents = new HashSet<>(); long minimumGenerationNonAncient = 0; - for (final EventImpl event : events) { + for (final GossipEvent event : events) { sequencer.assignStreamSequenceNumber(event); assertFalse(writer.isEventDurable(event)); @@ -406,12 +398,12 @@ void advanceNonAncientGenerationTest(final AdvanceNonAncientGenerationParams par // Events should become durable as they are written to disk writer.requestFlush(); - for (final EventImpl event : events) { + for (final GossipEvent event : events) { assertTrue(writer.waitUntilDurable(event, Duration.ofSeconds(1))); } // Rejected events should never become durable - for (final EventImpl event : rejectedEvents) { + for (final GossipEvent event : rejectedEvents) { assertFalse(writer.isEventDurable(event)); } @@ -463,13 +455,13 @@ void restartSimulationTest(final boolean truncateLastFile) throws InterruptedExc final StandardGraphGenerator generator = buildGraphGenerator(random); - final List events1 = new LinkedList<>(); - final List events2 = new LinkedList<>(); + final List events1 = new LinkedList<>(); + final List events2 = new LinkedList<>(); for (int i = 0; i < numEvents; i++) { if (i < numEvents / 2) { - events1.add(generator.generateEvent().convertToEventImpl()); + events1.add(generator.generateEvent().getBaseEvent()); } else { - events2.add(generator.generateEvent().convertToEventImpl()); + events2.add(generator.generateEvent().getBaseEvent()); } } @@ -488,8 +480,8 @@ void restartSimulationTest(final boolean truncateLastFile) throws InterruptedExc writer1.beginStreamingNewEvents(); long minimumGenerationNonAncient = 0; - final Set rejectedEvents1 = new HashSet<>(); - for (final EventImpl event : events1) { + final Set rejectedEvents1 = new HashSet<>(); + for (final GossipEvent event : events1) { sequencer1.assignStreamSequenceNumber(event); assertFalse(writer1.isEventDurable(event)); @@ -537,8 +529,7 @@ void restartSimulationTest(final boolean truncateLastFile) throws InterruptedExc // Write all events currently in the stream, we expect these to be ignored and not written to the stream twice. final IOIterator iterator = fileManager1b.getEventIterator(NO_MINIMUM_GENERATION); while (iterator.hasNext()) { - final GossipEvent gossipEvent = iterator.next(); - final EventImpl next = new EventImpl(gossipEvent.getHashedData(), gossipEvent.getUnhashedData()); + final GossipEvent next = iterator.next(); sequencer2.assignStreamSequenceNumber(next); writer2.writeEvent(next); @@ -551,8 +542,8 @@ void restartSimulationTest(final boolean truncateLastFile) throws InterruptedExc writer2.beginStreamingNewEvents(); writer2.setMinimumGenerationNonAncient(minimumGenerationNonAncient); - final Set rejectedEvents2 = new HashSet<>(); - for (final EventImpl event : events2) { + final Set rejectedEvents2 = new HashSet<>(); + for (final GossipEvent event : events2) { sequencer2.assignStreamSequenceNumber(event); assertFalse(writer2.isEventDurable(event)); @@ -572,11 +563,11 @@ void restartSimulationTest(final boolean truncateLastFile) throws InterruptedExc // Events should become durable as they are written to disk writer2.requestFlush(); - for (final EventImpl event : events2) { + for (final GossipEvent event : events2) { assertTrue(writer2.waitUntilDurable(event, Duration.ofSeconds(1))); } - final List allEvents = new ArrayList<>(); + final List allEvents = new ArrayList<>(); allEvents.addAll(events1); allEvents.addAll(events2); diff --git a/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/event/preconsensus/PreconsensusEventReadWriteTests.java b/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/event/preconsensus/PreconsensusEventReadWriteTests.java index 62605b921544..cee29d8c5595 100644 --- a/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/event/preconsensus/PreconsensusEventReadWriteTests.java +++ b/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/event/preconsensus/PreconsensusEventReadWriteTests.java @@ -18,7 +18,6 @@ import static com.swirlds.common.test.fixtures.io.FileManipulation.corruptFile; import static com.swirlds.common.test.fixtures.io.FileManipulation.truncateFile; -import static com.swirlds.platform.test.event.preconsensus.AsyncPreconsensusEventWriterTests.assertEventsAreEqual; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotEquals; @@ -34,7 +33,6 @@ import com.swirlds.platform.event.preconsensus.PreconsensusEventFile; import com.swirlds.platform.event.preconsensus.PreconsensusEventFileIterator; import com.swirlds.platform.event.preconsensus.PreconsensusEventMutableFile; -import com.swirlds.platform.internal.EventImpl; import com.swirlds.platform.test.fixtures.event.generator.StandardGraphGenerator; import com.swirlds.platform.test.fixtures.event.source.StandardEventSource; import java.io.IOException; @@ -96,13 +94,13 @@ void writeThenReadTest() throws IOException { new StandardEventSource(), new StandardEventSource()); - final List events = new ArrayList<>(); + final List events = new ArrayList<>(); for (int i = 0; i < numEvents; i++) { - events.add(generator.generateEvent()); + events.add(generator.generateEvent().getBaseEvent()); } long maximumGeneration = Long.MIN_VALUE; - for (final EventImpl event : events) { + for (final GossipEvent event : events) { maximumGeneration = Math.max(maximumGeneration, event.getGeneration()); } @@ -112,8 +110,8 @@ void writeThenReadTest() throws IOException { RandomUtils.randomInstant(random), random.nextInt(0, 100), 0, maximumGeneration, 0, testDirectory); final PreconsensusEventMutableFile mutableFile = file.getMutableFile(); - for (final EventImpl event : events) { - mutableFile.writeEvent(event.getBaseEvent()); + for (final GossipEvent event : events) { + mutableFile.writeEvent(event); } mutableFile.close(); @@ -123,7 +121,7 @@ void writeThenReadTest() throws IOException { iterator.forEachRemaining(deserializedEvents::add); assertEquals(events.size(), deserializedEvents.size()); for (int i = 0; i < events.size(); i++) { - assertEventsAreEqual(events.get(i), deserializedEvents.get(i)); + assertEquals(events.get(i), deserializedEvents.get(i)); } } @@ -141,13 +139,13 @@ void readFilesAfterMinimumTest() throws IOException { new StandardEventSource(), new StandardEventSource()); - final List events = new ArrayList<>(); + final List events = new ArrayList<>(); for (int i = 0; i < numEvents; i++) { - events.add(generator.generateEvent()); + events.add(generator.generateEvent().getBaseEvent()); } long maximumGeneration = Long.MIN_VALUE; - for (final EventImpl event : events) { + for (final GossipEvent event : events) { maximumGeneration = Math.max(maximumGeneration, event.getGeneration()); } @@ -164,8 +162,8 @@ void readFilesAfterMinimumTest() throws IOException { testDirectory); final PreconsensusEventMutableFile mutableFile = file.getMutableFile(); - for (final EventImpl event : events) { - mutableFile.writeEvent(event.getBaseEvent()); + for (final GossipEvent event : events) { + mutableFile.writeEvent(event); } mutableFile.close(); @@ -175,9 +173,9 @@ void readFilesAfterMinimumTest() throws IOException { iterator.forEachRemaining(deserializedEvents::add); // We don't want any events with a generation less than the middle - final Iterator it = events.iterator(); + final Iterator it = events.iterator(); while (it.hasNext()) { - final EventImpl event = it.next(); + final GossipEvent event = it.next(); if (event.getGeneration() < middle) { it.remove(); } @@ -185,7 +183,7 @@ void readFilesAfterMinimumTest() throws IOException { assertEquals(events.size(), deserializedEvents.size()); for (int i = 0; i < events.size(); i++) { - assertEventsAreEqual(events.get(i), deserializedEvents.get(i)); + assertEquals(events.get(i), deserializedEvents.get(i)); } } @@ -224,13 +222,13 @@ void truncatedEventTest(final boolean truncateOnBoundary) throws IOException { new StandardEventSource(), new StandardEventSource()); - final List events = new ArrayList<>(); + final List events = new ArrayList<>(); for (int i = 0; i < numEvents; i++) { - events.add(generator.generateEvent()); + events.add(generator.generateEvent().getBaseEvent()); } long maximumGeneration = Long.MIN_VALUE; - for (final EventImpl event : events) { + for (final GossipEvent event : events) { maximumGeneration = Math.max(maximumGeneration, event.getGeneration()); } @@ -248,8 +246,8 @@ void truncatedEventTest(final boolean truncateOnBoundary) throws IOException { final PreconsensusEventMutableFile mutableFile = file.getMutableFile(); for (int i = 0; i < events.size(); i++) { - final EventImpl event = events.get(i); - mutableFile.writeEvent(event.getBaseEvent()); + final GossipEvent event = events.get(i); + mutableFile.writeEvent(event); byteBoundaries.put(i, (int) mutableFile.fileSize()); } @@ -271,7 +269,7 @@ void truncatedEventTest(final boolean truncateOnBoundary) throws IOException { assertEquals(lastEventIndex + 1, deserializedEvents.size()); for (int i = 0; i < deserializedEvents.size(); i++) { - assertEventsAreEqual(events.get(i), deserializedEvents.get(i)); + assertEquals(events.get(i), deserializedEvents.get(i)); } } @@ -289,13 +287,13 @@ void corruptedEventsTest() throws IOException { new StandardEventSource(), new StandardEventSource()); - final List events = new ArrayList<>(); + final List events = new ArrayList<>(); for (int i = 0; i < numEvents; i++) { - events.add(generator.generateEvent()); + events.add(generator.generateEvent().getBaseEvent()); } long maximumGeneration = Long.MIN_VALUE; - for (final EventImpl event : events) { + for (final GossipEvent event : events) { maximumGeneration = Math.max(maximumGeneration, event.getGeneration()); } @@ -308,8 +306,8 @@ void corruptedEventsTest() throws IOException { final PreconsensusEventMutableFile mutableFile = file.getMutableFile(); for (int i = 0; i < events.size(); i++) { - final EventImpl event = events.get(i); - mutableFile.writeEvent(event.getBaseEvent()); + final GossipEvent event = events.get(i); + mutableFile.writeEvent(event); byteBoundaries.put(i, (int) mutableFile.fileSize()); } @@ -325,7 +323,7 @@ void corruptedEventsTest() throws IOException { final PreconsensusEventFileIterator iterator = file.iterator(Long.MIN_VALUE); for (int i = 0; i <= lastEventIndex; i++) { - assertEventsAreEqual(events.get(i), iterator.next()); + assertEquals(events.get(i), iterator.next()); } assertThrows(IOException.class, iterator::next); @@ -345,14 +343,14 @@ void writeInvalidEventTest() throws IOException { new StandardEventSource(), new StandardEventSource()); - final List events = new ArrayList<>(); + final List events = new ArrayList<>(); for (int i = 0; i < numEvents; i++) { - events.add(generator.generateEvent()); + events.add(generator.generateEvent().getBaseEvent()); } long minimumGeneration = Long.MAX_VALUE; long maximumGeneration = Long.MIN_VALUE; - for (final EventImpl event : events) { + for (final GossipEvent event : events) { minimumGeneration = Math.min(minimumGeneration, event.getGeneration()); maximumGeneration = Math.max(maximumGeneration, event.getGeneration()); } @@ -370,23 +368,23 @@ void writeInvalidEventTest() throws IOException { testDirectory); final PreconsensusEventMutableFile mutableFile = file.getMutableFile(); - final List validEvents = new ArrayList<>(); - for (final EventImpl event : events) { + final List validEvents = new ArrayList<>(); + for (final GossipEvent event : events) { if (event.getGeneration() >= restrictedMinimumGeneration && event.getGeneration() <= restrictedMaximumGeneration) { - mutableFile.writeEvent(event.getBaseEvent()); + mutableFile.writeEvent(event); validEvents.add(event); } else { - assertThrows(IllegalStateException.class, () -> mutableFile.writeEvent(event.getBaseEvent())); + assertThrows(IllegalStateException.class, () -> mutableFile.writeEvent(event)); } } mutableFile.close(); final IOIterator iterator = file.iterator(Long.MIN_VALUE); - for (final EventImpl event : validEvents) { + for (final GossipEvent event : validEvents) { assertTrue(iterator.hasNext()); - assertEventsAreEqual(event, iterator.next()); + assertEquals(event, iterator.next()); } assertFalse(iterator.hasNext()); } @@ -405,14 +403,14 @@ void spanCompressionTest() throws IOException { new StandardEventSource(), new StandardEventSource()); - final List events = new ArrayList<>(); + final List events = new ArrayList<>(); for (int i = 0; i < numEvents; i++) { - events.add(generator.generateEvent()); + events.add(generator.generateEvent().getBaseEvent()); } long minimumGeneration = Long.MAX_VALUE; long maximumGeneration = Long.MIN_VALUE; - for (final EventImpl event : events) { + for (final GossipEvent event : events) { minimumGeneration = Math.min(minimumGeneration, event.getGeneration()); maximumGeneration = Math.max(maximumGeneration, event.getGeneration()); } @@ -428,8 +426,8 @@ void spanCompressionTest() throws IOException { testDirectory); final PreconsensusEventMutableFile mutableFile = file.getMutableFile(); - for (final EventImpl event : events) { - mutableFile.writeEvent(event.getBaseEvent()); + for (final GossipEvent event : events) { + mutableFile.writeEvent(event); } mutableFile.close(); @@ -452,7 +450,7 @@ void spanCompressionTest() throws IOException { iterator.forEachRemaining(deserializedEvents::add); assertEquals(events.size(), deserializedEvents.size()); for (int i = 0; i < events.size(); i++) { - assertEventsAreEqual(events.get(i), deserializedEvents.get(i)); + assertEquals(events.get(i), deserializedEvents.get(i)); } } @@ -470,14 +468,14 @@ void partialSpanCompressionTest() throws IOException { new StandardEventSource(), new StandardEventSource()); - final List events = new ArrayList<>(); + final List events = new ArrayList<>(); for (int i = 0; i < numEvents; i++) { - events.add(generator.generateEvent()); + events.add(generator.generateEvent().getBaseEvent()); } long minimumEventGeneration = Long.MAX_VALUE; long maximumEventGeneration = Long.MIN_VALUE; - for (final EventImpl event : events) { + for (final GossipEvent event : events) { minimumEventGeneration = Math.min(minimumEventGeneration, event.getGeneration()); maximumEventGeneration = Math.max(maximumEventGeneration, event.getGeneration()); } @@ -494,8 +492,8 @@ void partialSpanCompressionTest() throws IOException { testDirectory); final PreconsensusEventMutableFile mutableFile = file.getMutableFile(); - for (final EventImpl event : events) { - mutableFile.writeEvent(event.getBaseEvent()); + for (final GossipEvent event : events) { + mutableFile.writeEvent(event); } mutableFile.close(); @@ -519,7 +517,7 @@ void partialSpanCompressionTest() throws IOException { iterator.forEachRemaining(deserializedEvents::add); assertEquals(events.size(), deserializedEvents.size()); for (int i = 0; i < events.size(); i++) { - assertEventsAreEqual(events.get(i), deserializedEvents.get(i)); + assertEquals(events.get(i), deserializedEvents.get(i)); } } diff --git a/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/event/preconsensus/PreconsensusEventStreamSequencerTests.java b/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/event/preconsensus/PreconsensusEventStreamSequencerTests.java index 468910d5b228..31b2cac2de6d 100644 --- a/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/event/preconsensus/PreconsensusEventStreamSequencerTests.java +++ b/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/event/preconsensus/PreconsensusEventStreamSequencerTests.java @@ -24,8 +24,8 @@ import static org.mockito.Mockito.mock; import com.swirlds.common.utility.ValueReference; +import com.swirlds.platform.event.GossipEvent; import com.swirlds.platform.event.preconsensus.PreconsensusEventStreamSequencer; -import com.swirlds.platform.internal.EventImpl; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; @@ -39,8 +39,8 @@ void standardBehaviorTest() { long prev = -1; for (int i = 0; i < 1000; i++) { - final ValueReference seq = new ValueReference<>(EventImpl.NO_STREAM_SEQUENCE_NUMBER); - final EventImpl event = mock(EventImpl.class); + final ValueReference seq = new ValueReference<>(GossipEvent.NO_STREAM_SEQUENCE_NUMBER); + final GossipEvent event = mock(GossipEvent.class); doAnswer(invocation -> { seq.setValue(invocation.getArgument(0)); return null; @@ -60,7 +60,7 @@ void standardBehaviorTest() { void setValueTwiceTest() { final PreconsensusEventStreamSequencer sequencer = new PreconsensusEventStreamSequencer(); - final EventImpl event = new EventImpl(); + final GossipEvent event = new GossipEvent(); sequencer.assignStreamSequenceNumber(event); assertThrows(IllegalStateException.class, () -> sequencer.assignStreamSequenceNumber(event)); @@ -71,11 +71,11 @@ void setValueTwiceTest() { void setStaleTest() { final PreconsensusEventStreamSequencer sequencer = new PreconsensusEventStreamSequencer(); - final EventImpl event = new EventImpl(); + final GossipEvent event = new GossipEvent(); sequencer.assignStreamSequenceNumber(event); - event.setStreamSequenceNumber(EventImpl.STALE_EVENT_STREAM_SEQUENCE_NUMBER); - assertEquals(EventImpl.STALE_EVENT_STREAM_SEQUENCE_NUMBER, event.getStreamSequenceNumber()); + event.setStreamSequenceNumber(GossipEvent.STALE_EVENT_STREAM_SEQUENCE_NUMBER); + assertEquals(GossipEvent.STALE_EVENT_STREAM_SEQUENCE_NUMBER, event.getStreamSequenceNumber()); assertThrows(IllegalStateException.class, () -> sequencer.assignStreamSequenceNumber(event)); } diff --git a/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/event/preconsensus/SyncPreconsensusEventWriterTests.java b/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/event/preconsensus/SyncPreconsensusEventWriterTests.java index edf26c124d19..fe54254ab15a 100644 --- a/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/event/preconsensus/SyncPreconsensusEventWriterTests.java +++ b/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/event/preconsensus/SyncPreconsensusEventWriterTests.java @@ -36,13 +36,13 @@ import com.swirlds.common.test.fixtures.RandomUtils; import com.swirlds.common.test.fixtures.TestRecycleBin; import com.swirlds.config.api.Configuration; +import com.swirlds.platform.event.GossipEvent; import com.swirlds.platform.event.preconsensus.PreconsensusEventFile; import com.swirlds.platform.event.preconsensus.PreconsensusEventFileManager; import com.swirlds.platform.event.preconsensus.PreconsensusEventStreamConfig_; import com.swirlds.platform.event.preconsensus.PreconsensusEventStreamSequencer; import com.swirlds.platform.event.preconsensus.PreconsensusEventWriter; import com.swirlds.platform.event.preconsensus.SyncPreconsensusEventWriter; -import com.swirlds.platform.internal.EventImpl; import com.swirlds.platform.test.fixtures.event.generator.StandardGraphGenerator; import com.swirlds.test.framework.config.TestConfigBuilder; import java.io.IOException; @@ -111,9 +111,9 @@ void standardOperationTest() throws IOException, InterruptedException { final StandardGraphGenerator generator = buildGraphGenerator(random); - final List events = new LinkedList<>(); + final List events = new LinkedList<>(); for (int i = 0; i < numEvents; i++) { - events.add(generator.generateEvent().convertToEventImpl()); + events.add(generator.generateEvent().getBaseEvent()); } final PlatformContext platformContext = buildContext(); @@ -128,9 +128,9 @@ void standardOperationTest() throws IOException, InterruptedException { writer.beginStreamingNewEvents(); long minimumGenerationNonAncient = 0; - final Iterator iterator = events.iterator(); + final Iterator iterator = events.iterator(); while (iterator.hasNext()) { - final EventImpl event = iterator.next(); + final GossipEvent event = iterator.next(); sequencer.assignStreamSequenceNumber(event); @@ -167,9 +167,9 @@ void stopFlushesEventsTest() throws IOException, InterruptedException { final StandardGraphGenerator generator = buildGraphGenerator(random); - final List events = new LinkedList<>(); + final List events = new LinkedList<>(); for (int i = 0; i < numEvents; i++) { - events.add(generator.generateEvent().convertToEventImpl()); + events.add(generator.generateEvent().getBaseEvent()); } final PlatformContext platformContext = buildContext(); @@ -184,9 +184,9 @@ void stopFlushesEventsTest() throws IOException, InterruptedException { writer.beginStreamingNewEvents(); long minimumGenerationNonAncient = 0; - final Iterator iterator = events.iterator(); + final Iterator iterator = events.iterator(); while (iterator.hasNext()) { - final EventImpl event = iterator.next(); + final GossipEvent event = iterator.next(); sequencer.assignStreamSequenceNumber(event); minimumGenerationNonAncient = @@ -221,11 +221,11 @@ void ancientEventTest() throws IOException, InterruptedException { final StandardGraphGenerator generator = buildGraphGenerator(random); // We will add this event at the very end, it should be ancient by then - final EventImpl ancientEvent = generator.generateEvent().convertToEventImpl(); + final GossipEvent ancientEvent = generator.generateEvent().getBaseEvent(); - final List events = new LinkedList<>(); + final List events = new LinkedList<>(); for (int i = 0; i < numEvents; i++) { - events.add(generator.generateEvent().convertToEventImpl()); + events.add(generator.generateEvent().getBaseEvent()); } final PlatformContext platformContext = buildContext(); @@ -240,9 +240,9 @@ void ancientEventTest() throws IOException, InterruptedException { writer.beginStreamingNewEvents(); long minimumGenerationNonAncient = 0; - final Iterator iterator = events.iterator(); + final Iterator iterator = events.iterator(); while (iterator.hasNext()) { - final EventImpl event = iterator.next(); + final GossipEvent event = iterator.next(); sequencer.assignStreamSequenceNumber(event); @@ -271,7 +271,7 @@ void ancientEventTest() throws IOException, InterruptedException { } writer.writeEvent(ancientEvent); - assertEquals(EventImpl.STALE_EVENT_STREAM_SEQUENCE_NUMBER, ancientEvent.getStreamSequenceNumber()); + assertEquals(GossipEvent.STALE_EVENT_STREAM_SEQUENCE_NUMBER, ancientEvent.getStreamSequenceNumber()); writer.requestFlush(); @@ -296,9 +296,9 @@ void overflowTest() throws IOException, InterruptedException { final StandardGraphGenerator generator = buildGraphGenerator(random); - final List events = new ArrayList<>(); + final List events = new ArrayList<>(); for (int i = 0; i < numEvents; i++) { - events.add(generator.generateEvent().convertToEventImpl()); + events.add(generator.generateEvent().getBaseEvent()); } final PlatformContext platformContext = buildContext(); @@ -312,7 +312,7 @@ void overflowTest() throws IOException, InterruptedException { writer.start(); writer.beginStreamingNewEvents(); - for (final EventImpl event : events) { + for (final GossipEvent event : events) { sequencer.assignStreamSequenceNumber(event); writer.writeEvent(event); } @@ -342,9 +342,9 @@ void beginStreamingEventsTest() throws IOException, InterruptedException { final StandardGraphGenerator generator = buildGraphGenerator(random); - final List events = new LinkedList<>(); + final List events = new LinkedList<>(); for (int i = 0; i < numEvents; i++) { - events.add(generator.generateEvent().convertToEventImpl()); + events.add(generator.generateEvent().getBaseEvent()); } final PlatformContext platformContext = buildContext(); @@ -361,7 +361,7 @@ void beginStreamingEventsTest() throws IOException, InterruptedException { // passed into the writer to be more or less ignored. long minimumGenerationNonAncient = 0; - for (EventImpl event : events) { + for (GossipEvent event : events) { sequencer.assignStreamSequenceNumber(event); minimumGenerationNonAncient = @@ -394,10 +394,10 @@ void discontinuityTest() throws IOException, InterruptedException { final StandardGraphGenerator generator = buildGraphGenerator(random); - final List eventsBeforeDiscontinuity = new LinkedList<>(); - final List eventsAfterDiscontinuity = new LinkedList<>(); + final List eventsBeforeDiscontinuity = new LinkedList<>(); + final List eventsAfterDiscontinuity = new LinkedList<>(); for (int i = 0; i < numEvents; i++) { - final EventImpl event = generator.generateEvent().convertToEventImpl(); + final GossipEvent event = generator.generateEvent().getBaseEvent(); if (i < numEvents / 2) { eventsBeforeDiscontinuity.add(event); } else { @@ -417,9 +417,9 @@ void discontinuityTest() throws IOException, InterruptedException { writer.beginStreamingNewEvents(); long minimumGenerationNonAncient = 0; - final Iterator iterator1 = eventsBeforeDiscontinuity.iterator(); + final Iterator iterator1 = eventsBeforeDiscontinuity.iterator(); while (iterator1.hasNext()) { - final EventImpl event = iterator1.next(); + final GossipEvent event = iterator1.next(); sequencer.assignStreamSequenceNumber(event); @@ -438,9 +438,9 @@ void discontinuityTest() throws IOException, InterruptedException { writer.registerDiscontinuity(100); - final Iterator iterator2 = eventsAfterDiscontinuity.iterator(); + final Iterator iterator2 = eventsAfterDiscontinuity.iterator(); while (iterator2.hasNext()) { - final EventImpl event = iterator2.next(); + final GossipEvent event = iterator2.next(); sequencer.assignStreamSequenceNumber(event); From 12f28ea72fe989eaafd7a02eb704fdd90352c382 Mon Sep 17 00:00:00 2001 From: Matt Hess Date: Fri, 15 Dec 2023 11:06:27 -0600 Subject: [PATCH 09/13] fix: Eliminate extra service registration (#10526) Signed-off-by: Matt Hess --- .../node/app/OrderedServiceMigrator.java | 2 -- .../state/merkle/DependencyMigrationTest.java | 20 +++++++++---------- 2 files changed, 10 insertions(+), 12 deletions(-) diff --git a/hedera-node/hedera-app/src/main/java/com/hedera/node/app/OrderedServiceMigrator.java b/hedera-node/hedera-app/src/main/java/com/hedera/node/app/OrderedServiceMigrator.java index 4d20194ec159..d4c63787f182 100644 --- a/hedera-node/hedera-app/src/main/java/com/hedera/node/app/OrderedServiceMigrator.java +++ b/hedera-node/hedera-app/src/main/java/com/hedera/node/app/OrderedServiceMigrator.java @@ -77,9 +77,7 @@ public void doMigrations( .filter(service -> EntityIdService.NAME.equals(service.service().getServiceName())) .findFirst() .orElseThrow(); - final var entityIdService = new EntityIdService(); final var entityIdRegistry = (MerkleSchemaRegistry) entityIdRegistration.registry(); - entityIdService.registerSchemas(entityIdRegistry, currentVersion); entityIdRegistry.migrate( state, previousVersion, diff --git a/hedera-node/hedera-app/src/test/java/com/hedera/node/app/state/merkle/DependencyMigrationTest.java b/hedera-node/hedera-app/src/test/java/com/hedera/node/app/state/merkle/DependencyMigrationTest.java index 2fabac77c75e..66649a39df60 100644 --- a/hedera-node/hedera-app/src/test/java/com/hedera/node/app/state/merkle/DependencyMigrationTest.java +++ b/hedera-node/hedera-app/src/test/java/com/hedera/node/app/state/merkle/DependencyMigrationTest.java @@ -55,15 +55,15 @@ @ExtendWith(MockitoExtension.class) class DependencyMigrationTest extends MerkleTestBase { - private static final HederaSoftwareVersion version = + private static final HederaSoftwareVersion VERSION = new HederaSoftwareVersion(RELEASE_045_VERSION, RELEASE_045_VERSION); + private static final VersionedConfigImpl VERSIONED_CONFIG = + new VersionedConfigImpl(HederaTestConfigBuilder.createConfig(), 1); private static final long INITIAL_ENTITY_ID = 5; @Mock private ThrottleAccumulator accumulator; - private VersionedConfigImpl versionedConfig = new VersionedConfigImpl(HederaTestConfigBuilder.createConfig(), 1); - @Mock private NetworkInfo networkInfo; @@ -102,7 +102,7 @@ final class DoMigrationsNullParams { void stateRequired() { final var subject = new OrderedServiceMigrator(servicesRegistry, accumulator); Assertions.assertThatThrownBy( - () -> subject.doMigrations(null, RELEASE_045_VERSION, null, versionedConfig, networkInfo)) + () -> subject.doMigrations(null, RELEASE_045_VERSION, null, VERSIONED_CONFIG, networkInfo)) .isInstanceOf(NullPointerException.class); } @@ -110,7 +110,7 @@ void stateRequired() { void currentVersionRequired() { final var subject = new OrderedServiceMigrator(servicesRegistry, accumulator); Assertions.assertThatThrownBy( - () -> subject.doMigrations(merkleTree, null, null, versionedConfig, networkInfo)) + () -> subject.doMigrations(merkleTree, null, null, VERSIONED_CONFIG, networkInfo)) .isInstanceOf(NullPointerException.class); } @@ -126,7 +126,7 @@ void versionedConfigRequired() { void networkInfoRequired() { final var subject = new OrderedServiceMigrator(servicesRegistry, accumulator); Assertions.assertThatThrownBy( - () -> subject.doMigrations(merkleTree, RELEASE_045_VERSION, null, versionedConfig, null)) + () -> subject.doMigrations(merkleTree, RELEASE_045_VERSION, null, VERSIONED_CONFIG, null)) .isInstanceOf(NullPointerException.class); } } @@ -154,12 +154,12 @@ public void migrate(@NonNull MigrationContext ctx) { } }; final DependentService dsService = new DependentService(); - Set.of(entityService, dsService).forEach(service -> servicesRegistry.register(service, version)); + Set.of(entityService, dsService).forEach(service -> servicesRegistry.register(service, VERSION)); // When: the migrations are run final var subject = new OrderedServiceMigrator(servicesRegistry, mock(ThrottleAccumulator.class)); subject.doMigrations( - merkleTree, SemanticVersion.newBuilder().major(2).build(), null, versionedConfig, networkInfo); + merkleTree, SemanticVersion.newBuilder().major(2).build(), null, VERSIONED_CONFIG, networkInfo); // Then: we verify the migrations had the desired effects on both entity ID state and DependentService state // First check that the entity ID service has an updated entity ID, despite its schema migration not doing @@ -250,12 +250,12 @@ public void migrate(@NonNull MigrationContext ctx) { }; // Intentionally register the services in a different order than the expected migration order List.of(dsService, serviceA, entityIdService, serviceB) - .forEach(service -> servicesRegistry.register(service, version)); + .forEach(service -> servicesRegistry.register(service, VERSION)); // When: the migrations are run final var subject = new OrderedServiceMigrator(servicesRegistry, mock(ThrottleAccumulator.class)); subject.doMigrations( - merkleTree, SemanticVersion.newBuilder().major(1).build(), null, versionedConfig, networkInfo); + merkleTree, SemanticVersion.newBuilder().major(1).build(), null, VERSIONED_CONFIG, networkInfo); // Then: we verify the migrations were run in the expected order Assertions.assertThat(orderedInvocations) From 44bba9cb3899f93e9e664a47f81c1edf9512eff2 Mon Sep 17 00:00:00 2001 From: Cody Littley <56973212+cody-littley@users.noreply.github.com> Date: Fri, 15 Dec 2023 11:48:05 -0600 Subject: [PATCH 10/13] fix: race condition in wiring unit test (#10525) Signed-off-by: Cody Littley --- .../wiring/schedulers/SequentialTaskSchedulerTests.java | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/platform-sdk/swirlds-common/src/test/java/com/swirlds/common/wiring/schedulers/SequentialTaskSchedulerTests.java b/platform-sdk/swirlds-common/src/test/java/com/swirlds/common/wiring/schedulers/SequentialTaskSchedulerTests.java index 9091bcb93fd1..1933952f0547 100644 --- a/platform-sdk/swirlds-common/src/test/java/com/swirlds/common/wiring/schedulers/SequentialTaskSchedulerTests.java +++ b/platform-sdk/swirlds-common/src/test/java/com/swirlds/common/wiring/schedulers/SequentialTaskSchedulerTests.java @@ -1819,11 +1819,14 @@ void squelchNullValuesInWiresTest(final String typeString) { expectedCountD = hash32(expectedCountD, i); } + assertEventuallyEquals( + expectedCountA, countA::get, Duration.ofSeconds(1), "Wire sum did not match expected sum"); + assertEventuallyEquals( + expectedCountB, countB::get, Duration.ofSeconds(1), "Wire sum did not match expected sum"); + assertEventuallyEquals( + expectedCountC, countC::get, Duration.ofSeconds(1), "Wire sum did not match expected sum"); assertEventuallyEquals( expectedCountD, countD::get, Duration.ofSeconds(1), "Wire sum did not match expected sum"); - assertEquals(expectedCountA, countA.get()); - assertEquals(expectedCountB, countB.get()); - assertEquals(expectedCountC, countC.get()); model.stop(); } From 005d5ee55ff01f068c0c0033d60d454457ff9c4b Mon Sep 17 00:00:00 2001 From: Hendrik Ebbers Date: Fri, 15 Dec 2023 21:46:31 +0100 Subject: [PATCH 11/13] chore: Config records moved to correct modules (#10284) Signed-off-by: Hendrik Ebbers --- .../testfixtures/HederaTestConfigBuilder.java | 33 +++++++++++++++---- .../swirlds/common/config/BasicConfig.java | 2 +- .../common/config/ConfigUtilsTest.java | 3 -- .../swirlds-platform-core/build.gradle.kts | 1 - .../platform/core/jmh/ConsensusBenchmark.java | 2 +- .../platform/ApplicationDefinitionLoader.java | 2 +- .../java/com/swirlds/platform/Browser.java | 2 +- .../com/swirlds/platform/ConsensusImpl.java | 2 +- .../platform/StaticPlatformBuilder.java | 2 +- .../com/swirlds/platform/SwirldsPlatform.java | 4 +-- .../swirlds/platform/cli/CleanCommand.java | 2 +- .../platform/components/EventIntake.java | 2 +- .../components/LinkedEventIntake.java | 2 +- .../appcomm/AppCommunicationComponent.java | 1 - .../components/appcomm}/WiringConfig.java | 4 +-- .../swirlds/platform}/config/PathsConfig.java | 2 +- .../platform/consensus}/ConsensusConfig.java | 4 +-- .../platform/consensus/ConsensusRounds.java | 1 - .../platform/consensus/SyntheticSnapshot.java | 1 - .../consensus/ThreadSafeConsensusInfo.java | 1 - .../swirlds/platform/crypto/CryptoStatic.java | 2 +- .../event/linking/AbstractEventLinker.java | 2 +- .../event/linking/OrphanBufferingLinker.java | 2 +- .../PreconsensusEventReplayWorkflow.java | 2 +- .../eventhandling/ConsensusRoundHandler.java | 3 +- .../platform/eventhandling}/EventConfig.java | 2 +- .../platform/gossip/AbstractGossip.java | 4 +-- .../gossip/sync/SingleNodeSyncGossip.java | 2 +- .../platform/gossip/sync/SyncGossip.java | 2 +- .../platform/gossip/sync/SyncInputStream.java | 2 +- .../platform/gossip/sync/SyncManagerImpl.java | 2 +- .../gossip/sync/SyncOutputStream.java | 2 +- .../platform/health/OSHealthCheck.java | 2 -- .../platform/health}/OSHealthCheckConfig.java | 2 +- .../platform/health/OSHealthChecker.java | 1 - .../clock/OSClockSpeedSourceChecker.java | 2 +- .../health/entropy/OSEntropyChecker.java | 2 +- .../filesystem/OSFileSystemChecker.java | 2 +- .../platform/network}/SocketConfig.java | 2 +- .../platform/network/SocketConnection.java | 1 - .../InboundConnectionHandler.java | 2 +- .../OutboundConnectionCreator.java | 2 +- .../network/connectivity/SocketFactory.java | 2 +- .../network/connectivity/TcpFactory.java | 2 +- .../network/connectivity/TlsFactory.java | 2 +- .../recovery/EventRecoveryWorkflow.java | 2 +- .../swirlds/platform/state/PlatformData.java | 2 +- .../state/iss/ConsensusHashManager.java | 2 +- .../swirlds/platform/util/BootstrapUtils.java | 12 +++---- .../platform/wiring/PlatformSchedulers.java | 1 - .../wiring}/PlatformSchedulersConfig.java | 4 +-- .../platform/wiring/PlatformWiring.java | 2 +- .../com/swirlds/platform/SyncManagerTest.java | 4 +-- .../platform/config/ConfigMappingsTest.java | 2 +- .../ConsensusRoundHandlerTests.java | 1 - .../connectivity/SocketFactoryTest.java | 4 +-- .../test/consensus/ConsensusUtils.java | 2 +- .../platform/test/consensus/TestIntake.java | 2 +- .../framework/validation/NoEventsLost.java | 2 +- .../consensus/ConsensusTestDefinitions.java | 2 +- .../consensus/IntakeAndConsensusTests.java | 4 +-- .../event/intake/OrphanEventsIntakeTest.java | 2 +- .../linking/OrphanBufferingLinkerTest.java | 2 +- .../OutboundConnectionCreatorTest.java | 2 +- .../test/state/ConsensusHashManagerTests.java | 2 +- 65 files changed, 92 insertions(+), 88 deletions(-) rename platform-sdk/{swirlds-common/src/main/java/com/swirlds/common/config => swirlds-platform-core/src/main/java/com/swirlds/platform/components/appcomm}/WiringConfig.java (91%) rename platform-sdk/{swirlds-common/src/main/java/com/swirlds/common => swirlds-platform-core/src/main/java/com/swirlds/platform}/config/PathsConfig.java (98%) rename platform-sdk/{swirlds-common/src/main/java/com/swirlds/common/config => swirlds-platform-core/src/main/java/com/swirlds/platform/consensus}/ConsensusConfig.java (95%) rename platform-sdk/{swirlds-common/src/main/java/com/swirlds/common/config => swirlds-platform-core/src/main/java/com/swirlds/platform/eventhandling}/EventConfig.java (99%) rename platform-sdk/{swirlds-common/src/main/java/com/swirlds/common/config => swirlds-platform-core/src/main/java/com/swirlds/platform/health}/OSHealthCheckConfig.java (98%) rename platform-sdk/{swirlds-common/src/main/java/com/swirlds/common/config => swirlds-platform-core/src/main/java/com/swirlds/platform/network}/SocketConfig.java (98%) rename platform-sdk/{swirlds-common/src/main/java/com/swirlds/common/config => swirlds-platform-core/src/main/java/com/swirlds/platform/wiring}/PlatformSchedulersConfig.java (98%) diff --git a/hedera-node/hedera-config/src/testFixtures/java/com/hedera/node/config/testfixtures/HederaTestConfigBuilder.java b/hedera-node/hedera-config/src/testFixtures/java/com/hedera/node/config/testfixtures/HederaTestConfigBuilder.java index d574587fac5f..40c4693a28f7 100644 --- a/hedera-node/hedera-config/src/testFixtures/java/com/hedera/node/config/testfixtures/HederaTestConfigBuilder.java +++ b/hedera-node/hedera-config/src/testFixtures/java/com/hedera/node/config/testfixtures/HederaTestConfigBuilder.java @@ -18,7 +18,26 @@ import com.hedera.node.config.ConfigProvider; import com.hedera.node.config.VersionedConfigImpl; -import com.hedera.node.config.converter.*; +import com.hedera.node.config.converter.AccountIDConverter; +import com.hedera.node.config.converter.BytesConverter; +import com.hedera.node.config.converter.CongestionMultipliersConverter; +import com.hedera.node.config.converter.ContractIDConverter; +import com.hedera.node.config.converter.EntityScaleFactorsConverter; +import com.hedera.node.config.converter.EntityTypeConverter; +import com.hedera.node.config.converter.FileIDConverter; +import com.hedera.node.config.converter.FunctionalitySetConverter; +import com.hedera.node.config.converter.HederaFunctionalityConverter; +import com.hedera.node.config.converter.KeyValuePairConverter; +import com.hedera.node.config.converter.KnownBlockValuesConverter; +import com.hedera.node.config.converter.LegacyContractIdActivationsConverter; +import com.hedera.node.config.converter.LongPairConverter; +import com.hedera.node.config.converter.MapAccessTypeConverter; +import com.hedera.node.config.converter.PermissionedAccountsRangeConverter; +import com.hedera.node.config.converter.ProfileConverter; +import com.hedera.node.config.converter.RecomputeTypeConverter; +import com.hedera.node.config.converter.ScaleFactorConverter; +import com.hedera.node.config.converter.SemanticVersionConverter; +import com.hedera.node.config.converter.SidecarTypeConverter; import com.hedera.node.config.data.AccountsConfig; import com.hedera.node.config.data.ApiPermissionConfig; import com.hedera.node.config.data.AutoCreationConfig; @@ -55,13 +74,8 @@ import com.hedera.node.config.data.VersionConfig; import com.hedera.node.config.validation.EmulatesMapValidator; import com.swirlds.common.config.BasicConfig; -import com.swirlds.common.config.EventConfig; -import com.swirlds.common.config.OSHealthCheckConfig; -import com.swirlds.common.config.PathsConfig; -import com.swirlds.common.config.SocketConfig; import com.swirlds.common.config.StateConfig; import com.swirlds.common.config.TransactionConfig; -import com.swirlds.common.config.WiringConfig; import com.swirlds.common.crypto.config.CryptoConfig; import com.swirlds.common.io.config.RecycleBinConfig; import com.swirlds.common.io.config.TemporaryFileConfig; @@ -71,6 +85,11 @@ import com.swirlds.config.api.Configuration; import com.swirlds.fchashmap.config.FCHashMapConfig; import com.swirlds.merkledb.config.MerkleDbConfig; +import com.swirlds.platform.components.appcomm.WiringConfig; +import com.swirlds.platform.config.PathsConfig; +import com.swirlds.platform.eventhandling.EventConfig; +import com.swirlds.platform.health.OSHealthCheckConfig; +import com.swirlds.platform.network.SocketConfig; import com.swirlds.platform.system.status.PlatformStatusConfig; import com.swirlds.test.framework.config.TestConfigBuilder; import com.swirlds.virtualmap.config.VirtualMapConfig; @@ -97,7 +116,7 @@ public static TestConfigBuilder create() { return new TestConfigBuilder(false) // Configuration Data Types from the Hashgraph Platform. .withConfigDataType(BasicConfig.class) - .withConfigDataType(com.swirlds.common.config.ConsensusConfig.class) + .withConfigDataType(ConsensusConfig.class) .withConfigDataType(EventConfig.class) .withConfigDataType(OSHealthCheckConfig.class) .withConfigDataType(PathsConfig.class) diff --git a/platform-sdk/swirlds-common/src/main/java/com/swirlds/common/config/BasicConfig.java b/platform-sdk/swirlds-common/src/main/java/com/swirlds/common/config/BasicConfig.java index eff2fa244006..b811442e1de8 100644 --- a/platform-sdk/swirlds-common/src/main/java/com/swirlds/common/config/BasicConfig.java +++ b/platform-sdk/swirlds-common/src/main/java/com/swirlds/common/config/BasicConfig.java @@ -47,7 +47,7 @@ * @param freezeSecondsAfterStartup * do not create events for this many seconds after the platform has started (0 or less to not freeze at startup) * @param loadKeysFromPfxFiles - * When enabled, the platform will try to load node keys from .pfx files located in the {@link PathsConfig keysDirPath}. If even a + * When enabled, the platform will try to load node keys from .pfx files located in the {@code PathsConfig.keysDirPath}. If even a * single key is missing, the platform will warn and exit. If disabled, the platform will generate keys * deterministically. * @param jvmPauseDetectorSleepMs diff --git a/platform-sdk/swirlds-common/src/test/java/com/swirlds/common/config/ConfigUtilsTest.java b/platform-sdk/swirlds-common/src/test/java/com/swirlds/common/config/ConfigUtilsTest.java index 06ef62d064f1..58250f676f17 100644 --- a/platform-sdk/swirlds-common/src/test/java/com/swirlds/common/config/ConfigUtilsTest.java +++ b/platform-sdk/swirlds-common/src/test/java/com/swirlds/common/config/ConfigUtilsTest.java @@ -41,10 +41,7 @@ void testDefaultBehavior() { // then Assertions.assertFalse(configuration.getConfigDataTypes().isEmpty()); Assertions.assertTrue(configuration.getConfigDataTypes().contains(BasicConfig.class)); - Assertions.assertTrue(configuration.getConfigDataTypes().contains(ConsensusConfig.class)); - Assertions.assertTrue(configuration.getConfigDataTypes().contains(OSHealthCheckConfig.class)); Assertions.assertTrue(configuration.getConfigDataTypes().contains(StateConfig.class)); - Assertions.assertTrue(configuration.getConfigDataTypes().contains(WiringConfig.class)); Assertions.assertTrue(configuration.getConfigDataTypes().contains(CryptoConfig.class)); Assertions.assertTrue(configuration.getConfigDataTypes().contains(TemporaryFileConfig.class)); Assertions.assertTrue(configuration.getConfigDataTypes().contains(ReconnectConfig.class)); diff --git a/platform-sdk/swirlds-platform-core/build.gradle.kts b/platform-sdk/swirlds-platform-core/build.gradle.kts index 68543749dbe9..a64080c2bdce 100644 --- a/platform-sdk/swirlds-platform-core/build.gradle.kts +++ b/platform-sdk/swirlds-platform-core/build.gradle.kts @@ -28,7 +28,6 @@ mainModuleInfo { jmhModuleInfo { requires("com.swirlds.base") - requires("com.swirlds.common") requires("com.swirlds.config.api") requires("com.swirlds.platform.core") requires("com.swirlds.platform.test") diff --git a/platform-sdk/swirlds-platform-core/src/jmh/java/com/swirlds/platform/core/jmh/ConsensusBenchmark.java b/platform-sdk/swirlds-platform-core/src/jmh/java/com/swirlds/platform/core/jmh/ConsensusBenchmark.java index b3e9183b0d78..3c03106a9116 100644 --- a/platform-sdk/swirlds-platform-core/src/jmh/java/com/swirlds/platform/core/jmh/ConsensusBenchmark.java +++ b/platform-sdk/swirlds-platform-core/src/jmh/java/com/swirlds/platform/core/jmh/ConsensusBenchmark.java @@ -17,12 +17,12 @@ package com.swirlds.platform.core.jmh; import com.swirlds.base.utility.Pair; -import com.swirlds.common.config.ConsensusConfig; import com.swirlds.common.test.fixtures.WeightGenerators; import com.swirlds.config.api.Configuration; import com.swirlds.platform.Consensus; import com.swirlds.platform.ConsensusImpl; import com.swirlds.platform.config.DefaultConfiguration; +import com.swirlds.platform.consensus.ConsensusConfig; import com.swirlds.platform.test.NoOpConsensusMetrics; import com.swirlds.platform.test.event.emitter.StandardEventEmitter; import com.swirlds.platform.test.event.source.EventSourceFactory; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/ApplicationDefinitionLoader.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/ApplicationDefinitionLoader.java index 01ce07644444..d2283097de8d 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/ApplicationDefinitionLoader.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/ApplicationDefinitionLoader.java @@ -18,9 +18,9 @@ import static com.swirlds.logging.legacy.LogMarker.EXCEPTION; -import com.swirlds.common.config.PathsConfig; import com.swirlds.common.config.singleton.ConfigurationHolder; import com.swirlds.common.utility.CommonUtils; +import com.swirlds.platform.config.PathsConfig; import com.swirlds.platform.config.legacy.ConfigurationException; import com.swirlds.platform.config.legacy.JarAppConfig; import com.swirlds.platform.config.legacy.LegacyConfigProperties; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/Browser.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/Browser.java index 930aa3d1dc13..32b1b019ffc2 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/Browser.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/Browser.java @@ -30,13 +30,13 @@ import static com.swirlds.platform.util.BootstrapUtils.loadSwirldMains; import static com.swirlds.platform.util.BootstrapUtils.setupBrowserWindow; -import com.swirlds.common.config.PathsConfig; import com.swirlds.common.config.singleton.ConfigurationHolder; import com.swirlds.common.platform.NodeId; import com.swirlds.common.startup.Log4jSetup; import com.swirlds.common.threading.framework.config.ThreadConfiguration; import com.swirlds.common.utility.CommonUtils; import com.swirlds.config.api.ConfigurationBuilder; +import com.swirlds.platform.config.PathsConfig; import com.swirlds.platform.crypto.CryptoConstants; import com.swirlds.platform.gui.internal.StateHierarchy; import com.swirlds.platform.gui.model.GuiModel; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/ConsensusImpl.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/ConsensusImpl.java index 4019acaa6783..bfad19a14daf 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/ConsensusImpl.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/ConsensusImpl.java @@ -20,11 +20,11 @@ import static com.swirlds.logging.legacy.LogMarker.STARTUP; import static com.swirlds.platform.consensus.ConsensusConstants.FIRST_CONSENSUS_NUMBER; -import com.swirlds.common.config.ConsensusConfig; import com.swirlds.common.platform.NodeId; import com.swirlds.common.utility.Threshold; import com.swirlds.platform.consensus.AncestorSearch; import com.swirlds.platform.consensus.CandidateWitness; +import com.swirlds.platform.consensus.ConsensusConfig; import com.swirlds.platform.consensus.ConsensusConstants; import com.swirlds.platform.consensus.ConsensusRounds; import com.swirlds.platform.consensus.ConsensusSnapshot; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/StaticPlatformBuilder.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/StaticPlatformBuilder.java index 55eddd6a68a1..cd4027eb70fe 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/StaticPlatformBuilder.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/StaticPlatformBuilder.java @@ -21,13 +21,13 @@ import static com.swirlds.platform.util.BootstrapUtils.startThreadDumpGenerator; import static com.swirlds.platform.util.BootstrapUtils.writeSettingsUsed; -import com.swirlds.common.config.PathsConfig; import com.swirlds.common.config.singleton.ConfigurationHolder; import com.swirlds.common.metrics.Metrics; import com.swirlds.common.metrics.platform.DefaultMetricsProvider; import com.swirlds.common.startup.Log4jSetup; import com.swirlds.config.api.Configuration; import com.swirlds.logging.legacy.payload.NodeStartPayload; +import com.swirlds.platform.config.PathsConfig; import com.swirlds.platform.util.BootstrapUtils; import edu.umd.cs.findbugs.annotations.NonNull; import edu.umd.cs.findbugs.annotations.Nullable; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/SwirldsPlatform.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/SwirldsPlatform.java index 802107540cef..87ca6e340dde 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/SwirldsPlatform.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/SwirldsPlatform.java @@ -35,8 +35,6 @@ import com.swirlds.base.state.Startable; import com.swirlds.base.time.Time; import com.swirlds.base.utility.Pair; -import com.swirlds.common.config.ConsensusConfig; -import com.swirlds.common.config.EventConfig; import com.swirlds.common.config.StateConfig; import com.swirlds.common.config.TransactionConfig; import com.swirlds.common.context.PlatformContext; @@ -75,6 +73,7 @@ import com.swirlds.platform.components.transaction.system.ConsensusSystemTransactionManager; import com.swirlds.platform.components.transaction.system.PreconsensusSystemTransactionManager; import com.swirlds.platform.config.ThreadConfig; +import com.swirlds.platform.consensus.ConsensusConfig; import com.swirlds.platform.crypto.CryptoStatic; import com.swirlds.platform.crypto.KeysAndCerts; import com.swirlds.platform.crypto.PlatformSigner; @@ -113,6 +112,7 @@ import com.swirlds.platform.event.validation.StaticValidators; import com.swirlds.platform.event.validation.TransactionSizeValidator; import com.swirlds.platform.eventhandling.ConsensusRoundHandler; +import com.swirlds.platform.eventhandling.EventConfig; import com.swirlds.platform.eventhandling.PreConsensusEventHandler; import com.swirlds.platform.eventhandling.TransactionPool; import com.swirlds.platform.gossip.DefaultIntakeEventCounter; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/cli/CleanCommand.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/cli/CleanCommand.java index a450b3f0dd97..543e8ed7b789 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/cli/CleanCommand.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/cli/CleanCommand.java @@ -22,12 +22,12 @@ import com.swirlds.cli.PlatformCli; import com.swirlds.cli.utility.AbstractCommand; import com.swirlds.cli.utility.SubcommandOf; -import com.swirlds.common.config.EventConfig; import com.swirlds.common.config.StateConfig; import com.swirlds.common.io.utility.FileUtils; import com.swirlds.config.api.Configuration; import com.swirlds.platform.config.AddressBookConfig; import com.swirlds.platform.config.DefaultConfiguration; +import com.swirlds.platform.eventhandling.EventConfig; import edu.umd.cs.findbugs.annotations.NonNull; import java.io.IOException; import java.nio.file.Path; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/components/EventIntake.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/components/EventIntake.java index ac112fb6b47d..856c74f7b810 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/components/EventIntake.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/components/EventIntake.java @@ -20,7 +20,6 @@ import static com.swirlds.logging.legacy.LogMarker.STALE_EVENTS; import com.swirlds.base.time.Time; -import com.swirlds.common.config.EventConfig; import com.swirlds.common.context.PlatformContext; import com.swirlds.common.metrics.extensions.PhaseTimer; import com.swirlds.common.platform.NodeId; @@ -30,6 +29,7 @@ import com.swirlds.platform.event.linking.EventLinker; import com.swirlds.platform.event.validation.StaticValidators; import com.swirlds.platform.eventhandling.ConsensusRoundHandler; +import com.swirlds.platform.eventhandling.EventConfig; import com.swirlds.platform.gossip.IntakeEventCounter; import com.swirlds.platform.gossip.shadowgraph.ShadowGraph; import com.swirlds.platform.intake.EventIntakePhase; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/components/LinkedEventIntake.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/components/LinkedEventIntake.java index ee57cf0c28d4..274801c1ae01 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/components/LinkedEventIntake.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/components/LinkedEventIntake.java @@ -17,11 +17,11 @@ package com.swirlds.platform.components; import com.swirlds.base.time.Time; -import com.swirlds.common.config.EventConfig; import com.swirlds.common.context.PlatformContext; import com.swirlds.common.threading.manager.ThreadManager; import com.swirlds.platform.Consensus; import com.swirlds.platform.eventhandling.ConsensusRoundHandler; +import com.swirlds.platform.eventhandling.EventConfig; import com.swirlds.platform.gossip.IntakeEventCounter; import com.swirlds.platform.gossip.shadowgraph.ShadowGraph; import com.swirlds.platform.internal.ConsensusRound; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/components/appcomm/AppCommunicationComponent.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/components/appcomm/AppCommunicationComponent.java index 0aa588a90101..4f5b19b4960c 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/components/appcomm/AppCommunicationComponent.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/components/appcomm/AppCommunicationComponent.java @@ -21,7 +21,6 @@ import static com.swirlds.common.threading.manager.AdHocThreadManager.getStaticThreadManager; import static com.swirlds.logging.legacy.LogMarker.EXCEPTION; -import com.swirlds.common.config.WiringConfig; import com.swirlds.common.context.PlatformContext; import com.swirlds.common.notification.NotificationEngine; import com.swirlds.common.platform.NodeId; diff --git a/platform-sdk/swirlds-common/src/main/java/com/swirlds/common/config/WiringConfig.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/components/appcomm/WiringConfig.java similarity index 91% rename from platform-sdk/swirlds-common/src/main/java/com/swirlds/common/config/WiringConfig.java rename to platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/components/appcomm/WiringConfig.java index 69d9dd94ed63..b4df5b0e100b 100644 --- a/platform-sdk/swirlds-common/src/main/java/com/swirlds/common/config/WiringConfig.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/components/appcomm/WiringConfig.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2018-2023 Hedera Hashgraph, LLC + * Copyright (C) 2023 Hedera Hashgraph, LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.swirlds.common.config; +package com.swirlds.platform.components.appcomm; import com.swirlds.config.api.ConfigData; import com.swirlds.config.api.ConfigProperty; diff --git a/platform-sdk/swirlds-common/src/main/java/com/swirlds/common/config/PathsConfig.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/config/PathsConfig.java similarity index 98% rename from platform-sdk/swirlds-common/src/main/java/com/swirlds/common/config/PathsConfig.java rename to platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/config/PathsConfig.java index a99354c0cf51..1cfa1e5a6db3 100644 --- a/platform-sdk/swirlds-common/src/main/java/com/swirlds/common/config/PathsConfig.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/config/PathsConfig.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.swirlds.common.config; +package com.swirlds.platform.config; import static com.swirlds.common.io.utility.FileUtils.getAbsolutePath; import static com.swirlds.common.io.utility.FileUtils.rethrowIO; diff --git a/platform-sdk/swirlds-common/src/main/java/com/swirlds/common/config/ConsensusConfig.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/consensus/ConsensusConfig.java similarity index 95% rename from platform-sdk/swirlds-common/src/main/java/com/swirlds/common/config/ConsensusConfig.java rename to platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/consensus/ConsensusConfig.java index 65833c5fa4e5..6c8171feb68e 100644 --- a/platform-sdk/swirlds-common/src/main/java/com/swirlds/common/config/ConsensusConfig.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/consensus/ConsensusConfig.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2022-2023 Hedera Hashgraph, LLC + * Copyright (C) 2023 Hedera Hashgraph, LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.swirlds.common.config; +package com.swirlds.platform.consensus; import com.swirlds.config.api.ConfigData; import com.swirlds.config.api.ConfigProperty; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/consensus/ConsensusRounds.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/consensus/ConsensusRounds.java index 1e4bef28f9c4..f327fb7dcc19 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/consensus/ConsensusRounds.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/consensus/ConsensusRounds.java @@ -16,7 +16,6 @@ package com.swirlds.platform.consensus; -import com.swirlds.common.config.ConsensusConfig; import com.swirlds.logging.legacy.LogMarker; import com.swirlds.platform.internal.EventImpl; import com.swirlds.platform.state.MinGenInfo; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/consensus/SyntheticSnapshot.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/consensus/SyntheticSnapshot.java index f3f8f5aa7e05..c44af62799d4 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/consensus/SyntheticSnapshot.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/consensus/SyntheticSnapshot.java @@ -16,7 +16,6 @@ package com.swirlds.platform.consensus; -import com.swirlds.common.config.ConsensusConfig; import com.swirlds.platform.event.GossipEvent; import com.swirlds.platform.state.MinGenInfo; import edu.umd.cs.findbugs.annotations.NonNull; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/consensus/ThreadSafeConsensusInfo.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/consensus/ThreadSafeConsensusInfo.java index c05cdee8a549..465449baad68 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/consensus/ThreadSafeConsensusInfo.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/consensus/ThreadSafeConsensusInfo.java @@ -16,7 +16,6 @@ package com.swirlds.platform.consensus; -import com.swirlds.common.config.ConsensusConfig; import com.swirlds.logging.legacy.LogMarker; import com.swirlds.platform.state.MinGenInfo; import edu.umd.cs.findbugs.annotations.NonNull; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/crypto/CryptoStatic.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/crypto/CryptoStatic.java index 0572b59efb41..ac1be6916060 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/crypto/CryptoStatic.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/crypto/CryptoStatic.java @@ -24,7 +24,6 @@ import static com.swirlds.platform.crypto.CryptoConstants.PUBLIC_KEYS_FILE; import com.swirlds.common.config.BasicConfig; -import com.swirlds.common.config.PathsConfig; import com.swirlds.common.crypto.CryptographyException; import com.swirlds.common.crypto.config.CryptoConfig; import com.swirlds.common.platform.NodeId; @@ -33,6 +32,7 @@ import com.swirlds.config.api.Configuration; import com.swirlds.logging.legacy.LogMarker; import com.swirlds.platform.Utilities; +import com.swirlds.platform.config.PathsConfig; import com.swirlds.platform.state.address.AddressBookNetworkUtils; import com.swirlds.platform.system.SystemExitCode; import com.swirlds.platform.system.SystemExitUtils; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/linking/AbstractEventLinker.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/linking/AbstractEventLinker.java index 8c5861b275f9..c3e7bed269ae 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/linking/AbstractEventLinker.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/linking/AbstractEventLinker.java @@ -16,7 +16,7 @@ package com.swirlds.platform.event.linking; -import com.swirlds.common.config.ConsensusConfig; +import com.swirlds.platform.consensus.ConsensusConfig; import com.swirlds.platform.consensus.GraphGenerations; import com.swirlds.platform.consensus.RoundCalculationUtils; import com.swirlds.platform.gossip.shadowgraph.Generations; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/linking/OrphanBufferingLinker.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/linking/OrphanBufferingLinker.java index 7ba0ca75e1c6..fd4e9c84e17c 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/linking/OrphanBufferingLinker.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/linking/OrphanBufferingLinker.java @@ -18,11 +18,11 @@ import static com.swirlds.logging.legacy.LogMarker.EXCEPTION; -import com.swirlds.common.config.ConsensusConfig; import com.swirlds.common.crypto.Hash; import com.swirlds.common.sequence.map.SequenceMap; import com.swirlds.common.sequence.map.StandardSequenceMap; import com.swirlds.logging.legacy.LogMarker; +import com.swirlds.platform.consensus.ConsensusConfig; import com.swirlds.platform.consensus.GraphGenerations; import com.swirlds.platform.event.GossipEvent; import com.swirlds.platform.gossip.IntakeEventCounter; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/PreconsensusEventReplayWorkflow.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/PreconsensusEventReplayWorkflow.java index 0cb62ea4dd6b..41795c20a429 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/PreconsensusEventReplayWorkflow.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/event/preconsensus/PreconsensusEventReplayWorkflow.java @@ -22,7 +22,6 @@ import static com.swirlds.logging.legacy.LogMarker.STARTUP; import com.swirlds.base.time.Time; -import com.swirlds.common.config.EventConfig; import com.swirlds.common.context.PlatformContext; import com.swirlds.common.formatting.UnitFormatter; import com.swirlds.common.io.IOIterator; @@ -31,6 +30,7 @@ import com.swirlds.common.threading.manager.ThreadManager; import com.swirlds.platform.event.GossipEvent; import com.swirlds.platform.eventhandling.ConsensusRoundHandler; +import com.swirlds.platform.eventhandling.EventConfig; import com.swirlds.platform.state.signed.ReservedSignedState; import edu.umd.cs.findbugs.annotations.NonNull; import edu.umd.cs.findbugs.annotations.Nullable; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/eventhandling/ConsensusRoundHandler.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/eventhandling/ConsensusRoundHandler.java index a358a9df02ee..59aa2c1aa8fe 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/eventhandling/ConsensusRoundHandler.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/eventhandling/ConsensusRoundHandler.java @@ -25,8 +25,6 @@ import com.swirlds.base.function.CheckedConsumer; import com.swirlds.base.state.Startable; -import com.swirlds.common.config.ConsensusConfig; -import com.swirlds.common.config.EventConfig; import com.swirlds.common.config.StateConfig; import com.swirlds.common.context.PlatformContext; import com.swirlds.common.crypto.CryptographyHolder; @@ -44,6 +42,7 @@ import com.swirlds.common.threading.manager.ThreadManager; import com.swirlds.common.utility.Clearable; import com.swirlds.platform.config.ThreadConfig; +import com.swirlds.platform.consensus.ConsensusConfig; import com.swirlds.platform.event.GossipEvent; import com.swirlds.platform.internal.ConsensusRound; import com.swirlds.platform.internal.EventImpl; diff --git a/platform-sdk/swirlds-common/src/main/java/com/swirlds/common/config/EventConfig.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/eventhandling/EventConfig.java similarity index 99% rename from platform-sdk/swirlds-common/src/main/java/com/swirlds/common/config/EventConfig.java rename to platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/eventhandling/EventConfig.java index 64d98b839991..395482f45168 100644 --- a/platform-sdk/swirlds-common/src/main/java/com/swirlds/common/config/EventConfig.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/eventhandling/EventConfig.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.swirlds.common.config; +package com.swirlds.platform.eventhandling; import com.swirlds.common.threading.framework.config.QueueThreadConfiguration; import com.swirlds.config.api.ConfigData; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/gossip/AbstractGossip.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/gossip/AbstractGossip.java index a278c131e9ca..e33a2d124e6d 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/gossip/AbstractGossip.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/gossip/AbstractGossip.java @@ -23,8 +23,6 @@ import com.swirlds.base.state.Startable; import com.swirlds.base.time.Time; import com.swirlds.common.config.BasicConfig; -import com.swirlds.common.config.EventConfig; -import com.swirlds.common.config.SocketConfig; import com.swirlds.common.config.StateConfig; import com.swirlds.common.context.PlatformContext; import com.swirlds.common.crypto.config.CryptoConfig; @@ -36,12 +34,14 @@ import com.swirlds.platform.config.ThreadConfig; import com.swirlds.platform.crypto.KeysAndCerts; import com.swirlds.platform.event.GossipEvent; +import com.swirlds.platform.eventhandling.EventConfig; import com.swirlds.platform.gossip.sync.SyncManagerImpl; import com.swirlds.platform.metrics.ReconnectMetrics; import com.swirlds.platform.metrics.SyncMetrics; import com.swirlds.platform.network.Connection; import com.swirlds.platform.network.ConnectionTracker; import com.swirlds.platform.network.NetworkMetrics; +import com.swirlds.platform.network.SocketConfig; import com.swirlds.platform.network.connectivity.ConnectionServer; import com.swirlds.platform.network.connectivity.InboundConnectionHandler; import com.swirlds.platform.network.connectivity.OutboundConnectionCreator; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/gossip/sync/SingleNodeSyncGossip.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/gossip/sync/SingleNodeSyncGossip.java index 1101c430a1a2..903bca7f4e88 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/gossip/sync/SingleNodeSyncGossip.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/gossip/sync/SingleNodeSyncGossip.java @@ -20,7 +20,6 @@ import com.swirlds.base.time.Time; import com.swirlds.base.utility.Pair; -import com.swirlds.common.config.EventConfig; import com.swirlds.common.context.PlatformContext; import com.swirlds.common.merkle.synchronization.config.ReconnectConfig; import com.swirlds.common.platform.NodeId; @@ -30,6 +29,7 @@ import com.swirlds.common.utility.LoggingClearables; import com.swirlds.platform.crypto.KeysAndCerts; import com.swirlds.platform.event.GossipEvent; +import com.swirlds.platform.eventhandling.EventConfig; import com.swirlds.platform.gossip.AbstractGossip; import com.swirlds.platform.gossip.FallenBehindManagerImpl; import com.swirlds.platform.gossip.shadowgraph.ShadowGraph; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/gossip/sync/SyncGossip.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/gossip/sync/SyncGossip.java index 82213775e3dc..55e2871b0216 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/gossip/sync/SyncGossip.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/gossip/sync/SyncGossip.java @@ -23,7 +23,6 @@ import com.swirlds.base.time.Time; import com.swirlds.base.utility.Pair; import com.swirlds.common.config.BasicConfig; -import com.swirlds.common.config.EventConfig; import com.swirlds.common.context.PlatformContext; import com.swirlds.common.crypto.Hash; import com.swirlds.common.merkle.synchronization.config.ReconnectConfig; @@ -41,6 +40,7 @@ import com.swirlds.platform.crypto.KeysAndCerts; import com.swirlds.platform.event.GossipEvent; import com.swirlds.platform.event.linking.EventLinker; +import com.swirlds.platform.eventhandling.EventConfig; import com.swirlds.platform.gossip.AbstractGossip; import com.swirlds.platform.gossip.FallenBehindManagerImpl; import com.swirlds.platform.gossip.IntakeEventCounter; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/gossip/sync/SyncInputStream.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/gossip/sync/SyncInputStream.java index 5438672c87ed..89c1a4a1622a 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/gossip/sync/SyncInputStream.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/gossip/sync/SyncInputStream.java @@ -18,7 +18,6 @@ import static com.swirlds.common.io.extendable.ExtendableInputStream.extendInputStream; -import com.swirlds.common.config.SocketConfig; import com.swirlds.common.context.PlatformContext; import com.swirlds.common.crypto.Hash; import com.swirlds.common.io.extendable.extensions.CountingStreamExtension; @@ -27,6 +26,7 @@ import com.swirlds.platform.gossip.SyncException; import com.swirlds.platform.gossip.shadowgraph.Generations; import com.swirlds.platform.network.ByteConstants; +import com.swirlds.platform.network.SocketConfig; import edu.umd.cs.findbugs.annotations.NonNull; import java.io.BufferedInputStream; import java.io.IOException; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/gossip/sync/SyncManagerImpl.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/gossip/sync/SyncManagerImpl.java index c33259c1461e..54310570f5e9 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/gossip/sync/SyncManagerImpl.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/gossip/sync/SyncManagerImpl.java @@ -19,11 +19,11 @@ import static com.swirlds.common.metrics.Metrics.INTERNAL_CATEGORY; import static com.swirlds.logging.legacy.LogMarker.FREEZE; -import com.swirlds.common.config.EventConfig; import com.swirlds.common.context.PlatformContext; import com.swirlds.common.metrics.FunctionGauge; import com.swirlds.common.platform.NodeId; import com.swirlds.platform.event.GossipEvent; +import com.swirlds.platform.eventhandling.EventConfig; import com.swirlds.platform.gossip.FallenBehindManager; import edu.umd.cs.findbugs.annotations.NonNull; import java.util.List; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/gossip/sync/SyncOutputStream.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/gossip/sync/SyncOutputStream.java index 370f4b0e84dc..5836bd5daf96 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/gossip/sync/SyncOutputStream.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/gossip/sync/SyncOutputStream.java @@ -18,7 +18,6 @@ import static com.swirlds.common.io.extendable.ExtendableOutputStream.extendOutputStream; -import com.swirlds.common.config.SocketConfig; import com.swirlds.common.context.PlatformContext; import com.swirlds.common.crypto.Hash; import com.swirlds.common.io.extendable.extensions.CountingStreamExtension; @@ -26,6 +25,7 @@ import com.swirlds.platform.gossip.shadowgraph.Generations; import com.swirlds.platform.internal.EventImpl; import com.swirlds.platform.network.ByteConstants; +import com.swirlds.platform.network.SocketConfig; import edu.umd.cs.findbugs.annotations.NonNull; import java.io.BufferedOutputStream; import java.io.IOException; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/health/OSHealthCheck.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/health/OSHealthCheck.java index d85c1ddce650..9d02397f20b5 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/health/OSHealthCheck.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/health/OSHealthCheck.java @@ -16,8 +16,6 @@ package com.swirlds.platform.health; -import com.swirlds.common.config.OSHealthCheckConfig; - /** * Performs an OS health check and reports the results */ diff --git a/platform-sdk/swirlds-common/src/main/java/com/swirlds/common/config/OSHealthCheckConfig.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/health/OSHealthCheckConfig.java similarity index 98% rename from platform-sdk/swirlds-common/src/main/java/com/swirlds/common/config/OSHealthCheckConfig.java rename to platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/health/OSHealthCheckConfig.java index eca8672cabb6..cebef948d8c1 100644 --- a/platform-sdk/swirlds-common/src/main/java/com/swirlds/common/config/OSHealthCheckConfig.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/health/OSHealthCheckConfig.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.swirlds.common.config; +package com.swirlds.platform.health; import com.swirlds.config.api.ConfigData; import com.swirlds.config.api.ConfigProperty; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/health/OSHealthChecker.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/health/OSHealthChecker.java index 5ffce027d9b5..114f89b1306f 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/health/OSHealthChecker.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/health/OSHealthChecker.java @@ -19,7 +19,6 @@ import static com.swirlds.common.formatting.StringFormattingUtils.addLine; import static com.swirlds.logging.legacy.LogMarker.STARTUP; -import com.swirlds.common.config.OSHealthCheckConfig; import java.util.concurrent.TimeUnit; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/health/clock/OSClockSpeedSourceChecker.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/health/clock/OSClockSpeedSourceChecker.java index 92925496d846..ef68d9280381 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/health/clock/OSClockSpeedSourceChecker.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/health/clock/OSClockSpeedSourceChecker.java @@ -19,7 +19,7 @@ import static com.swirlds.common.formatting.StringFormattingUtils.addLine; import static com.swirlds.platform.health.OSHealthCheckUtils.reportHeader; -import com.swirlds.common.config.OSHealthCheckConfig; +import com.swirlds.platform.health.OSHealthCheckConfig; /** * Utility class that performs OS clock source speed checks and writes the report to a {@link StringBuilder}. diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/health/entropy/OSEntropyChecker.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/health/entropy/OSEntropyChecker.java index 3c8d468a6f41..87197bbbc78b 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/health/entropy/OSEntropyChecker.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/health/entropy/OSEntropyChecker.java @@ -19,7 +19,7 @@ import static com.swirlds.common.formatting.StringFormattingUtils.addLine; import static com.swirlds.platform.health.OSHealthCheckUtils.reportHeader; -import com.swirlds.common.config.OSHealthCheckConfig; +import com.swirlds.platform.health.OSHealthCheckConfig; import java.util.List; import java.util.concurrent.TimeUnit; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/health/filesystem/OSFileSystemChecker.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/health/filesystem/OSFileSystemChecker.java index 851f110a7817..c67f318500c5 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/health/filesystem/OSFileSystemChecker.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/health/filesystem/OSFileSystemChecker.java @@ -20,7 +20,7 @@ import static com.swirlds.platform.health.OSHealthCheckUtils.reportHeader; import com.swirlds.base.units.UnitConstants; -import com.swirlds.common.config.OSHealthCheckConfig; +import com.swirlds.platform.health.OSHealthCheckConfig; import edu.umd.cs.findbugs.annotations.NonNull; import java.nio.file.Path; import java.util.Objects; diff --git a/platform-sdk/swirlds-common/src/main/java/com/swirlds/common/config/SocketConfig.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/SocketConfig.java similarity index 98% rename from platform-sdk/swirlds-common/src/main/java/com/swirlds/common/config/SocketConfig.java rename to platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/SocketConfig.java index 6b22d305b648..0a7002d1f802 100644 --- a/platform-sdk/swirlds-common/src/main/java/com/swirlds/common/config/SocketConfig.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/SocketConfig.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.swirlds.common.config; +package com.swirlds.platform.network; import com.swirlds.config.api.ConfigData; import com.swirlds.config.api.ConfigProperty; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/SocketConnection.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/SocketConnection.java index 0b4cac057871..22abd66a8302 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/SocketConnection.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/SocketConnection.java @@ -19,7 +19,6 @@ import static com.swirlds.logging.legacy.LogMarker.EXCEPTION; import static com.swirlds.logging.legacy.LogMarker.NETWORK; -import com.swirlds.common.config.SocketConfig; import com.swirlds.common.io.exceptions.BadIOException; import com.swirlds.common.platform.NodeId; import com.swirlds.config.api.Configuration; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/connectivity/InboundConnectionHandler.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/connectivity/InboundConnectionHandler.java index 6093ca880967..78bb6d803b41 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/connectivity/InboundConnectionHandler.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/connectivity/InboundConnectionHandler.java @@ -20,7 +20,6 @@ import static com.swirlds.logging.legacy.LogMarker.SOCKET_EXCEPTIONS; import com.swirlds.base.time.Time; -import com.swirlds.common.config.SocketConfig; import com.swirlds.common.context.PlatformContext; import com.swirlds.common.io.streams.SerializableDataInputStream; import com.swirlds.common.io.streams.SerializableDataOutputStream; @@ -33,6 +32,7 @@ import com.swirlds.platform.network.Connection; import com.swirlds.platform.network.ConnectionTracker; import com.swirlds.platform.network.NetworkUtils; +import com.swirlds.platform.network.SocketConfig; import com.swirlds.platform.network.SocketConnection; import com.swirlds.platform.system.SoftwareVersion; import com.swirlds.platform.system.address.AddressBook; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/connectivity/OutboundConnectionCreator.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/connectivity/OutboundConnectionCreator.java index a8417c5bcf15..7d0f4fa1243d 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/connectivity/OutboundConnectionCreator.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/connectivity/OutboundConnectionCreator.java @@ -21,7 +21,6 @@ import static com.swirlds.logging.legacy.LogMarker.SOCKET_EXCEPTIONS; import static com.swirlds.logging.legacy.LogMarker.TCP_CONNECT_EXCEPTIONS; -import com.swirlds.common.config.SocketConfig; import com.swirlds.common.context.PlatformContext; import com.swirlds.common.platform.NodeId; import com.swirlds.platform.gossip.sync.SyncInputStream; @@ -30,6 +29,7 @@ import com.swirlds.platform.network.Connection; import com.swirlds.platform.network.ConnectionTracker; import com.swirlds.platform.network.NetworkUtils; +import com.swirlds.platform.network.SocketConfig; import com.swirlds.platform.network.SocketConnection; import com.swirlds.platform.network.connection.NotConnectedConnection; import com.swirlds.platform.state.address.AddressBookNetworkUtils; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/connectivity/SocketFactory.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/connectivity/SocketFactory.java index 91d5da781cde..9bd1504bd432 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/connectivity/SocketFactory.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/connectivity/SocketFactory.java @@ -16,7 +16,7 @@ package com.swirlds.platform.network.connectivity; -import com.swirlds.common.config.SocketConfig; +import com.swirlds.platform.network.SocketConfig; import java.io.IOException; import java.net.InetAddress; import java.net.InetSocketAddress; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/connectivity/TcpFactory.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/connectivity/TcpFactory.java index 64c81caf67dc..bb948d6412a2 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/connectivity/TcpFactory.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/connectivity/TcpFactory.java @@ -16,7 +16,7 @@ package com.swirlds.platform.network.connectivity; -import com.swirlds.common.config.SocketConfig; +import com.swirlds.platform.network.SocketConfig; import edu.umd.cs.findbugs.annotations.NonNull; import java.io.IOException; import java.net.ServerSocket; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/connectivity/TlsFactory.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/connectivity/TlsFactory.java index 0b7f2572eaed..cce987fef3fa 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/connectivity/TlsFactory.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/connectivity/TlsFactory.java @@ -16,11 +16,11 @@ package com.swirlds.platform.network.connectivity; -import com.swirlds.common.config.SocketConfig; import com.swirlds.common.crypto.config.CryptoConfig; import com.swirlds.platform.crypto.CryptoConstants; import com.swirlds.platform.crypto.CryptoStatic; import com.swirlds.platform.crypto.KeysAndCerts; +import com.swirlds.platform.network.SocketConfig; import edu.umd.cs.findbugs.annotations.NonNull; import java.io.IOException; import java.net.ServerSocket; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/recovery/EventRecoveryWorkflow.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/recovery/EventRecoveryWorkflow.java index d324b3fa63bb..8d8ac78d270c 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/recovery/EventRecoveryWorkflow.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/recovery/EventRecoveryWorkflow.java @@ -23,7 +23,6 @@ import static com.swirlds.platform.util.BootstrapUtils.loadAppMain; import static com.swirlds.platform.util.BootstrapUtils.setupConstructableRegistry; -import com.swirlds.common.config.ConsensusConfig; import com.swirlds.common.config.StateConfig; import com.swirlds.common.context.PlatformContext; import com.swirlds.common.crypto.CryptographyHolder; @@ -38,6 +37,7 @@ import com.swirlds.platform.ApplicationDefinition; import com.swirlds.platform.ApplicationDefinitionLoader; import com.swirlds.platform.ParameterProvider; +import com.swirlds.platform.consensus.ConsensusConfig; import com.swirlds.platform.consensus.SyntheticSnapshot; import com.swirlds.platform.event.GossipEvent; import com.swirlds.platform.event.preconsensus.PreconsensusEventFile; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/state/PlatformData.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/state/PlatformData.java index a3396099f7f1..80cfbb05cf6a 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/state/PlatformData.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/state/PlatformData.java @@ -17,7 +17,6 @@ package com.swirlds.platform.state; import com.swirlds.base.utility.ToStringBuilder; -import com.swirlds.common.config.ConsensusConfig; import com.swirlds.common.config.singleton.ConfigurationHolder; import com.swirlds.common.crypto.Hash; import com.swirlds.common.io.streams.SerializableDataInputStream; @@ -25,6 +24,7 @@ import com.swirlds.common.merkle.MerkleLeaf; import com.swirlds.common.merkle.impl.PartialMerkleLeaf; import com.swirlds.common.utility.NonCryptographicHashing; +import com.swirlds.platform.consensus.ConsensusConfig; import com.swirlds.platform.consensus.ConsensusSnapshot; import com.swirlds.platform.consensus.RoundCalculationUtils; import com.swirlds.platform.internal.EventImpl; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/state/iss/ConsensusHashManager.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/state/iss/ConsensusHashManager.java index f7632c3e2b15..fd3e96d56c50 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/state/iss/ConsensusHashManager.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/state/iss/ConsensusHashManager.java @@ -21,7 +21,6 @@ import static com.swirlds.logging.legacy.LogMarker.STATE_HASH; import com.swirlds.base.time.Time; -import com.swirlds.common.config.ConsensusConfig; import com.swirlds.common.config.StateConfig; import com.swirlds.common.context.PlatformContext; import com.swirlds.common.crypto.Hash; @@ -30,6 +29,7 @@ import com.swirlds.common.sequence.map.SequenceMap; import com.swirlds.common.utility.throttle.RateLimiter; import com.swirlds.logging.legacy.payload.IssPayload; +import com.swirlds.platform.consensus.ConsensusConfig; import com.swirlds.platform.dispatch.DispatchBuilder; import com.swirlds.platform.dispatch.Observer; import com.swirlds.platform.dispatch.triggers.error.CatastrophicIssTrigger; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/util/BootstrapUtils.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/util/BootstrapUtils.java index 5630a5539f64..610a7bc3944e 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/util/BootstrapUtils.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/util/BootstrapUtils.java @@ -24,14 +24,8 @@ import static com.swirlds.platform.system.SystemExitUtils.exitSystem; import com.swirlds.common.config.BasicConfig; -import com.swirlds.common.config.ConsensusConfig; -import com.swirlds.common.config.EventConfig; -import com.swirlds.common.config.OSHealthCheckConfig; -import com.swirlds.common.config.PathsConfig; -import com.swirlds.common.config.SocketConfig; import com.swirlds.common.config.StateConfig; import com.swirlds.common.config.TransactionConfig; -import com.swirlds.common.config.WiringConfig; import com.swirlds.common.config.singleton.ConfigurationHolder; import com.swirlds.common.constructable.ConstructableRegistry; import com.swirlds.common.constructable.ConstructableRegistryException; @@ -56,22 +50,28 @@ import com.swirlds.platform.ApplicationDefinition; import com.swirlds.platform.JVMPauseDetectorThread; import com.swirlds.platform.ThreadDumpGenerator; +import com.swirlds.platform.components.appcomm.WiringConfig; import com.swirlds.platform.config.AddressBookConfig; +import com.swirlds.platform.config.PathsConfig; import com.swirlds.platform.config.ThreadConfig; import com.swirlds.platform.config.internal.ConfigMappings; import com.swirlds.platform.config.internal.PlatformConfigUtils; +import com.swirlds.platform.consensus.ConsensusConfig; import com.swirlds.platform.dispatch.DispatchConfiguration; import com.swirlds.platform.event.creation.EventCreationConfig; import com.swirlds.platform.event.preconsensus.PreconsensusEventStreamConfig; +import com.swirlds.platform.eventhandling.EventConfig; import com.swirlds.platform.gossip.ProtocolConfig; import com.swirlds.platform.gossip.chatter.config.ChatterConfig; import com.swirlds.platform.gossip.sync.config.SyncConfig; import com.swirlds.platform.gui.WindowConfig; +import com.swirlds.platform.health.OSHealthCheckConfig; import com.swirlds.platform.health.OSHealthChecker; import com.swirlds.platform.health.clock.OSClockSpeedSourceChecker; import com.swirlds.platform.health.entropy.OSEntropyChecker; import com.swirlds.platform.health.filesystem.OSFileSystemChecker; import com.swirlds.platform.network.Network; +import com.swirlds.platform.network.SocketConfig; import com.swirlds.platform.state.address.AddressBookNetworkUtils; import com.swirlds.platform.state.signed.SignedState; import com.swirlds.platform.swirldapp.AppLoaderException; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/wiring/PlatformSchedulers.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/wiring/PlatformSchedulers.java index dbc2e10f5721..99f74c074e43 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/wiring/PlatformSchedulers.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/wiring/PlatformSchedulers.java @@ -16,7 +16,6 @@ package com.swirlds.platform.wiring; -import com.swirlds.common.config.PlatformSchedulersConfig; import com.swirlds.common.context.PlatformContext; import com.swirlds.common.wiring.model.WiringModel; import com.swirlds.common.wiring.schedulers.TaskScheduler; diff --git a/platform-sdk/swirlds-common/src/main/java/com/swirlds/common/config/PlatformSchedulersConfig.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/wiring/PlatformSchedulersConfig.java similarity index 98% rename from platform-sdk/swirlds-common/src/main/java/com/swirlds/common/config/PlatformSchedulersConfig.java rename to platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/wiring/PlatformSchedulersConfig.java index 0850585ade4b..ea407df23b5b 100644 --- a/platform-sdk/swirlds-common/src/main/java/com/swirlds/common/config/PlatformSchedulersConfig.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/wiring/PlatformSchedulersConfig.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2022-2023 Hedera Hashgraph, LLC + * Copyright (C) 2023 Hedera Hashgraph, LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.swirlds.common.config; +package com.swirlds.platform.wiring; import com.swirlds.common.wiring.schedulers.builders.TaskSchedulerType; import com.swirlds.config.api.ConfigData; diff --git a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/wiring/PlatformWiring.java b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/wiring/PlatformWiring.java index f429b0531ca3..cf2a18a0be06 100644 --- a/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/wiring/PlatformWiring.java +++ b/platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/wiring/PlatformWiring.java @@ -21,7 +21,6 @@ import com.swirlds.base.state.Startable; import com.swirlds.base.state.Stoppable; import com.swirlds.base.time.Time; -import com.swirlds.common.config.EventConfig; import com.swirlds.common.context.PlatformContext; import com.swirlds.common.utility.Clearable; import com.swirlds.common.wiring.model.WiringModel; @@ -39,6 +38,7 @@ import com.swirlds.platform.event.validation.AddressBookUpdate; import com.swirlds.platform.event.validation.EventSignatureValidator; import com.swirlds.platform.event.validation.InternalEventValidator; +import com.swirlds.platform.eventhandling.EventConfig; import com.swirlds.platform.eventhandling.TransactionPool; import com.swirlds.platform.state.signed.ReservedSignedState; import com.swirlds.platform.state.signed.SignedStateFileManager; diff --git a/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/SyncManagerTest.java b/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/SyncManagerTest.java index fa6c4596a8d8..c6539c26878c 100644 --- a/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/SyncManagerTest.java +++ b/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/SyncManagerTest.java @@ -23,13 +23,13 @@ import static org.mockito.Mockito.mock; import static org.mockito.Mockito.spy; -import com.swirlds.common.config.EventConfig; -import com.swirlds.common.config.EventConfig_; import com.swirlds.common.context.PlatformContext; import com.swirlds.common.merkle.synchronization.config.ReconnectConfig; import com.swirlds.common.merkle.synchronization.config.ReconnectConfig_; import com.swirlds.common.platform.NodeId; import com.swirlds.config.api.Configuration; +import com.swirlds.platform.eventhandling.EventConfig; +import com.swirlds.platform.eventhandling.EventConfig_; import com.swirlds.platform.eventhandling.TransactionPool; import com.swirlds.platform.gossip.FallenBehindManagerImpl; import com.swirlds.platform.gossip.sync.SyncManagerImpl; diff --git a/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/config/ConfigMappingsTest.java b/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/config/ConfigMappingsTest.java index d4d731449c31..d552138635df 100644 --- a/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/config/ConfigMappingsTest.java +++ b/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/config/ConfigMappingsTest.java @@ -18,11 +18,11 @@ import static org.junit.jupiter.api.Assertions.assertEquals; -import com.swirlds.common.config.ConsensusConfig; import com.swirlds.config.api.Configuration; import com.swirlds.config.api.ConfigurationBuilder; import com.swirlds.config.extensions.sources.SimpleConfigSource; import com.swirlds.platform.config.internal.ConfigMappings; +import com.swirlds.platform.consensus.ConsensusConfig; import org.junit.jupiter.api.Test; class ConfigMappingsTest { diff --git a/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/eventhandling/ConsensusRoundHandlerTests.java b/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/eventhandling/ConsensusRoundHandlerTests.java index e5c1035443e4..d98ebecc0fcc 100644 --- a/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/eventhandling/ConsensusRoundHandlerTests.java +++ b/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/eventhandling/ConsensusRoundHandlerTests.java @@ -27,7 +27,6 @@ import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -import com.swirlds.common.config.EventConfig_; import com.swirlds.common.context.PlatformContext; import com.swirlds.common.stream.EventStreamManager; import com.swirlds.common.test.fixtures.RandomAddressBookGenerator; diff --git a/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/network/connectivity/SocketFactoryTest.java b/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/network/connectivity/SocketFactoryTest.java index 201a2058eec4..f73dd2368655 100644 --- a/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/network/connectivity/SocketFactoryTest.java +++ b/platform-sdk/swirlds-platform-core/src/test/java/com/swirlds/platform/network/connectivity/SocketFactoryTest.java @@ -18,11 +18,11 @@ import static org.junit.jupiter.api.Assertions.assertArrayEquals; -import com.swirlds.common.config.SocketConfig; -import com.swirlds.common.config.SocketConfig_; import com.swirlds.common.crypto.config.CryptoConfig; import com.swirlds.config.api.Configuration; import com.swirlds.platform.crypto.KeysAndCerts; +import com.swirlds.platform.network.SocketConfig; +import com.swirlds.platform.network.SocketConfig_; import com.swirlds.platform.system.address.AddressBook; import com.swirlds.test.framework.TestQualifierTags; import com.swirlds.test.framework.config.TestConfigBuilder; diff --git a/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/main/java/com/swirlds/platform/test/consensus/ConsensusUtils.java b/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/main/java/com/swirlds/platform/test/consensus/ConsensusUtils.java index db5e6b2aee4f..1f71ddae2ccd 100644 --- a/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/main/java/com/swirlds/platform/test/consensus/ConsensusUtils.java +++ b/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/main/java/com/swirlds/platform/test/consensus/ConsensusUtils.java @@ -16,10 +16,10 @@ package com.swirlds.platform.test.consensus; -import com.swirlds.common.config.ConsensusConfig; import com.swirlds.common.config.singleton.ConfigurationHolder; import com.swirlds.platform.Consensus; import com.swirlds.platform.ConsensusImpl; +import com.swirlds.platform.consensus.ConsensusConfig; import com.swirlds.platform.internal.ConsensusRound; import com.swirlds.platform.internal.EventImpl; import com.swirlds.platform.metrics.ConsensusMetrics; diff --git a/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/main/java/com/swirlds/platform/test/consensus/TestIntake.java b/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/main/java/com/swirlds/platform/test/consensus/TestIntake.java index 672261f1cb42..2183742cf86a 100644 --- a/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/main/java/com/swirlds/platform/test/consensus/TestIntake.java +++ b/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/main/java/com/swirlds/platform/test/consensus/TestIntake.java @@ -20,13 +20,13 @@ import static org.mockito.Mockito.mock; import com.swirlds.base.time.Time; -import com.swirlds.common.config.ConsensusConfig; import com.swirlds.common.context.PlatformContext; import com.swirlds.common.metrics.extensions.PhaseTimer; import com.swirlds.common.platform.NodeId; import com.swirlds.platform.Consensus; import com.swirlds.platform.ConsensusImpl; import com.swirlds.platform.components.EventIntake; +import com.swirlds.platform.consensus.ConsensusConfig; import com.swirlds.platform.consensus.ConsensusSnapshot; import com.swirlds.platform.event.GossipEvent; import com.swirlds.platform.event.linking.EventLinker; diff --git a/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/main/java/com/swirlds/platform/test/consensus/framework/validation/NoEventsLost.java b/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/main/java/com/swirlds/platform/test/consensus/framework/validation/NoEventsLost.java index be1bf85fb161..17c871588372 100644 --- a/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/main/java/com/swirlds/platform/test/consensus/framework/validation/NoEventsLost.java +++ b/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/main/java/com/swirlds/platform/test/consensus/framework/validation/NoEventsLost.java @@ -16,8 +16,8 @@ package com.swirlds.platform.test.consensus.framework.validation; -import com.swirlds.common.config.ConsensusConfig; import com.swirlds.common.crypto.Hash; +import com.swirlds.platform.consensus.ConsensusConfig; import com.swirlds.platform.internal.EventImpl; import com.swirlds.platform.test.consensus.framework.ConsensusOutput; import com.swirlds.test.framework.config.TestConfigBuilder; diff --git a/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/consensus/ConsensusTestDefinitions.java b/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/consensus/ConsensusTestDefinitions.java index 4e8d78ca2bbe..ce13aef29e47 100644 --- a/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/consensus/ConsensusTestDefinitions.java +++ b/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/consensus/ConsensusTestDefinitions.java @@ -22,12 +22,12 @@ import static com.swirlds.platform.test.graph.OtherParentMatrixFactory.createPartitionedOtherParentAffinityMatrix; import static com.swirlds.platform.test.graph.OtherParentMatrixFactory.createShunnedNodeOtherParentAffinityMatrix; -import com.swirlds.common.config.ConsensusConfig; import com.swirlds.common.constructable.ConstructableRegistry; import com.swirlds.common.constructable.ConstructableRegistryException; import com.swirlds.common.platform.NodeId; import com.swirlds.common.utility.Threshold; import com.swirlds.config.api.ConfigurationBuilder; +import com.swirlds.platform.consensus.ConsensusConfig; import com.swirlds.platform.consensus.ConsensusConstants; import com.swirlds.platform.consensus.ConsensusSnapshot; import com.swirlds.platform.consensus.SyntheticSnapshot; diff --git a/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/consensus/IntakeAndConsensusTests.java b/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/consensus/IntakeAndConsensusTests.java index 4c9ff080eff4..05f73f473539 100644 --- a/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/consensus/IntakeAndConsensusTests.java +++ b/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/consensus/IntakeAndConsensusTests.java @@ -18,10 +18,10 @@ import static com.swirlds.test.framework.TestQualifierTags.TIME_CONSUMING; -import com.swirlds.common.config.ConsensusConfig; -import com.swirlds.common.config.ConsensusConfig_; import com.swirlds.common.platform.NodeId; import com.swirlds.config.api.Configuration; +import com.swirlds.platform.consensus.ConsensusConfig; +import com.swirlds.platform.consensus.ConsensusConfig_; import com.swirlds.platform.system.address.AddressBook; import com.swirlds.platform.system.events.EventConstants; import com.swirlds.platform.test.consensus.framework.validation.ConsensusRoundValidation; diff --git a/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/event/intake/OrphanEventsIntakeTest.java b/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/event/intake/OrphanEventsIntakeTest.java index fc71244e00e2..1be42898739a 100644 --- a/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/event/intake/OrphanEventsIntakeTest.java +++ b/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/event/intake/OrphanEventsIntakeTest.java @@ -20,7 +20,6 @@ import static org.mockito.Mockito.mock; import com.swirlds.base.time.Time; -import com.swirlds.common.config.ConsensusConfig; import com.swirlds.common.config.singleton.ConfigurationHolder; import com.swirlds.common.context.PlatformContext; import com.swirlds.common.crypto.Hash; @@ -29,6 +28,7 @@ import com.swirlds.common.test.fixtures.RandomUtils; import com.swirlds.platform.Consensus; import com.swirlds.platform.components.EventIntake; +import com.swirlds.platform.consensus.ConsensusConfig; import com.swirlds.platform.event.GossipEvent; import com.swirlds.platform.event.linking.OrphanBufferingLinker; import com.swirlds.platform.event.linking.ParentFinder; diff --git a/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/event/linking/OrphanBufferingLinkerTest.java b/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/event/linking/OrphanBufferingLinkerTest.java index 03af79be970c..7a7e08ce721e 100644 --- a/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/event/linking/OrphanBufferingLinkerTest.java +++ b/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/event/linking/OrphanBufferingLinkerTest.java @@ -21,8 +21,8 @@ import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; -import com.swirlds.common.config.ConsensusConfig; import com.swirlds.common.test.fixtures.RandomUtils; +import com.swirlds.platform.consensus.ConsensusConfig; import com.swirlds.platform.event.GossipEvent; import com.swirlds.platform.event.linking.OrphanBufferingLinker; import com.swirlds.platform.event.linking.ParentFinder; diff --git a/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/network/OutboundConnectionCreatorTest.java b/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/network/OutboundConnectionCreatorTest.java index 0b48c89f6464..d91558195278 100644 --- a/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/network/OutboundConnectionCreatorTest.java +++ b/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/network/OutboundConnectionCreatorTest.java @@ -24,7 +24,6 @@ import static org.mockito.Mockito.doAnswer; import static org.mockito.Mockito.mock; -import com.swirlds.common.config.SocketConfig_; import com.swirlds.common.constructable.ClassConstructorPair; import com.swirlds.common.constructable.ConstructableRegistry; import com.swirlds.common.constructable.ConstructableRegistryException; @@ -37,6 +36,7 @@ import com.swirlds.platform.network.ByteConstants; import com.swirlds.platform.network.Connection; import com.swirlds.platform.network.ConnectionTracker; +import com.swirlds.platform.network.SocketConfig_; import com.swirlds.platform.network.SocketConnection; import com.swirlds.platform.network.connection.NotConnectedConnection; import com.swirlds.platform.network.connectivity.OutboundConnectionCreator; diff --git a/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/state/ConsensusHashManagerTests.java b/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/state/ConsensusHashManagerTests.java index cf2e08ea835b..48cf65beb408 100644 --- a/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/state/ConsensusHashManagerTests.java +++ b/platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/state/ConsensusHashManagerTests.java @@ -34,12 +34,12 @@ import static org.mockito.Mockito.mock; import com.swirlds.base.time.Time; -import com.swirlds.common.config.ConsensusConfig; import com.swirlds.common.context.PlatformContext; import com.swirlds.common.crypto.Hash; import com.swirlds.common.crypto.Signature; import com.swirlds.common.platform.NodeId; import com.swirlds.common.test.fixtures.RandomAddressBookGenerator; +import com.swirlds.platform.consensus.ConsensusConfig; import com.swirlds.platform.dispatch.DispatchBuilder; import com.swirlds.platform.dispatch.triggers.error.CatastrophicIssTrigger; import com.swirlds.platform.dispatch.triggers.error.SelfIssTrigger; From e2c5d2a289680d2e7b062fc23b4e1193273c84db Mon Sep 17 00:00:00 2001 From: Edward Wertz <123979964+edward-swirldslabs@users.noreply.github.com> Date: Fri, 15 Dec 2023 15:11:40 -0600 Subject: [PATCH 12/13] docs: Consensus Roster Terminology (#9834) Signed-off-by: Edward Wertz Signed-off-by: Edward Wertz <123979964+edward-swirldslabs@users.noreply.github.com> Co-authored-by: Kelly Greco <82919061+poulok@users.noreply.github.com> --- ...namicAddressBook-PlatformDesign.drawio.svg | 4 + .../DynamicAddressBook-PlatformDesign.md | 134 +++++++++++++++ .../roster/EventWindowTerminology.drawio.svg | 4 + .../RosterTerminologyDiagram.drawio.svg | 4 + .../roster/glossary-of-terms.md | 155 ++++++++++++++++++ 5 files changed, 301 insertions(+) create mode 100644 platform-sdk/docs/core/dynamic-address-book/DynamicAddressBook-PlatformDesign.drawio.svg create mode 100644 platform-sdk/docs/core/dynamic-address-book/DynamicAddressBook-PlatformDesign.md create mode 100644 platform-sdk/docs/core/dynamic-address-book/roster/EventWindowTerminology.drawio.svg create mode 100644 platform-sdk/docs/core/dynamic-address-book/roster/RosterTerminologyDiagram.drawio.svg create mode 100644 platform-sdk/docs/core/dynamic-address-book/roster/glossary-of-terms.md diff --git a/platform-sdk/docs/core/dynamic-address-book/DynamicAddressBook-PlatformDesign.drawio.svg b/platform-sdk/docs/core/dynamic-address-book/DynamicAddressBook-PlatformDesign.drawio.svg new file mode 100644 index 000000000000..442f463428b8 --- /dev/null +++ b/platform-sdk/docs/core/dynamic-address-book/DynamicAddressBook-PlatformDesign.drawio.svg @@ -0,0 +1,4 @@ + + + +
RosterDiffForRound
RosterDiffForRound
Long pendingConsensusRound
Long pendingConsensusRound
RosterDiff currentEffectiveRoster
RosterDiff currentEffectiveRoster
RosterDiff
RosterDiff
Roster newRoster
Roster newRoster
long effectiveRound
long effectiveRound
List<NodeId> addedNodes
List<NodeId> addedNodes
List<NodeId> removedNodes
List<NodeId> removedNodes
List<NodeId> changedKeys
List<NodeId> changedKeys
boolean weightChanged
boolean weightChanged
Application on Handle Transaction Thread
Application on Handle Transaction Thread
handleConsensusRound
handleConsensusRound
EventHorizonManager (EHM) 
EventHorizonManager (EHM) 
void accept(RosterForRound)
void accept(RosterForRound)
void accept(NonAncientEventWindow window)
void accept(NonAncientEventWindow window)
Roster getRosterForRound(long round) 
Roster getRosterForRound(long round) 
Roster getCurrentEffectiveRoster()
Roster getCurrentEffectiveRoster()
void addFutureEventHorizonConsumer(Consumer<Long>  consumer)
void addFutureEventHorizonConsumer(Consumer<Long>  consumer)
void addPendingRoundConsumer(Consumer<Long> consumer) 
void addPendingRoundConsumer(Consumer<Long> consumer) 
void addPastEventHorizonConsumer(Consumer<lLong> consumer)
void addPastEventHorizonConsumer(Consumer<lLong> consumer)
Platform
Platform
Buffered Validation
Buffered Validation
Event Round Buffer
Event Round Bu...
Signature
Validator
Signature...
Orphan
Buffer
Orphan...
EHM
EHM
Parent Time
Validation
Parent Time...
EHM
EHM
Event Intake
Event Intake
preConsensus
preConsensus
preHandle
preHandle
consensus
consensus
Event
Observer
Event...
handle
Consensus
Rounds
handle...
handle
stale
events
handle...
Platform.setNewRoster(Roster) 
Platform.setNewRoster(Roster) 
StateRosterStore
StateRosterStore
Event Validation
Event Validation
Ancient
Validator
Ancient...
Event
Deduplication
Event...
Parent
Validator
Parent...
Transaction
Size Validator
Transaction...
EHM
EHM
Load from state at startup
Load from state...
Event Creation
Event Creation
Tipset
Event
Creation
Manager
Tipset...
Tipset
Event
Creator
Impl
Tipset...
Tipset
Metrics
Tipset...
Tipset
Tracker
Tipset...
Tipset
Weight
Calculator
Tipset...
Gossip
Gossip
GossipFactory
GossipFactory
Chatter
Gossip
Chatter...
Sync
Gossip
Sync...
Abstract
Gossip
Abstract...
Network
Topology
Network...
Connection
Managers
Connection...
Outbound
Manager
Outbound...
Inbound
Manager
Inbound...
Fallen
Behind
Fallen...
Shadow
Graph
Shadow...
Reconnect
Learner
Reconnect...
EHM
EHM
Sync
Manager
Sync...
EHM
EHM
EventTask
Creator
EventTask...
Network
Reconnect
Metrics
Network...
Consensus
Consensus
Consensus
Impl
Consensus...
EHM
EHM
Consensus
Rounds
Consensus...
EHM
EHM
ISS Detection
ISS Detection
Consensus
HashManager
Consensus...
EHM
EHM
NetworkManager Refactor
NetworkManager Refactor

Start of day, all rosters in the saved EventHorizon are broadcast in order of round.
Start of day, all rosters in the saved EventHorizo...
Metrics
Metrics
Network
Network
ISS
ISS
Reconnect
Reconnect
RosterForRound FutureEventHorizon
RosterForRound FutureEventHorizon
NonAncientEventWindow PastEventHorizon
NonAncientEventWindow PastEventHorizon
RosterDiffForRound for pendingConsensusRound
RosterDiffForRound for pendingConsensusRound
RosterForRound
RosterForRound
Long round
Long round
Roster roster
Roster roster
NonAncientEventWindow
NonAncientEventWindow
Long latestConsensusRound
Long latestConsensusRound
Long minRoundNonAncient
Long minRoundNonAncientText is not SVG - cannot display \ No newline at end of file diff --git a/platform-sdk/docs/core/dynamic-address-book/DynamicAddressBook-PlatformDesign.md b/platform-sdk/docs/core/dynamic-address-book/DynamicAddressBook-PlatformDesign.md new file mode 100644 index 000000000000..8ecb99d0386d --- /dev/null +++ b/platform-sdk/docs/core/dynamic-address-book/DynamicAddressBook-PlatformDesign.md @@ -0,0 +1,134 @@ +# Dynamic Address Book - Platform Design + +![Dynamic Address Book Platform Design](DynamicAddressBook-PlatformDesign.drawio.svg) + +## Network Connection + +### Add Node + +Existing nodes need to create or receive mutual TLS gossip connections with the added node. + +This change takes effect when a roster with an added node becomes the `currentEffectiveRoster` for +the `pendingConsensusRound`. + +### Remove Node + +Existing nodes need to stop gossiping with the removed node. Events from the removed node can still be gossiped, +validated and come to consensus until the last roster that includes the removed node becomes ancient. + +This change takes effect when a roster with a removed node becomes the `currentEffectiveRoster` for +the `pendingConsensusRound`. + +### Rotate Signing Key + +All nodes need to tear down their existing mutual TLS connection with the node that has had its key rotated and +establish a new connection with the node using the new signing certificate as the trusted root certificate. + +This change takes effect when a roster with the node's key changes becomes the `currentEffectiveRoster` for +the `pendingConsensusRound`. + +### Node Weight Change + +This has no effect on the existence of network connections. + +## Event Creation + +### Add Node + +Begin using events from the node as parents of new events. + +This change takes effect when a roster with an added node becomes the `currentEffectiveRoster` for +the `pendingConsensusRound`. + +This change will modify network membership and the event creation algorithm will be reset. + +The event creator can build on top of any event that has a birth round that is less than or equal to the event creator's +known value for the `pendingConsensusRound`. Events that have a higher birth round need to be buffered until the event +creator's known `pendingConsensusRound` becomes equal to or higher than their birth round. + +Buffer: Only the latest events from each node within the same birthRound need to be buffered. + +### Remove Node + +When a roster with a removed node becomes the `currentEffectiveRoster` for the `pendingConsensusRound`, the event +creation algorithm is reset. + +### Rotate Signing Key + +The `currentEffectiveRoster` contains the key used to sign the event. Rotation of the roster will update the signing +key to use for signing self events. + +### Node Weight Change + +Changing network weight in the `currentEffectiveRoster` for the `pendingConsensusRound` should cause the event creation +algorithm to reset. + +## Gossip + +### Receiving Events + +The `futureEventHorizon` and the `pastEventHorizon` define the thresholds for receiving gossipped Events. Received +events with `birthRound` outside of this node's Event Horizon will be rejected or discarded. + +### Sending Events + +A node will store ancient events and send them through gossip to help nodes which are behind. + +### Add Node + +When transaction handling creates a roster with a new node in it, it becomes the `greatestEffectiveRoster` for +the `futureEventHorizon` and this node will be able to receive these events. + +### Remove Node + +When a node is removed from a roster and all rosters containing the node have become ancient, this node will no longer +receive events from the removed node. If received, they will be discarded. + +### Rotate Signing Key + +This roster change has no effect on whether or not send or receive events through Gossip. + +### Node Weight Change + +This roster change has no effect on whether or not send or receive events through Gossip. + +## Event Validation + +For each event, lookup the roster within the `eventHorizon` that matches the `birthRound` of the event. Events +outside the `eventHorizon` are not validatable. + +## Orphan Buffer + +Drop ancient events that have a birthRound less than `minRoundNonAncient`. + +## ISS Detection + +Use the effective roster for the round in question. + +## Consensus Effects + +Uses the `currentEffectiveRoster` for the `pendingConsensusRound`. + +When a round comes to consensus: + +* The `latestConsensusRound` and `latestConsensRoster` can be retrieved from the produced `ConsensusRound`. +* A new `NonAncientEventWindow` is produced on an output wire. +* Consensus advances the `pendingConsensusRound` and uses the `currentEffectiveRoster` for that round. +* The `RosterDiff` between the `currentEffectiveRoster` and the `latestConsensusRoster` is produced on an output wire. + +## Signature Gathering for State + +Use the effective roster for the relevant round when validating signatures on the round's state. + +## Reconnect + +Validating state signatures. + +Use the effective roster for the relevant round when validating signatures on the round's state. + +NOTE: The node must be able to validate >1/2 of the weight with its current effective roster. Since >2/3 of the +weight is needed to sign the state, a reconnecting node can tolerate 1/6 of variance in weight assigned to nodes. + +## Metrics + +Most metrics will need to stay in sync with the `currentEffectiveRoster` for the `pendingConsensusRound`. \ No newline at end of file diff --git a/platform-sdk/docs/core/dynamic-address-book/roster/EventWindowTerminology.drawio.svg b/platform-sdk/docs/core/dynamic-address-book/roster/EventWindowTerminology.drawio.svg new file mode 100644 index 000000000000..5abb110ed8d0 --- /dev/null +++ b/platform-sdk/docs/core/dynamic-address-book/roster/EventWindowTerminology.drawio.svg @@ -0,0 +1,4 @@ + + + +
Consensus: Non-Ancient Event Window
Consensus: Non-...

latestConsensusRound
latestConsensusRound
pendingConsensusRound
pendingConsensusRound
Ancient Rounds
Ancient Ro...
latestHandledRound
latestHand...
greatestEffectiveRoster
greatestEffectiveRoster
Gossip: Validatable Event Window
Within The "EventHorizon" 
Gossip: Validat...
Latest Handled Round Creates
Greatest Effective Roster
Latest Handled Round Creates...
Roster Offset
Roster Offset
currentEffectiveRoster
currentEffectiveRoster
maxGossipRound
maxGossipRound
minGossipRound
minGossipRound
minRoundNonAncient
minRoundNonAncient
Rounds
Rounds
Rosters For Rounds
Rosters For Rounds
latestConsensusRoster
latestConsensusRoster
minRosterNonAncient
minRosterNonAncient
futureEventHorizon
futureEventHorizon
pastEventHorizon
pastEventHorizon Text is not SVG - cannot display \ No newline at end of file diff --git a/platform-sdk/docs/core/dynamic-address-book/roster/RosterTerminologyDiagram.drawio.svg b/platform-sdk/docs/core/dynamic-address-book/roster/RosterTerminologyDiagram.drawio.svg new file mode 100644 index 000000000000..5d565771f61d --- /dev/null +++ b/platform-sdk/docs/core/dynamic-address-book/roster/RosterTerminologyDiagram.drawio.svg @@ -0,0 +1,4 @@ + + + +
creates
creates
Roster
Effective Round: 100
Roster...
Roster
Effective Round: 99
Roster...
Roster
Effective Round: 98
Roster...
Roster
Effective Round: 97
Roster...
Roster
Effective Round: 75
Roster...
Roster
Effective Round: 74
Roster...
Round 100
Round 100
Round 99
Round 99
Round 98
Round 98
Round 97
Round 97
Round 75
Round 75
Round 74
Round 74
Roster Store
Roster Round Offset: 2
Roster Store...
creates
creates
Roster
Effective Round: 101
Roster...
creates
creates
Non Ancient
Non Ancient
Ancient
Ancient
Roster
Effective Round: 73
Roster...
Round 73
Round 73
creates
creates
The consensus algorithm is trying to reach consensus on round 101 (the pending consensus round) using the roster effective for round 101.
The consensus algorithm is trying to r...
Roster
Effective Round: 102
Roster...
creates
creates
BR 102
BR 102
BR 103
BR 103
BR 95
BR 95
BR 74
BR 74
Event Validation
Event Validation
Events with Birth Round (BR):
Events with Birth Round (BR):
BR 102
BR 102
BR 95
BR 95
Event with BR 103 is rejected because we do not yet have a roster with which to validate its signature and creator membership.

Event with BR 74 is rejected because the birth round is ancient.
Event with BR 103 is rejected b...
Event Creator
Event Creator
BR 101
BR 101
The event creator creates events with a birth round of 101, because that is the roster currently being used to calculate consensus. Any node that has applied the transactions of round 99 will have the roster required to validate this event.
The event creator creates events wit...Text is not SVG - cannot display \ No newline at end of file diff --git a/platform-sdk/docs/core/dynamic-address-book/roster/glossary-of-terms.md b/platform-sdk/docs/core/dynamic-address-book/roster/glossary-of-terms.md new file mode 100644 index 000000000000..195b0ca2ad18 --- /dev/null +++ b/platform-sdk/docs/core/dynamic-address-book/roster/glossary-of-terms.md @@ -0,0 +1,155 @@ +# Roster Glossary of Terms + +![Event Window Terminology](./EventWindowTerminology.drawio.svg) +![Roster Terminology Diagram](./RosterTerminologyDiagram.drawio.svg) + +## Round Terminology + +### Latest Consensus Round + +The `latestConsensusRound` is the most recent round to have reached consensus. Equal to the pending consensus round - 1. + +### Pending Consensus Round + +The `pendingConsensusRound` is the round that the consensus algorithm is currently attempting to reach consensus on. +Equal to the latest consensus round + 1. + +### Rounds Non-Ancient + +A setting. `roundsNonAncient` is the number of rounds that have reached consensus that are not ancient. + +### Ancient + +An event is ancient if its `birthRound` is less than or equal to the `latestConsensusRound` - `roundsNonAncient`. + +### Minimum Round Non-Ancient + +`minRoundNonAncient` is the minimum round that is considered non-ancient. This is equal to +`pendingConsensusRound` - `roundsNonAncient`. + +### Non-Ancient Event Window + +Specifies the window of events that are being considered in consensus. The window specifies the following: + +* `latestConsensusRound` - the latest round that has reached consensus. +* `minRoundNonAncient` - the minimum round that is considered non-ancient. + +### Latest Handled Round + +The `latestHandledRound` is the latest round to have been completely handled and applied to the state by the node. +Note that the application of this round to state produces a new roster to become effective after a configured +`rosterOffset`. see terminology below. + +### Future Event Horizon (a.k.a. Max Gossip Round) + +The `futureEventHorizon` is the maximum round for which the node has an effective roster. It is also the +maximum round that this node can gossip about. Events which have a birth round higher than the `futureEventHorizon` +will not be gossipped. + +### Past Event Horizon (a.k.a. Min Gossip Round) + +The `pastEventHorizon`, equal to `minRoundNonAncient`, is the minimum round for which the node has an effective roster. +It is also the minimum round that this node can receive gossip for. Events which have a birth round lower than the +`pastEventHorizon` are ancient. Ancient events are retained in gossip for a period of time to support peers that are +behind in consensus. + +### Validatable Event Window (within the Event Horizon) + +The `validatableEventWindow` is the window of rounds which have effective rosters that have not become ancient. It +spans, inclusively, from the `pastEventHorizon` to the `futureEventHorizon`. Events with `birthRound` within this +window are non-ancient and can be validated. + +## Roster Terminology + +### Roster (a.k.a. Consensus Roster) + +The collection of nodes which create events and participate in consensus. Prior to the dynamic address book effort, +this was called the `AddressBook` in the platform's code. The name was changed to `Roster` to disambiguate it from +the application's concept of an address book. The application's address book contains the consensus roster. + +### Effective Roster (for a round) + +The roster that was used to determine consensus for a particular round. The `effective roster for round X` is the +roster that was used to compute consensus for round X. + +The effective roster is used for more than just consensus: + +* **Networking** - determine who to connect to and facilitate mutual TLS connection with that node. +* **Event Creation** - determine which other nodes' events are available to use as parents of events. +* **Event Validation** - validate the signature using the signing key of the node that created the event. +* **State Validation** - validating the signatures on the state of a round using the signatures in the effective + roster for that round. + +### Roster's Effective Round + +The round that the roster will be used to calculate consensus for. This is the round number used to look up the +appropriate roster to validate an event. The event contains this round number as the event's `birthRound` and is +used to uniquely identify the roster that should be used to validate the event. + +Not a field inside the roster. + +### Roster's Creation Round + +The round of transactions that created this roster once they were applied to the state. + +### Roster Offset + +A setting. The number of rounds it takes for a roster to become effective after being created. This is likely to be +a small integer value, e.g. 2. If this number is 2, then processing all the transactions in round 100 yields the +effective roster for round 102. + +### Ancient Roster + +All rosters that are effective for ancient rounds are ancient rosters. + +### Minimum Roster Non-Ancient + +`minRosterNonAncient` is the roster that is effective for `minRoundNonAncient`. + +### Latest Handled Roster + +`latestHandledRoster` is the roster that was effective and used to calculate consensus for the `latestHandledRound`. + +### Latest Consensus Roster + +`latestConsensusRoster` is the roster that is effective for the `latestConsensusRound`. + +### Current Effective Roster + +`currentEffectiveRoster` is the roster that is effective for the `pendingConsensusRound`. It is currently being +used by consensus and determines the current network topology. + +### Greatest Effective Roster + +`greatestEffectiveRoster` is the roster that is effective for the `futureEventHorizon`. It is the greatest roster +to have been produced by handling transactions and applying them to the state. + +## Event Terminology + +### Event Fields + +Events have four parts to them: + +1. Hashed Data +2. Signature +3. Consensus scratchpad +4. Generated by consensus + +### Birth Round + +`birthRound` - The pending consensus round as known by the event creator thread at the time the event was created. + +This field allows nodes to determine if the event is ancient or not. + +Uniquely defines the roster that should be used when validating this event. An event with birth round X should be +validated using the roster with an effective round of X. + +### Consensus Round + +`consensusRound` - The round in which an event reaches consensus. Previously known as `roundReceived`. + +### Current Round + +Used only in the consensus algorithm. Previously known as `roundCreated`. In the future, this data will +not be exposed outside of consensus. + From 50a7d5cc0623dfb56f4bd4d8e1faa860c69a46b8 Mon Sep 17 00:00:00 2001 From: Jendrik Johannes Date: Mon, 18 Dec 2023 08:24:51 +0100 Subject: [PATCH 13/13] build: merge 'Sync' tasks that wrote into the same destination (#10533) Signed-off-by: Jendrik Johannes Signed-off-by: Nathan Klick Co-authored-by: Nathan Klick --- hedera-node/hedera-app/build.gradle.kts | 55 +++++++++++-------------- 1 file changed, 24 insertions(+), 31 deletions(-) diff --git a/hedera-node/hedera-app/build.gradle.kts b/hedera-node/hedera-app/build.gradle.kts index 496832c719f3..1f82c94bdd2e 100644 --- a/hedera-node/hedera-app/build.gradle.kts +++ b/hedera-node/hedera-app/build.gradle.kts @@ -141,32 +141,6 @@ tasks.jar { } } -// Define build directory -val buildDir = layout.projectDirectory.dir("./build/node") - -// Copy everything from hedera-node/data -val copyNodeData = - tasks.register("copyNodeData") { - dependsOn(copyLib) - dependsOn(copyApp) - from(layout.projectDirectory.dir("../data/keys")) { into("data/keys") } - from(layout.projectDirectory.dir("../data")) - into(buildDir) - exclude("config", "keys") // Exclude config directory - shouldRunAfter(tasks.named("copyApp")) - shouldRunAfter(tasks.named("copyLib")) - } - -//// Copy hedera-node/configuration/dev as hedera-node/hedera-app/build/node/data/config } -val copyConfig = - tasks.register("copyConfig") { - from(layout.projectDirectory.dir("../configuration/dev")) { into("data/config") } - from(layout.projectDirectory.file("../config.txt")) - from(layout.projectDirectory.file("../log4j2.xml")) - into(buildDir) - shouldRunAfter(tasks.named("copyNodeData")) - } - // Copy dependencies into `data/lib` val copyLib = tasks.register("copyLib") { @@ -183,27 +157,46 @@ val copyApp = shouldRunAfter(tasks.named("copyLib")) } +// Working directory for 'run' tasks +val nodeWorkingDir = layout.buildDirectory.dir("node") + +val copyNodeData = + tasks.register("copyNodeDataAndConfig") { + into(nodeWorkingDir) + + // Copy things from hedera-node/data + into("data/lib") { from(copyLib) } + into("data/apps") { from(copyApp) } + into("data/onboard") { from(layout.projectDirectory.dir("../data/onboard")) } + into("data/keys") { from(layout.projectDirectory.dir("../data/keys")) } + + // Copy hedera-node/configuration/dev as hedera-node/hedera-app/build/node/data/config } + from(layout.projectDirectory.dir("../configuration/dev")) { into("data/config") } + from(layout.projectDirectory.file("../config.txt")) + from(layout.projectDirectory.file("../log4j2.xml")) + from(layout.projectDirectory.file("../configuration/dev/settings.txt")) + } + tasks.assemble { dependsOn(copyLib) dependsOn(copyApp) dependsOn(copyNodeData) - dependsOn(copyConfig) } // Create the "run" task for running a Hedera consensus node tasks.register("run") { group = "application" dependsOn(tasks.assemble) - workingDir = layout.projectDirectory.dir("./build/node").asFile - jvmArgs = listOf("-cp", "lib/*") + workingDir = nodeWorkingDir.get().asFile + jvmArgs = listOf("-cp", "data/lib/*") mainClass.set("com.swirlds.platform.Browser") } tasks.register("modrun") { group = "application" dependsOn(tasks.assemble) - workingDir = layout.projectDirectory.dir("./build/node").asFile - jvmArgs = listOf("-cp", "lib/*:apps/*", "-Dhedera.workflows.enabled=true") + workingDir = nodeWorkingDir.get().asFile + jvmArgs = listOf("-cp", "data/lib/*:data/apps/*", "-Dhedera.workflows.enabled=true") mainClass.set("com.hedera.node.app.ServicesMain") }