Merge branch 'main' into add-otter-module

* main:
  chore: Moved EventCreation and TransactionPool classes to event-creator module (#18740)
  chore: 12987 improve token and staking unit test coverage (#18531)
  chore: remove some obsolete feature flags (#18639)
  chore: Make the check for slack user ID case insensitive (#18739)
  feat: Handle `BlockAcknowledgements` received from Block Nodes (#18536)
  chore: Lazy initialize `SNARK_KEYS` (#18709)
  feat: 18593: Need a mechanism to repair key to path mapping from data files at startup (#18625)
  chore: remove some obsolete feature flags pt2 (#18641)
  fix: 1280 hip 1056 block item with failed contract create result contains a contract (#18728)
  chore: set blockPeriod to 2 sec (#18707)
  test: Add tests to cover missing test scenarios from TCK (#18667)
  feat: Jumbo bytes throttle (#18389)
  chore: prepare consensus-utility for event-creator-module (#18695)
  chore: Add missing dependencies (#18724)
  chore: remove obsolete feature flags pt3 (#18643)
  feat: Use existing key to create an account (#18611)
  ci: add 'needs' to HAPI Tests (ISS) (#18556)

Author: netopyr

.github/workflows/node-flow-pull-request-checks.yaml

@@ -105,6 +105,9 @@ jobs:
   hapi-tests-iss:
     name: HAPI Tests (ISS)
     uses: ./.github/workflows/node-zxc-compile-application-code.yaml
+    needs:
+      - dependency-check
+      - spotless
     with:
       custom-job-label: Standard
       enable-unit-tests: false

.github/workflows/zxcron-extended-test-suite.yaml

@@ -460,7 +460,10 @@ jobs:
           SLACK_BOT_TOKEN: ${{ secrets.SLACK_CITR_BOT_TOKEN }}
           EMAIL: ${{ needs.fetch-xts-candidate.outputs.xts-tag-commit-email }}
         run: |
-          SLACK_USER_ID=$(curl -s -X GET "https://slack.com/api/users.list"  -H "Authorization: Bearer ${SLACK_BOT_TOKEN}" | jq -r --arg email "${EMAIL}" '.members[] | select(.profile.email == $email) | .name')
+          SLACK_USER_ID=$(curl -s -X GET "https://slack.com/api/users.list" \
+            -H "Authorization: Bearer ${SLACK_BOT_TOKEN}" | jq -r --arg email "${EMAIL}" \
+            '.members[] | select((.profile.email // "" | ascii_downcase) == ($email | ascii_downcase)) | .name')
+
           if [[ -z "${SLACK_USER_ID}" || "${SLACK_USER_ID}" == "null" ]]; then
             echo "No Slack user found for email: ${EMAIL}"
             SLACK_USER_ID="No matching slack user found"

hedera-node/configuration/dev/bootstrap.properties

@@ -1,7 +1,6 @@
 # SPDX-License-Identifier: Apache-2.0
+
 bootstrap.throttleDefsJson.resource=genesis/throttles-dev.json
-accounts.storeOnDisk=true
-accounts.releaseAliasAfterDeletion=true
 tokens.storeRelsOnDisk=true
 tokens.nfts.useVirtualMerkle=true
 accounts.blocklist.enabled=false

hedera-node/data/config/application.properties

@@ -1,4 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
+
 bootstrap.throttleDefsJson.resource=throttles-dev.json
 ledger.id=0x03
 staking.periodMins=1
@@ -7,8 +8,6 @@ scheduling.whitelist=ConsensusSubmitMessage,CryptoTransfer,TokenMint,TokenBurn,C
 hedera.workflows.enabled=true
 #hedera.workflows.enabled=ConsensusCreateTopic,ConsensusUpdateTopic,ConsensusDeleteTopic,ConsensusSubmitMessage,ConsensusGetTopicInfo
 # Initial Service workflow schemas require on-disk storage, so all these need to be true if enabling workflows
-accounts.storeOnDisk=true
-accounts.releaseAliasAfterDeletion=true
 tokens.storeRelsOnDisk=true
 tokens.nfts.useVirtualMerkle=true
 records.useConsolidatedFcq=true

hedera-node/data/config/bootstrap.properties

@@ -1,4 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
+
 bootstrap.throttleDefsJson.resource=throttles-dev.json
 ledger.id=0x03
 staking.periodMins=1
@@ -7,8 +8,6 @@ scheduling.whitelist=ConsensusSubmitMessage,CryptoTransfer,TokenMint,TokenBurn,C
 hedera.workflows.enabled=
 #hedera.workflows.enabled=ConsensusCreateTopic,ConsensusUpdateTopic,ConsensusDeleteTopic,ConsensusSubmitMessage,ConsensusGetTopicInfo
 # Initial Service workflow schemas require on-disk storage, so all these need to be true if enabling workflows
-accounts.storeOnDisk=true
-accounts.releaseAliasAfterDeletion=true
 tokens.storeRelsOnDisk=true
 tokens.nfts.useVirtualMerkle=true
 records.useConsolidatedFcq=true

hedera-node/docs/design/services/service-configuration.md

@@ -11,7 +11,6 @@ For more detailed information on other types of configuration, please refer to t
 
 - **AccountsConfig.java**: Provides configuration settings for various account-related properties, including admin roles and treasury accounts.
 - **ApiPermissionConfig.java**: Manages permissions for different API functionalities, specifying which accounts are allowed to execute certain operations.
-- **AutoCreationConfig.java**: Configures settings related to the automatic creation of accounts.
 - **AutoRenew2Config.java**: Contains settings for automatic renewal processes, specifying scan and renewal parameters.
 - **AutoRenewConfig.java**: Defines configurations for the auto-renewal feature, including target types for auto-renewal.
 - **BalancesConfig.java**: Manages the export and handling of account balance information, including export directory and compression settings.
@@ -21,14 +20,12 @@ For more detailed information on other types of configuration, please refer to t
 - **CacheConfig.java**: Manages settings related to caching, including record TTL and the number of warm-up threads.
 - **ConsensusConfig.java**: Configures various consensus-related settings, including message size limits and handling parameters for preceding and following records.
 - **ContractsConfig.java**: Manages configurations for smart contracts, including storage fees, delegate caller permissions, and gas usage limits.
-- **CryptoCreateWithAliasConfig.java**: Enables or disables the feature for creating crypto accounts with an alias.
 - **EntitiesConfig.java**: Manages settings related to entities, including maximum lifetime and token association limits.
 - **ExpiryConfig.java**: Configures expiration-related settings, including throttle resources.
 - **FeesConfig.java**: Manages fee-related configurations, including congestion multipliers and token transfer usage multipliers.
 - **FilesConfig.java**: Configures file-related settings, including file IDs for various system files and maximum file sizes.
 - **GrpcConfig.java**: Manages gRPC configuration settings, including port numbers, message size limits, and node operator port settings.
 - **HederaConfig.java**: Contains general Hedera network settings, including user entity IDs, transaction parameters, and active profiles.
-- **LazyCreationConfig.java**: Enables or disables the lazy creation feature for accounts.
 - **LedgerConfig.java**: Manages ledger-related settings including system accounts, auto-renew periods, and token transfer limits.
 - **NettyConfig.java**: Contains settings for Netty-based gRPC server configurations, including connection limits, retry intervals, and TLS paths.
 - **NetworkAdminConfig.java**: Configures the network administration service, including paths for upgrade artifacts and system file locations.
@@ -41,5 +38,4 @@ For more detailed information on other types of configuration, please refer to t
 - **TopicsConfig.java**: Configures topic-related settings including the maximum number of topics.
 - **TraceabilityConfig.java**: Manages traceability settings including export limits and gas throttle ratios.
 - **TssConfig.java**: Configures the Threshold Signature Scheme (TSS) service, including retry settings and ledger ID enabling.
-- **UtilPrngConfig.java**: Contains settings related to the pseudo-random number generator utility.
 - **VersionConfig.java**: Manages version-related settings including software version numbers and configuration versions.

hedera-node/docs/design/services/util-service/util-service.md

@@ -106,14 +106,6 @@ then their containing AtomicBatch transaction must be signed by both `batchKey`
 
 ## Configuration
 
-- ```UtilPrngConfig``` is a configuration class used in the Hedera Hashgraph network.
-  This class is used to configure the behavior of the ```UtilPrngHandler```. The ```UtilPrngConfig```
-  class is a record that contains a single boolean property, isEnabled. This property is
-  annotated with ```@ConfigProperty``` and ```@NetworkProperty```, indicating that it can be
-  configured via the network's configuration file. The isEnabled property determines whether
-  the ```UtilPrngHandler``` allows a transaction to proceed. If isEnabled is set to true, the
-  ```UtilPrngHandler``` will allow the transaction. If isEnabled is set to false,
-  the ```UtilPrngHandler``` will not allow the transaction.
 - ```AtomicBatchConfig``` is a configuration class used in the Hedera Hashgraph network.
   This class is used to configure the behavior of the ```AtomicBatchHandler```. The ```AtomicBatchConfig```
   class is a record that contains three properties:

hedera-node/hapi-utils/src/main/java/com/hedera/node/app/hapi/utils/throttles/GasLimitDeterministicThrottle.java renamed to hedera-node/hapi-utils/src/main/java/com/hedera/node/app/hapi/utils/throttles/LeakyBucketDeterministicThrottle.java

@@ -12,11 +12,11 @@
 /**
  * Main class responsible for throttling transactions by gasLimit. Keeps track of the instance the
  * last decision was made and calculates the time elapsed since then. Uses a {@link
- * GasLimitBucketThrottle} under the hood.
+ * LeakyBucketThrottle} under the hood.
  */
-public class GasLimitDeterministicThrottle implements CongestibleThrottle {
-    private static final String THROTTLE_NAME = "Gas";
-    private final GasLimitBucketThrottle delegate;
+public class LeakyBucketDeterministicThrottle implements CongestibleThrottle {
+    private final String throttleName;
+    private final LeakyBucketThrottle delegate;
     private Timestamp lastDecisionTime;
     private final long capacity;
 
@@ -26,31 +26,32 @@ public class GasLimitDeterministicThrottle implements CongestibleThrottle {
      *
      * @param capacity - the total amount of gas allowed per sec.
      */
-    public GasLimitDeterministicThrottle(long capacity) {
+    public LeakyBucketDeterministicThrottle(long capacity, String name) {
+        this.throttleName = name;
         this.capacity = capacity;
-        this.delegate = new GasLimitBucketThrottle(capacity);
+        this.delegate = new LeakyBucketThrottle(capacity);
     }
 
     /**
      * Calculates the amount of nanoseconds that elapsed since the last time the method was called.
      * Verifies whether there is enough capacity to handle a transaction with some gasLimit.
      *
-     * @param now        - the instant against which the {@link GasLimitBucketThrottle} is tested.
-     * @param txGasLimit - the gasLimit extracted from the transaction payload.
+     * @param now        - the instant against which the {@link LeakyBucketThrottle} is tested.
+     * @param throttleLimit - the throttle limit extracted from the transaction payload.
      * @return true if there is enough capacity to handle this transaction; false if it should be
      * throttled.
      */
-    public boolean allow(@NonNull final Instant now, final long txGasLimit) {
+    public boolean allow(@NonNull final Instant now, final long throttleLimit) {
         final var elapsedNanos = nanosBetween(lastDecisionTime, now);
         if (elapsedNanos < 0L) {
             throw new IllegalArgumentException("Throttle timeline must advance, but " + now + " is not after "
                     + Instant.ofEpochSecond(lastDecisionTime.seconds(), lastDecisionTime.nanos()));
         }
-        if (txGasLimit < 0) {
-            throw new IllegalArgumentException("Gas limit must be non-negative, but was " + txGasLimit);
+        if (throttleLimit < 0) {
+            throw new IllegalArgumentException("Throttle limit must be non-negative, but was " + throttleLimit);
         }
         lastDecisionTime = new Timestamp(now.getEpochSecond(), now.getNano());
-        return delegate.allow(txGasLimit, elapsedNanos);
+        return delegate.allow(throttleLimit, elapsedNanos);
     }
 
     /**
@@ -110,7 +111,7 @@ public long mtps() {
 
     @Override
     public String name() {
-        return THROTTLE_NAME;
+        return throttleName;
     }
 
     /**
@@ -125,7 +126,7 @@ public long used() {
 
     /**
      * Used to release some capacity previously reserved by calling {@link
-     * GasLimitDeterministicThrottle#allow(Instant, long)} without having to wait for the natural
+     * LeakyBucketDeterministicThrottle#allow(Instant, long)} without having to wait for the natural
      * leakage.
      *
      * @param value - the amount to release
@@ -135,11 +136,11 @@ public void leakUnusedGasPreviouslyReserved(long value) {
     }
 
     /**
-     * returns an instance of the {@link GasLimitBucketThrottle} used under the hood.
+     * returns an instance of the {@link LeakyBucketThrottle} used under the hood.
      *
-     * @return - an instance of the {@link GasLimitBucketThrottle} used under the hood
+     * @return - an instance of the {@link LeakyBucketThrottle} used under the hood
      */
-    GasLimitBucketThrottle delegate() {
+    LeakyBucketThrottle delegate() {
         return delegate;
     }
 

hedera-node/hapi-utils/src/main/java/com/hedera/node/app/hapi/utils/throttles/GasLimitBucketThrottle.java renamed to hedera-node/hapi-utils/src/main/java/com/hedera/node/app/hapi/utils/throttles/LeakyBucketThrottle.java

@@ -5,12 +5,12 @@
 import static com.swirlds.base.units.UnitConstants.SECONDS_TO_NANOSECONDS;
 
 /**
- * Responsible for throttling transaction by gas limit. Uses a {@link DiscreteLeakyBucket} under the
- * hood. Calculates the amount of gas that should be leaked from the bucket based on the amount of
- * elapsed nanoseconds since the last time {@link GasLimitBucketThrottle#allow(long, long)} was
+ * Responsible for throttling transaction by given limit units. Uses a {@link DiscreteLeakyBucket} under the
+ * hood. Calculates the amount of capacity that should be leaked from the bucket based on the amount of
+ * elapsed nanoseconds since the last time {@link LeakyBucketThrottle#allow(long, long)} was
  * called.
  */
-public class GasLimitBucketThrottle {
+public class LeakyBucketThrottle {
     private static final long TIME_TO_EMPTY = SECONDS_TO_NANOSECONDS;
 
     private final DiscreteLeakyBucket bucket;
@@ -21,25 +21,25 @@ public class GasLimitBucketThrottle {
      *
      * @param capacity - the capacity for the throttle
      */
-    public GasLimitBucketThrottle(final long capacity) {
+    public LeakyBucketThrottle(final long capacity) {
         this.bucket = new DiscreteLeakyBucket(capacity);
     }
 
     /**
-     * Calculates and leaks the amount of gas that should be leaked from the bucket based on the
+     * Calculates and leaks the amount of capacity that should be leaked from the bucket based on the
      * amount of nanoseconds passed as input argument. Verifies whether there is enough capacity to
-     * handle a transaction with the specified gas limit. Reserves the capacity needed for the
+     * handle a transaction with the specified limit. Reserves the capacity needed for the
      * transaction if there is enough free space.
      *
-     * @param txGasLimit - the gas limit of the transaction
+     * @param txLimit - the limit amount of the transaction
      * @param elapsedNanos - the amount of time passed since the last call
      * @return true if there is enough capacity, false if the transaction should be throttled
      */
-    public boolean allow(final long txGasLimit, final long elapsedNanos) {
+    public boolean allow(final long txLimit, final long elapsedNanos) {
         leakFor(elapsedNanos);
-        if (bucket.capacityFree() >= txGasLimit) {
-            bucket.useCapacity(txGasLimit);
-            lastAllowedUnits += txGasLimit;
+        if (bucket.capacityFree() >= txLimit) {
+            bucket.useCapacity(txLimit);
+            lastAllowedUnits += txLimit;
             return true;
         } else {
             return false;

hedera-node/hapi-utils/src/test/java/com/hedera/node/app/hapi/utils/throttles/GasLimitDeterministicThrottleTest.java renamed to hedera-node/hapi-utils/src/test/java/com/hedera/node/app/hapi/utils/throttles/LeakyBucketDeterministicThrottleTest.java

@@ -14,16 +14,17 @@
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
-class GasLimitDeterministicThrottleTest {
+class LeakyBucketDeterministicThrottleTest {
 
+    private static final String THROTTLE_NAME = "Gas";
     private static final long DEFAULT_CAPACITY = 1_000_000;
     private static final long ONE_SECOND_IN_NANOSECONDS = 1_000_000_000;
 
-    GasLimitDeterministicThrottle subject;
+    LeakyBucketDeterministicThrottle subject;
 
     @BeforeEach
     void setup() {
-        subject = new GasLimitDeterministicThrottle(DEFAULT_CAPACITY);
+        subject = new LeakyBucketDeterministicThrottle(DEFAULT_CAPACITY, THROTTLE_NAME);
     }
 
     @Test
@@ -44,14 +45,14 @@ void usesZeroElapsedNanosOnFirstDecision() {
     @Test
     void implementsCongestibleThrottle() {
         assertEquals(DEFAULT_CAPACITY * 1000, subject.mtps());
-        assertEquals("Gas", subject.name());
+        assertEquals(THROTTLE_NAME, subject.name());
     }
 
     @Test
     void canGetPercentUsed() {
         final var now = Instant.ofEpochSecond(1_234_567L);
         final var capacity = 1_000_000;
-        final var subject = new GasLimitDeterministicThrottle(capacity);
+        final var subject = new LeakyBucketDeterministicThrottle(capacity, THROTTLE_NAME);
         assertEquals(0.0, subject.percentUsed(now));
         subject.allow(now, capacity / 2);
         assertEquals(50.0, subject.percentUsed(now));
@@ -62,7 +63,7 @@ void canGetPercentUsed() {
     void canGetInstantaneousPercentUsed() {
         final var now = Instant.ofEpochSecond(1_234_567L);
         final var capacity = 1_000_000;
-        final var subject = new GasLimitDeterministicThrottle(capacity);
+        final var subject = new LeakyBucketDeterministicThrottle(capacity, THROTTLE_NAME);
         assertEquals(0.0, subject.instantaneousPercentUsed());
         subject.allow(now, capacity / 2);
         assertEquals(50.0, subject.instantaneousPercentUsed());
@@ -72,15 +73,15 @@ void canGetInstantaneousPercentUsed() {
     void canGetFreeToUsedRatio() {
         final var now = Instant.ofEpochSecond(1_234_567L);
         final var capacity = 1_000_000;
-        final var subject = new GasLimitDeterministicThrottle(capacity);
+        final var subject = new LeakyBucketDeterministicThrottle(capacity, THROTTLE_NAME);
         subject.allow(now, capacity / 4);
         assertEquals(3, subject.instantaneousFreeToUsedRatio());
     }
 
     @Test
     void leaksUntilNowBeforeEstimatingFreeToUsed() {
         final var capacity = 1_000_000;
-        final var subject = new GasLimitDeterministicThrottle(capacity);
+        final var subject = new LeakyBucketDeterministicThrottle(capacity, THROTTLE_NAME);
         assertEquals(Long.MAX_VALUE, subject.instantaneousFreeToUsedRatio());
     }
 

hedera-node/hapi-utils/src/test/java/com/hedera/node/app/hapi/utils/throttles/GasLimitBucketThrottleTest.java renamed to hedera-node/hapi-utils/src/test/java/com/hedera/node/app/hapi/utils/throttles/LeakyBucketThrottleTest.java

@@ -8,17 +8,17 @@
 
 import org.junit.jupiter.api.Test;
 
-class GasLimitBucketThrottleTest {
+class LeakyBucketThrottleTest {
 
     private static final long BUCKET_CAPACITY = 1_234_568;
     private static final long BEYOND_CAPACITY = 1_234_569;
 
-    GasLimitBucketThrottle subject = new GasLimitBucketThrottle(BUCKET_CAPACITY);
+    LeakyBucketThrottle subject = new LeakyBucketThrottle(BUCKET_CAPACITY);
 
     @Test
     void hasExpectedPercentUsed() {
         final var capacity = 1_000_000;
-        var subject = new GasLimitBucketThrottle(capacity);
+        var subject = new LeakyBucketThrottle(capacity);
         subject.bucket().useCapacity(capacity / 2);
 
         assertEquals(50.0, subject.percentUsed(0));
@@ -28,15 +28,15 @@ void hasExpectedPercentUsed() {
     @Test
     void hasExpectedInstantaneousPercentUsed() {
         final var capacity = 1_000_000;
-        var subject = new GasLimitBucketThrottle(capacity);
+        var subject = new LeakyBucketThrottle(capacity);
         subject.bucket().useCapacity(capacity / 2);
         assertEquals(50.0, subject.instantaneousPercentUsed());
     }
 
     @Test
     void hasExpectedUsageRatio() {
         final var capacity = 1_000_000;
-        var subject = new GasLimitBucketThrottle(capacity);
+        var subject = new LeakyBucketThrottle(capacity);
         subject.bucket().useCapacity(capacity / 4);
 
         assertEquals(3, subject.freeToUsedRatio());
@@ -45,7 +45,7 @@ void hasExpectedUsageRatio() {
     @Test
     void hasExpectedUsageRatioIfAllFree() {
         final var capacity = 1_000_000;
-        var subject = new GasLimitBucketThrottle(capacity);
+        var subject = new LeakyBucketThrottle(capacity);
 
         assertEquals(Long.MAX_VALUE, subject.freeToUsedRatio());
     }

hedera-node/hedera-app/src/main/java/com/hedera/node/app/blocks/impl/BlockStreamManagerImpl.java

@@ -471,7 +471,7 @@ public boolean endRound(@NonNull final State state, final long roundNum) {
             }
             requireNonNull(fatalShutdownFuture).complete(null);
         }
-        return closesBlock || lastRoundOfPrevBlock == 0;
+        return closesBlock;
     }
 
     @Override
@@ -596,7 +596,7 @@ private boolean shouldCloseBlock(final long roundNumber, final int roundsPerBloc
         }
 
         // During freeze round, we should close the block regardless of other conditions
-        if (roundNumber == freezeRoundNumber) {
+        if (roundNumber == freezeRoundNumber || roundNumber == 1) {
             return true;
         }