{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TupleSections #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# OPTIONS_GHC -Wno-orphans #-}

module Bench.Consensus.Mempool.TestBlock
  ( -- * Test block
    TestBlock

    -- * Initial parameters
  , initialLedgerState
  , sampleLedgerConfig

    -- * Transactions
  , Token (Token)
  , Tx (Tx)
  , mkTx
  , txSize
  ) where

import Cardano.Ledger.BaseTypes (knownNonZeroBounded)
import qualified Cardano.Slotting.Time as Time
import Codec.Serialise (Serialise (..))
import Control.DeepSeq (NFData)
import Control.Monad.Trans.Except (except)
import qualified Data.Map.Strict as Map
import Data.MemPack
import Data.Set (Set)
import qualified Data.Set as Set
import Data.TreeDiff (ToExpr)
import GHC.Generics (Generic)
import NoThunks.Class (NoThunks)
import qualified Ouroboros.Consensus.Block as Block
import Ouroboros.Consensus.Config.SecurityParam as Consensus
import qualified Ouroboros.Consensus.HardFork.History as HardFork
import qualified Ouroboros.Consensus.Ledger.Basics as Ledger
import qualified Ouroboros.Consensus.Ledger.SupportsMempool as Ledger
import Ouroboros.Consensus.Ledger.Tables
import qualified Ouroboros.Consensus.Ledger.Tables.Diff as Diff
import qualified Ouroboros.Consensus.Ledger.Tables.Utils as Ledger
import Ouroboros.Consensus.Util.IndexedMemPack (IndexedMemPack (..))
import Test.Util.TestBlock hiding (TestBlock)

{-------------------------------------------------------------------------------
  MempoolTestBlock
-------------------------------------------------------------------------------}

type TestBlock = TestBlockWith Tx

data Tx = Tx
  { Tx -> Set Token
consumed :: !(Set Token)
  , Tx -> Set Token
produced :: !(Set Token)
  }
  deriving stock (Tx -> Tx -> Bool
(Tx -> Tx -> Bool) -> (Tx -> Tx -> Bool) -> Eq Tx
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Tx -> Tx -> Bool
== :: Tx -> Tx -> Bool
$c/= :: Tx -> Tx -> Bool
/= :: Tx -> Tx -> Bool
Eq, Eq Tx
Eq Tx =>
(Tx -> Tx -> Ordering)
-> (Tx -> Tx -> Bool)
-> (Tx -> Tx -> Bool)
-> (Tx -> Tx -> Bool)
-> (Tx -> Tx -> Bool)
-> (Tx -> Tx -> Tx)
-> (Tx -> Tx -> Tx)
-> Ord Tx
Tx -> Tx -> Bool
Tx -> Tx -> Ordering
Tx -> Tx -> Tx
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Tx -> Tx -> Ordering
compare :: Tx -> Tx -> Ordering
$c< :: Tx -> Tx -> Bool
< :: Tx -> Tx -> Bool
$c<= :: Tx -> Tx -> Bool
<= :: Tx -> Tx -> Bool
$c> :: Tx -> Tx -> Bool
> :: Tx -> Tx -> Bool
$c>= :: Tx -> Tx -> Bool
>= :: Tx -> Tx -> Bool
$cmax :: Tx -> Tx -> Tx
max :: Tx -> Tx -> Tx
$cmin :: Tx -> Tx -> Tx
min :: Tx -> Tx -> Tx
Ord, (forall x. Tx -> Rep Tx x)
-> (forall x. Rep Tx x -> Tx) -> Generic Tx
forall x. Rep Tx x -> Tx
forall x. Tx -> Rep Tx x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Tx -> Rep Tx x
from :: forall x. Tx -> Rep Tx x
$cto :: forall x. Rep Tx x -> Tx
to :: forall x. Rep Tx x -> Tx
Generic, Int -> Tx -> ShowS
[Tx] -> ShowS
Tx -> String
(Int -> Tx -> ShowS)
-> (Tx -> String) -> ([Tx] -> ShowS) -> Show Tx
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Tx -> ShowS
showsPrec :: Int -> Tx -> ShowS
$cshow :: Tx -> String
show :: Tx -> String
$cshowList :: [Tx] -> ShowS
showList :: [Tx] -> ShowS
Show)
  deriving anyclass (Context -> Tx -> IO (Maybe ThunkInfo)
Proxy Tx -> String
(Context -> Tx -> IO (Maybe ThunkInfo))
-> (Context -> Tx -> IO (Maybe ThunkInfo))
-> (Proxy Tx -> String)
-> NoThunks Tx
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> Tx -> IO (Maybe ThunkInfo)
noThunks :: Context -> Tx -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> Tx -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> Tx -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy Tx -> String
showTypeOf :: Proxy Tx -> String
NoThunks, Tx -> ()
(Tx -> ()) -> NFData Tx
forall a. (a -> ()) -> NFData a
$crnf :: Tx -> ()
rnf :: Tx -> ()
NFData)

newtype Token = Token {Token -> Int
unToken :: Int}
  deriving stock (Int -> Token -> ShowS
[Token] -> ShowS
Token -> String
(Int -> Token -> ShowS)
-> (Token -> String) -> ([Token] -> ShowS) -> Show Token
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Token -> ShowS
showsPrec :: Int -> Token -> ShowS
$cshow :: Token -> String
show :: Token -> String
$cshowList :: [Token] -> ShowS
showList :: [Token] -> ShowS
Show, Token -> Token -> Bool
(Token -> Token -> Bool) -> (Token -> Token -> Bool) -> Eq Token
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Token -> Token -> Bool
== :: Token -> Token -> Bool
$c/= :: Token -> Token -> Bool
/= :: Token -> Token -> Bool
Eq, Eq Token
Eq Token =>
(Token -> Token -> Ordering)
-> (Token -> Token -> Bool)
-> (Token -> Token -> Bool)
-> (Token -> Token -> Bool)
-> (Token -> Token -> Bool)
-> (Token -> Token -> Token)
-> (Token -> Token -> Token)
-> Ord Token
Token -> Token -> Bool
Token -> Token -> Ordering
Token -> Token -> Token
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Token -> Token -> Ordering
compare :: Token -> Token -> Ordering
$c< :: Token -> Token -> Bool
< :: Token -> Token -> Bool
$c<= :: Token -> Token -> Bool
<= :: Token -> Token -> Bool
$c> :: Token -> Token -> Bool
> :: Token -> Token -> Bool
$c>= :: Token -> Token -> Bool
>= :: Token -> Token -> Bool
$cmax :: Token -> Token -> Token
max :: Token -> Token -> Token
$cmin :: Token -> Token -> Token
min :: Token -> Token -> Token
Ord, (forall x. Token -> Rep Token x)
-> (forall x. Rep Token x -> Token) -> Generic Token
forall x. Rep Token x -> Token
forall x. Token -> Rep Token x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Token -> Rep Token x
from :: forall x. Token -> Rep Token x
$cto :: forall x. Rep Token x -> Token
to :: forall x. Rep Token x -> Token
Generic)
  deriving newtype (String
String
-> (Token -> Int)
-> (forall s. Token -> Pack s ())
-> (forall b. Buffer b => Unpack b Token)
-> MemPack Token
Token -> Int
forall a.
String
-> (a -> Int)
-> (forall s. a -> Pack s ())
-> (forall b. Buffer b => Unpack b a)
-> MemPack a
forall b. Buffer b => Unpack b Token
forall s. Token -> Pack s ()
$ctypeName :: String
typeName :: String
$cpackedByteCount :: Token -> Int
packedByteCount :: Token -> Int
$cpackM :: forall s. Token -> Pack s ()
packM :: forall s. Token -> Pack s ()
$cunpackM :: forall b. Buffer b => Unpack b Token
unpackM :: forall b. Buffer b => Unpack b Token
MemPack, Integer -> Token
Token -> Token
Token -> Token -> Token
(Token -> Token -> Token)
-> (Token -> Token -> Token)
-> (Token -> Token -> Token)
-> (Token -> Token)
-> (Token -> Token)
-> (Token -> Token)
-> (Integer -> Token)
-> Num Token
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: Token -> Token -> Token
+ :: Token -> Token -> Token
$c- :: Token -> Token -> Token
- :: Token -> Token -> Token
$c* :: Token -> Token -> Token
* :: Token -> Token -> Token
$cnegate :: Token -> Token
negate :: Token -> Token
$cabs :: Token -> Token
abs :: Token -> Token
$csignum :: Token -> Token
signum :: Token -> Token
$cfromInteger :: Integer -> Token
fromInteger :: Integer -> Token
Num, Int -> Token
Token -> Int
Token -> [Token]
Token -> Token
Token -> Token -> [Token]
Token -> Token -> Token -> [Token]
(Token -> Token)
-> (Token -> Token)
-> (Int -> Token)
-> (Token -> Int)
-> (Token -> [Token])
-> (Token -> Token -> [Token])
-> (Token -> Token -> [Token])
-> (Token -> Token -> Token -> [Token])
-> Enum Token
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Token -> Token
succ :: Token -> Token
$cpred :: Token -> Token
pred :: Token -> Token
$ctoEnum :: Int -> Token
toEnum :: Int -> Token
$cfromEnum :: Token -> Int
fromEnum :: Token -> Int
$cenumFrom :: Token -> [Token]
enumFrom :: Token -> [Token]
$cenumFromThen :: Token -> Token -> [Token]
enumFromThen :: Token -> Token -> [Token]
$cenumFromTo :: Token -> Token -> [Token]
enumFromTo :: Token -> Token -> [Token]
$cenumFromThenTo :: Token -> Token -> Token -> [Token]
enumFromThenTo :: Token -> Token -> Token -> [Token]
Enum)
  deriving anyclass (Context -> Token -> IO (Maybe ThunkInfo)
Proxy Token -> String
(Context -> Token -> IO (Maybe ThunkInfo))
-> (Context -> Token -> IO (Maybe ThunkInfo))
-> (Proxy Token -> String)
-> NoThunks Token
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> Token -> IO (Maybe ThunkInfo)
noThunks :: Context -> Token -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> Token -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> Token -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy Token -> String
showTypeOf :: Proxy Token -> String
NoThunks, [Token] -> Expr
Token -> Expr
(Token -> Expr) -> ([Token] -> Expr) -> ToExpr Token
forall a. (a -> Expr) -> ([a] -> Expr) -> ToExpr a
$ctoExpr :: Token -> Expr
toExpr :: Token -> Expr
$clistToExpr :: [Token] -> Expr
listToExpr :: [Token] -> Expr
ToExpr, [Token] -> Encoding
Token -> Encoding
(Token -> Encoding)
-> (forall s. Decoder s Token)
-> ([Token] -> Encoding)
-> (forall s. Decoder s [Token])
-> Serialise Token
forall s. Decoder s [Token]
forall s. Decoder s Token
forall a.
(a -> Encoding)
-> (forall s. Decoder s a)
-> ([a] -> Encoding)
-> (forall s. Decoder s [a])
-> Serialise a
$cencode :: Token -> Encoding
encode :: Token -> Encoding
$cdecode :: forall s. Decoder s Token
decode :: forall s. Decoder s Token
$cencodeList :: [Token] -> Encoding
encodeList :: [Token] -> Encoding
$cdecodeList :: forall s. Decoder s [Token]
decodeList :: forall s. Decoder s [Token]
Serialise, Token -> ()
(Token -> ()) -> NFData Token
forall a. (a -> ()) -> NFData a
$crnf :: Token -> ()
rnf :: Token -> ()
NFData)

mkTx ::
  -- | Consumed
  [Token] ->
  -- | Produced
  [Token] ->
  Ledger.GenTx TestBlock
mkTx :: [Token] -> [Token] -> GenTx TestBlock
mkTx [Token]
cons [Token]
prod =
  Tx -> GenTx TestBlock
TestBlockGenTx (Tx -> GenTx TestBlock) -> Tx -> GenTx TestBlock
forall a b. (a -> b) -> a -> b
$
    Tx
      { consumed :: Set Token
consumed = [Token] -> Set Token
forall a. Ord a => [a] -> Set a
Set.fromList [Token]
cons
      , produced :: Set Token
produced = [Token] -> Set Token
forall a. Ord a => [a] -> Set a
Set.fromList [Token]
prod
      }

{-------------------------------------------------------------------------------
  Initial parameters
-------------------------------------------------------------------------------}

initialLedgerState :: LedgerState (TestBlockWith Tx) ValuesMK
initialLedgerState :: LedgerState TestBlock ValuesMK
initialLedgerState =
  TestLedger
    { lastAppliedPoint :: Point TestBlock
lastAppliedPoint = Point TestBlock
forall {k} (block :: k). Point block
Block.GenesisPoint
    , payloadDependentState :: PayloadDependentState Tx ValuesMK
payloadDependentState =
        TestPLDS
          { getTestPLDS :: ValuesMK Token ()
getTestPLDS = Map Token () -> ValuesMK Token ()
forall k v. Map k v -> ValuesMK k v
ValuesMK Map Token ()
forall k a. Map k a
Map.empty
          }
    }

sampleLedgerConfig :: Ledger.LedgerConfig TestBlock
sampleLedgerConfig :: LedgerConfig TestBlock
sampleLedgerConfig =
  EraParams -> TestBlockLedgerConfig
testBlockLedgerConfigFrom (EraParams -> TestBlockLedgerConfig)
-> EraParams -> TestBlockLedgerConfig
forall a b. (a -> b) -> a -> b
$
    SecurityParam -> SlotLength -> EraParams
HardFork.defaultEraParams
      (NonZero Word64 -> SecurityParam
Consensus.SecurityParam (NonZero Word64 -> SecurityParam)
-> NonZero Word64 -> SecurityParam
forall a b. (a -> b) -> a -> b
$ forall (n :: Natural) a.
(KnownNat n, 1 <= n, WithinBounds n a, Num a) =>
NonZero a
knownNonZeroBounded @10)
      (Integer -> SlotLength
Time.slotLengthFromSec Integer
2)

{-------------------------------------------------------------------------------
  Payload semantics
-------------------------------------------------------------------------------}

data TestLedgerState = TestLedgerState
  { TestLedgerState -> Set Token
availableTokens :: !(Set Token)
  }
  deriving stock ((forall x. TestLedgerState -> Rep TestLedgerState x)
-> (forall x. Rep TestLedgerState x -> TestLedgerState)
-> Generic TestLedgerState
forall x. Rep TestLedgerState x -> TestLedgerState
forall x. TestLedgerState -> Rep TestLedgerState x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TestLedgerState -> Rep TestLedgerState x
from :: forall x. TestLedgerState -> Rep TestLedgerState x
$cto :: forall x. Rep TestLedgerState x -> TestLedgerState
to :: forall x. Rep TestLedgerState x -> TestLedgerState
Generic, TestLedgerState -> TestLedgerState -> Bool
(TestLedgerState -> TestLedgerState -> Bool)
-> (TestLedgerState -> TestLedgerState -> Bool)
-> Eq TestLedgerState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TestLedgerState -> TestLedgerState -> Bool
== :: TestLedgerState -> TestLedgerState -> Bool
$c/= :: TestLedgerState -> TestLedgerState -> Bool
/= :: TestLedgerState -> TestLedgerState -> Bool
Eq, Int -> TestLedgerState -> ShowS
[TestLedgerState] -> ShowS
TestLedgerState -> String
(Int -> TestLedgerState -> ShowS)
-> (TestLedgerState -> String)
-> ([TestLedgerState] -> ShowS)
-> Show TestLedgerState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TestLedgerState -> ShowS
showsPrec :: Int -> TestLedgerState -> ShowS
$cshow :: TestLedgerState -> String
show :: TestLedgerState -> String
$cshowList :: [TestLedgerState] -> ShowS
showList :: [TestLedgerState] -> ShowS
Show)
  deriving anyclass (Context -> TestLedgerState -> IO (Maybe ThunkInfo)
Proxy TestLedgerState -> String
(Context -> TestLedgerState -> IO (Maybe ThunkInfo))
-> (Context -> TestLedgerState -> IO (Maybe ThunkInfo))
-> (Proxy TestLedgerState -> String)
-> NoThunks TestLedgerState
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> TestLedgerState -> IO (Maybe ThunkInfo)
noThunks :: Context -> TestLedgerState -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> TestLedgerState -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> TestLedgerState -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy TestLedgerState -> String
showTypeOf :: Proxy TestLedgerState -> String
NoThunks, [TestLedgerState] -> Expr
TestLedgerState -> Expr
(TestLedgerState -> Expr)
-> ([TestLedgerState] -> Expr) -> ToExpr TestLedgerState
forall a. (a -> Expr) -> ([a] -> Expr) -> ToExpr a
$ctoExpr :: TestLedgerState -> Expr
toExpr :: TestLedgerState -> Expr
$clistToExpr :: [TestLedgerState] -> Expr
listToExpr :: [TestLedgerState] -> Expr
ToExpr, [TestLedgerState] -> Encoding
TestLedgerState -> Encoding
(TestLedgerState -> Encoding)
-> (forall s. Decoder s TestLedgerState)
-> ([TestLedgerState] -> Encoding)
-> (forall s. Decoder s [TestLedgerState])
-> Serialise TestLedgerState
forall s. Decoder s [TestLedgerState]
forall s. Decoder s TestLedgerState
forall a.
(a -> Encoding)
-> (forall s. Decoder s a)
-> ([a] -> Encoding)
-> (forall s. Decoder s [a])
-> Serialise a
$cencode :: TestLedgerState -> Encoding
encode :: TestLedgerState -> Encoding
$cdecode :: forall s. Decoder s TestLedgerState
decode :: forall s. Decoder s TestLedgerState
$cencodeList :: [TestLedgerState] -> Encoding
encodeList :: [TestLedgerState] -> Encoding
$cdecodeList :: forall s. Decoder s [TestLedgerState]
decodeList :: forall s. Decoder s [TestLedgerState]
Serialise)

data TxApplicationError
  = -- | The transaction could not be applied due to the given unavailable tokens.
    TxApplicationError {TxApplicationError -> Set Token
unavailable :: Set Token}
  deriving stock ((forall x. TxApplicationError -> Rep TxApplicationError x)
-> (forall x. Rep TxApplicationError x -> TxApplicationError)
-> Generic TxApplicationError
forall x. Rep TxApplicationError x -> TxApplicationError
forall x. TxApplicationError -> Rep TxApplicationError x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TxApplicationError -> Rep TxApplicationError x
from :: forall x. TxApplicationError -> Rep TxApplicationError x
$cto :: forall x. Rep TxApplicationError x -> TxApplicationError
to :: forall x. Rep TxApplicationError x -> TxApplicationError
Generic, TxApplicationError -> TxApplicationError -> Bool
(TxApplicationError -> TxApplicationError -> Bool)
-> (TxApplicationError -> TxApplicationError -> Bool)
-> Eq TxApplicationError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TxApplicationError -> TxApplicationError -> Bool
== :: TxApplicationError -> TxApplicationError -> Bool
$c/= :: TxApplicationError -> TxApplicationError -> Bool
/= :: TxApplicationError -> TxApplicationError -> Bool
Eq, Int -> TxApplicationError -> ShowS
[TxApplicationError] -> ShowS
TxApplicationError -> String
(Int -> TxApplicationError -> ShowS)
-> (TxApplicationError -> String)
-> ([TxApplicationError] -> ShowS)
-> Show TxApplicationError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TxApplicationError -> ShowS
showsPrec :: Int -> TxApplicationError -> ShowS
$cshow :: TxApplicationError -> String
show :: TxApplicationError -> String
$cshowList :: [TxApplicationError] -> ShowS
showList :: [TxApplicationError] -> ShowS
Show)
  deriving anyclass (Context -> TxApplicationError -> IO (Maybe ThunkInfo)
Proxy TxApplicationError -> String
(Context -> TxApplicationError -> IO (Maybe ThunkInfo))
-> (Context -> TxApplicationError -> IO (Maybe ThunkInfo))
-> (Proxy TxApplicationError -> String)
-> NoThunks TxApplicationError
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> TxApplicationError -> IO (Maybe ThunkInfo)
noThunks :: Context -> TxApplicationError -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> TxApplicationError -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> TxApplicationError -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy TxApplicationError -> String
showTypeOf :: Proxy TxApplicationError -> String
NoThunks, [TxApplicationError] -> Expr
TxApplicationError -> Expr
(TxApplicationError -> Expr)
-> ([TxApplicationError] -> Expr) -> ToExpr TxApplicationError
forall a. (a -> Expr) -> ([a] -> Expr) -> ToExpr a
$ctoExpr :: TxApplicationError -> Expr
toExpr :: TxApplicationError -> Expr
$clistToExpr :: [TxApplicationError] -> Expr
listToExpr :: [TxApplicationError] -> Expr
ToExpr, [TxApplicationError] -> Encoding
TxApplicationError -> Encoding
(TxApplicationError -> Encoding)
-> (forall s. Decoder s TxApplicationError)
-> ([TxApplicationError] -> Encoding)
-> (forall s. Decoder s [TxApplicationError])
-> Serialise TxApplicationError
forall s. Decoder s [TxApplicationError]
forall s. Decoder s TxApplicationError
forall a.
(a -> Encoding)
-> (forall s. Decoder s a)
-> ([a] -> Encoding)
-> (forall s. Decoder s [a])
-> Serialise a
$cencode :: TxApplicationError -> Encoding
encode :: TxApplicationError -> Encoding
$cdecode :: forall s. Decoder s TxApplicationError
decode :: forall s. Decoder s TxApplicationError
$cencodeList :: [TxApplicationError] -> Encoding
encodeList :: [TxApplicationError] -> Encoding
$cdecodeList :: forall s. Decoder s [TxApplicationError]
decodeList :: forall s. Decoder s [TxApplicationError]
Serialise)

instance PayloadSemantics Tx where
  newtype PayloadDependentState Tx mk = TestPLDS
    { forall (mk :: MapKind). PayloadDependentState Tx mk -> mk Token ()
getTestPLDS :: mk Token ()
    }
    deriving stock (forall x.
 PayloadDependentState Tx mk -> Rep (PayloadDependentState Tx mk) x)
-> (forall x.
    Rep (PayloadDependentState Tx mk) x -> PayloadDependentState Tx mk)
-> Generic (PayloadDependentState Tx mk)
forall x.
Rep (PayloadDependentState Tx mk) x -> PayloadDependentState Tx mk
forall x.
PayloadDependentState Tx mk -> Rep (PayloadDependentState Tx mk) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (mk :: MapKind) x.
Rep (PayloadDependentState Tx mk) x -> PayloadDependentState Tx mk
forall (mk :: MapKind) x.
PayloadDependentState Tx mk -> Rep (PayloadDependentState Tx mk) x
$cfrom :: forall (mk :: MapKind) x.
PayloadDependentState Tx mk -> Rep (PayloadDependentState Tx mk) x
from :: forall x.
PayloadDependentState Tx mk -> Rep (PayloadDependentState Tx mk) x
$cto :: forall (mk :: MapKind) x.
Rep (PayloadDependentState Tx mk) x -> PayloadDependentState Tx mk
to :: forall x.
Rep (PayloadDependentState Tx mk) x -> PayloadDependentState Tx mk
Generic

  type PayloadDependentError Tx = TxApplicationError

  applyPayload :: PayloadDependentState Tx ValuesMK
-> Tx
-> Either
     (PayloadDependentError Tx) (PayloadDependentState Tx TrackingMK)
applyPayload PayloadDependentState Tx ValuesMK
plds Tx
tx =
    let
      notFound :: Set Token
notFound = (Token -> Bool) -> Set Token -> Set Token
forall a. (a -> Bool) -> Set a -> Set a
Set.filter (Bool -> Bool
not (Bool -> Bool) -> (Token -> Bool) -> Token -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Token -> Map Token () -> Bool
forall k a. Ord k => k -> Map k a -> Bool
`Map.member` Map Token ()
tokMap)) Set Token
consumed
     in
      if Set Token -> Bool
