Implement block-submitting Imp functions

[neilmayhew]

Description

Add functions to:

• submit a list of fixed-up transactions in a block
• capture submitted transactions in a "simulation" and then group them into a block and submit it

Checklist

• Commits in meaningful sequence and with useful messages.
• Tests added or updated when needed.
• CHANGELOG.md files updated for packages with externally visible changes.
  NOTE: New section is never added with the code changes. (See RELEASING.md).
• Versions updated in .cabal and CHANGELOG.md files when necessary, according to the
  versioning process.
• Version bounds in .cabal files updated when necessary.
  NOTE: If bounds change in a cabal file, that package itself must have a version increase. (See RELEASING.md).
• Code formatted (use scripts/fourmolize.sh).
• Cabal files formatted (use scripts/cabal-format.sh).
• CDDL files are up to date (use scripts/gen-cddl.sh)
• hie.yaml updated (use scripts/gen-hie.sh).
• Self-reviewed the diff.

[lehins]

I really do like the direction where this is going, however this PR does need some changes.
I'll be happy to talk more about all the suggestions that I made in this PR

[lehins]

This addition should get a mention in the changelog

[lehins]

Ditto. Adding chnagelog entry for NFData and Generic will be nice

[lehins]

I am not a big fan of sticking two totally unrelated concepts together into the same field named Events. In other words sequence of transactions has nothing to do with STS events, which is what this field was designed for.
FTR. we don't need to rely on the MonadWriter for this, in fact I'd rather avoid using it for recording transactions period. Writer was used for events, because that is also how it behaves in STS.

[neilmayhew]

Yes, separating it seems much better, and not having to use Writer is very freeing

[lehins]

Suggested change

	instance MonadWriter (Seq.Seq (Tx TopTx era), Seq.Seq (SomeSTSEvent era)) (ImpTestM era) where
	instance MonadWriter (Seq.Seq (SomeSTSEvent era)) (ImpTestM era) where

[lehins]

Please never use bool in the Ledger codebase. I understand the C developer in you is looking for ways to use ? like function 😁, but that function is seldom used in Haskell and tends to introduce bugs into the codebase, because not everyone remembers the order of which one is the True and which one is the False case.

This will be much more clear (combined with my other suggestions)

Suggested change

	txsToRecord <- bool mempty (Seq.singleton txFixed) <$> use impRecordTxsL
	modify' $ \impState ->
	case impRecordedTransactions impState of
	SNothing -> impState
	SJust txs -> impState {impRecordedTransactions = tx SSeq.:<| txs}

[lehins]

I think in order to have it consistent with trySubmitTx, this function should accept a list of transactions that have not been fixed up and this function itself will call the simulateThenRestore in order to do all the fixing up and then submission as a block.

If we don't do that then usability of these functions will be limited.

That being said, naturally we'll need a help like this that will be capable of submitting transactions that have already been fixed up and ready to go into a block, I just think it needs to have a special name that is distinct from trySubmitBlock. Maybe trySubmitFixedUpBlock 🤷

[neilmayhew]

Yes, this makes sense.

There are two Conway tests that I've updated to use these functions (in eras/conway/impl/testlib/Test/Cardano/Ledger/Conway/Imp/BbodySpec.hs). The first doesn't require running the simulation itself, but the second definitely does, because the transactions all depend on each other. Also, the tests I'm porting from AlonzoBBODY work that way too. I think we'll find that this style will be more common, but time will tell.

Also, I found that it was just more convenient to write test code as if the transactions are being submitted, so that they use the same patterns as the rest of our test code, and then harvest them afterwards (by wrapping the transaction-generating code inside withTxsInBlock) rather than having to save the transactions explicitly. The fact that they're submitted in a block is then abstracted away from the code that creates the transactions.

I'll make all the other improvements (such as splitting events and transactions, and using SMaybe) first and then see how trySubmitBlock looks. Also, I'll push my latest changes to my AlonzoBBODY PR so that we can see what that test code looks like.

[lehins]

I think this function et al. should modify the sequence of transactions.

Suggested change

-- The transactions are not modified to make them balance.

[lehins]

See my suggestion below

Suggested change

	pure (txIn, NE.fromList refIns)
	pure $ mkTxWithRefInputs txIn (NE.fromList refIns)

[lehins]

Suggested change

	allInputs <- for txScriptCounts $ \n -> do
	txs <- for txScriptCounts $ \n -> do

[lehins]

With my suggestion of making submitBlock et al. do the fixup, this becomes:

Suggested change

	let
	-- These txs will be grouped into a block
	buildTxs = for_ allInputs $ uncurry submitTxWithRefInputs
	withTxsInFailingBlock
	buildTxs
	[ injectFailure
	( BodyRefScriptsSizeTooBig $
	Mismatch
	{ mismatchSupplied = scriptSize * sum txScriptCounts
	, mismatchExpected = maxRefScriptSizePerBlock
	}
	)
	]
	submitFailingBlock
	txs
	[ injectFailure
	( BodyRefScriptsSizeTooBig $
	Mismatch
	{ mismatchSupplied = scriptSize * sum txScriptCounts
	, mismatchExpected = maxRefScriptSizePerBlock
	}
	)
	]