fix: check throttle usage on committing changes

hedera-node/hedera-app-spi/src/main/java/com/hedera/node/app/spi/throttle/HandleThrottleParser.java

@@ -24,13 +24,34 @@
 import java.util.List;
 
 public interface HandleThrottleParser {
+    /*
+     * Rebuilds the throttle requirements based on the given throttle definitions.
+     *
+     * @param defs the throttle definitions to rebuild the throttle requirements based on
+     */
     void rebuildFor(@NonNull final ThrottleDefinitions defs);
 
+    /*
+     * Rebuilds the gas throttle based on the current configuration.
+     */
     void applyGasConfig();
 
+    /*
+     * Gets the current list of active throttles.
+     *
+     * @return the current list of active throttles
+     */
     @NonNull
     List<DeterministicThrottle> allActiveThrottles();
 
+    /*
+     * Resets the usage for all snapshots.
+     */
+    void resetUsageThrottlesTo(List<DeterministicThrottle.UsageSnapshot> snapshots);
+
+    /*
+     * Gets the gas throttle.
+     */
     @Nullable
-    public GasLimitDeterministicThrottle gasLimitThrottle();
+    GasLimitDeterministicThrottle gasLimitThrottle();
 }

hedera-node/hedera-app-spi/src/main/java/com/hedera/node/app/spi/workflows/HandleContext.java

@@ -24,6 +24,7 @@
 import com.hedera.hapi.node.base.Key;
 import com.hedera.hapi.node.base.SubType;
 import com.hedera.hapi.node.transaction.TransactionBody;
+import com.hedera.node.app.hapi.utils.throttles.DeterministicThrottle;
 import com.hedera.node.app.spi.authorization.SystemPrivilege;
 import com.hedera.node.app.spi.fees.ExchangeRateInfo;
 import com.hedera.node.app.spi.fees.FeeAccumulator;
@@ -43,6 +44,7 @@
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
 import java.time.Instant;
+import java.util.List;
 import java.util.function.Predicate;
 
 /**
@@ -668,6 +670,26 @@ default <T> T dispatchRemovableChildTransaction(
      */
     void reclaimPreviouslyReservedThrottle(int n, HederaFunctionality function);
 
+    /**
+     * Verifies if the throttle in this operation context has enough capacity to handle the given number of the
+     * given function at the given time. (The time matters because we want to consider how much
+     * will have leaked between now and that time.)
+     *
+     * @param n the number of the given function
+     * @param function the function
+     * @return true if the system should throttle the given number of the given function
+     * at the instant for which throttling should be calculated
+     */
+    boolean shouldThrottleNOfUnscaled(int n, HederaFunctionality function);
+
+    /**
+     * For each following child transaction consumes the capacity
+     * required for that child transaction in the consensus throttle buckets.
+     *
+     * @return true if all the child transactions were allowed through the throttle consideration, false otherwise.
+     */
+    boolean hasThrottleCapacityForChildTransactions();
+
     /**
      * Create a checkpoint for the current childRecords.
      *
@@ -677,6 +699,19 @@ default <T> T dispatchRemovableChildTransaction(
     @NonNull
     RecordListCheckPoint createRecordListCheckPoint();
 
+    /**
+     * Returns a list of snapshots of the current usage of all active throttles.
+     * @return the active snapshots
+     */
+    List<DeterministicThrottle.UsageSnapshot> getUsageSnapshots();
+
+    /**
+     * Resets the current usage of all active throttles to the given snapshots.
+     *
+     * @param snapshots the snapshots to reset to
+     */
+    void resetUsageThrottlesTo(List<DeterministicThrottle.UsageSnapshot> snapshots);
+
     /**
      * Returns whether the current transaction being processed was submitted by this node.
      *

hedera-node/hedera-app-spi/src/testFixtures/java/com/hedera/node/app/spi/fixtures/throttle/FakeHandleThrottleParser.java

@@ -42,6 +42,9 @@ public List<DeterministicThrottle> allActiveThrottles() {
         return Collections.emptyList();
     }
 
+    @Override
+    public void resetUsageThrottlesTo(List<DeterministicThrottle.UsageSnapshot> snapshots) {}
+
     @Nullable
     @Override
     public GasLimitDeterministicThrottle gasLimitThrottle() {

hedera-node/hedera-app/src/main/java/com/hedera/node/app/throttle/NetworkUtilizationManager.java

@@ -17,10 +17,13 @@
 package com.hedera.node.app.throttle;
 
 import com.hedera.hapi.node.base.AccountID;
+import com.hedera.hapi.node.base.HederaFunctionality;
+import com.hedera.node.app.hapi.utils.throttles.DeterministicThrottle;
 import com.hedera.node.app.state.HederaState;
 import com.hedera.node.app.workflows.TransactionInfo;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import java.time.Instant;
+import java.util.List;
 
 /**
  * Interface which purpose is to do the work of tracking network utilization (and its impact on
@@ -78,4 +81,43 @@ void trackFeePayments(
      * @param state the state of the node
      */
     void saveTo(@NonNull final HederaState state);