forall a. Set a -> Bool
Set.null Set Token
notFound
        then PayloadDependentState Tx TrackingMK
-> Either
     (PayloadDependentError Tx) (PayloadDependentState Tx TrackingMK)
forall a b. b -> Either a b
Right (PayloadDependentState Tx TrackingMK
 -> Either
      (PayloadDependentError Tx) (PayloadDependentState Tx TrackingMK))
-> PayloadDependentState Tx TrackingMK
-> Either
     (PayloadDependentError Tx) (PayloadDependentState Tx TrackingMK)
forall a b. (a -> b) -> a -> b
$ TrackingMK Token () -> PayloadDependentState Tx TrackingMK
forall (mk :: MapKind). mk Token () -> PayloadDependentState Tx mk
TestPLDS (ValuesMK Token () -> DiffMK Token () -> TrackingMK Token ()
forall k v. Ord k => ValuesMK k v -> DiffMK k v -> TrackingMK k v
Ledger.rawAttachAndApplyDiffs ValuesMK Token ()
toks DiffMK Token ()
fullDiff)
        else TxApplicationError
-> Either TxApplicationError (PayloadDependentState Tx TrackingMK)
forall a b. a -> Either a b
Left (TxApplicationError
 -> Either TxApplicationError (PayloadDependentState Tx TrackingMK))
