Trim the transaction table

CHANGELOG.md

@@ -1,6 +1,7 @@
 # Changelog
 
 ## Unreleased changes
+- If an account does not have any non-finalized transactions, then the transaction table is no longer used for tracking next available account nonce.
 
 ## 6.2.1
 

concordium-consensus/src/Concordium/GlobalState/BlockState.hs

@@ -1437,8 +1437,8 @@ class (BlockStateOperations m, FixedSizeSerialization (BlockStateRef m)) => Bloc
     -- | Cache the block state.
     cacheBlockState :: BlockState m -> m ()
 
-    -- | Cache the block state and get the initial (empty) transaction table with the next account nonces
-    --  and update sequence numbers populated.
+    -- | Cache the block state and get the initial (empty) transaction table with
+    --  the next "update sequence numbers".
     cacheBlockStateAndGetTransactionTable :: BlockState m -> m TransactionTable
 
     -- | Populate the LMDB account map if it has not already been initialized.

concordium-consensus/src/Concordium/GlobalState/Persistent/BlockState.hs

@@ -3789,22 +3789,7 @@ cacheStateAndGetTransactionTable ::
     m TransactionTable.TransactionTable
 cacheStateAndGetTransactionTable hpbs = do
     BlockStatePointers{..} <- loadPBS (hpbsPointers hpbs)
-    -- When caching the accounts, we populate the transaction table with the next account nonces.
-    -- This is done by using 'liftCache' on the account table with a custom cache function that
-    -- records the nonces.
-    let perAcct acct = do
-            -- Note: we do not need to cache the account because a loaded account is already fully
-            -- cached. (Indeed, 'cache' is defined to be 'pure'.)
-            nonce <- accountNonce acct
-            unless (nonce == minNonce) $ do
-                addr <- accountCanonicalAddress acct
-                MTL.modify
-                    ( TransactionTable.ttNonFinalizedTransactions . at' (accountAddressEmbed addr)
-                        ?~ TransactionTable.emptyANFTWithNonce nonce
-                    )
-            return acct
-    (accts, tt0) <- MTL.runStateT (liftCache perAcct bspAccounts) TransactionTable.emptyTransactionTable
-    -- first cache the modules
+    -- cache the modules
     mods <- cache bspModules
     -- then cache the instances, but don't cache the modules again. Instead
     -- share the references in memory we have already constructed by caching
@@ -3825,14 +3810,14 @@ cacheStateAndGetTransactionTable hpbs = do
                             & TransactionTable.ttNonFinalizedChainUpdates . at' uty
                                 ?~ TransactionTable.emptyNFCUWithSequenceNumber sn
                 else return tt
-    tt <- foldM updInTT tt0 [minBound ..]
+    tt <- foldM updInTT TransactionTable.emptyTransactionTable [minBound ..]
     rels <- cache bspReleaseSchedule
     red <- cache bspRewardDetails
     _ <-
         storePBS
             (hpbsPointers hpbs)
             BlockStatePointers