+
+    /*
+     * Updates the throttle requirements for the given transaction and returns whether the transaction
+     * should be throttled for the current time(Instant.now).
+     *
+     * @param txnInfo the transaction to update the throttle requirements for
+     * @param state the current state of the node
+     * @param consensusTime the consensus time
+     * @return whether the transaction should be throttled
+     */
+    boolean shouldThrottle(
+            @NonNull final TransactionInfo txnInfo,
+            @NonNull final HederaState state,
+            @NonNull final Instant consensusTime);
+
+    /**
+     * Verifies if the throttle in this operation context has enough capacity to handle the given number of the
+     * given function at the given time. (The time matters because we want to consider how much
+     * will have leaked between now and that time.)
+     *
+     * @param n the number of the given function
+     * @param function the function
+     * @return true if the system should throttle the given number of the given function
+     * at the instant for which throttling should be calculated
+     */
+    boolean shouldThrottleNOfUnscaled(int n, @NonNull HederaFunctionality function, @NonNull Instant consensusTime);
+
+    /**
+     * Returns a list of snapshots of the current usage of all active throttles.
+     * @return the active snapshots
+     */
+    List<DeterministicThrottle.UsageSnapshot> getUsageSnapshots();
+
+    /**
+     * Resets the current usage of all active throttles to the given snapshots.
+     *
+     * @param snapshots the snapshots to reset to
+     */
+    void resetUsageThrottlesTo(List<DeterministicThrottle.UsageSnapshot> snapshots);
 }

hedera-node/hedera-app/src/main/java/com/hedera/node/app/throttle/SynchronizedThrottleAccumulator.java

@@ -53,7 +53,7 @@ public SynchronizedThrottleAccumulator(ThrottleAccumulator frontendThrottle) {
      * @return whether the transaction should be throttled
      */
     public synchronized boolean shouldThrottle(@NonNull TransactionInfo txnInfo, HederaState state) {
-        setDecisionTime();
+        setDecisionTime(Instant.now());
         return frontendThrottle.shouldThrottle(txnInfo, lastDecisionTime, state);
     }
 
@@ -67,16 +67,15 @@ public synchronized boolean shouldThrottle(@NonNull TransactionInfo txnInfo, Hed
      * @return whether the query should be throttled
      */
     public synchronized boolean shouldThrottle(HederaFunctionality queryFunction, Query query, AccountID queryPayerId) {
-        setDecisionTime();
+        setDecisionTime(Instant.now());
         return frontendThrottle.shouldThrottle(queryFunction, lastDecisionTime, query, queryPayerId);
     }
 
-    private void setDecisionTime() {
-        final var now = Instant.now();
-        lastDecisionTime = now.isBefore(lastDecisionTime) ? lastDecisionTime : now;
-    }
-
     public void leakUnusedThrottlePreviouslyReserved(int n, HederaFunctionality function) {
         frontendThrottle.leakCapacityForNOfUnscaled(n, function);
     }
+
+    private void setDecisionTime(@NonNull final Instant time) {
+        lastDecisionTime = time.isBefore(lastDecisionTime) ? lastDecisionTime : time;
+    }
 }

hedera-node/hedera-app/src/main/java/com/hedera/node/app/throttle/ThrottleAccumulator.java

@@ -288,6 +288,16 @@ public void resetUsage() {
         }
     }
 