-> TxApplicationError
-> Either TxApplicationError (PayloadDependentState Tx TrackingMK)
forall a b. (a -> b) -> a -> b
$ Set Token -> TxApplicationError
TxApplicationError Set Token
notFound
   where
    TestPLDS toks :: ValuesMK Token ()
toks@(ValuesMK Map Token ()
tokMap) = PayloadDependentState Tx ValuesMK
plds
    Tx{Set Token
consumed :: Tx -> Set Token
consumed :: Set Token
consumed, Set Token
produced :: Tx -> Set Token
produced :: Set Token
produced} = Tx
tx

    consumedDiff, producedDiff :: Diff.Diff Token ()
    consumedDiff :: Diff Token ()
consumedDiff = [(Token, ())] -> Diff Token ()
forall k v. Ord k => [(k, v)] -> Diff k v
Diff.fromListDeletes [(Token
t, ()) | Token
t <- Set Token -> [Token]
forall a. Set a -> [a]
Set.toList Set Token
consumed]
    producedDiff :: Diff Token ()
producedDiff = [(Token, ())] -> Diff Token ()
forall k v. Ord k => [(k, v)] -> Diff k v
Diff.fromListInserts [(Token
t, ()) | Token
t <- Set Token -> [Token]
forall a. Set a -> [a]
Set.toList Set Token
produced]

    fullDiff :: DiffMK Token ()
    fullDiff :: DiffMK Token ()
