From cb9516249454a827e916ef5e7a382eb589bbbbbb Mon Sep 17 00:00:00 2001 From: Marcin Szamotulski Date: Wed, 20 May 2026 16:27:04 +0200 Subject: [PATCH 1/4] Added changelog entry --- ...20_161705_coot_ouroboros_network_update.md | 31 +++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 dmq-node/changelog.d/20260520_161705_coot_ouroboros_network_update.md diff --git a/dmq-node/changelog.d/20260520_161705_coot_ouroboros_network_update.md b/dmq-node/changelog.d/20260520_161705_coot_ouroboros_network_update.md new file mode 100644 index 0000000..eb8017b --- /dev/null +++ b/dmq-node/changelog.d/20260520_161705_coot_ouroboros_network_update.md @@ -0,0 +1,31 @@ + + +### Breaking + +- Using `KeepAliveRegistry` instead of `FetchClientRegistry` introduced in + a recent `ouroboros-network` PR. The `fetchClientRegistry` field of + `NodeKernel` was replaced with `keepAliveRegistry` field. + +### Non-Breaking + +- Added `PrettyShow` instances for + - `NodeToNodeVersion` + - `NodeToNodeVersionData` + - `NodeToClientVersion` + - `NodeToClientVersionData` +- Signature validation changed, we're no longer using the `mark set`, pools + with no stake will be able to mint signatures as long as they have non zero + stake in the `set set`. + + + From df9b9a94b6a461afb8c291731b8d7f31da179c8f Mon Sep 17 00:00:00 2001 From: Marcin Szamotulski Date: Wed, 4 Mar 2026 09:09:10 +0100 Subject: [PATCH 2/4] Connect to cardano-node in dmq kernel. --- cabal.project | 1 + dmq-node/app/Main.hs | 16 +- dmq-node/dmq-node.cabal | 1 + dmq-node/src/DMQ/Diffusion/NodeKernel.hs | 141 ++++++++++++++-- .../DMQ/NodeToClient/LocalStateQueryClient.hs | 156 ++++++++---------- 5 files changed, 200 insertions(+), 115 deletions(-) diff --git a/cabal.project b/cabal.project index b3f8301..20e1850 100644 --- a/cabal.project +++ b/cabal.project @@ -53,6 +53,7 @@ source-repository-package subdir: network-mux cardano-diffusion ouroboros-network + acts-generic source-repository-package type: git diff --git a/dmq-node/app/Main.hs b/dmq-node/app/Main.hs index 3fb417f..3d62ab5 100644 --- a/dmq-node/app/Main.hs +++ b/dmq-node/app/Main.hs @@ -52,7 +52,6 @@ import DMQ.Diffusion.PeerSelectionPolicy (policy) import DMQ.Genesis import DMQ.Handlers.TopLevel (toplevelExceptionHandler) import DMQ.NodeToClient qualified as NtC -import DMQ.NodeToClient.LocalStateQueryClient import DMQ.NodeToNode (NodeToNodeVersion, dmqCodecs, dmqLimitsAndTimeouts, ntnApps) import DMQ.Policy qualified as Policy @@ -97,10 +96,8 @@ runDMQ commandLineConfig = do dmqcTopologyFile = I topologyFile, dmqcCardanoNodeSocket = I socketPath, dmqcVersion = I version, - dmqcLedgerPeers = I ledgerPeers, dmqcShelleyGenesisFile = I genesisFile, dmqcShelleyGenesisHash = I genesisHash - } = fromRight mempty config' <> commandLineConfig `act` @@ -128,7 +125,6 @@ runDMQ commandLineConfig = do ( dmqTracers@DMQTracers { dmqStartupTracer, - localStateQueryClientTracer, sigValidationTracer, localSigValidationTracer, cardanoNodeHandshakeTracer @@ -179,19 +175,13 @@ runDMQ commandLineConfig = do -- TODO: this might not work, since `ouroboros-network` creates its own IO Completion Port. withIOManager \iocp -> do - let localSnocket' = localSnocket iocp - mkStakePoolMonitor = connectToCardanoNode - localStateQueryClientTracer - ledgerPeers - localSnocket' - socketPath - withNodeKernel @StandardCrypto dmqTracers + (localSnocket iocp) + makeLocalBearer dmqConfig shelleyGenesis - psRng - mkStakePoolMonitor $ \nodeKernel -> do + psRng $ \nodeKernel -> do dmqDiffusionConfiguration <- mkDiffusionConfiguration dmqConfig nt nodeKernel.stakePools.ledgerBigPeersVar diff --git a/dmq-node/dmq-node.cabal b/dmq-node/dmq-node.cabal index 1b778ab..1639992 100644 --- a/dmq-node/dmq-node.cabal +++ b/dmq-node/dmq-node.cabal @@ -112,6 +112,7 @@ library cardano-ledger-byron, cardano-ledger-core, cardano-ledger-shelley, + cardano-protocol-tpraos, cardano-slotting, cardano-strict-containers, cborg >=0.2.1 && <0.3, diff --git a/dmq-node/src/DMQ/Diffusion/NodeKernel.hs b/dmq-node/src/DMQ/Diffusion/NodeKernel.hs index 6fc125b..8659010 100644 --- a/dmq-node/src/DMQ/Diffusion/NodeKernel.hs +++ b/dmq-node/src/DMQ/Diffusion/NodeKernel.hs @@ -1,15 +1,19 @@ -{-# LANGUAGE DataKinds #-} -{-# LANGUAGE PackageImports #-} -{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE DataKinds #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE FlexibleContexts #-} +{-# LANGUAGE PackageImports #-} +{-# LANGUAGE RankNTypes #-} module DMQ.Diffusion.NodeKernel ( module DMQ.Diffusion.NodeKernel.Types , withNodeKernel ) where +import Control.Applicative (Alternative) import Control.Concurrent.Class.MonadMVar import Control.Concurrent.Class.MonadSTM.Strict import Control.Monad.Class.MonadAsync +import Control.Monad.Class.MonadST import Control.Monad.Class.MonadThrow import Control.Monad.Class.MonadTime.SI import Control.Monad.Class.MonadTimer.SI @@ -18,22 +22,44 @@ import "contra-tracer" Control.Tracer (nullTracer) import Data.Function (on) import Data.Hashable import Data.Map.Strict qualified as Map +import Data.Proxy import Data.Sequence (Seq) import Data.Sequence qualified as Seq import Data.Set (Set) import Data.Set qualified as Set import Data.Time.Clock.POSIX (POSIXTime) import Data.Time.Clock.POSIX qualified as Time -import Data.Void (Void) +import Data.Void (Void, absurd) import System.Random (StdGen) import System.Random qualified as Random +import Network.Mux qualified as Mx + +import Cardano.Chain.Slotting (EpochSlots (..)) +import Cardano.Network.NodeToClient qualified as Cardano.NtoC +import Cardano.Protocol.Crypto qualified as Cardano (StandardCrypto) + +import Ouroboros.Consensus.Cardano.Block (CardanoBlock) +import Ouroboros.Consensus.Cardano.Node +import Ouroboros.Consensus.Network.NodeToClient +import Ouroboros.Consensus.Node.NetworkProtocolVersion +import Ouroboros.Consensus.Node.ProtocolInfo + +import Ouroboros.Network.Handshake.Queryable (Queryable (..)) import Ouroboros.Network.KeepAlive (newKeepAliveRegistry) -import Ouroboros.Network.Magic (NetworkMagic (..)) +import Ouroboros.Network.Mux qualified as Mx import Ouroboros.Network.PeerSelection.Governor.Types (makePublicPeerSelectionStateVar) import Ouroboros.Network.PeerSharing (newPeerSharingAPI, newPeerSharingRegistry, ps_POLICY_PEER_SHARE_MAX_PEERS, ps_POLICY_PEER_SHARE_STICKY_TIME) +import Ouroboros.Network.Protocol.Handshake (Acceptable (..)) +import Ouroboros.Network.Protocol.Handshake.Codec (cborTermVersionDataCodec, + noTimeLimitsHandshake) +import Ouroboros.Network.Protocol.LocalStateQuery.Client +import Ouroboros.Network.Protocol.LocalStateQuery.Type +import Ouroboros.Network.Snocket (Snocket, localAddressFromPath) +import Ouroboros.Network.Socket (ConnectToArgs (..), + HandshakeCallbacks (HandshakeCallbacks), connectToNode) import Ouroboros.Network.TxSubmission.Inbound.V2 import Ouroboros.Network.TxSubmission.Mempool.Simple (Mempool (..), MempoolSeq (..), WithIndex (..)) @@ -43,10 +69,12 @@ import DMQ.Configuration import DMQ.Diffusion.NodeKernel.Types import DMQ.Diffusion.PeerSelection.PeerMetric (mkPeerMetric) import DMQ.Genesis +import DMQ.NodeToClient.LocalStateQueryClient import DMQ.Policy qualified as Policy import DMQ.Protocol.SigSubmission.Type (Sig (sigExpiresAt, sigId), SigId) import DMQ.Tracer + newNodeKernel :: forall crypto ntnAddr m. ( MonadLabelledSTM m , MonadMVar m @@ -115,32 +143,45 @@ newNodeKernel rng ShelleyGenesis {sgMaxKESEvolutions} = do withNodeKernel :: forall crypto ntnAddr ntcAddr m a. - ( MonadAsync m - , MonadFork m - , MonadDelay m - , MonadLabelledSTM m - , MonadMask m - , MonadMVar m - , MonadTime m + ( Alternative (STM m) + , MonadAsync m + , MonadEvaluate m + , MonadFork m + , MonadDelay m + , MonadLabelledSTM m + , MonadMask m + , MonadMVar m + , Mx.MonadReadBuffer m + , MonadST m + , MonadThrow (STM m) + , MonadTime m + , MonadTimer m , Ord ntnAddr , Hashable ntnAddr ) => DMQTracers crypto ntnAddr ntcAddr m + -> Snocket m Cardano.NtoC.LocalSocket LocalAddress + -> Mx.MakeBearer m Cardano.NtoC.LocalSocket -> Configuration -> ShelleyGenesis -> StdGen - -> (NetworkMagic -> NodeKernel crypto ntnAddr m -> m (Either SomeException Void)) -> (NodeKernel crypto ntnAddr m -> m a) -- ^ as soon as the callback exits the `mempoolWorker` and all -- decision logic threads will be killed -> m a -withNodeKernel DMQTracers { sigSubmissionLogicTracer } +withNodeKernel DMQTracers { sigSubmissionLogicTracer, + localStateQueryClientTracer + } + localSnocket + mkLocalBearer Configuration { - dmqcCardanoNetworkMagic = I networkMagic + dmqcCardanoNetworkMagic = I networkMagic, + dmqcCardanoNodeSocket = I cardanoNodeSocketPath, + dmqcLedgerPeers = I ledgerPeers } shelleyGenesis rng - mkStakePoolMonitor k = do + k = do nodeKernel@NodeKernel { mempool, sigChannelVar, sigSharedTxStateVar @@ -155,11 +196,77 @@ withNodeKernel DMQTracers { sigSubmissionLogicTracer } sigChannelVar sigSharedTxStateVar) $ \sigLogicThread -> - withAsync (mkStakePoolMonitor networkMagic nodeKernel) \spmAid -> do + withAsync (connectToCardanoNode nodeKernel) \spmAid -> do link mempoolThread link sigLogicThread link spmAid k nodeKernel + where + connectToCardanoNode :: NodeKernel crypto ntnAddr m + -> m (Either SomeException Void) + connectToCardanoNode nodeKernel = + fmap fn <$> + connectToNode + localSnocket + mkLocalBearer + ConnectToArgs { + ctaHandshakeCodec = Cardano.NtoC.nodeToClientHandshakeCodec, + ctaHandshakeTimeLimits = noTimeLimitsHandshake, + ctaVersionDataCodec = cborTermVersionDataCodec Cardano.NtoC.nodeToClientCodecCBORTerm, + ctaConnectTracers = Cardano.NtoC.nullNetworkConnectTracers, --debuggingNetworkConnectTracers, + ctaHandshakeCallbacks = HandshakeCallbacks acceptableVersion queryVersion + } + (\_ -> return ()) + (Cardano.NtoC.combineVersions + [ Cardano.NtoC.simpleSingletonVersions + version + Cardano.NtoC.NodeToClientVersionData { + Cardano.NtoC.networkMagic + , Cardano.NtoC.query = False + } + \_version -> + Mx.OuroborosApplication + [ Mx.MiniProtocol + { Mx.miniProtocolNum = Mx.MiniProtocolNum 7 + , Mx.miniProtocolStart = Mx.StartEagerly + , Mx.miniProtocolLimits = + Mx.MiniProtocolLimits + { Mx.maximumIngressQueue = 0xffffffff + } + , Mx.miniProtocolRun = + Mx.InitiatorProtocolOnly + . Mx.mkMiniProtocolCbFromPeerSt + . const + $ ( nullTracer -- TODO: add tracer + , cStateQueryCodec + , StateIdle + , localStateQueryClientPeer $ + cardanoLocalStateQueryClient + localStateQueryClientTracer + ledgerPeers + (stakePools nodeKernel) + (readinessVar nodeKernel) + ) + } + ] + | version <- [minBound..maxBound] + , let -- NOTE: the query protocol is running using + -- `Cardano.StandardCrypto`, while `dmq-node` is using + -- `StandardCrypto` defined in `kes-agent-krypto`. These two + -- must agree, but even if they did not, all the queries we do + -- are crypto agnostic. + supportedVersionMap = + supportedNodeToClientVersions (Proxy :: Proxy (CardanoBlock Cardano.StandardCrypto)) + blk = supportedVersionMap Map.! version + Codecs {cStateQueryCodec} = + clientCodecs (pClientInfoCodecConfig . protocolClientInfoCardano $ EpochSlots 21600) + blk version + ]) + Nothing + (localAddressFromPath cardanoNodeSocketPath) + where + fn :: forall x. Either x Void -> x + fn = either id absurd mempoolWorker :: forall crypto m. diff --git a/dmq-node/src/DMQ/NodeToClient/LocalStateQueryClient.hs b/dmq-node/src/DMQ/NodeToClient/LocalStateQueryClient.hs index 660c385..f2c598d 100644 --- a/dmq-node/src/DMQ/NodeToClient/LocalStateQueryClient.hs +++ b/dmq-node/src/DMQ/NodeToClient/LocalStateQueryClient.hs @@ -5,13 +5,12 @@ {-# LANGUAGE PackageImports #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-} -{-# LANGUAGE TypeOperators #-} module DMQ.NodeToClient.LocalStateQueryClient ( Readiness (..) + , CardanoLocalStateQueryClient , TraceLocalStateQueryClient (..) - , cardanoClient - , connectToCardanoNode + , cardanoLocalStateQueryClient ) where import Control.Concurrent.Class.MonadSTM.Strict @@ -20,44 +19,34 @@ import Control.Monad.Class.MonadThrow import Control.Monad.Class.MonadTime.SI import Control.Monad.Class.MonadTimer.SI import Control.Monad.Trans.Except -import "contra-tracer" Control.Tracer (Tracer, nullTracer, traceWith) +import "contra-tracer" Control.Tracer (Tracer, traceWith) import Data.Functor ((<&>)) import Data.List.NonEmpty qualified as NonEmpty -import Data.Map.Strict qualified as Map -import Data.Proxy import Data.Void -import Cardano.Chain.Slotting (EpochSlots (..)) import Cardano.Ledger.Api (EraGov) import Cardano.Ledger.Api.State.Query (StakeSnapshots (..)) -import Cardano.Network.NodeToClient import Cardano.Network.PeerSelection (LedgerPeerSnapshot (..), LedgerRelayAccessPoint (..), SingLedgerPeersKind (..)) import Cardano.Slotting.EpochInfo.API import Cardano.Slotting.Slot (EpochNo) import Cardano.Slotting.Time -import DMQ.Diffusion.NodeKernel +import DMQ.Diffusion.NodeKernel.Types (Readiness (..), StakePools (..)) + import Ouroboros.Consensus.Cardano.Block -import Ouroboros.Consensus.Cardano.Node (protocolClientInfoCardano) import Ouroboros.Consensus.HardFork.Combinator.AcrossEras (mkEraMismatch) import Ouroboros.Consensus.HardFork.Combinator.Ledger.Query (QueryHardFork (GetCurrentEra, GetInterpreter)) import Ouroboros.Consensus.HardFork.History (Interpreter, interpreterToEpochInfo) import Ouroboros.Consensus.Ledger.Query (Query (..), QueryFootprint (..)) -import Ouroboros.Consensus.Network.NodeToClient -import Ouroboros.Consensus.Node.NetworkProtocolVersion -import Ouroboros.Consensus.Node.ProtocolInfo import Ouroboros.Consensus.Shelley.Ledger.Block import Ouroboros.Consensus.Shelley.Ledger.Query import Ouroboros.Consensus.Shelley.Ledger.SupportsProtocol () import Ouroboros.Network.Block -import Ouroboros.Network.Magic -import Ouroboros.Network.Mux qualified as Mx import Ouroboros.Network.PeerSelection.LedgerPeers (LedgerPeersKind (..), - accumulateBigLedgerStake) -import Ouroboros.Network.PeerSelection.LedgerPeers.Type (RawBlockHash) + RawBlockHash, accumulateBigLedgerStake) import Ouroboros.Network.Point (Block (..)) import Ouroboros.Network.Protocol.LocalStateQuery.Client import Ouroboros.Network.Protocol.LocalStateQuery.Type @@ -78,23 +67,67 @@ data QueryInEra c proto era where -> QueryInEra c proto era --- | Connect the dmq node to cardano node via local state query protocol and --- update the node kernel with stake pool data necessary to perform mithril --- signature validation +-- +-- Type aliases +-- + +-- | `LocalStateQuery` using `CardanoBlock` +type CardanoLocalStateQueryClient crypto m a = + LocalStateQueryClient (CardanoBlock crypto) + (Point (CardanoBlock crypto)) + (Query (CardanoBlock crypto)) m Void + +-- | `ClientStIdle` state using `CardanoBlock` +type CardanoClientStIdle crypto m a = + ClientStIdle (CardanoBlock crypto) + (Point (CardanoBlock crypto)) + (Query (CardanoBlock crypto)) + m a + +-- | `ClientStAcuiring` using `CardanoBlock` +type CardanoClientStAcquiring crypto m a = + ClientStAcquiring (CardanoBlock crypto) + (Point (CardanoBlock crypto)) + (Query (CardanoBlock crypto)) + m a + +-- | `ClientStAcuired` using `CardanoBlock` +type CardanoClientStAcquired crypto m a = + ClientStAcquired (CardanoBlock crypto) + (Point (CardanoBlock crypto)) + (Query (CardanoBlock crypto)) + m a + +-- | `ClientStQuerying` using `CardanoBlock` +type CardanoClientStQuerying crypto m a b = + ClientStQuerying (CardanoBlock crypto) + (Point (CardanoBlock crypto)) + (Query (CardanoBlock crypto)) + m a b + + +-- | Local state query client which queries cardano node for +-- +-- * stake pool data (for signature validation) +-- * ledger peers (for peer selection) -- -- NOTE: we are querying using VolatileTip, e.g. for stake snapshot this -- means that the mark set should not be trusted as it might be different -- on different forks. -- -cardanoClient - :: forall block query point crypto m. (MonadDelay m, MonadSTM m, MonadThrow m, MonadTime m) - => (block ~ CardanoBlock crypto, query ~ Query block, point ~ Point block) +cardanoLocalStateQueryClient + :: forall crypto m. + ( MonadDelay m + , MonadSTM m + , MonadThrow m + , MonadTime m + ) => Tracer m TraceLocalStateQueryClient -> Bool -- ^ use ledger peers -> StakePools m -> StrictTVar m Readiness -- ^ from node kernel - -> LocalStateQueryClient (CardanoBlock crypto) (Point block) (Query block) m Void -cardanoClient tracer ledgerPeers + -> CardanoLocalStateQueryClient crypto m Void +cardanoLocalStateQueryClient tracer ledgerPeers StakePools { stakePoolsVar, ledgerPeersVar, @@ -102,10 +135,14 @@ cardanoClient tracer ledgerPeers } readyVar = LocalStateQueryClient (idle Nothing) where + idle :: Maybe SystemStart + -> m (CardanoClientStIdle crypto m Void) idle mSystemStart = do traceWith tracer $ Acquiring mSystemStart pure $ SendMsgAcquire VolatileTip (acquire mSystemStart) + acquire :: Maybe SystemStart + -> CardanoClientStAcquiring crypto m Void acquire mSystemStart = ClientStAcquiring { recvMsgAcquired = maybe systemStartQuery eraQuery mSystemStart , recvMsgFailure = \failure -> @@ -128,15 +165,15 @@ cardanoClient tracer ledgerPeers epochQuery :: SystemStart -> QueryInEra crypto proto era - -> m (ClientStAcquired block point query m Void) + -> m (CardanoClientStAcquired crypto m Void) epochQuery systemStart qie@(QueryInEra f) = pure . SendMsgQuery (BlockQuery $ f GetEpochNo) $ wrappingMismatch (handleEpoch systemStart qie) wrappingMismatch :: forall r. - (r -> m (ClientStAcquired block point query m Void)) - -> ClientStQuerying block point query m Void (CardanoQueryResult crypto r) + (r -> m (CardanoClientStAcquired crypto m Void)) + -> CardanoClientStQuerying crypto m Void (CardanoQueryResult crypto r) wrappingMismatch k = ClientStQuerying $ either (throwIO . userError . show . mkEraMismatch) k @@ -144,7 +181,7 @@ cardanoClient tracer ledgerPeers handleEpoch :: SystemStart -> QueryInEra crypto proto era -> EpochNo - -> m (ClientStAcquired block point query m Void) + -> m (CardanoClientStAcquired crypto m Void) handleEpoch systemStart qie epoch = pure . SendMsgQuery (BlockQuery . QueryHardFork $ GetInterpreter) $ getInterpreter systemStart qie epoch @@ -153,7 +190,7 @@ cardanoClient tracer ledgerPeers getInterpreter :: SystemStart -> QueryInEra crypto proto era -> EpochNo - -> ClientStQuerying block point query m Void (Interpreter xs) + -> CardanoClientStQuerying crypto m Void (Interpreter xs) getInterpreter systemStart qie epoch = ClientStQuerying \interpreter -> do let ei = interpreterToEpochInfo interpreter @@ -180,7 +217,7 @@ cardanoClient tracer ledgerPeers queryStakeSnapshots :: SystemStart -> UTCTime -> QueryInEra crypto proto era - -> m (ClientStAcquired block point query m Void) + -> m (CardanoClientStAcquired crypto m Void) queryStakeSnapshots systemStart nextEpoch qie@(QueryInEra f) = pure . SendMsgQuery (BlockQuery . f $ GetStakeSnapshots Nothing) $ wrappingMismatch \StakeSnapshots { ssStakeSnapshots } -> do @@ -202,14 +239,14 @@ cardanoClient tracer ledgerPeers :: SystemStart -> UTCTime -> QueryInEra crypto proto era - -> ClientStAcquired block point query m Void + -> CardanoClientStAcquired crypto m Void queryLedgerPeers systemStart nextEpoch (QueryInEra f) = SendMsgQuery (BlockQuery . f $ GetLedgerPeerSnapshot SingAllLedgerPeers) $ wrappingMismatch handleLedgerPeers where handleLedgerPeers :: LedgerPeerSnapshot AllLedgerPeers - -> m (ClientStAcquired block point query m Void) + -> m (CardanoClientStAcquired crypto m Void) handleLedgerPeers (LedgerAllPeerSnapshotV23 pt magic peers) = do let bigSrvRelays = force [(accStake, (stake, NonEmpty.fromList relays')) @@ -248,7 +285,7 @@ cardanoClient tracer ledgerPeers release :: SystemStart -> UTCTime -- ^ next epoch - -> ClientStAcquired block point query m Void + -> CardanoClientStAcquired crypto m Void release systemStart nextEpoch = SendMsgRelease do toNextEpoch <- diffUTCTime nextEpoch <$> getCurrentTime let toNextEpoch' :: DiffTime @@ -256,54 +293,3 @@ cardanoClient tracer ledgerPeers traceWith tracer $ NextEpoch nextEpoch toNextEpoch' threadDelay toNextEpoch' idle $ Just systemStart - - -connectToCardanoNode :: Tracer IO TraceLocalStateQueryClient - -> Bool -- ^ use ledger peers - -> LocalSnocket - -> FilePath - -> NetworkMagic - -> NodeKernel crypto ntnAddr IO - -> IO (Either SomeException Void) -connectToCardanoNode tracer ledgerPeers localSnocket' snocketPath networkMagic nodeKernel = - connectTo - localSnocket' - nullNetworkConnectTracers --debuggingNetworkConnectTracers - (combineVersions - [ simpleSingletonVersions - version - NodeToClientVersionData { - networkMagic - , query = False - } - \_version -> - Mx.OuroborosApplication - [ Mx.MiniProtocol - { miniProtocolNum = Mx.MiniProtocolNum 7 - , miniProtocolStart = Mx.StartEagerly - , miniProtocolLimits = - Mx.MiniProtocolLimits - { maximumIngressQueue = 0xffffffff - } - , miniProtocolRun = - Mx.InitiatorProtocolOnly - . Mx.mkMiniProtocolCbFromPeerSt - . const - $ ( nullTracer -- TODO: add tracer - , cStateQueryCodec - , StateIdle - , localStateQueryClientPeer - $ cardanoClient tracer - ledgerPeers - (stakePools nodeKernel) - (readinessVar nodeKernel) - ) - } - ] - | version <- [minBound..maxBound] - , let supportedVersionMap = supportedNodeToClientVersions (Proxy :: Proxy (CardanoBlock StandardCrypto)) - blk = supportedVersionMap Map.! version - Codecs {cStateQueryCodec} = - clientCodecs (pClientInfoCodecConfig . protocolClientInfoCardano $ EpochSlots 21600) blk version - ]) - snocketPath From cf45f55949dfdbbf91983d2a5c1aff9797107b95 Mon Sep 17 00:00:00 2001 From: Marcin Szamotulski Date: Thu, 21 May 2026 15:21:05 +0200 Subject: [PATCH 3/4] policy: fixed a typo Renamed `maxSigsInflight` to `maxSigIdsInflight`. --- dmq-node/src/DMQ/Policy.hs | 14 +++++++------- dmq-node/src/DMQ/Protocol/SigSubmission/Codec.hs | 6 +++--- dmq-node/src/DMQ/Protocol/SigSubmissionV2/Codec.hs | 2 +- 3 files changed, 11 insertions(+), 11 deletions(-) diff --git a/dmq-node/src/DMQ/Policy.hs b/dmq-node/src/DMQ/Policy.hs index 25c83e5..39891d2 100644 --- a/dmq-node/src/DMQ/Policy.hs +++ b/dmq-node/src/DMQ/Policy.hs @@ -3,7 +3,7 @@ module DMQ.Policy , sigSubmissionIngressLimit , peerMetricConfiguration , maxSigSize - , maxSigsInflight + , maxSigIdsInflight ) where import DMQ.Diffusion.PeerSelection.PeerMetric (PeerMetricConfiguration (..)) @@ -18,7 +18,7 @@ import Ouroboros.Network.TxSubmission.Inbound.V2 maxSigSize :: SizeInBytes maxSigSize = 2800 --- | Maximum numbers signatures in-flight per peer. +-- | Maximum numbers signature id's in-flight per peer. -- -- NOTE: it is used by: -- * `sigDecisionPolicy` @@ -31,8 +31,8 @@ maxSigSize = 2800 -- protocol version. -- -- TODO: make it configurable -maxSigsInflight :: NumTxIdsToReq -maxSigsInflight = 33 +maxSigIdsInflight :: NumTxIdsToReq +maxSigIdsInflight = 33 -- | The `TxDecisionPolicy` used by `SigSubmission`. -- @@ -46,9 +46,9 @@ maxSigsInflight = 33 -- sigDecisionPolicy :: TxDecisionPolicy sigDecisionPolicy = TxDecisionPolicy { - maxNumTxIdsToRequest = maxSigsInflight, - maxUnacknowledgedTxIds = 4 * maxSigsInflight, - txsSizeInflightPerPeer = maxSigSize * fromIntegral maxSigsInflight, + maxNumTxIdsToRequest = maxSigIdsInflight, + maxUnacknowledgedTxIds = 4 * maxSigIdsInflight, + txsSizeInflightPerPeer = maxSigSize * fromIntegral maxSigIdsInflight, txInflightMultiplicity = 1, bufferedTxsMinLifetime = 0, scoreRate = 0.1, diff --git a/dmq-node/src/DMQ/Protocol/SigSubmission/Codec.hs b/dmq-node/src/DMQ/Protocol/SigSubmission/Codec.hs index 7b7ecf9..12830d1 100644 --- a/dmq-node/src/DMQ/Protocol/SigSubmission/Codec.hs +++ b/dmq-node/src/DMQ/Protocol/SigSubmission/Codec.hs @@ -85,10 +85,10 @@ byteLimitsSigSubmission :: forall crypto bytes. byteLimitsSigSubmission = ProtocolSizeLimits stateToLimit where -- `(33 + 1) * 2800 = 95200` plus 2800 bytes of overhead. We add `1` to - -- `maxSigsInflight` since the txSubmission logic can download one signature - -- more that the `maxSigsInflight` limit. + -- `maxSigIdsInflight` since the txSubmission logic can download one signature + -- more that the `maxSigIdsInflight` limit. byteLimit :: Word - byteLimit = fromIntegral Policy.maxSigSize * (fromIntegral Policy.maxSigsInflight + 2) + byteLimit = fromIntegral Policy.maxSigSize * (fromIntegral Policy.maxSigIdsInflight + 2) stateToLimit :: forall (st :: SigSubmission crypto). ActiveState st => StateToken st -> Word diff --git a/dmq-node/src/DMQ/Protocol/SigSubmissionV2/Codec.hs b/dmq-node/src/DMQ/Protocol/SigSubmissionV2/Codec.hs index 7dedaac..2fe6f86 100644 --- a/dmq-node/src/DMQ/Protocol/SigSubmissionV2/Codec.hs +++ b/dmq-node/src/DMQ/Protocol/SigSubmissionV2/Codec.hs @@ -52,7 +52,7 @@ byteLimitsSigSubmissionV2 = ProtocolSizeLimits stateToLimit -- `maxSigsInflight` since the txSubmission logic can download one signature -- more that the `maxSigsInflight` limit. byteLimit :: Word - byteLimit = fromIntegral Policy.maxSigSize * (fromIntegral Policy.maxSigsInflight + 2) + byteLimit = fromIntegral Policy.maxSigSize * (fromIntegral Policy.maxSigIdsInflight + 2) stateToLimit :: forall (st :: SigSubmissionV2 sigId sig). From 306de632b8abf25d1fe21fb7326e83da00e71c49 Mon Sep 17 00:00:00 2001 From: Marcin Szamotulski Date: Mon, 22 Jun 2026 16:57:20 +0200 Subject: [PATCH 4/4] Updated hackage index-state Removed an srp for monoidal-containers. --- cabal.project | 9 +-------- flake.lock | 6 +++--- 2 files changed, 4 insertions(+), 11 deletions(-) diff --git a/cabal.project b/cabal.project index 20e1850..bf7f9fd 100644 --- a/cabal.project +++ b/cabal.project @@ -15,7 +15,7 @@ repository cardano-haskell-packages -- repeat the index-state for hackage to work around haskell.nix parsing limitation index-state: -- Bump this if you need newer packages from Hackage - , hackage.haskell.org 2026-05-13T07:31:22Z + , hackage.haskell.org 2026-06-20T00:51:00Z -- Bump this if you need newer packages from CHaP , cardano-haskell-packages 2026-05-11T20:15:43Z @@ -61,13 +61,6 @@ source-repository-package tag: ec9df6ee1d7ab918e75219107fc17e1b2cf1a0e9 --sha256: sha256-c+yGPftvlas2CcnFLUPPqjnitz5yTu/Qud5LaSMyY34= --- https://github.com/bgamari/monoidal-containers/pull/112 -source-repository-package - type: git - location: https://github.com/coot/monoidal-containers - tag: 8319c34e260c7b44adaf0ac04074b3e37e510cea - --sha256: sha256-HkQC2Hb1OAyN8mI2BPcIylcUYF0Mts4DrffJ7Fkkh6Q= - constraints: semialign >= 1.4, validation < 1.2 allow-newer: hedgehog-quickcheck:QuickCheck, diff --git a/flake.lock b/flake.lock index 6476700..9134400 100644 --- a/flake.lock +++ b/flake.lock @@ -155,11 +155,11 @@ "hackage": { "flake": false, "locked": { - "lastModified": 1779358087, - "narHash": "sha256-+tHfNr4EZabb5HaEzHXIOmG6WLkImGfG5DJg/JwKBE4=", + "lastModified": 1782113726, + "narHash": "sha256-Uwh+sHSOKIzicEyHFqnwexReNBvX9jbFiuExI0r51iM=", "owner": "input-output-hk", "repo": "hackage.nix", - "rev": "5ee161948ef9f17ff778d86e03eae8f10e3fd1f1", + "rev": "7dfb22c38f71a464f1c352d88d16e67b23ada26c", "type": "github" }, "original": {