+    /*
+     * Resets the usage for all snapshots.
+     */
+    @Override
+    public void resetUsageThrottlesTo(final List<DeterministicThrottle.UsageSnapshot> snapshots) {
+        for (int i = 0, n = activeThrottles.size(); i < n; i++) {
+            activeThrottles.get(i).resetUsageTo(snapshots.get(i));
+        }
+    }
+
     private boolean shouldThrottleTxn(
             final boolean isScheduled,
             @NonNull final TransactionInfo txnInfo,
@@ -487,11 +497,14 @@ private boolean shouldThrottleScheduleSign(
     }
 
     public static boolean throttleExempt(
-            @NonNull final AccountID accountID, @NonNull final Configuration configuration) {
+            @Nullable final AccountID accountID, @NonNull final Configuration configuration) {
         final long maxThrottleExemptNum =
                 configuration.getConfigData(AccountsConfig.class).lastThrottleExempt();
-        final long accountNum = accountID.accountNum().longValue();
-        return 1L <= accountNum && accountNum <= maxThrottleExemptNum;
+        if (accountID != null) {
+            final long accountNum = accountID.accountNum().longValue();
+            return 1L <= accountNum && accountNum <= maxThrottleExemptNum;
+        }
+        return false;
     }
 
     private void reclaimLastAllowedUse() {

hedera-node/hedera-app/src/main/java/com/hedera/node/app/throttle/impl/NetworkUtilizationManagerImpl.java

@@ -24,6 +24,7 @@
 import static java.util.Objects.requireNonNull;
 
 import com.hedera.hapi.node.base.AccountID;
+import com.hedera.hapi.node.base.HederaFunctionality;
 import com.hedera.hapi.node.base.SignatureMap;
 import com.hedera.hapi.node.base.Timestamp;
 import com.hedera.hapi.node.base.Transaction;
@@ -201,4 +202,30 @@ public boolean wasLastTxnGasThrottled() {
     public void leakUnusedGasPreviouslyReserved(@NonNull final TransactionInfo txnInfo, long value) {
         backendThrottle.leakUnusedGasPreviouslyReserved(txnInfo, value);
     }
+
+    @Override
+    public boolean shouldThrottle(
+            @NonNull final TransactionInfo txnInfo,
+            @NonNull final HederaState state,
+            @NonNull final Instant consensusTime) {
+        return backendThrottle.shouldThrottle(txnInfo, consensusTime, state);
+    }
+
+    @Override
+    public boolean shouldThrottleNOfUnscaled(
+            final int n, @NonNull final HederaFunctionality function, @NonNull final Instant consensusTime) {
+        return backendThrottle.shouldThrottleNOfUnscaled(n, function, consensusTime);
+    }
+
+    @Override
+    public List<DeterministicThrottle.UsageSnapshot> getUsageSnapshots() {
+        return backendThrottle.allActiveThrottles().stream()
+                .map(DeterministicThrottle::usageSnapshot)
+                .toList();
+    }
+
+    @Override
+    public void resetUsageThrottlesTo(List<DeterministicThrottle.UsageSnapshot> snapshots) {
+        backendThrottle.resetUsageThrottlesTo(snapshots);
+    }
 }

hedera-node/hedera-app/src/main/java/com/hedera/node/app/workflows/TransactionInfo.java

@@ -25,6 +25,7 @@
 import com.hedera.hapi.node.transaction.TransactionBody;
 import com.hedera.pbj.runtime.io.buffer.Bytes;
 import edu.umd.cs.findbugs.annotations.NonNull;
+import edu.umd.cs.findbugs.annotations.Nullable;
 
 /**
  * Contains information related to a parsed transaction.
@@ -49,8 +50,8 @@
 public record TransactionInfo(
         @NonNull Transaction transaction,
         @NonNull TransactionBody txBody,
-        @NonNull TransactionID transactionID,
-        @NonNull AccountID payerID,
+        @Nullable TransactionID transactionID,
+        @Nullable AccountID payerID,
         @NonNull SignatureMap signatureMap,
         @NonNull Bytes signedBytes,
         @NonNull HederaFunctionality functionality) {
@@ -70,4 +71,22 @@ public TransactionInfo(
                 signedBytes,
                 functionality);
     }
+
+    public static TransactionInfo from(
+            @NonNull Transaction transaction,
+            @NonNull TransactionBody txBody,
+            @NonNull SignatureMap signatureMap,
+            @NonNull Bytes signedBytes,
+            @NonNull HederaFunctionality functionality) {
+        TransactionID transactionId = null;
+        AccountID payerId = null;
+        if (txBody.transactionID() != null) {
+            transactionId = txBody.transactionID();
+            if (transactionId.accountID() != null) {
+                payerId = txBody.transactionID().accountID();
+            }
+        }
+        return new TransactionInfo(
+                transaction, txBody, transactionId, payerId, signatureMap, signedBytes, functionality);
+    }
 }