fullDiff = Diff Token () -> DiffMK Token ()
forall k v. Diff k v -> DiffMK k v
DiffMK (Diff Token () -> DiffMK Token ())
-> Diff Token () -> DiffMK Token ()
forall a b. (a -> b) -> a -> b
$ Diff Token ()
consumedDiff Diff Token () -> Diff Token () -> Diff Token ()
forall a. Semigroup a => a -> a -> a
<> Diff Token ()
producedDiff

  getPayloadKeySets :: Tx -> LedgerTables (LedgerState TestBlock) KeysMK
getPayloadKeySets Tx
tx = KeysMK
  (TxIn (LedgerState TestBlock)) (TxOut (LedgerState TestBlock))
-> LedgerTables (LedgerState TestBlock) KeysMK
forall (l :: MapKind -> *) (mk :: MapKind).
mk (TxIn l) (TxOut l) -> LedgerTables l mk
LedgerTables (KeysMK
   (TxIn (LedgerState TestBlock)) (TxOut (LedgerState TestBlock))
 -> LedgerTables (LedgerState TestBlock) KeysMK)
-> KeysMK
     (TxIn (LedgerState TestBlock)) (TxOut (LedgerState TestBlock))
-> LedgerTables (LedgerState TestBlock) KeysMK
forall a b. (a -> b) -> a -> b
$ Set Token -> KeysMK Token ()
forall k v. Set k -> KeysMK k v
KeysMK Set Token
consumed
   where
    Tx{Set Token
consumed :: Tx -> Set Token
consumed :: Set Token
consumed} = Tx
tx

deriving stock instance
  EqMK mk =>
  Eq (PayloadDependentState Tx mk)
deriving stock instance
  ShowMK mk =>
  Show (PayloadDependentState Tx mk)
deriving anyclass instance
  NoThunksMK mk =>
  NoThunks (PayloadDependentState Tx mk)

instance Serialise (PayloadDependentState Tx EmptyMK) where
  encode :: PayloadDependentState Tx EmptyMK -> Encoding
encode = String -> PayloadDependentState Tx EmptyMK -> Encoding
forall a. HasCallStack => String -> a
error String
"Mempool bench TestBlock unused: encode"
  decode :: forall s. Decoder s (PayloadDependentState Tx EmptyMK)
decode = String -> Decoder s (PayloadDependentState Tx EmptyMK)
forall a. HasCallStack => String -> a
error String
"Mempool bench TestBlock unused: decode"

-- | TODO: for the time being 'TestBlock' does not have any codec config
data instance Block.CodecConfig TestBlock = TestBlockCodecConfig
  deriving (Int -> CodecConfig TestBlock -> ShowS
[CodecConfig TestBlock] -> ShowS
CodecConfig TestBlock -> String
(Int -> CodecConfig TestBlock -> ShowS)
-> (CodecConfig TestBlock -> String)
-> ([CodecConfig TestBlock] -> ShowS)
-> Show (CodecConfig TestBlock)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CodecConfig TestBlock -> ShowS
showsPrec :: Int -> CodecConfig TestBlock -> ShowS
$cshow :: CodecConfig TestBlock -> String
show :: CodecConfig TestBlock -> String
$cshowList :: [CodecConfig TestBlock] -> ShowS
showList :: [CodecConfig TestBlock] -> ShowS
Show, (forall x. CodecConfig TestBlock -> Rep (CodecConfig TestBlock) x)
-> (forall x.
    Rep (CodecConfig TestBlock) x -> CodecConfig TestBlock)
-> Generic (CodecConfig TestBlock)
forall x. Rep (CodecConfig TestBlock) x -> CodecConfig TestBlock
forall x. CodecConfig TestBlock -> Rep (CodecConfig TestBlock) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CodecConfig TestBlock -> Rep (CodecConfig TestBlock) x
from :: forall x. CodecConfig TestBlock -> Rep (CodecConfig TestBlock) x
$cto :: forall x. Rep (CodecConfig TestBlock) x -> CodecConfig TestBlock
to :: forall x. Rep (CodecConfig TestBlock) x -> CodecConfig TestBlock
Generic, Context -> CodecConfig TestBlock -> IO (Maybe ThunkInfo)
Proxy (CodecConfig TestBlock) -> String
(Context -> CodecConfig TestBlock -> IO (Maybe ThunkInfo))
-> (Context -> CodecConfig TestBlock -> IO (Maybe ThunkInfo))
-> (Proxy (CodecConfig TestBlock) -> String)
-> NoThunks (CodecConfig TestBlock)
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> CodecConfig TestBlock -> IO (Maybe ThunkInfo)
noThunks :: Context -> CodecConfig TestBlock -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> CodecConfig TestBlock -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> CodecConfig TestBlock -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy (CodecConfig TestBlock) -> String
showTypeOf :: Proxy (CodecConfig TestBlock) -> String
NoThunks)

-- | TODO: for the time being 'TestBlock' does not have any storage config
data instance Block.StorageConfig TestBlock = TestBlockStorageConfig
  deriving (Int -> StorageConfig TestBlock -> ShowS
[StorageConfig TestBlock] -> ShowS
StorageConfig TestBlock -> String
(Int -> StorageConfig TestBlock -> ShowS)
-> (StorageConfig TestBlock -> String)
-> ([StorageConfig TestBlock] -> ShowS)
-> Show (StorageConfig TestBlock)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StorageConfig TestBlock -> ShowS
showsPrec :: Int -> StorageConfig TestBlock -> ShowS
$cshow :: StorageConfig TestBlock -> String
show :: StorageConfig TestBlock -> String
$cshowList :: [StorageConfig TestBlock] -> ShowS
showList :: [StorageConfig TestBlock] -> ShowS
Show, (forall x.
 StorageConfig TestBlock -> Rep (StorageConfig TestBlock) x)
-> (forall x.
    Rep (StorageConfig TestBlock) x -> StorageConfig TestBlock)
-> Generic (StorageConfig TestBlock)
forall x.
Rep (StorageConfig TestBlock) x -> StorageConfig TestBlock
forall x.
StorageConfig TestBlock -> Rep (StorageConfig TestBlock) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
StorageConfig TestBlock -> Rep (StorageConfig TestBlock) x
from :: forall x.
StorageConfig TestBlock -> Rep (StorageConfig TestBlock) x
$cto :: forall x.
Rep (StorageConfig TestBlock) x -> StorageConfig TestBlock
to :: forall x.
Rep (StorageConfig TestBlock) x -> StorageConfig TestBlock
Generic, Context -> StorageConfig TestBlock -> IO (Maybe ThunkInfo)
Proxy (StorageConfig TestBlock) -> String
(Context -> StorageConfig TestBlock -> IO (Maybe ThunkInfo))
-> (Context -> StorageConfig TestBlock -> IO (Maybe ThunkInfo))
-> (Proxy (StorageConfig TestBlock) -> String)
-> NoThunks (StorageConfig TestBlock)
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> StorageConfig TestBlock -> IO (Maybe ThunkInfo)
noThunks :: Context -> StorageConfig TestBlock -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> StorageConfig TestBlock -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> StorageConfig TestBlock -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy (StorageConfig TestBlock) -> String
showTypeOf :: Proxy (StorageConfig TestBlock) -> String
NoThunks)