-                { bspAccounts = accts,
+                { bspAccounts = bspAccounts,
                   bspInstances = insts,
                   bspModules = mods,
                   bspBank = bspBank,

concordium-consensus/src/Concordium/GlobalState/Persistent/TreeState.hs

@@ -634,17 +634,37 @@ constructBlock StoredBlockWithStateHash{sbshStoredBlock = StoredBlock{..}, ..} =
 
 instance
     ( MonadState state m,
-      HasSkovPersistentData pv state
+      HasSkovPersistentData pv state,
+      BlockStateQuery m,
+      BlockState m ~ PBS.HashedPersistentBlockState pv,
+      MonadProtocolVersion m,
+      MPV m ~ pv,
+      MonadLogger (PersistentTreeStateMonad state m),
+      MonadIO (PersistentTreeStateMonad state m),
+      BlockStateStorage (PersistentTreeStateMonad state m)
     ) =>
     AccountNonceQuery (PersistentTreeStateMonad state m)
     where
-    getNextAccountNonce addr = nextAccountNonce addr <$> use (skovPersistentData . transactionTable)
+    getNextAccountNonce addr =
+        fetchFromTransactionTable >>= \case
+            Just ttResult -> return ttResult
+            Nothing -> fetchFromLastFinalizedBlock
+      where
+        fetchFromTransactionTable = nextAccountNonce addr <$> use (skovPersistentData . transactionTable)
+        fetchFromLastFinalizedBlock = do
+            lfb <- use (skovPersistentData . lastFinalized)
+            st <- blockState lfb
+            macct <- getAccount st (aaeAddress addr)
+            nextNonce <- fromMaybe minNonce <$> mapM (getAccountNonce . snd) macct
+            return (nextNonce, True)
+    {-# INLINE getNextAccountNonce #-}
 
 instance
     ( MonadLogger (PersistentTreeStateMonad state m),
       MonadIO (PersistentTreeStateMonad state m),
       BlockStateStorage (PersistentTreeStateMonad state m),
       MonadState state m,
+      BlockStateQuery m,
       HasSkovPersistentData pv state,
       MonadProtocolVersion m,
       MPV m ~ pv,
@@ -901,9 +921,11 @@ instance
         finTrans WithMetadata{wmdData = NormalTransaction tr, ..} = do
             let nonce = transactionNonce tr
                 sender = accountAddressEmbed (transactionSender tr)
-            anft <- use (skovPersistentData . transactionTable . ttNonFinalizedTransactions . at' sender . non emptyANFT)
-            if anft ^. anftNextNonce == nonce
-                then do
+            tt <- use (skovPersistentData . transactionTable)
+            let mAnft = tt ^? ttNonFinalizedTransactions . ix sender
+            case mAnft of
+                Nothing -> logErrorAndThrowTS $ "When finalizing transactions there was no recorded next nonce for sender " <> show sender
+                Just anft -> do
                     let nfn = anft ^. anftMap . at' nonce . non Map.empty
                         wmdtr = WithMetadata{wmdData = tr, ..}
                     if Map.member wmdtr nfn
@@ -919,16 +941,13 @@ instance
                                 . transactionTable
                                 . ttNonFinalizedTransactions
                                 . at' sender
-                                ?= ( anft
+                                ?=! ( anft
                                         & (anftMap . at' nonce .~ Nothing)
                                         & (anftNextNonce .~ nonce + 1)
-                                   )
+                                    )
                             return ss
                         else do
                             logErrorAndThrowTS $ "Tried to finalize transaction which is not known to be in the set of non-finalized transactions for the sender " ++ show sender
-                else do
-                    logErrorAndThrowTS $
-                        "The recorded next nonce for the account " ++ show sender ++ " (" ++ show (anft ^. anftNextNonce) ++ ") doesn't match the one that is going to be finalized (" ++ show nonce ++ ")"
         finTrans WithMetadata{wmdData = CredentialDeployment{}, ..} =
             deleteAndFinalizeStatus wmdHash
         finTrans WithMetadata{wmdData = ChainUpdate cu, ..} = do

concordium-consensus/src/Concordium/GlobalState/PurgeTransactions.hs

@@ -107,20 +107,32 @@ purgeTables lastFinCommitPoint oldestArrivalTime currentTime TransactionTable{..
                 | otherwise = (mmnonce <> Just (Max n), Just ts')
         put (mmnonce', tht')
         return mres
-    -- Purge the non-finalized transactions for a specific account.
-    purgeAccount :: AccountAddressEq -> AccountNonFinalizedTransactions -> State (PendingTransactionTable, TransactionHashTable) AccountNonFinalizedTransactions
-    purgeAccount addr AccountNonFinalizedTransactions{..} = do
-        (ptt0, trs0) <- get
+    -- Purge the non-finalized transactions for a specific account by
+    -- collect non-finalized transactions for all accounts.
+    purgeAccount ::
+        -- accummulator
+        ( HM.HashMap AccountAddressEq AccountNonFinalizedTransactions,
+          (PendingTransactionTable, TransactionHashTable)
+        ) ->
+        -- current entry key
+        AccountAddressEq ->
+        -- current entry value
+        AccountNonFinalizedTransactions ->
+        -- result
+        ( HM.HashMap AccountAddressEq AccountNonFinalizedTransactions,
+          (PendingTransactionTable, TransactionHashTable)
+        )
+    purgeAccount (anfts, (ptt0, trs0)) addr AccountNonFinalizedTransactions{..} =
         -- Purge the transactions from the transaction table.
         let (newANFTMap, (mmax, !trs1)) = runState (Map.traverseMaybeWithKey purgeTxs _anftMap) (Nothing, trs0)
-        -- Update the pending transaction table.
-        let updptt (Just (Max newHigh)) (Just (low, _))
+            -- Update the pending transaction table.
+            updptt (Just (Max newHigh)) (Just (low, _))
                 | newHigh < low = Nothing
                 | otherwise = Just (low, newHigh)
             updptt _ _ = Nothing
             !ptt1 = ptt0 & pttWithSender . at' addr %~ updptt mmax
-        put (ptt1, trs1)
-        return AccountNonFinalizedTransactions{_anftMap = newANFTMap, ..}
+            anfts' = if null newANFTMap then anfts else HM.insert addr AccountNonFinalizedTransactions{_anftMap = newANFTMap, ..} anfts
+        in  (anfts', (ptt1, trs1))
     -- Purge the deploy credential transactions that are pending.
     purgeDeployCredentials = do
         dc0 <- use (_1 . pttDeployCredential)
@@ -175,8 +187,11 @@ purgeTables lastFinCommitPoint oldestArrivalTime currentTime TransactionTable{..
             !ptt1 = ptt0 & pttUpdates . at' uty %~ updptt mmax
         in  (nfcu{_nfcuMap = newNFCUMap}, (ptt1, uis1))
     purge = do
-        -- Purge each account
-        nnft <- HM.traverseWithKey purgeAccount _ttNonFinalizedTransactions
+        -- Purge each account, and possibly remove the @AccountNonFinalizedTransactions@
+        -- if an account does not have any pending transactions left.
+        s <- get
+        let (nnft, s') = HM.foldlWithKey' purgeAccount (HM.empty, s) _ttNonFinalizedTransactions
+        put s'
         -- Purge credential deployments
         purgeDeployCredentials
         -- Purge chain updates

concordium-consensus/src/Concordium/GlobalState/TransactionTable.hs

@@ -207,14 +207,13 @@ emptyNFCUWithSequenceNumber = NonFinalizedChainUpdates Map.empty
 --  may also have a non-zero highest commit point if it is received in a block, but that block
 --  is not yet considered arrived (e.g. it is pending its parent).
 --
---  Generally, '_ttNonFinalizedTransactions' should have an entry for every account,
---  with the exception of where the entry would be 'emptyANFT'. Similarly with
---  '_ttNonFinalizedChainUpdates' and 'emptyNFCU'.  In particular, there should be
---  an entry if the next nonce/sequence number is not the minimum value.
+--  The '_ttNonFinalizedTransactions' should have an entry for every account which have non-finalized transactions.
+--  The '_ttNonFinalizedChainUpdates' should have an entry for all kinds of 'UpdateType's with the exception of where it would be 'emptyNFCU'.
+--  In particular, there should be an entry if the next nonce/sequence number is not the minimum value.
 data TransactionTable = TransactionTable
     { -- | Map from transaction hashes to transactions, together with their current status.
       _ttHashMap :: !(HM.HashMap TransactionHash (BlockItem, LiveTransactionStatus)),
-      -- | For each account, the non-finalized transactions for that account,
+      -- | For accounts that have non-finalized transactions, the non-finalized transactions for that account,
       --  grouped by nonce. See $equivalence for reasons why AccountAddressEq is used.
       _ttNonFinalizedTransactions :: !(HM.HashMap AccountAddressEq AccountNonFinalizedTransactions),
       -- | For each update types, the non-finalized update instructions, grouped by
@@ -260,16 +259,26 @@ emptyTransactionTableWithSequenceNumbers accs upds =
 -- | Add a transaction to a transaction table if its nonce/sequence number is at least the next
 --  non-finalized nonce/sequence number.  A return value of 'True' indicates that the transaction
 --  was added.  The caller should check that the transaction is not already present.
-addTransaction :: BlockItem -> CommitPoint -> TVer.VerificationResult -> TransactionTable -> (Bool, TransactionTable)
+addTransaction ::
+    -- | Transaction to add.
+    BlockItem ->
+    -- | Commit point of the transaction.
+    CommitPoint ->
+    -- | The associated verification result.
+    TVer.VerificationResult ->
+    -- | The transaction table to update.
+    TransactionTable ->
+    -- | First component is @True@ if table was updated.
+    --  Second component is the updated table.
+    (Bool, TransactionTable)
 addTransaction blockItem@WithMetadata{..} cp !verRes tt0 =
     case wmdData of
-        NormalTransaction tr
-            | tt0 ^. senderANFT . anftNextNonce <= nonce ->
-                (True, tt1 & senderANFT . anftMap . at' nonce . non Map.empty . at' wmdtr ?~ verRes)
+        NormalTransaction tr -> (True, tt1 & senderANFT . anftMap . at' nonce . non Map.empty . at' wmdtr ?~ verRes)
           where
             sender = accountAddressEmbed (transactionSender tr)
             senderANFT :: Lens' TransactionTable AccountNonFinalizedTransactions
-            senderANFT = ttNonFinalizedTransactions . at' sender . non emptyANFT
+            senderANFT = ttNonFinalizedTransactions . at' sender . non anft
+            anft = emptyANFTWithNonce nonce
             nonce = transactionNonce tr
             wmdtr = WithMetadata{wmdData = tr, ..}
         CredentialDeployment{} -> (True, tt1)
@@ -450,19 +459,20 @@ reversePTT trs ptt0 = foldr reverse1 ptt0 trs
 --  provided account address in the first component and the
 --  'Bool' in the second component is 'True' only if all transactions from the
 --  provided account are finalized.
+--  Returns @Nothing@ if no non-finalized transactions were recorded for the provided account.
 nextAccountNonce ::
     -- | The account to look up the next account nonce for.
     AccountAddressEq ->
     -- | The transaction table to look up in.
     TransactionTable ->
     -- | ("the next available account nonce", "whether all transactions from the account are finalized").
-    (Nonce, Bool)
+    Maybe (Nonce, Bool)
 nextAccountNonce addr tt = case tt ^. ttNonFinalizedTransactions . at' addr of
-    Nothing -> (minNonce, True)
+    Nothing -> Nothing
     Just anfts ->
         case Map.lookupMax (anfts ^. anftMap) of
-            Nothing -> (anfts ^. anftNextNonce, True)
-            Just (nonce, _) -> (nonce + 1, False)
+            Nothing -> Just (anfts ^. anftNextNonce, True)
+            Just (nonce, _) -> Just (nonce + 1, False)
 
 -- * Transaction grouping