add helper to init node state

> also rename DraftHydraNode and HydraNode nodeState field no nodeStateHandler to avoid confusion

Author: ffakenz

hydra-node/src/Hydra/API/Server.hs

@@ -30,19 +30,19 @@ import Hydra.API.ServerOutputFilter (
 import Hydra.API.WSServer (wsApp)
 import Hydra.Cardano.Api (LedgerEra)
 import Hydra.Chain (Chain (..))
-import Hydra.Chain.ChainState (IsChainState, chainStateSlot)
+import Hydra.Chain.ChainState (IsChainState)
 import Hydra.Chain.Direct.State ()
 import Hydra.Events (EventSink (..), EventSource (..))
 import Hydra.HeadLogic (
   Deposit (..),
   HeadState (..),
-  IdleState (..),
   InitialState (..),
   NodeState (..),
   OpenState (..),
   aggregateNodeState,
  )
 import Hydra.HeadLogic.Outcome qualified as StateChanged
+import Hydra.HeadLogic.State (initNodeState)
 import Hydra.HeadLogic.StateEvent (StateEvent (..))
 import Hydra.Logging (Tracer, traceWith)
 import Hydra.Network (IP, PortNumber)
@@ -100,16 +100,7 @@ withAPIServer config env party eventSource tracer chain pparams serverOutputFilt
     responseChannel <- newBroadcastTChanIO
     -- Initialize our read models from stored events
     -- NOTE: we do not keep the stored events around in memory
-    nodeStateP <-
-      mkProjection
-        "nodeStateP"
-        ( NodeState
-            { headState = Idle $ IdleState mkChainState
-            , pendingDeposits = mempty
-            , currentSlot = chainStateSlot mkChainState
-            }
-        )
-        aggregateNodeState
+    nodeStateP <- mkProjection "nodeStateP" (initNodeState mkChainState) aggregateNodeState
     -- XXX: We never subscribe to changes of commitInfoP et al directly so a
     -- single read model and normal functions mapping from HeadState ->
     -- CommitInfo etc. would suffice and are less fragile

hydra-node/src/Hydra/HeadLogic/State.hs

@@ -7,7 +7,7 @@ module Hydra.HeadLogic.State where
 import Hydra.Prelude
 
 import Data.Map qualified as Map
-import Hydra.Chain.ChainState (ChainSlot, ChainStateType)
+import Hydra.Chain.ChainState (ChainSlot, IsChainState (..))
 import Hydra.Tx (
   HeadId,
   HeadParameters,
@@ -33,7 +33,7 @@ data NodeState tx = NodeState
   , pendingDeposits :: PendingDeposits tx
   -- ^ Pending deposits as observed on chain.
   -- TODO: could even move the chain state here (also see todo below)
-  -- , chainState :: ChaiStateType tx
+  -- , chainState :: ChainStateType tx
   , currentSlot :: ChainSlot
   }
   deriving stock (Generic)
@@ -46,6 +46,14 @@ deriving stock instance (IsTx tx, Show (ChainStateType tx)) => Show (NodeState t
 deriving anyclass instance (IsTx tx, ToJSON (ChainStateType tx)) => ToJSON (NodeState tx)
 deriving anyclass instance (IsTx tx, FromJSON (ChainStateType tx)) => FromJSON (NodeState tx)
 
+initNodeState :: IsChainState tx => ChainStateType tx -> NodeState tx
+initNodeState chainState =
+  NodeState
+    { headState = Idle IdleState{chainState}
+    , pendingDeposits = mempty
+    , currentSlot = chainStateSlot chainState
+    }
+
 -- | The main state of the Hydra protocol state machine. It holds both, the
 -- overall protocol state, but also the off-chain 'CoordinatedHeadState'.
 --

hydra-node/src/Hydra/Node.hs

@@ -29,13 +29,12 @@ import Hydra.Chain (
   PostTxError,
   initHistory,
  )
-import Hydra.Chain.ChainState (ChainStateType, IsChainState, chainStateSlot)
+import Hydra.Chain.ChainState (ChainStateType, IsChainState)
 import Hydra.Events (EventId, EventSink (..), EventSource (..), getEventId, putEventsToSinks)
 import Hydra.Events.Rotation (EventStore (..))
 import Hydra.HeadLogic (
   Effect (..),
   HeadState (..),
-  IdleState (..),
   Input (..),
   NodeState (..),
   Outcome (..),
@@ -46,7 +45,7 @@ import Hydra.HeadLogic (
  )
 import Hydra.HeadLogic qualified as HeadLogic
 import Hydra.HeadLogic.Outcome (StateChanged (..))
-import Hydra.HeadLogic.State (getHeadParameters)
+import Hydra.HeadLogic.State (getHeadParameters, initNodeState)
 import Hydra.HeadLogic.StateEvent (StateEvent (..))
 import Hydra.Ledger (Ledger)
 import Hydra.Logging (Tracer, traceWith)
@@ -160,7 +159,7 @@ data DraftHydraNode tx m = DraftHydraNode
   { tracer :: Tracer m (HydraNodeLog tx)
   , env :: Environment
   , ledger :: Ledger tx
-  , nodeState :: NodeStateHandler tx m
+  , nodeStateHandler :: NodeStateHandler tx m
   , inputQueue :: InputQueue m (Input tx)
   , eventSource :: EventSource (StateEvent tx) m
   , eventSinks :: [EventSink (StateEvent tx) m]
@@ -209,19 +208,14 @@ hydrate tracer env ledger initialChainState EventStore{eventSource, eventSink} e
       { tracer
       , env
       , ledger
-      , nodeState = nodeStateHandler
+      , nodeStateHandler
       , inputQueue
       , eventSource
       , eventSinks = eventSink : eventSinks
       , chainStateHistory
       }
  where
-  initialState =
-    NodeState
-      { headState = Idle IdleState{chainState = initialChainState}
-      , pendingDeposits = mempty
-      , currentSlot = chainStateSlot initialChainState
-      }
+  initialState = initNodeState initialChainState
 
   recoverNodeStateC =
     mapC stateChanged
@@ -270,16 +264,16 @@ connect ::
   DraftHydraNode tx m ->
   m (HydraNode tx m)
 connect chain network server node =
-  pure HydraNode{tracer, env, ledger, nodeState, inputQueue, eventSource, eventSinks, oc = chain, hn = network, server}
+  pure HydraNode{tracer, env, ledger, nodeStateHandler, inputQueue, eventSource, eventSinks, oc = chain, hn = network, server}
  where
-  DraftHydraNode{tracer, env, ledger, nodeState, inputQueue, eventSource, eventSinks} = node
+  DraftHydraNode{tracer, env, ledger, nodeStateHandler, inputQueue, eventSource, eventSinks} = node
 
 -- | Fully connected hydra node with everything wired in.
 data HydraNode tx m = HydraNode
   { tracer :: Tracer m (HydraNodeLog tx)
   , env :: Environment
   , ledger :: Ledger tx
-  , nodeState :: NodeStateHandler tx m
+  , nodeStateHandler :: NodeStateHandler tx m
   , inputQueue :: InputQueue m (Input tx)
   , eventSource :: EventSource (StateEvent tx) m
   , eventSinks :: [EventSink (StateEvent tx) m]
@@ -354,12 +348,12 @@ processNextInput ::
   HydraNode tx m ->
   Input tx ->
   STM m (Outcome tx)
-processNextInput HydraNode{nodeState, ledger, env} e =
+processNextInput HydraNode{nodeStateHandler, ledger, env} e =
   modifyNodeState $ \s ->
     let outcome = computeOutcome s e
      in (outcome, aggregateState s outcome)
  where
-  NodeStateHandler{modifyNodeState} = nodeState
+  NodeStateHandler{modifyNodeState} = nodeStateHandler
 
   computeOutcome = HeadLogic.update env ledger
 
@@ -373,7 +367,7 @@ processStateChanges node stateChanges = do
  where
   HydraNode
     { eventSinks
-    , nodeState = NodeStateHandler{getNextEventId}
+    , nodeStateHandler = NodeStateHandler{getNextEventId}
     } = node
 
 processEffects ::

hydra-node/src/Hydra/Node/Run.hs

@@ -22,15 +22,15 @@ import Hydra.Chain (ChainComponent, ChainStateHistory, maximumNumberOfParties)
 import Hydra.Chain.Backend (ChainBackend (queryGenesisParameters))
 import Hydra.Chain.Blockfrost (BlockfrostBackend (..))
 import Hydra.Chain.Cardano (withCardanoChain)
-import Hydra.Chain.ChainState (IsChainState (..), chainStateSlot)
+import Hydra.Chain.ChainState (IsChainState (..))
 import Hydra.Chain.Direct (DirectBackend (..))
 import Hydra.Chain.Direct.State (initialChainState)
 import Hydra.Chain.Offline (loadGenesisFile, withOfflineChain)
 import Hydra.Events (EventSink)
 import Hydra.Events.FileBased (mkFileBasedEventStore)
 import Hydra.Events.Rotation (EventStore (..), RotationConfig (..), newRotatedEventStore)
 import Hydra.HeadLogic (aggregateNodeState)
-import Hydra.HeadLogic.State (HeadState (..), IdleState (..), NodeState (..))
+import Hydra.HeadLogic.State (NodeState (..), initNodeState)
 import Hydra.HeadLogic.StateEvent (StateEvent (StateEvent, stateChanged), mkCheckpoint)
 import Hydra.Ledger (Ledger)
 import Hydra.Ledger.Cardano (cardanoLedger, newLedgerEnv)
@@ -150,12 +150,7 @@ run opts = do
       Nothing ->
         pure eventStore
       Just rotationConfig -> do
-        let initialState =
-              NodeState
-                { headState = Idle IdleState{chainState = initialChainState}
-                , pendingDeposits = mempty
-                , currentSlot = chainStateSlot initialChainState
-                }
+        let initialState = initNodeState initialChainState
         let aggregator :: IsChainState tx => NodeState tx -> StateEvent tx -> NodeState tx
             aggregator s StateEvent{stateChanged} = aggregateNodeState s stateChanged
         newRotatedEventStore rotationConfig initialState aggregator mkCheckpoint eventStore

hydra-node/test/Hydra/BehaviorSpec.hs

@@ -33,7 +33,8 @@ import Hydra.Chain.ChainState (ChainSlot (ChainSlot), ChainStateType, IsChainSta
 import Hydra.Chain.Direct.Handlers (LocalChainState, getLatest, newLocalChainState, pushNew, rollback)
 import Hydra.Events (EventSink (..))
 import Hydra.Events.Rotation (EventStore (..))
-import Hydra.HeadLogic (CoordinatedHeadState (..), Effect (..), HeadState (..), IdleState (..), InitialState (..), Input (..), NodeState (..), OpenState (..))
+import Hydra.HeadLogic (CoordinatedHeadState (..), Effect (..), HeadState (..), InitialState (..), Input (..), NodeState (..), OpenState (..))
+import Hydra.HeadLogic.State (initNodeState)
 import Hydra.HeadLogicSpec (testSnapshot)
 import Hydra.Ledger (Ledger, nextChainSlot)
 import Hydra.Ledger.Simple (SimpleChainState (..), SimpleTx (..), aValidTx, simpleLedger, utxoRef, utxoRefs)
@@ -1288,14 +1289,14 @@ createTestHydraClient ::
   TVar m [ServerOutput tx] ->
   HydraNode tx m ->
   TestHydraClient tx m
-createTestHydraClient outputs messages outputHistory HydraNode{inputQueue, nodeState} =
+createTestHydraClient outputs messages outputHistory HydraNode{inputQueue, nodeStateHandler} =
   TestHydraClient
     { send = enqueue inputQueue . ClientInput
     , waitForNext = atomically (readTQueue outputs)
     , waitForNextMessage = atomically (readTQueue messages)
     , injectChainEvent = enqueue inputQueue . ChainInput
     , serverOutputs = reverse <$> readTVarIO outputHistory
-    , queryState = atomically (queryNodeState nodeState)
+    , queryState = atomically (queryNodeState nodeStateHandler)
     }
 
 createHydraNode ::
@@ -1324,7 +1325,7 @@ createHydraNode tracer ledger chainState signingKey otherParties outputs message
                   modifyTVar' outputHistory (output :)
           }
   -- NOTE: Not using 'hydrate' as we don't want to run the event source conduit.
-  let nodeState = NodeState{headState = Idle IdleState{chainState}, pendingDeposits = mempty, currentSlot = ChainSlot 0}
+  let nodeState = initNodeState chainState
   let chainStateHistory = initHistory chainState
   nodeStateHandler <- createNodeStateHandler Nothing nodeState
   inputQueue <- createInputQueue
@@ -1335,7 +1336,7 @@ createHydraNode tracer ledger chainState signingKey otherParties outputs message
         { tracer
         , env
         , ledger
-        , nodeState = nodeStateHandler
+        , nodeStateHandler
         , inputQueue
         , eventSource
         , eventSinks = [apiSink, eventSink]

hydra-node/test/Hydra/Events/RotationSpec.hs

@@ -9,7 +9,8 @@ import Hydra.Chain (OnChainTx (..))
 import Hydra.Chain.ChainState (ChainSlot (..), IsChainState)
 import Hydra.Events (EventId, EventSink (..), HasEventId (..), getEvents)
 import Hydra.Events.Rotation (EventStore (..), RotationConfig (..), newRotatedEventStore)
-import Hydra.HeadLogic (HeadState (..), IdleState (..), NodeState (..), StateChanged (..), aggregateNodeState)
+import Hydra.HeadLogic (HeadState (..), NodeState (..), StateChanged (..), aggregateNodeState)
+import Hydra.HeadLogic.State (initNodeState)
 import Hydra.HeadLogic.StateEvent (StateEvent (..), mkCheckpoint)
 import Hydra.Ledger.Simple (SimpleChainState (..), SimpleTx, simpleLedger)
 import Hydra.Logging (showLogsOnFailure)
@@ -44,7 +45,7 @@ spec = parallel $ do
           -- NOTE: because there will be 5 inputs processed in total,
           -- this is hardcoded to ensure we get a checkpoint + a single event at the end
           let rotationConfig = RotateAfter (Positive 3)
-          let s0 = NodeState{headState = Idle IdleState{chainState = SimpleChainState{slot = ChainSlot 0}}, pendingDeposits = mempty, currentSlot = ChainSlot 0}
+          let s0 = initNodeState SimpleChainState{slot = ChainSlot 0}
           rotatingEventStore <- newRotatedEventStore rotationConfig s0 mkAggregator mkCheckpoint eventStore
           testHydrate rotatingEventStore []
             >>= notConnect
@@ -58,7 +59,7 @@ spec = parallel $ do
           -- NOTE: because there will be 6 inputs processed in total,
           -- this is hardcoded to ensure we get a single checkpoint event at the end
           let rotationConfig = RotateAfter (Positive 1)
-          let s0 = NodeState{headState = Idle IdleState{chainState = SimpleChainState{slot = ChainSlot 0}}, pendingDeposits = mempty, currentSlot = ChainSlot 0}
+          let s0 = initNodeState SimpleChainState{slot = ChainSlot 0}
           rotatingEventStore <- newRotatedEventStore rotationConfig s0 mkAggregator mkCheckpoint eventStore
           testHydrate rotatingEventStore []
             >>= notConnect
@@ -87,7 +88,7 @@ spec = parallel $ do
           -- this is hardcoded to ensure we get a single checkpoint event at the end
           let rotationConfig = RotateAfter (Positive 1)
           -- run rotated event store with prepared inputs
-          let s0 = NodeState{headState = Idle IdleState{chainState = SimpleChainState{slot = ChainSlot 0}}, pendingDeposits = mempty, currentSlot = ChainSlot 0}
+          let s0 = initNodeState SimpleChainState{slot = ChainSlot 0}
           rotatingEventStore <- newRotatedEventStore rotationConfig s0 mkAggregator mkCheckpoint eventStore
           testHydrate rotatingEventStore []
             >>= notConnect
@@ -113,7 +114,7 @@ spec = parallel $ do
         let inputs1 = take 3 inputs
         let inputs2 = drop 3 inputs
         failAfter 1 $ do
-          let s0 = NodeState{headState = Idle IdleState{chainState = SimpleChainState{slot = ChainSlot 0}}, pendingDeposits = mempty, currentSlot = ChainSlot 0}
+          let s0 = initNodeState SimpleChainState{slot = ChainSlot 0}
           -- NOTE: because there will be 6 inputs processed in total,
           -- this is hardcoded to ensure we get a single checkpoint event at the end
           let rotationConfig = RotateAfter (Positive 1)

hydra-node/test/Hydra/HeadLogicSpec.hs

@@ -28,8 +28,8 @@ import Hydra.Chain (
  )
 import Hydra.Chain.ChainState (ChainSlot (..), IsChainState)
 import Hydra.Chain.Direct.State ()
-import Hydra.HeadLogic (ClosedState (..), CoordinatedHeadState (..), Effect (..), HeadState (..), IdleState (..), InitialState (..), Input (..), LogicError (..), NodeState (..), OpenState (..), Outcome (..), RequirementFailure (..), SideLoadRequirementFailure (..), StateChanged (..), TTL, WaitReason (..), aggregateState, cause, noop, update)
-import Hydra.HeadLogic.State (SeenSnapshot (..), getHeadParameters)
+import Hydra.HeadLogic (ClosedState (..), CoordinatedHeadState (..), Effect (..), HeadState (..), InitialState (..), Input (..), LogicError (..), NodeState (..), OpenState (..), Outcome (..), RequirementFailure (..), SideLoadRequirementFailure (..), StateChanged (..), TTL, WaitReason (..), aggregateState, cause, noop, update)
+import Hydra.HeadLogic.State (SeenSnapshot (..), getHeadParameters, initNodeState)
 import Hydra.Ledger (Ledger (..), ValidationError (..))
 import Hydra.Ledger.Cardano (cardanoLedger, mkRangedTx)
 import Hydra.Ledger.Cardano.TimeSpec (genUTCTime)
@@ -1072,12 +1072,7 @@ connectivityChanged ttl connectivityMessage =
     }
 
 inIdleState :: NodeState SimpleTx
-inIdleState =
-  NodeState
-    { headState = Idle IdleState{chainState = SimpleChainState{slot = ChainSlot 0}}
-    , pendingDeposits = mempty
-    , currentSlot = ChainSlot 0
-    }
+inIdleState = initNodeState SimpleChainState{slot = ChainSlot 0}
 
 -- XXX: This is always called with threeParties and simpleLedger
 inInitialState :: [Party] -> NodeState SimpleTx

hydra-node/test/Hydra/Model/MockChain.hs

@@ -224,7 +224,7 @@ mockChainAndNetwork tr seedKeys commits = do
       Nothing -> error "closeWithInitialSnapshot: Could not find matching HydraNode"
       Just
         MockHydraNode
-          { node = HydraNode{oc = Chain{postTx}, nodeState = NodeStateHandler{queryNodeState}}
+          { node = HydraNode{oc = Chain{postTx}, nodeStateHandler = NodeStateHandler{queryNodeState}}
           } -> do
           NodeState{headState = hs} <- atomically queryNodeState
           case hs of