{-------------------------------------------------------------------------------
  Ledger tables
-------------------------------------------------------------------------------}

type instance TxIn (LedgerState TestBlock) = Token
type instance TxOut (LedgerState TestBlock) = ()

instance HasLedgerTables (LedgerState TestBlock) where
  projectLedgerTables :: forall (mk :: MapKind).
(CanMapMK mk, CanMapKeysMK mk, ZeroableMK mk) =>
LedgerState TestBlock mk -> LedgerTables (LedgerState TestBlock) mk
projectLedgerTables LedgerState TestBlock mk
st =
    mk (TxIn (LedgerState TestBlock)) (TxOut (LedgerState TestBlock))
-> LedgerTables (LedgerState TestBlock) mk
forall (l :: MapKind -> *) (mk :: MapKind).
mk (TxIn l) (TxOut l) -> LedgerTables l mk
LedgerTables (mk (TxIn (LedgerState TestBlock)) (TxOut (LedgerState TestBlock))
 -> LedgerTables (LedgerState TestBlock) mk)
-> mk
     (TxIn (LedgerState TestBlock)) (TxOut (LedgerState TestBlock))
-> LedgerTables (LedgerState TestBlock) mk
forall a b. (a -> b) -> a -> b
$ PayloadDependentState Tx mk -> mk Token ()
forall (mk :: MapKind). PayloadDependentState Tx mk -> mk Token ()
getTestPLDS (PayloadDependentState Tx mk -> mk Token ())
-> PayloadDependentState Tx mk -> mk Token ()
forall a b. (a -> b) -> a -> b
$ LedgerState TestBlock mk -> PayloadDependentState Tx mk
forall ptype (mk :: MapKind).
LedgerState (TestBlockWith ptype) mk
-> PayloadDependentState ptype mk
payloadDependentState LedgerState TestBlock mk
st
  withLedgerTables :: forall (mk :: MapKind) (any :: MapKind).
(CanMapMK mk, CanMapKeysMK mk, ZeroableMK mk) =>
LedgerState TestBlock any
-> LedgerTables (LedgerState TestBlock) mk
-> LedgerState TestBlock mk
withLedgerTables LedgerState TestBlock any
st LedgerTables (LedgerState TestBlock) mk
table =
    LedgerState TestBlock any
st
      { payloadDependentState =
          plds
            { getTestPLDS = Ledger.getLedgerTables table
            }
      }
   where
    TestLedger{payloadDependentState :: forall ptype (mk :: MapKind).
LedgerState (TestBlockWith ptype) mk
-> PayloadDependentState ptype mk
payloadDependentState = PayloadDependentState Tx any
plds} = LedgerState TestBlock any
st

instance HasLedgerTables (Ticked (LedgerState TestBlock)) where
  projectLedgerTables :: forall (mk :: MapKind).
(CanMapMK mk, CanMapKeysMK mk, ZeroableMK mk) =>
Ticked (LedgerState TestBlock) mk
-> LedgerTables (Ticked (LedgerState TestBlock)) mk
projectLedgerTables (TickedTestLedger LedgerState TestBlock mk
st) =
    LedgerTables (LedgerState TestBlock) mk
