Hydra.Options/Hydra Node RunOptions ‑ does parse --peer given ipv6 addresses
Hydra.Options/Hydra Node RunOptions/publish-scripts sub-command ‑ does not parse with some missing option (1)
Hydra.Options/Hydra Node RunOptions/publish-scripts sub-command ‑ does not parse with some missing option (2)
Hydra.Options/Hydra Node RunOptions/publish-scripts sub-command ‑ does not parse with some missing option (3)
Hydra.Options/Hydra Node RunOptions/publish-scripts sub-command ‑ does not parse without any options

Hydra.API.ClientInput/FromJSON (ValidatedTx era) ‑ accepts transactions produced via cardano-cli
Hydra.API.ClientInput/JSON encoding of (ReasonablySized (ClientInput (Tx ConwayEra))) ‑ allows to encode values with aeson and read them back
Hydra.API.ClientInput/JSON encoding of (ReasonablySized (ClientInput (Tx ConwayEra))) ‑ produces the same JSON as is found in golden/ReasonablySized (ClientInput (Tx ConwayEra)).json
Hydra.API.ClientInput/JSON encoding of (ReasonablySized (ClientInput SimpleTx)) ‑ allows to encode values with aeson and read them back
Hydra.API.ClientInput/JSON encoding of (ReasonablySized (ClientInput SimpleTx)) ‑ produces the same JSON as is found in golden/ReasonablySized (ClientInput SimpleTx).json
Hydra.API.HTTPServer ‑ Validate /cardano-transaction publish api schema
Hydra.API.HTTPServer ‑ Validate /cardano-transaction subscribe api schema
Hydra.API.HTTPServer ‑ Validate /commit publish api schema
Hydra.API.HTTPServer ‑ Validate /commit subscribe api schema
Hydra.API.HTTPServer ‑ Validate /decommit publish api schema
Hydra.API.HTTPServer ‑ Validate /decommit subscribe api schema
Hydra.API.HTTPServer/API should respond correctly/GET /protocol-parameters ‑ matches schema
Hydra.API.HTTPServer/API should respond correctly/GET /protocol-parameters ‑ responds given parameters
Hydra.API.HTTPServer/API should respond correctly/GET /snapshot/utxo ‑ ok response matches schema
Hydra.API.HTTPServer/API should respond correctly/GET /snapshot/utxo ‑ responds correctly
Hydra.API.HTTPServer/API should respond correctly/POST /commit ‑ handles PostTxErrors accordingly
Hydra.API.HTTPServer/API should respond correctly/POST /commit ‑ responds on valid requests
Hydra.API.HTTPServer/JSON encoding of (ReasonablySized (DraftCommitTxRequest (Tx ConwayEra))) ‑ allows to encode values with aeson and read them back
Hydra.API.HTTPServer/JSON encoding of (ReasonablySized (DraftCommitTxRequest (Tx ConwayEra))) ‑ produces the same JSON as is found in golden/ReasonablySized (DraftCommitTxRequest (Tx ConwayEra)).json
Hydra.API.HTTPServer/JSON encoding of (ReasonablySized (DraftCommitTxResponse (Tx ConwayEra))) ‑ allows to encode values with aeson and read them back
Hydra.API.HTTPServer/JSON encoding of (ReasonablySized (DraftCommitTxResponse (Tx ConwayEra))) ‑ produces the same JSON as is found in golden/ReasonablySized (DraftCommitTxResponse (Tx ConwayEra)).json
Hydra.API.HTTPServer/JSON encoding of (ReasonablySized (SubmitTxRequest (Tx ConwayEra))) ‑ allows to encode values with aeson and read them back
Hydra.API.HTTPServer/JSON encoding of (ReasonablySized (SubmitTxRequest (Tx ConwayEra))) ‑ produces the same JSON as is found in golden/ReasonablySized (SubmitTxRequest (Tx ConwayEra)).json
Hydra.API.HTTPServer/JSON encoding of (ReasonablySized TransactionSubmitted) ‑ allows to encode values with aeson and read them back
Hydra.API.HTTPServer/JSON encoding of (ReasonablySized TransactionSubmitted) ‑ produces the same JSON as is found in golden/ReasonablySized TransactionSubmitted.json
Hydra.API.HTTPServer/SubmitTxRequest accepted tx formats ‑ accepts json encoded transaction
Hydra.API.HTTPServer/SubmitTxRequest accepted tx formats ‑ accepts transaction encoded as TextEnvelope
Hydra.API.Server ‑ Greetings should contain the hydra-node version
Hydra.API.Server ‑ displays correctly headStatus and snapshotUtxo in a Greeting message
Hydra.API.Server ‑ does not echo history if client says no
Hydra.API.Server ‑ echoes history (past outputs) to client upon reconnection
Hydra.API.Server ‑ greets
Hydra.API.Server ‑ greets with correct head status and snapshot utxo after restart
Hydra.API.Server ‑ removes UTXO from snapshot when clients request it
Hydra.API.Server ‑ sends all sendOutput history to all connected clients after a restart
Hydra.API.Server ‑ sends an error when input cannot be decoded
Hydra.API.Server ‑ sends sendOutput to all connected clients
Hydra.API.Server ‑ sequence numbers are continuous
Hydra.API.Server ‑ should fail on port in use
Hydra.API.Server/TLS support ‑ accepts TLS connections when configured
Hydra.API.ServerOutput ‑ matches JSON schema
Hydra.API.ServerOutput/JSON encoding of (ReasonablySized (ServerOutput (Tx ConwayEra))) ‑ allows to encode values with aeson and read them back
Hydra.API.ServerOutput/JSON encoding of (ReasonablySized (ServerOutput (Tx ConwayEra))) ‑ produces the same JSON as is found in golden/ReasonablySized (ServerOutput (Tx ConwayEra)).json
Hydra.API.ServerOutput/JSON encoding of (ReasonablySized (ServerOutput SimpleTx)) ‑ allows to encode values with aeson and read them back
Hydra.API.ServerOutput/JSON encoding of (ReasonablySized (ServerOutput SimpleTx)) ‑ produces the same JSON as is found in golden/ReasonablySized (ServerOutput SimpleTx).json
Hydra.API.ServerOutput/JSON encoding of (ReasonablySized (TimedServerOutput (Tx ConwayEra))) ‑ allows to encode values with aeson and read them back
Hydra.API.ServerOutput/JSON encoding of (ReasonablySized (TimedServerOutput (Tx ConwayEra))) ‑ produces the same JSON as is found in golden/ReasonablySized (TimedServerOutput (Tx ConwayEra)).json
Hydra.Behavior/Hydra Node Logging ‑ traces handling of effects
Hydra.Behavior/Hydra Node Logging ‑ traces processing of events
Hydra.Behavior/Sanity tests of test suite ‑ does not delay for real
Hydra.Behavior/Single participant Head ‑ accepts Commit after successful Init
Hydra.Behavior/Single participant Head ‑ accepts Init command
Hydra.Behavior/Single participant Head ‑ can close an open head
Hydra.Behavior/Single participant Head ‑ does finalize head after contestation period upon command
Hydra.Behavior/Single participant Head ‑ does not fanout automatically
Hydra.Behavior/Two participant Head ‑ can abort and re-open a head when one party has not committed
Hydra.Behavior/Two participant Head ‑ can be finalized by all parties after contestation period
Hydra.Behavior/Two participant Head ‑ can close with decommit in flight
Hydra.Behavior/Two participant Head ‑ cannot abort head when commits have been collected
Hydra.Behavior/Two participant Head ‑ contest automatically when detecting closing with old snapshot
Hydra.Behavior/Two participant Head ‑ fanout utxo is correct after a decommit
Hydra.Behavior/Two participant Head ‑ ignores head initialization of other head
Hydra.Behavior/Two participant Head ‑ only opens the head after all nodes committed
Hydra.Behavior/Two participant Head ‑ outputs committed utxo when client requests it
Hydra.Behavior/Two participant Head/in an open head ‑ can only process one decommit at once
Hydra.Behavior/Two participant Head/in an open head ‑ can process transactions while decommit pending
Hydra.Behavior/Two participant Head/in an open head ‑ can request decommit
Hydra.Behavior/Two participant Head/in an open head ‑ depending transactions expire if not applicable in time
Hydra.Behavior/Two participant Head/in an open head ‑ depending transactions stay pending and are confirmed in order
Hydra.Behavior/Two participant Head/in an open head ‑ outputs utxo from confirmed snapshot when client requests it
Hydra.Behavior/Two participant Head/in an open head ‑ requested decommits get approved
Hydra.Behavior/Two participant Head/in an open head ‑ sees the head closed by other nodes
Hydra.Behavior/Two participant Head/in an open head ‑ sending two conflicting transactions should lead one being confirmed and one expired
Hydra.Behavior/Two participant Head/in an open head ‑ snapshots are created as long as transactions to snapshot exist
Hydra.Behavior/Two participant Head/in an open head ‑ valid new transactions are seen by all parties
Hydra.Behavior/Two participant Head/in an open head ‑ valid new transactions get snapshotted
Hydra.Behavior/rolling back & forward does not make the node crash ‑ does work for rollbacks past init
Hydra.Behavior/rolling back & forward does not make the node crash ‑ does work for rollbacks past open
Hydra.Chain.Direct.Handlers/LocalChainState ‑ can resume from chain state
Hydra.Chain.Direct.Handlers/chainSyncHandler ‑ observes transactions onRollForward
Hydra.Chain.Direct.Handlers/chainSyncHandler ‑ roll forward fails with outdated TimeHandle
Hydra.Chain.Direct.Handlers/chainSyncHandler ‑ roll forward results in Tick events
Hydra.Chain.Direct.Handlers/chainSyncHandler ‑ rollbacks state onRollBackward
Hydra.Chain.Direct.ScriptRegistry ‑ newScriptRegistry (registryUTxO r) === Just r
Hydra.Chain.Direct.State/JSON encoding of PubKeyHash ‑ allows to encode values with aeson and read them back
Hydra.Chain.Direct.State/JSON encoding of PubKeyHash ‑ produces the same JSON as is found in golden/PubKeyHash.json
Hydra.Chain.Direct.State/abort ‑ can create valid abort transactions for any observed head
Hydra.Chain.Direct.State/abort ‑ transaction size is below 16kB
Hydra.Chain.Direct.State/abort ‑ validates within maxTxExecutionUnits
Hydra.Chain.Direct.State/acceptance ‑ can close & fanout every collected head
Hydra.Chain.Direct.State/close ‑ transaction size is below 16kB
Hydra.Chain.Direct.State/close ‑ validates within maxTxExecutionUnits
Hydra.Chain.Direct.State/collectCom ‑ transaction size is below 16kB
Hydra.Chain.Direct.State/collectCom ‑ validates within maxTxExecutionUnits
Hydra.Chain.Direct.State/commit ‑ can only be applied / observed once
Hydra.Chain.Direct.State/commit ‑ consumes all inputs that are committed
Hydra.Chain.Direct.State/commit ‑ only proper head is observed
Hydra.Chain.Direct.State/commit ‑ reject Commits with more than maxMainnetLovelace Lovelace
Hydra.Chain.Direct.State/commit ‑ reject committing outputs with byron addresses
Hydra.Chain.Direct.State/commit ‑ transaction size is below 16kB
Hydra.Chain.Direct.State/commit ‑ validates within maxTxExecutionUnits
Hydra.Chain.Direct.State/contest ‑ transaction size is below 16kB
Hydra.Chain.Direct.State/contest ‑ validates within maxTxExecutionUnits
Hydra.Chain.Direct.State/decrement ‑ observes distributed outputs
Hydra.Chain.Direct.State/decrement ‑ transaction size is below 16kB
Hydra.Chain.Direct.State/decrement ‑ validates within maxTxExecutionUnits
Hydra.Chain.Direct.State/fanout ‑ transaction size is below 16kB
Hydra.Chain.Direct.State/fanout ‑ validates within maxTxExecutionUnits
Hydra.Chain.Direct.State/init ‑ only proper head is observed
Hydra.Chain.Direct.State/init ‑ transaction size is below 16kB
Hydra.Chain.Direct.State/init ‑ validates within maxTxExecutionUnits
Hydra.Chain.Direct.State/observeTx ‑ All valid transitions for all possible states can be observed.
Hydra.Chain.Direct.State/splitUTxO ‑ it splits at least one utxo off
Hydra.Chain.Direct.TimeHandle ‑ can roundtrip currentPointInTime
Hydra.Chain.Direct.TimeHandle ‑ should convert slot within latest/current era
Hydra.Chain.Direct.Tx/HeadId (cardano) ‑ curencySymbolToHeadId . headIdToCurrencySymbol === id
Hydra.Chain.Direct.Tx/HeadId (cardano) ‑ headIdToPolicyId . mkHeadId === id
Hydra.Chain.Direct.Tx/HeadSeed (cardano) ‑ headSeedToTxIn . txInToHeadSeed === id
Hydra.Chain.Direct.Tx/commitTx ‑ Validate blueprint and commit transactions
Hydra.Chain.Direct.Tx/commitTx ‑ genBlueprintTx generates interesting txs
Hydra.Chain.Direct.Tx/observeHeadTx ‑ All valid transitions for all possible states can be observed.
Hydra.Chain.Direct.TxTrace ‑ all valid transactions
Hydra.Chain.Direct.TxTrace ‑ generates interesting transaction traces
Hydra.Chain.Direct.TxTrace ‑ realWorldModelUTxO preserves addition
Hydra.Chain.Direct.Wallet/applyTxs ‑ Seen inputs are consumed and not in the resulting UTXO
Hydra.Chain.Direct.Wallet/applyTxs ‑ only reduces the UTXO set when no address is ours
Hydra.Chain.Direct.Wallet/coverFee ‑ balances transaction with fees
Hydra.Chain.Direct.Wallet/coverFee ‑ prefers largest utxo
Hydra.Chain.Direct.Wallet/coverFee ‑ sets min utxo values
Hydra.Chain.Direct.Wallet/genTxsSpending / genUTxO ‑ are well-suited for testing
Hydra.Chain.Direct.Wallet/newTinyWallet ‑ initialises wallet by querying UTxO
Hydra.Chain.Direct.Wallet/newTinyWallet ‑ re-queries UTxO from the tip, even on reset
Hydra.ContestationPeriod/fromNominalDiffTime ‑ fails for diff times <= 0
Hydra.ContestationPeriod/fromNominalDiffTime ‑ rounds to 1 second
Hydra.ContestationPeriod/fromNominalDiffTime ‑ works for diff times > 0
Hydra.Crypto/MultiSignature ‑ aggregate/verifyMultiSignature roundtrip
Hydra.Crypto/MultiSignature ‑ aggregateInOrder/verifyMultiSignature roundtrip
Hydra.Crypto/MultiSignature ‑ does not validate multisig if less keys given
Hydra.Crypto/MultiSignature ‑ is sensitive to order
Hydra.Crypto/MultiSignature ‑ verifyMultiSignature fails when signature is missing
Hydra.Crypto/Signature ‑ can sign arbitrary messages
Hydra.Crypto/Signature ‑ show includes escaped hex
Hydra.Crypto/Signature ‑ sign/verify roundtrip
Hydra.Crypto/SigningKey ‑ arbitrary @(SigningKey HydraKey) is reasonably collision resistant
Hydra.Crypto/SigningKey ‑ can be generated
Hydra.Crypto/SigningKey ‑ can be generated when seed exceeds the max seed size for algorithm
Hydra.Crypto/SigningKey ‑ show includes escaped hex
Hydra.Crypto/VerificationKey ‑ show includes escaped hex
Hydra.Crypto/VerificationKey/JSON encoding of (VerificationKey HydraKey) ‑ allows to encode values with aeson and read them back
Hydra.Crypto/VerificationKey/JSON encoding of (VerificationKey HydraKey) ‑ produces the same JSON as is found in golden/VerificationKey HydraKey.json
Hydra.Data.ContestationPeriod/to/from NominalDiffTime ‑ is isomorphic to NominalDiffTime
Hydra.Events.FileBased/eventPairFromPersistenceIncremental ‑ can bootstrap from plain StateChanged events
Hydra.Events.FileBased/eventPairFromPersistenceIncremental ‑ can handle continuous events
Hydra.Events.FileBased/eventPairFromPersistenceIncremental ‑ can handle duplicate events
Hydra.Events.FileBased/eventPairFromPersistenceIncremental ‑ can handle non-continuous events
Hydra.Events.FileBased/persisted event format/JSON encoding of (StateEvent (Tx ConwayEra)) ‑ allows to encode values with aeson and read them back
Hydra.Events.FileBased/persisted event format/JSON encoding of (StateEvent (Tx ConwayEra)) ‑ produces the same JSON as is found in golden/StateEvent (Tx ConwayEra).json
Hydra.Events.FileBased/persisted event format/JSON encoding of StateChanged ‑ allows to encode values with aeson and read them back
Hydra.Events.FileBased/persisted event format/JSON encoding of StateChanged ‑ produces the same JSON as is found in golden/StateChanged/ChainRolledBack.json
Hydra.Events.FileBased/persisted event format/JSON encoding of StateChanged ‑ produces the same JSON as is found in golden/StateChanged/CommittedUTxO.json
Hydra.Events.FileBased/persisted event format/JSON encoding of StateChanged ‑ produces the same JSON as is found in golden/StateChanged/DecommitFinalized.json
Hydra.Events.FileBased/persisted event format/JSON encoding of StateChanged ‑ produces the same JSON as is found in golden/StateChanged/DecommitRecorded.json
Hydra.Events.FileBased/persisted event format/JSON encoding of StateChanged ‑ produces the same JSON as is found in golden/StateChanged/HeadAborted.json
Hydra.Events.FileBased/persisted event format/JSON encoding of StateChanged ‑ produces the same JSON as is found in golden/StateChanged/HeadClosed.json
Hydra.Events.FileBased/persisted event format/JSON encoding of StateChanged ‑ produces the same JSON as is found in golden/StateChanged/HeadContested.json
Hydra.Events.FileBased/persisted event format/JSON encoding of StateChanged ‑ produces the same JSON as is found in golden/StateChanged/HeadFannedOut.json
Hydra.Events.FileBased/persisted event format/JSON encoding of StateChanged ‑ produces the same JSON as is found in golden/StateChanged/HeadInitialized.json
Hydra.Events.FileBased/persisted event format/JSON encoding of StateChanged ‑ produces the same JSON as is found in golden/StateChanged/HeadIsReadyToFanout.json
Hydra.Events.FileBased/persisted event format/JSON encoding of StateChanged ‑ produces the same JSON as is found in golden/StateChanged/HeadOpened.json
Hydra.Events.FileBased/persisted event format/JSON encoding of StateChanged ‑ produces the same JSON as is found in golden/StateChanged/PartySignedSnapshot.json
Hydra.Events.FileBased/persisted event format/JSON encoding of StateChanged ‑ produces the same JSON as is found in golden/StateChanged/SnapshotConfirmed.json
Hydra.Events.FileBased/persisted event format/JSON encoding of StateChanged ‑ produces the same JSON as is found in golden/StateChanged/SnapshotRequestDecided.json
Hydra.Events.FileBased/persisted event format/JSON encoding of StateChanged ‑ produces the same JSON as is found in golden/StateChanged/SnapshotRequested.json
Hydra.Events.FileBased/persisted event format/JSON encoding of StateChanged ‑ produces the same JSON as is found in golden/StateChanged/TickObserved.json
Hydra.Events.FileBased/persisted event format/JSON encoding of StateChanged ‑ produces the same JSON as is found in golden/StateChanged/TransactionAppliedToLocalUTxO.json
Hydra.Events.FileBased/persisted event format/JSON encoding of StateChanged ‑ produces the same JSON as is found in golden/StateChanged/TransactionReceived.json
Hydra.FireForget ‑ client can send 'Hail Hydra!' to server
Hydra.HeadLogic ‑ empty inputs in decommit tx are prevented
Hydra.HeadLogic/Coordinated Head Protocol using real Tx ‑ any tx with expiring upper validity range gets pruned
Hydra.HeadLogic/Coordinated Head Protocol ‑ acks signed snapshot from the constant leader
Hydra.HeadLogic/Coordinated Head Protocol ‑ cannot observe abort after collect com
Hydra.HeadLogic/Coordinated Head Protocol ‑ cannot observe collect com after abort
Hydra.HeadLogic/Coordinated Head Protocol ‑ confirms snapshot given it receives AckSn from all parties
Hydra.HeadLogic/Coordinated Head Protocol ‑ connectivity messages passthrough without affecting the current state
Hydra.HeadLogic/Coordinated Head Protocol ‑ contests when detecting close with old snapshot
Hydra.HeadLogic/Coordinated Head Protocol ‑ does not ack snapshots from non-leaders
Hydra.HeadLogic/Coordinated Head Protocol ‑ everyone does collect on last commit after collect com
Hydra.HeadLogic/Coordinated Head Protocol ‑ ignores abortTx of another head
Hydra.HeadLogic/Coordinated Head Protocol ‑ ignores closeTx of another head
Hydra.HeadLogic/Coordinated Head Protocol ‑ ignores collectComTx of another head
Hydra.HeadLogic/Coordinated Head Protocol ‑ ignores contestTx of another head
Hydra.HeadLogic/Coordinated Head Protocol ‑ ignores decrementTx of another head
Hydra.HeadLogic/Coordinated Head Protocol ‑ ignores fanoutTx of another head
Hydra.HeadLogic/Coordinated Head Protocol ‑ ignores in-flight ReqDec when closed
Hydra.HeadLogic/Coordinated Head Protocol ‑ ignores in-flight ReqTx when closed
Hydra.HeadLogic/Coordinated Head Protocol ‑ ignores unrelated initTx
Hydra.HeadLogic/Coordinated Head Protocol ‑ notifies user on head closing and when passing the contestation deadline
Hydra.HeadLogic/Coordinated Head Protocol ‑ re-contests when detecting contest with old snapshot
Hydra.HeadLogic/Coordinated Head Protocol ‑ rejects if we receive a too far future snapshot
Hydra.HeadLogic/Coordinated Head Protocol ‑ rejects invalid snapshots version
Hydra.HeadLogic/Coordinated Head Protocol ‑ rejects last AckSn if already received signature from this party
Hydra.HeadLogic/Coordinated Head Protocol ‑ rejects last AckSn if one signature was from a completely different message
Hydra.HeadLogic/Coordinated Head Protocol ‑ rejects last AckSn if one signature was from a different key
Hydra.HeadLogic/Coordinated Head Protocol ‑ rejects last AckSn if one signature was from a different snapshot
Hydra.HeadLogic/Coordinated Head Protocol ‑ rejects overlapping snapshot requests from the leader
Hydra.HeadLogic/Coordinated Head Protocol ‑ rejects same version snapshot requests with differring decommit txs
Hydra.HeadLogic/Coordinated Head Protocol ‑ rejects snapshot request with transaction not applicable to previous snapshot
Hydra.HeadLogic/Coordinated Head Protocol ‑ rejects too-new snapshots from the leader
Hydra.HeadLogic/Coordinated Head Protocol ‑ rejects too-old snapshots
Hydra.HeadLogic/Coordinated Head Protocol ‑ rejects too-old snapshots when collecting signatures
Hydra.HeadLogic/Coordinated Head Protocol ‑ reports if a requested tx is expired
Hydra.HeadLogic/Coordinated Head Protocol ‑ waits if a requested tx is not (yet) applicable
Hydra.HeadLogic/Coordinated Head Protocol ‑ waits if we receive a future snapshot while collecting signatures
Hydra.HeadLogic/Coordinated Head Protocol ‑ waits if we receive a snapshot with unseen transactions
Hydra.HeadLogic/Coordinated Head Protocol ‑ waits if we receive an AckSn for an unseen snapshot
Hydra.HeadLogic/Coordinated Head Protocol/Decommit ‑ emits ReqSn on valid RecDec
Hydra.HeadLogic/Coordinated Head Protocol/Decommit ‑ ignores ReqDec when not in Open state
Hydra.HeadLogic/Coordinated Head Protocol/Decommit ‑ observes DecommitRequested and ReqDec in an Open state
Hydra.HeadLogic/Coordinated Head Protocol/Decommit ‑ reports if a requested decommit tx is expired
Hydra.HeadLogic/Coordinated Head Protocol/Decommit ‑ updates decommitTx on valid ReqDec
Hydra.HeadLogic/Coordinated Head Protocol/Decommit ‑ wait for second decommit when another one is in flight
Hydra.HeadLogic/Coordinated Head Protocol/Decommit ‑ waits if a requested decommit tx is not (yet) applicable
Hydra.HeadLogic/Coordinated Head Protocol/ReqSn ‑ prunes local txs in order
Hydra.HeadLogic/Coordinated Head Protocol/Tracks Transaction Ids ‑ keeps transactions in allTxs given it receives a ReqTx
Hydra.HeadLogic/Coordinated Head Protocol/Tracks Transaction Ids ‑ removes transactions from allTxs when included in a acked snapshot even when emitting a ReqSn
Hydra.HeadLogic/Coordinated Head Protocol/Tracks Transaction Ids ‑ removes transactions in allTxs given it receives a ReqSn
Hydra.HeadLogicSnapshot/Generic Snapshot property ‑ there's always a leader for every snapshot number
Hydra.HeadLogicSnapshot/On AckSn ‑ does NOT send ReqSn when we are NOT the leader but there are seen transactions
Hydra.HeadLogicSnapshot/On AckSn ‑ does NOT send ReqSn when we are the leader but there are NO seen transactions
Hydra.HeadLogicSnapshot/On AckSn ‑ sends ReqSn  when leader and there are seen transactions
Hydra.HeadLogicSnapshot/On AckSn ‑ updates seenSnapshot state when sending ReqSn
Hydra.HeadLogicSnapshot/On ReqTx ‑ always emit ReqSn given head has 1 member
Hydra.HeadLogicSnapshot/On ReqTx ‑ does NOT send ReqSn when we are NOT the leader even if no snapshot in flight
Hydra.HeadLogicSnapshot/On ReqTx ‑ does NOT send ReqSn when we are the leader but snapshot in flight
Hydra.HeadLogicSnapshot/On ReqTx ‑ sends ReqSn when leader and no snapshot in flight
Hydra.HeadLogicSnapshot/On ReqTx ‑ updates seenSnapshot state when sending ReqSn
Hydra.JSONSchema/prop_validateJSONSchema ‑ works with api.yaml and UTCTime
Hydra.JSONSchema/validateJSON withJsonSpecifications ‑ fails on non-existing schema file
Hydra.JSONSchema/validateJSON withJsonSpecifications ‑ fails with missing tool
Hydra.JSONSchema/validateJSON withJsonSpecifications ‑ produces helpful errors
Hydra.JSONSchema/validateJSON withJsonSpecifications ‑ resolves refs
Hydra.JSONSchema/validateJSON withJsonSpecifications ‑ selects a sub-schema correctly
Hydra.JSONSchema/validateJSON withJsonSpecifications ‑ works using identity selector and Null input
Hydra.Ledger.Cardano.Time ‑ roundtrip slotNoToUTCTime and slotNoFromUTCTime
Hydra.Ledger.Cardano.Time ‑ slotNoFromUTCTime works for any time
Hydra.Ledger.Cardano/Generators ‑ arbitrary @(Hash PaymentKey) is reasonably collision resistant
Hydra.Ledger.Cardano/Generators ‑ arbitrary @(VerificationKey PaymentKey) is reasonably collision resistant
Hydra.Ledger.Cardano/Generators ‑ arbitrary @TxId is reasonably collision resistant
Hydra.Ledger.Cardano/Generators ‑ arbitrary @TxIn is reasonably collision resistant
Hydra.Ledger.Cardano/Generators ‑ genOneUTxOFor is reasonably collision resistant
Hydra.Ledger.Cardano/Generators ‑ genUTxOAdaOnlyOfSize does not generate collapsing values
Hydra.Ledger.Cardano/Generators ‑ genUTxOAlonzo does not generate collapsing values
Hydra.Ledger.Cardano/Generators ‑ genUTxOFor is reasonably collision resistant
Hydra.Ledger.Cardano/Generators/genChainPoint ‑ generates only some genesis points
Hydra.Ledger.Cardano/Generators/genOutput ‑ has enough lovelace to cover assets
Hydra.Ledger.Cardano/Generators/genTxOut ‑ does generate good values
Hydra.Ledger.Cardano/Generators/genValue ‑ produces realistic values
Hydra.Ledger.Cardano/JSON encoding of AssetName ‑ allows to encode values with aeson and read them back
Hydra.Ledger.Cardano/JSON encoding of AssetName ‑ produces the same JSON as is found in golden/AssetName.json
Hydra.Ledger.Cardano/PParams ‑ Roundtrip JSON encoding
Hydra.Ledger.Cardano/Tx ‑ JSON encoding of Tx according to schema
Hydra.Ledger.Cardano/UTxO ‑ JSON encoding of UTxO according to schema
Hydra.Ledger.Cardano/UTxO ‑ parses a specific UTxO
Hydra.Ledger.Cardano/applyTransactions ‑ works with valid transaction
Hydra.Ledger.Cardano/applyTransactions ‑ works with valid transaction deserialised from JSON
Hydra.Ledger.Simple ‑ validates only correctly built transactions
Hydra.Logging ‑ Schema covers all defined log entries
Hydra.Logging ‑ Validates logs.yaml schema
Hydra.Logging ‑ dumps logs to stdout in JSON with timestamp
Hydra.Logging.Monitoring ‑ provides prometheus metrics from traces
Hydra.Model ‑ check conflict-free liveness
Hydra.Model ‑ check head opens if all participants commit
Hydra.Model ‑ fanout contains whole confirmed UTxO
Hydra.Model ‑ implementation respects model
Hydra.Model ‑ model generates consistent traces
Hydra.Model ‑ model should not generate 0 Ada UTxO
Hydra.Model ‑ parties contest to wrong closed snapshot
Hydra.Model ‑ toRealUTxO is distributive
Hydra.Model ‑ toTxOuts is distributive
Hydra.Model.MockChain ‑ works with valid transaction
Hydra.Network.Authenticate ‑ authenticate the message to broadcast
Hydra.Network.Authenticate ‑ drop message coming from party with wrong signature
Hydra.Network.Authenticate ‑ drop message coming from unknown party
Hydra.Network.Authenticate ‑ logs dropped messages
Hydra.Network.Authenticate ‑ pass the authenticated messages around
Hydra.Network.Authenticate/Serialization ‑ can roundtrip CBOR encoding/decoding of Signed Hydra Message
Hydra.Network.Authenticate/Serialization/JSON encoding of AuthLog ‑ allows to encode values with aeson and read them back
Hydra.Network.Authenticate/Serialization/JSON encoding of AuthLog ‑ produces the same JSON as is found in golden/AuthLog.json
Hydra.Network.Heartbeat ‑ do not send Connected on subsequent messages from already Connected party
Hydra.Network.Heartbeat ‑ restart sending heartbeat messages given last message sent is older than heartbeat delay
Hydra.Network.Heartbeat ‑ sends Connected when Ping received from other peer
Hydra.Network.Heartbeat ‑ sends Connected when any message received from other party
Hydra.Network.Heartbeat ‑ sends Disconnected given no messages has been received from known party within twice heartbeat delay
Hydra.Network.Heartbeat ‑ sends a heartbeat message with local host after 500 ms
Hydra.Network.Heartbeat ‑ stop sending heartbeat message given action sends a message
Hydra.Network.Reliability/receiving messages ‑ Ignores messages with malformed acks
Hydra.Network.Reliability/receiving messages ‑ do not drop messages with same ids from different peers
Hydra.Network.Reliability/receiving messages ‑ drops already received messages
Hydra.Network.Reliability/receiving messages ‑ forward received messages
Hydra.Network.Reliability/sending messages ‑ appends messages to disk and can load them back
Hydra.Network.Reliability/sending messages ‑ broadcast messages to the network assigning a sequential id
Hydra.Network.Reliability/sending messages ‑ broadcast updates counter from peers
Hydra.Network.Reliability/sending messages ‑ stress test networking layer
Hydra.Network/Ouroboros Network ‑ broadcasts messages between 3 connected peers
Hydra.Network/Ouroboros Network ‑ broadcasts messages to single connected peer
Hydra.Network/Ouroboros Network ‑ handshake failures should call the handshakeCallback
Hydra.Network/Serialisation ‑ can roundtrip CBOR encoding/decoding of Hydra Message
Hydra.Network/Serialisation/JSON encoding of (Message SimpleTx) ‑ allows to encode values with aeson and read them back
Hydra.Network/Serialisation/JSON encoding of (Message SimpleTx) ‑ produces the same JSON as is found in golden/Message SimpleTx.json
Hydra.Network/configureMessagePersistence ‑ throws ParameterMismatch when configuring given number of acks does not match number of parties
Hydra.Node.InputQueue ‑ adds sequential id to all enqueued items
Hydra.Node.Run ‑ throws exception given options are invalid
Hydra.Node/checkHeadState ‑ accepts configuration consistent with HeadState
Hydra.Node/checkHeadState ‑ log error given configuration mismatches head state
Hydra.Node/checkHeadState ‑ throws exception given contestation period differs
Hydra.Node/checkHeadState ‑ throws exception given parties differ
Hydra.Node/hydrate ‑ checks head state
Hydra.Node/hydrate ‑ event ids are consistent
Hydra.Node/hydrate ‑ fails if one sink fails
Hydra.Node/hydrate ‑ loads events from source into all sinks
Hydra.Node/stepHydraNode ‑ can continue after re-hydration
Hydra.Node/stepHydraNode ‑ emits a single ReqSn as leader, even after multiple ReqTxs
Hydra.Node/stepHydraNode ‑ event ids are strictly monotonic
Hydra.Node/stepHydraNode ‑ events are sent to all sinks
Hydra.Node/stepHydraNode ‑ notifies client when postTx throws PostTxError
Hydra.Node/stepHydraNode ‑ processes out-of-order AckSn
Hydra.Node/stepHydraNode ‑ rotates snapshot leaders
Hydra.Node/stepHydraNode ‑ signs snapshot even if it has seen conflicting transactions
Hydra.Options/Hydra Node RunOptions ‑ does parse --peer given ipv6 addresses
Hydra.Options/Hydra Node RunOptions ‑ flag --version returns version with base version from cabal
Hydra.Options/Hydra Node RunOptions ‑ parses --cardano-signing-key option as a filepath
Hydra.Options/Hydra Node RunOptions ‑ parses --cardano-verification-key option as a filepath
Hydra.Options/Hydra Node RunOptions ‑ parses --contestation-period option as a number of seconds
Hydra.Options/Hydra Node RunOptions ‑ parses --host option given valid IPv4 and IPv6 addresses
Hydra.Options/Hydra Node RunOptions ‑ parses --hydra-scripts-tx-id as a tx id
Hydra.Options/Hydra Node RunOptions ‑ parses --hydra-signing-key option as a filepath
Hydra.Options/Hydra Node RunOptions ‑ parses --hydra-verification-key option as a filepath
Hydra.Options/Hydra Node RunOptions ‑ parses --ledger-protocol-parameters-file as a filepath
Hydra.Options/Hydra Node RunOptions ‑ parses --mainnet flag
Hydra.Options/Hydra Node RunOptions ‑ parses --mainnet option
Hydra.Options/Hydra Node RunOptions ‑ parses --monitoring-port option given valid port number
Hydra.Options/Hydra Node RunOptions ‑ parses --node-socket as a filepath
Hydra.Options/Hydra Node RunOptions ‑ parses --peer `<host>:<port>` option
Hydra.Options/Hydra Node RunOptions ‑ parses --port option given valid port number
Hydra.Options/Hydra Node RunOptions ‑ parses --start-chain-from 0 as starting from genesis
Hydra.Options/Hydra Node RunOptions ‑ parses --start-chain-from as a pair of slot number and block header hash
Hydra.Options/Hydra Node RunOptions ‑ parses --testnet-magic option as a number
Hydra.Options/Hydra Node RunOptions ‑ parses with default values
Hydra.Options/Hydra Node RunOptions ‑ roundtrip parsing & printing
Hydra.Options/Hydra Node RunOptions ‑ switches to offline chain when using --initial-utxo
Hydra.Options/Hydra Node RunOptions ‑ validateRunOptions: loaded cardano keys needs to match with the hydra keys length
Hydra.Options/Hydra Node RunOptions ‑ validateRunOptions: using more than 5 parties should error out
Hydra.Options/Hydra Node RunOptions/JSON encoding of RunOptions ‑ allows to encode values with aeson and read them back
Hydra.Options/Hydra Node RunOptions/JSON encoding of RunOptions ‑ produces the same JSON as is found in golden/RunOptions.json
Hydra.Options/Hydra Node RunOptions/gen-hydra-keys sub-command ‑ should be able to parse gen-hydra-keys sub-command
Hydra.Options/Hydra Node RunOptions/gen-hydra-keys sub-command ‑ should parse gen-hydra-keys without the output-file flag using default file name
Hydra.Options/Hydra Node RunOptions/offline sub-command ‑ does parse --initial-utxo
Hydra.Options/Hydra Node RunOptions/offline sub-command ‑ does parse --ledger-genesis
Hydra.Options/Hydra Node RunOptions/offline sub-command ‑ does parse with defaults
Hydra.Options/Hydra Node RunOptions/publish-scripts sub-command ‑ does not parse with some missing option (1)
Hydra.Options/Hydra Node RunOptions/publish-scripts sub-command ‑ does not parse with some missing option (2)
Hydra.Options/Hydra Node RunOptions/publish-scripts sub-command ‑ does not parse with some missing option (3)
Hydra.Options/Hydra Node RunOptions/publish-scripts sub-command ‑ does not parse without any options
Hydra.Options/Hydra Node RunOptions/publish-scripts sub-command ‑ should parse using mainnet and all options
Hydra.Options/Hydra Node RunOptions/publish-scripts sub-command ‑ should parse using testnet and all options
Hydra.Party ‑ has alice, bob, carol sorted
Hydra.Party ‑ implements Eq and Ord correspondingly
Hydra.Party/JSON encoding of Party ‑ allows to encode values with aeson and read them back
Hydra.Party/JSON encoding of Party ‑ produces the same JSON as is found in golden/Party.json
Hydra.Party/Ord ‑ is antisymmetric
Hydra.Party/Ord ‑ is reflexive
Hydra.Party/Ord ‑ is transitive
Hydra.Persistence/Persistence ‑ can handle empty files
Hydra.Persistence/Persistence ‑ is consistent after save/load roundtrip
Hydra.Persistence/PersistenceIncremental ‑ can handle empty files
Hydra.Persistence/PersistenceIncremental ‑ is consistent after multiple append calls in presence of new-lines
Hydra.Persistence/PersistenceIncremental ‑ it cannot load from a different thread once having started appending
Hydra.Plutus.Golden ‑ Commit validator script
Hydra.Plutus.Golden ‑ Deposit validator script
Hydra.Plutus.Golden ‑ Head minting policy script
Hydra.Plutus.Golden ‑ Head validator script
Hydra.Plutus.Golden ‑ Initial validator script
Hydra.Tx.Contract.Contract/Abort ‑ does not survive random adversarial mutations
Hydra.Tx.Contract.Contract/Abort ‑ is healthy
Hydra.Tx.Contract.Contract/CloseInitial ‑ does not survive random adversarial mutations
Hydra.Tx.Contract.Contract/CloseInitial ‑ is healthy
Hydra.Tx.Contract.Contract/CloseUnused ‑ does not survive random adversarial mutations
Hydra.Tx.Contract.Contract/CloseUnused ‑ is healthy
Hydra.Tx.Contract.Contract/CloseUsed ‑ does not survive random adversarial mutations
Hydra.Tx.Contract.Contract/CloseUsed ‑ is healthy
Hydra.Tx.Contract.Contract/CollectCom ‑ does not survive random adversarial mutations
Hydra.Tx.Contract.Contract/CollectCom ‑ is healthy
Hydra.Tx.Contract.Contract/Commit ‑ does not survive random adversarial mutations
Hydra.Tx.Contract.Contract/Commit ‑ is healthy
Hydra.Tx.Contract.Contract/ContestCurrent ‑ does not survive random adversarial mutations
Hydra.Tx.Contract.Contract/ContestCurrent ‑ is healthy
Hydra.Tx.Contract.Contract/Decrement ‑ does not survive random adversarial mutations
Hydra.Tx.Contract.Contract/Decrement ‑ is healthy
Hydra.Tx.Contract.Contract/Deposit ‑ is healthy
Hydra.Tx.Contract.Contract/Fanout ‑ does not survive random adversarial mutations
Hydra.Tx.Contract.Contract/Fanout ‑ is healthy
Hydra.Tx.Contract.Contract/Init ‑ does not survive random adversarial mutations
Hydra.Tx.Contract.Contract/Init ‑ is healthy
Hydra.Tx.Contract.Contract/Recover ‑ does not survive random adversarial mutations
Hydra.Tx.Contract.Contract/Recover ‑ is healthy
Hydra.Tx.Contract.Contract/Serializing commits ‑ deserializeCommit . serializeCommit === id
Hydra.Tx.Contract.Contract/Signature validator ‑ verifies snapshot multi-signature
Hydra.Tx.Contract.Contract/TxOut hashing ‑ OnChain.hashPreSerializedCommits == OnChain.hashTxOuts (on sorted tx outs)
Hydra.Tx.Contract.Contract/TxOut hashing ‑ does care about ordering of TxOut
Hydra.Tx.Contract.Contract/TxOut hashing ‑ hashUTxO == OnChain.hashTxOuts (on sorted tx outs)
Hydra.Tx.IsTx/Tx ‑ CBOR decode Babbage era transactions
Hydra.Tx.IsTx/Tx ‑ JSON decode Babbage era transactions
Hydra.Tx.IsTx/Tx ‑ Roundtrip CBOR encoding
Hydra.Tx.IsTx/Tx ‑ Roundtrip to and from Ledger
Hydra.Tx.IsTx/Tx ‑ Same TxId as TxBody after JSON decoding
Hydra.Tx.IsTx/Tx ‑ Same TxId before/after JSON encoding
Hydra.Tx.IsTx/Tx/JSON encoding of (ReasonablySized (Tx ConwayEra)) ‑ allows to encode values with aeson and read them back
Hydra.Tx.IsTx/Tx/JSON encoding of (ReasonablySized (Tx ConwayEra)) ‑ produces the same JSON as is found in golden/ReasonablySized (Tx ConwayEra).json
Hydra.Tx.IsTx/UTxO ‑ Roundtrip to and from Api
Hydra.Tx.IsTx/UTxO/JSON encoding of (UTxO' (TxOut CtxUTxO ConwayEra)) ‑ allows to encode values with aeson and read them back
Hydra.Tx.IsTx/UTxO/JSON encoding of (UTxO' (TxOut CtxUTxO ConwayEra)) ‑ produces the same JSON as is found in golden/UTxO' (TxOut CtxUTxO ConwayEra).json
Hydra.Utils ‑ Should throw if it can't write on disk
Hydra.Utils ‑ Should throw if the file already exists
Plutus.Codec.CBOR.Encoding ‑ matches cborg library encoding
Plutus.MerkleTree ‑ can check membership of an element
Plutus.MerkleTree ‑ fromList . toList roundtrips MT
Plutus.MerkleTree ‑ tree is balanced
Test.CardanoClient ‑ queryGenesisParameters works as expected
Test.CardanoNode ‑ has expected cardano-node version available
Test.CardanoNode ‑ withCardanoNodeDevnet does start a block-producing devnet within 5 seconds
Test.CardanoNode ‑ withCardanoNodeOnKnownNetwork starts synchronizing within 10 seconds (Mainnet)
Test.CardanoNode ‑ withCardanoNodeOnKnownNetwork starts synchronizing within 10 seconds (Preproduction)
Test.CardanoNode ‑ withCardanoNodeOnKnownNetwork starts synchronizing within 10 seconds (Preview)
Test.CardanoNode ‑ withCardanoNodeOnKnownNetwork starts synchronizing within 10 seconds (Sanchonet)
Test.CardanoNode/findRunningCardanoNode ‑ returns Just running node on matching network
Test.CardanoNode/findRunningCardanoNode ‑ returns Nothing on non-matching network
Test.ChainObserver ‑ can observe hydra transactions created by hydra-nodes
Test.DirectChain ‑ can commit empty UTxO
Test.DirectChain ‑ can commit using external wallet
Test.DirectChain ‑ can commit using internal hydra-node wallet
Test.DirectChain ‑ can commit with multiple required signatures
Test.DirectChain ‑ can init and abort a 2-parties head after one party has committed
Test.DirectChain ‑ can init and abort a head given nothing has been committed
Test.DirectChain ‑ can only contest once
Test.DirectChain ‑ can open, close & fanout a Head
Test.DirectChain ‑ can publish and query reference scripts in a timely manner
Test.DirectChain ‑ can restart head to point in the past and replay on-chain events
Test.DirectChain ‑ cannot abort a non-participating head
Test.DirectChain ‑ cannot restart head to an unknown point
Test.EndToEnd ‑ End-to-end offline mode
Test.EndToEnd/End-to-end on Cardano devnet/Monitoring ‑ Node exposes Prometheus metrics on port 6001
Test.EndToEnd/End-to-end on Cardano devnet/hydra-node executable ‑ logs its command line arguments
Test.EndToEnd/End-to-end on Cardano devnet/hydra-node executable ‑ logs to a logfile
Test.EndToEnd/End-to-end on Cardano devnet/restarting nodes ‑ can abort head after restart
Test.EndToEnd/End-to-end on Cardano devnet/restarting nodes ‑ can observe a commit tx after a restart, even when a tx happened while down
Test.EndToEnd/End-to-end on Cardano devnet/restarting nodes ‑ can start chain from the past and replay on-chain events
Test.EndToEnd/End-to-end on Cardano devnet/restarting nodes ‑ close of an initial snapshot from re-initialized node is contested
Test.EndToEnd/End-to-end on Cardano devnet/restarting nodes ‑ prevent resuming a head after reconfiguring a peer
Test.EndToEnd/End-to-end on Cardano devnet/single party hydra head ‑ can close with long deadline
Test.EndToEnd/End-to-end on Cardano devnet/single party hydra head ‑ can decommit utxo
Test.EndToEnd/End-to-end on Cardano devnet/single party hydra head ‑ can submit a signed user transaction
Test.EndToEnd/End-to-end on Cardano devnet/single party hydra head ‑ can submit a timed tx
Test.EndToEnd/End-to-end on Cardano devnet/single party hydra head ‑ commits from external with tx blueprint
Test.EndToEnd/End-to-end on Cardano devnet/single party hydra head ‑ commits from external with utxo
Test.EndToEnd/End-to-end on Cardano devnet/single party hydra head ‑ full head life-cycle
Test.EndToEnd/End-to-end on Cardano devnet/three hydra nodes scenario ‑ does not error when all nodes open the head concurrently
Test.EndToEnd/End-to-end on Cardano devnet/three hydra nodes scenario ‑ inits a Head and closes it immediately
Test.EndToEnd/End-to-end on Cardano devnet/three hydra nodes scenario ‑ inits a Head, processes a single Cardano transaction and closes it again
Test.EndToEnd/End-to-end on Cardano devnet/two hydra heads scenario ‑ alice inits a Head with incorrect keys preventing bob from observing InitTx
Test.EndToEnd/End-to-end on Cardano devnet/two hydra heads scenario ‑ bob cannot abort alice's head
Test.EndToEnd/End-to-end on Cardano devnet/two hydra heads scenario ‑ two heads on the same network do not conflict
Test.Generator ‑ generates a Dataset that keeps UTXO constant
Test.Generator/JSON encoding of Dataset ‑ allows to encode values with aeson and read them back
Test.Hydra.Cluster.CardanoCli/cardano-cli ‑ cardano-cli can accept a draft commit tx in text-envelope format
Test.Hydra.Cluster.CardanoCli/cardano-cli ‑ has expected cardano-cli version available
Test.Hydra.Cluster.CardanoCli/cardano-cli ‑ query protocol-parameters is compatible with our FromJSON instance
Test.Hydra.Cluster.CardanoCli/cardano-cli ‑ query protocol-parameters matches our schema
Test.Hydra.Cluster.Faucet/returnFundsToFaucet ‑ does nothing if nothing to return
Test.Hydra.Cluster.Faucet/returnFundsToFaucet ‑ seedFromFaucet and returnFundsToFaucet should work together
Test.Hydra.Cluster.Faucet/seedFromFaucet ‑ should work concurrently when called multiple times with the same amount of lovelace
Test.Hydra.Cluster.Mithril/downloadLatestSnapshotTo ‑ invokes mithril-client correctly (Mainnet)
Test.Hydra.Cluster.Mithril/downloadLatestSnapshotTo ‑ invokes mithril-client correctly (Preproduction)
Test.Hydra.Cluster.Mithril/downloadLatestSnapshotTo ‑ invokes mithril-client correctly (Preview)
Test.Hydra.Cluster.Mithril/downloadLatestSnapshotTo ‑ invokes mithril-client correctly (Sanchonet)
Test.HydraExplorer ‑ can observe hydra transactions created by multiple hydra-nodes
Test.HydraExplorer ‑ can query for all hydra heads observed
Test.HydraExplorer ‑ can query for latest point in time observed on chain
Test.OfflineChain ‑ does derive head id from node id
Test.OfflineChain ‑ does not start on slot 0 with real genesis file
Test.OfflineChain ‑ does start on slot 0 with no genesis