-> LedgerTables (Ticked (LedgerState TestBlock)) mk
forall (l :: MapKind -> *) (l' :: MapKind -> *) (mk :: MapKind).
SameUtxoTypes l l' =>
LedgerTables l mk -> LedgerTables l' mk
Ledger.castLedgerTables (LedgerTables (LedgerState TestBlock) mk
 -> LedgerTables (Ticked (LedgerState TestBlock)) mk)
-> LedgerTables (LedgerState TestBlock) mk
-> LedgerTables (Ticked (LedgerState TestBlock)) mk
forall a b. (a -> b) -> a -> b
$
      LedgerState TestBlock mk -> LedgerTables (LedgerState TestBlock) mk
forall (mk :: MapKind).
(CanMapMK mk, CanMapKeysMK mk, ZeroableMK mk) =>
LedgerState TestBlock mk -> LedgerTables (LedgerState TestBlock) mk
forall (l :: MapKind -> *) (mk :: MapKind).
(HasLedgerTables l, CanMapMK mk, CanMapKeysMK mk, ZeroableMK mk) =>
l mk -> LedgerTables l mk
Ledger.projectLedgerTables LedgerState TestBlock mk
st
  withLedgerTables :: forall (mk :: MapKind) (any :: MapKind).
(CanMapMK mk, CanMapKeysMK mk, ZeroableMK mk) =>
Ticked (LedgerState TestBlock) any
-> LedgerTables (Ticked (LedgerState TestBlock)) mk
-> Ticked (LedgerState TestBlock) mk
withLedgerTables (TickedTestLedger LedgerState TestBlock any
st) LedgerTables (Ticked (LedgerState TestBlock)) mk
tables =
    LedgerState TestBlock mk -> Ticked (LedgerState TestBlock) mk
forall ptype (mk :: MapKind).
LedgerState (TestBlockWith ptype) mk
-> Ticked (LedgerState (TestBlockWith ptype)) mk
TickedTestLedger (LedgerState TestBlock mk -> Ticked (LedgerState TestBlock) mk)
-> LedgerState TestBlock mk -> Ticked (LedgerState TestBlock) mk
forall a b. (a -> b) -> a -> b
$ LedgerState TestBlock any
-> LedgerTables (LedgerState TestBlock) mk
-> LedgerState TestBlock mk
forall (mk :: MapKind) (any :: MapKind).
(CanMapMK mk, CanMapKeysMK mk, ZeroableMK mk) =>
LedgerState TestBlock any
-> LedgerTables (LedgerState TestBlock) mk
-> LedgerState TestBlock mk
forall (l :: MapKind -> *) (mk :: MapKind) (any :: MapKind).
(HasLedgerTables l, CanMapMK mk, CanMapKeysMK mk, ZeroableMK mk) =>
l any -> LedgerTables l mk -> l mk
Ledger.withLedgerTables LedgerState TestBlock any
st (LedgerTables (LedgerState TestBlock) mk
 -> LedgerState TestBlock mk)
-> LedgerTables (LedgerState TestBlock) mk
-> LedgerState TestBlock mk
forall a b. (a -> b) -> a -> b
$ LedgerTables (Ticked (LedgerState TestBlock)) mk
-> LedgerTables (LedgerState TestBlock) mk
forall (l :: MapKind -> *) (l' :: MapKind -> *) (mk :: MapKind).
SameUtxoTypes l l' =>
LedgerTables l mk -> LedgerTables l' mk
Ledger.castLedgerTables LedgerTables (Ticked (LedgerState TestBlock)) mk
tables

instance CanStowLedgerTables (LedgerState TestBlock) where
  stowLedgerTables :: LedgerState TestBlock ValuesMK -> LedgerState TestBlock EmptyMK
stowLedgerTables = String
-> LedgerState TestBlock ValuesMK -> LedgerState TestBlock EmptyMK
forall a. HasCallStack => String -> a
error String
"Mempool bench TestBlock unused: stowLedgerTables"
  unstowLedgerTables :: LedgerState TestBlock EmptyMK -> LedgerState TestBlock ValuesMK
unstowLedgerTables = String
-> LedgerState TestBlock EmptyMK -> LedgerState TestBlock ValuesMK
forall a. HasCallStack => String -> a
error String
"Mempool bench TestBlock unused: unstowLedgerTables"

instance IndexedMemPack (LedgerState TestBlock EmptyMK) () where
  indexedTypeName :: LedgerState TestBlock EmptyMK -> String
indexedTypeName LedgerState TestBlock EmptyMK
_ = forall a. MemPack a => String
typeName @()
  indexedPackedByteCount :: LedgerState TestBlock EmptyMK -> () -> Int
indexedPackedByteCount LedgerState TestBlock EmptyMK
_ = () -> Int
forall a. MemPack a => a -> Int
packedByteCount
  indexedPackM :: forall s. LedgerState TestBlock EmptyMK -> () -> Pack s ()
indexedPackM LedgerState TestBlock EmptyMK
_ = () -> Pack s ()
forall s. () -> Pack s ()
forall a s. MemPack a => a -> Pack s ()
packM
  indexedUnpackM :: forall b. Buffer b => LedgerState TestBlock EmptyMK -> Unpack b ()
indexedUnpackM LedgerState TestBlock EmptyMK
_ = Unpack b ()
forall b. Buffer b => Unpack b ()
forall a b. (MemPack a, Buffer b) => Unpack b a
unpackM

{-------------------------------------------------------------------------------
  Mempool support
-------------------------------------------------------------------------------}

newtype instance Ledger.GenTx TestBlock = TestBlockGenTx {GenTx TestBlock -> Tx
unGenTx :: Tx}
  deriving stock (forall x. GenTx TestBlock -> Rep (GenTx TestBlock) x)
-> (forall x. Rep (GenTx TestBlock) x -> GenTx TestBlock)
-> Generic (GenTx TestBlock)
forall x. Rep (GenTx TestBlock) x -> GenTx TestBlock
forall x. GenTx TestBlock -> Rep (GenTx TestBlock) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. GenTx TestBlock -> Rep (GenTx TestBlock) x
from :: forall x. GenTx TestBlock -> Rep (GenTx TestBlock) x
$cto :: forall x. Rep (GenTx TestBlock) x -> GenTx TestBlock
to :: forall x. Rep (GenTx TestBlock) x -> GenTx TestBlock
Generic
  deriving newtype (Int -> GenTx TestBlock -> ShowS
[GenTx TestBlock] -> ShowS
GenTx TestBlock -> String
(Int -> GenTx TestBlock -> ShowS)
-> (GenTx TestBlock -> String)
-> ([GenTx TestBlock] -> ShowS)
-> Show (GenTx TestBlock)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GenTx TestBlock -> ShowS
showsPrec :: Int -> GenTx TestBlock -> ShowS
$cshow :: GenTx TestBlock -> String
show :: GenTx TestBlock -> String
$cshowList :: [GenTx TestBlock] -> ShowS
showList :: [GenTx TestBlock] -> ShowS
Show, Context -> GenTx TestBlock -> IO (Maybe ThunkInfo)
Proxy (GenTx TestBlock) -> String
(Context -> GenTx TestBlock -> IO (Maybe ThunkInfo))
-> (Context -> GenTx TestBlock -> IO (Maybe ThunkInfo))
-> (Proxy (GenTx TestBlock) -> String)
-> NoThunks (GenTx TestBlock)
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> GenTx TestBlock -> IO (Maybe ThunkInfo)
noThunks :: Context -> GenTx TestBlock -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> GenTx TestBlock -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> GenTx TestBlock -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy (GenTx TestBlock) -> String
showTypeOf :: Proxy (GenTx TestBlock) -> String
NoThunks, GenTx TestBlock -> GenTx TestBlock -> Bool
(GenTx TestBlock -> GenTx TestBlock -> Bool)
-> (GenTx TestBlock -> GenTx TestBlock -> Bool)
-> Eq (GenTx TestBlock)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GenTx TestBlock -> GenTx TestBlock -> Bool
== :: GenTx TestBlock -> GenTx TestBlock -> Bool
$c/= :: GenTx TestBlock -> GenTx TestBlock -> Bool
/= :: GenTx TestBlock -> GenTx TestBlock -> Bool
Eq, Eq (GenTx TestBlock)
Eq (GenTx TestBlock) =>
(GenTx TestBlock -> GenTx TestBlock -> Ordering)
-> (GenTx TestBlock -> GenTx TestBlock -> Bool)
-> (GenTx TestBlock -> GenTx TestBlock -> Bool)
-> (GenTx TestBlock -> GenTx TestBlock -> Bool)
-> (GenTx TestBlock -> GenTx TestBlock -> Bool)
-> (GenTx TestBlock -> GenTx TestBlock -> GenTx TestBlock)
-> (GenTx TestBlock -> GenTx TestBlock -> GenTx TestBlock)
-> Ord (GenTx TestBlock)
GenTx TestBlock -> GenTx TestBlock -> Bool
GenTx TestBlock -> GenTx TestBlock -> Ordering
GenTx TestBlock -> GenTx TestBlock -> GenTx TestBlock
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: GenTx TestBlock -> GenTx TestBlock -> Ordering
compare :: GenTx TestBlock -> GenTx TestBlock -> Ordering
$c< :: GenTx TestBlock -> GenTx TestBlock -> Bool
< :: GenTx TestBlock -> GenTx TestBlock -> Bool
$c<= :: GenTx TestBlock -> GenTx TestBlock -> Bool
<= :: GenTx TestBlock -> GenTx TestBlock -> Bool
$c> :: GenTx TestBlock -> GenTx TestBlock -> Bool
> :: GenTx TestBlock -> GenTx TestBlock -> Bool
$c>= :: GenTx TestBlock -> GenTx TestBlock -> Bool
>= :: GenTx TestBlock -> GenTx TestBlock -> Bool
$cmax :: GenTx TestBlock -> GenTx TestBlock -> GenTx TestBlock
max :: GenTx TestBlock -> GenTx TestBlock -> GenTx TestBlock
$cmin :: GenTx TestBlock -> GenTx TestBlock -> GenTx TestBlock
min :: GenTx TestBlock -> GenTx TestBlock -> GenTx TestBlock
Ord, GenTx TestBlock -> ()
(GenTx TestBlock -> ()) -> NFData (GenTx TestBlock)
forall a. (a -> ()) -> NFData a
$crnf :: GenTx TestBlock -> ()
rnf :: GenTx TestBlock -> ()
NFData)

-- | For the mempool tests and benchmarks it is not imporant that we calculate
-- the actual size of the transaction in bytes.
txSize :: Ledger.GenTx TestBlock -> Ledger.ByteSize32
txSize :: GenTx TestBlock -> ByteSize32
txSize (TestBlockGenTx Tx
tx) =
  Word32 -> ByteSize32
Ledger.ByteSize32 (Word32 -> ByteSize32) -> Word32 -> ByteSize32
forall a b. (a -> b) -> a -> b
$
    Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$
      Int
1 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Set Token -> Int
forall a. Set a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (Tx -> Set Token
consumed Tx
tx) Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Set Token -> Int
forall a. Set a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (Tx -> Set Token
produced Tx
tx)

instance Ledger.LedgerSupportsMempool TestBlock where
  applyTx :: LedgerConfig TestBlock
-> WhetherToIntervene
-> SlotNo
-> GenTx TestBlock
-> TickedLedgerState TestBlock ValuesMK
-> Except
     (ApplyTxErr TestBlock)
     (TickedLedgerState TestBlock DiffMK, Validated (GenTx TestBlock))
applyTx LedgerConfig TestBlock
_cfg WhetherToIntervene
_shouldIntervene SlotNo
_slot (TestBlockGenTx Tx
tx) TickedLedgerState TestBlock ValuesMK
tickedSt =
    Either
  (ApplyTxErr TestBlock)
  (TickedLedgerState TestBlock DiffMK, Validated (GenTx TestBlock))
-> Except
     (ApplyTxErr TestBlock)
     (TickedLedgerState TestBlock DiffMK, Validated (GenTx TestBlock))
forall (m :: * -> *) e a. Monad m => Either e a -> ExceptT e m a
except (Either
   (ApplyTxErr TestBlock)
   (TickedLedgerState TestBlock DiffMK, Validated (GenTx TestBlock))
 -> Except
      (ApplyTxErr TestBlock)
      (TickedLedgerState TestBlock DiffMK, Validated (GenTx TestBlock)))
-> Either
     (ApplyTxErr TestBlock)
     (TickedLedgerState TestBlock DiffMK, Validated (GenTx TestBlock))
-> Except
     (ApplyTxErr TestBlock)
     (TickedLedgerState TestBlock DiffMK, Validated (GenTx TestBlock))
forall a b. (a -> b) -> a -> b
$
      (TickedLedgerState TestBlock TrackingMK
 -> (TickedLedgerState TestBlock DiffMK,
     Validated (GenTx TestBlock)))
-> Either
     (ApplyTxErr TestBlock) (TickedLedgerState TestBlock TrackingMK)
-> Either
     (ApplyTxErr TestBlock)
     (TickedLedgerState TestBlock DiffMK, Validated (GenTx TestBlock))
forall a b.
(a -> b)
-> Either (ApplyTxErr TestBlock) a
-> Either (ApplyTxErr TestBlock) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((,GenTx TestBlock -> Validated (GenTx TestBlock)
ValidatedGenTx (Tx -> GenTx TestBlock
TestBlockGenTx Tx
tx)) (TickedLedgerState TestBlock DiffMK
 -> (TickedLedgerState TestBlock DiffMK,
     Validated (GenTx TestBlock)))
-> (TickedLedgerState TestBlock TrackingMK
    -> TickedLedgerState TestBlock DiffMK)
-> TickedLedgerState TestBlock TrackingMK
-> (TickedLedgerState TestBlock DiffMK,
    Validated (GenTx TestBlock))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TickedLedgerState TestBlock TrackingMK
-> TickedLedgerState TestBlock DiffMK
forall (l :: MapKind -> *).
(HasLedgerTables l, LedgerTableConstraints l) =>
l TrackingMK -> l DiffMK
Ledger.trackingToDiffs) (Either
   (ApplyTxErr TestBlock) (TickedLedgerState TestBlock TrackingMK)
 -> Either
      (ApplyTxErr TestBlock)
      (TickedLedgerState TestBlock DiffMK, Validated (GenTx TestBlock)))
-> Either
     (ApplyTxErr TestBlock) (TickedLedgerState TestBlock TrackingMK)
-> Either
     (ApplyTxErr TestBlock)
     (TickedLedgerState TestBlock DiffMK, Validated (GenTx TestBlock))
forall a b. (a -> b) -> a -> b
$
        TickedLedgerState TestBlock ValuesMK
-> Tx
-> Either
     (PayloadDependentError Tx) (TickedLedgerState TestBlock TrackingMK)
forall ptype.
PayloadSemantics ptype =>
Ticked (LedgerState (TestBlockWith ptype)) ValuesMK
-> ptype
-> Either
     (PayloadDependentError ptype)
     (Ticked (LedgerState (TestBlockWith ptype)) TrackingMK)
applyDirectlyToPayloadDependentState TickedLedgerState TestBlock ValuesMK
tickedSt Tx
tx

  reapplyTx :: HasCallStack =>
ComputeDiffs
-> LedgerConfig TestBlock
-> SlotNo
-> Validated (GenTx TestBlock)
-> TickedLedgerState TestBlock ValuesMK
-> Except
     (ApplyTxErr TestBlock) (TickedLedgerState TestBlock TrackingMK)
reapplyTx ComputeDiffs
_ LedgerConfig TestBlock
cfg SlotNo
slot (ValidatedGenTx GenTx TestBlock
genTx) TickedLedgerState TestBlock ValuesMK
tickedSt =
    TickedLedgerState TestBlock ValuesMK
-> TickedLedgerState TestBlock DiffMK
-> TickedLedgerState TestBlock TrackingMK
forall (l :: MapKind -> *) (l' :: MapKind -> *).
(SameUtxoTypes l l', HasLedgerTables l, HasLedgerTables l') =>
l ValuesMK -> l' DiffMK -> l' TrackingMK
Ledger.attachAndApplyDiffs TickedLedgerState TestBlock ValuesMK
tickedSt (TickedLedgerState TestBlock DiffMK
 -> TickedLedgerState TestBlock TrackingMK)
-> ((TickedLedgerState TestBlock DiffMK,
     Validated (GenTx TestBlock))
    -> TickedLedgerState TestBlock DiffMK)
-> (TickedLedgerState TestBlock DiffMK,
    Validated (GenTx TestBlock))
-> TickedLedgerState TestBlock TrackingMK
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TickedLedgerState TestBlock DiffMK, Validated (GenTx TestBlock))
-> TickedLedgerState TestBlock DiffMK
forall a b. (a, b) -> a
fst
      ((TickedLedgerState TestBlock DiffMK, Validated (GenTx TestBlock))
 -> TickedLedgerState TestBlock TrackingMK)
-> ExceptT
     TxApplicationError
     Identity
     (TickedLedgerState TestBlock DiffMK, Validated (GenTx TestBlock))
-> ExceptT
     TxApplicationError
     Identity
     (TickedLedgerState TestBlock TrackingMK)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> LedgerConfig TestBlock
-> WhetherToIntervene
-> SlotNo
-> GenTx TestBlock
-> TickedLedgerState TestBlock ValuesMK
-> Except
     (ApplyTxErr TestBlock)
     (TickedLedgerState TestBlock DiffMK, Validated (GenTx TestBlock))
forall blk.
LedgerSupportsMempool blk =>
LedgerConfig blk
-> WhetherToIntervene
-> SlotNo
-> GenTx blk
-> TickedLedgerState blk ValuesMK
-> Except
     (ApplyTxErr blk)
     (TickedLedgerState blk DiffMK, Validated (GenTx blk))
Ledger.applyTx LedgerConfig TestBlock
cfg WhetherToIntervene
Ledger.DoNotIntervene SlotNo
slot GenTx TestBlock
genTx TickedLedgerState TestBlock ValuesMK
tickedSt

  -- FIXME: it is ok to use 'DoNotIntervene' here?

  txForgetValidated :: Validated (GenTx TestBlock) -> GenTx TestBlock
txForgetValidated (ValidatedGenTx GenTx TestBlock
tx) = GenTx TestBlock
tx

  getTransactionKeySets :: GenTx TestBlock -> LedgerTables (LedgerState TestBlock) KeysMK
getTransactionKeySets (TestBlockGenTx Tx
tx) = Tx -> LedgerTables (LedgerState TestBlock) KeysMK
forall ptype.
PayloadSemantics ptype =>
ptype -> LedgerTables (LedgerState (TestBlockWith ptype)) KeysMK
getPayloadKeySets Tx
tx

instance Ledger.TxLimits TestBlock where
  type TxMeasure TestBlock = Ledger.IgnoringOverflow Ledger.ByteSize32

  -- We tweaked this in such a way that we test the case in which we exceed the
  -- maximum mempool capacity. The value used here depends on 'txInBlockSize'.
  blockCapacityTxMeasure :: forall (mk :: MapKind).
LedgerConfig TestBlock
-> TickedLedgerState TestBlock mk -> TxMeasure TestBlock
blockCapacityTxMeasure LedgerConfig TestBlock
_cfg TickedLedgerState TestBlock mk
_st =
    ByteSize32 -> IgnoringOverflow ByteSize32
forall a. a -> IgnoringOverflow a
Ledger.IgnoringOverflow (ByteSize32 -> IgnoringOverflow ByteSize32)
-> ByteSize32 -> IgnoringOverflow ByteSize32
forall a b. (a -> b) -> a -> b
$ Word32 -> ByteSize32
Ledger.ByteSize32 Word32
20

  txMeasure :: LedgerConfig TestBlock
-> TickedLedgerState TestBlock ValuesMK
-> GenTx TestBlock
-> Except (ApplyTxErr TestBlock) (TxMeasure TestBlock)
txMeasure LedgerConfig TestBlock
_cfg TickedLedgerState TestBlock ValuesMK
_st = IgnoringOverflow ByteSize32
-> ExceptT
     TxApplicationError Identity (IgnoringOverflow ByteSize32)
forall a. a -> ExceptT TxApplicationError Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (IgnoringOverflow ByteSize32
 -> ExceptT
      TxApplicationError Identity (IgnoringOverflow ByteSize32))
-> (GenTx TestBlock -> IgnoringOverflow ByteSize32)
-> GenTx TestBlock
-> ExceptT
     TxApplicationError Identity (IgnoringOverflow ByteSize32)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteSize32 -> IgnoringOverflow ByteSize32
forall a. a -> IgnoringOverflow a
Ledger.IgnoringOverflow (ByteSize32 -> IgnoringOverflow ByteSize32)
-> (GenTx TestBlock -> ByteSize32)
-> GenTx TestBlock
-> IgnoringOverflow ByteSize32
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenTx TestBlock -> ByteSize32
txSize

newtype instance Ledger.TxId (Ledger.GenTx TestBlock) = TestBlockTxId Tx
  deriving stock (forall x.
 TxId (GenTx TestBlock) -> Rep (TxId (GenTx TestBlock)) x)
-> (forall x.
    Rep (TxId (GenTx TestBlock)) x -> TxId (GenTx TestBlock))
-> Generic (TxId (GenTx TestBlock))
forall x. Rep (TxId (GenTx TestBlock)) x -> TxId (GenTx TestBlock)
forall x. TxId (GenTx TestBlock) -> Rep (TxId (GenTx TestBlock)) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TxId (GenTx TestBlock) -> Rep (TxId (GenTx TestBlock)) x
from :: forall x. TxId (GenTx TestBlock) -> Rep (TxId (GenTx TestBlock)) x
$cto :: forall x. Rep (TxId (GenTx TestBlock)) x -> TxId (GenTx TestBlock)
to :: forall x. Rep (TxId (GenTx TestBlock)) x -> TxId (GenTx TestBlock)
Generic
  deriving newtype (Int -> TxId (GenTx TestBlock) -> ShowS
[TxId (GenTx TestBlock)] -> ShowS
TxId (GenTx TestBlock) -> String
(Int -> TxId (GenTx TestBlock) -> ShowS)
-> (TxId (GenTx TestBlock) -> String)
-> ([TxId (GenTx TestBlock)] -> ShowS)
-> Show (TxId (GenTx TestBlock))
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TxId (GenTx TestBlock) -> ShowS
showsPrec :: Int -> TxId (GenTx TestBlock) -> ShowS
$cshow :: TxId (GenTx TestBlock) -> String
show :: TxId (GenTx TestBlock) -> String
$cshowList :: [TxId (GenTx TestBlock)] -> ShowS
showList :: [TxId (GenTx TestBlock)] -> ShowS
Show, Eq (TxId (GenTx TestBlock))
Eq (TxId (GenTx TestBlock)) =>
(TxId (GenTx TestBlock) -> TxId (GenTx TestBlock) -> Ordering)
-> (TxId (GenTx TestBlock) -> TxId (GenTx TestBlock) -> Bool)
-> (TxId (GenTx TestBlock) -> TxId (GenTx TestBlock) -> Bool)
-> (TxId (GenTx TestBlock) -> TxId (GenTx TestBlock) -> Bool)
-> (TxId (GenTx TestBlock) -> TxId (GenTx TestBlock) -> Bool)
-> (TxId (GenTx TestBlock)
    -> TxId (GenTx TestBlock) -> TxId (GenTx TestBlock))
-> (TxId (GenTx TestBlock)
    -> TxId (GenTx TestBlock) -> TxId (GenTx TestBlock))
-> Ord (TxId (GenTx TestBlock))
TxId (GenTx TestBlock) -> TxId (GenTx TestBlock) -> Bool
TxId (GenTx TestBlock) -> TxId (GenTx TestBlock) -> Ordering
TxId (GenTx TestBlock)
-> TxId (GenTx TestBlock) -> TxId (GenTx TestBlock)
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TxId (GenTx TestBlock) -> TxId (GenTx TestBlock) -> Ordering
compare :: TxId (GenTx TestBlock) -> TxId (GenTx TestBlock) -> Ordering
$c< :: TxId (GenTx TestBlock) -> TxId (GenTx TestBlock) -> Bool
< :: TxId (GenTx TestBlock) -> TxId (GenTx TestBlock) -> Bool
$c<= :: TxId (GenTx TestBlock) -> TxId (GenTx TestBlock) -> Bool
<= :: TxId (GenTx TestBlock) -> TxId (GenTx TestBlock) -> Bool
$c> :: TxId (GenTx TestBlock) -> TxId (GenTx TestBlock) -> Bool
> :: TxId (GenTx TestBlock) -> TxId (GenTx TestBlock) -> Bool
$c>= :: TxId (GenTx TestBlock) -> TxId (GenTx TestBlock) -> Bool
>= :: TxId (GenTx TestBlock) -> TxId (GenTx TestBlock) -> Bool
$cmax :: TxId (GenTx TestBlock)
-> TxId (GenTx TestBlock) -> TxId (GenTx TestBlock)
max :: TxId (GenTx TestBlock)
-> TxId (GenTx TestBlock) -> TxId (GenTx TestBlock)
$cmin :: TxId (GenTx TestBlock)
-> TxId (GenTx TestBlock) -> TxId (GenTx TestBlock)
min :: TxId (GenTx TestBlock)
-> TxId (GenTx TestBlock) -> TxId (GenTx TestBlock)
Ord, TxId (GenTx TestBlock) -> TxId (GenTx TestBlock) -> Bool
(TxId (GenTx TestBlock) -> TxId (GenTx TestBlock) -> Bool)
-> (TxId (GenTx TestBlock) -> TxId (GenTx TestBlock) -> Bool)
-> Eq (TxId (GenTx TestBlock))
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TxId (GenTx TestBlock) -> TxId (GenTx TestBlock) -> Bool
== :: TxId (GenTx TestBlock) -> TxId (GenTx TestBlock) -> Bool
$c/= :: TxId (GenTx TestBlock) -> TxId (GenTx TestBlock) -> Bool
/= :: TxId (GenTx TestBlock) -> TxId (GenTx TestBlock) -> Bool
Eq)
  deriving anyclass Context -> TxId (GenTx TestBlock) -> IO (Maybe ThunkInfo)
Proxy (TxId (GenTx TestBlock)) -> String
(Context -> TxId (GenTx TestBlock) -> IO (Maybe ThunkInfo))
-> (Context -> TxId (GenTx TestBlock) -> IO (Maybe ThunkInfo))
-> (Proxy (TxId (GenTx TestBlock)) -> String)
-> NoThunks (TxId (GenTx TestBlock))
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> TxId (GenTx TestBlock) -> IO (Maybe ThunkInfo)
noThunks :: Context -> TxId (GenTx TestBlock) -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> TxId (GenTx TestBlock) -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> TxId (GenTx TestBlock) -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy (TxId (GenTx TestBlock)) -> String
showTypeOf :: Proxy (TxId (GenTx TestBlock)) -> String
NoThunks

instance Ledger.HasTxId (Ledger.GenTx TestBlock) where
  txId :: GenTx TestBlock -> TxId (GenTx TestBlock)
txId (TestBlockGenTx Tx
tx) = Tx -> TxId (GenTx TestBlock)
TestBlockTxId Tx
tx

newtype instance Ledger.Validated (Ledger.GenTx TestBlock)
  = ValidatedGenTx (Ledger.GenTx TestBlock)
  deriving stock (forall x.
 Validated (GenTx TestBlock) -> Rep (Validated (GenTx TestBlock)) x)
-> (forall x.
    Rep (Validated (GenTx TestBlock)) x -> Validated (GenTx TestBlock))
-> Generic (Validated (GenTx TestBlock))
forall x.
Rep (Validated (GenTx TestBlock)) x -> Validated (GenTx TestBlock)
forall x.
Validated (GenTx TestBlock) -> Rep (Validated (GenTx TestBlock)) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
Validated (GenTx TestBlock) -> Rep (Validated (GenTx TestBlock)) x
from :: forall x.
Validated (GenTx TestBlock) -> Rep (Validated (GenTx TestBlock)) x
$cto :: forall x.
Rep (Validated (GenTx TestBlock)) x -> Validated (GenTx TestBlock)
to :: forall x.
Rep (Validated (GenTx TestBlock)) x -> Validated (GenTx TestBlock)
Generic
  deriving newtype (Int -> Validated (GenTx TestBlock) -> ShowS
[Validated (GenTx TestBlock)] -> ShowS
Validated (GenTx TestBlock) -> String
(Int -> Validated (GenTx TestBlock) -> ShowS)
-> (Validated (GenTx TestBlock) -> String)
-> ([Validated (GenTx TestBlock)] -> ShowS)
-> Show (Validated (GenTx TestBlock))
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Validated (GenTx TestBlock) -> ShowS
showsPrec :: Int -> Validated (GenTx TestBlock) -> ShowS
$cshow :: Validated (GenTx TestBlock) -> String
show :: Validated (GenTx TestBlock) -> String
$cshowList :: [Validated (GenTx TestBlock)] -> ShowS
showList :: [Validated (GenTx TestBlock)] -> ShowS
Show, Context -> Validated (GenTx TestBlock) -> IO (Maybe ThunkInfo)
Proxy (Validated (GenTx TestBlock)) -> String
(Context -> Validated (GenTx TestBlock) -> IO (Maybe ThunkInfo))
-> (Context -> Validated (GenTx TestBlock) -> IO (Maybe ThunkInfo))
-> (Proxy (Validated (GenTx TestBlock)) -> String)
-> NoThunks (Validated (GenTx TestBlock))
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> Validated (GenTx TestBlock) -> IO (Maybe ThunkInfo)
noThunks :: Context -> Validated (GenTx TestBlock) -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> Validated (GenTx TestBlock) -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> Validated (GenTx TestBlock) -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy (Validated (GenTx TestBlock)) -> String
showTypeOf :: Proxy (Validated (GenTx TestBlock)) -> String
NoThunks)

type instance Ledger.ApplyTxErr TestBlock = TxApplicationError