{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
{-# OPTIONS_GHC -Wno-orphans #-}

-- | A Proof parameterized equality test, that records the 'sameness' of
--   individual record fields, this way it is possible to know where the
--   equality failed.
module Test.Cardano.Ledger.Generic.Same where

import Cardano.Ledger.Allegra.TxBody (AllegraTxBody (..))
import Cardano.Ledger.Alonzo.Tx (AlonzoTx (..))
import Cardano.Ledger.Alonzo.TxBody (AlonzoTxBody (..))
import Cardano.Ledger.Alonzo.TxSeq (AlonzoTxSeq (..))
import Cardano.Ledger.Alonzo.TxWits (AlonzoTxWits (..), Redeemers (..), TxDats (..))
import Cardano.Ledger.Babbage.TxBody (BabbageTxBody (..))
import Cardano.Ledger.Binary (sizedValue)
import Cardano.Ledger.Block (Block (..))
import Cardano.Ledger.Conway.Core
import Cardano.Ledger.Conway.Governance (VotingProcedures (..))
import Cardano.Ledger.Conway.TxBody (ConwayTxBody (..))
import Cardano.Ledger.Mary.TxBody (MaryTxBody (..))
import Cardano.Ledger.Shelley.API.Mempool (ApplyTxError)
import Cardano.Ledger.Shelley.BlockChain (ShelleyTxSeq (..))
import Cardano.Ledger.Shelley.LedgerState (
  CertState (..),
  DState (..),
  EpochState (..),
  LedgerState (..),
  NewEpochState (..),
  PState (..),
  StashedAVVMAddresses,
  UTxOState (..),
  VState (..),
  curPParamsEpochStateL,
  prevPParamsEpochStateL,
 )
import Cardano.Ledger.Shelley.PParams (ProposedPPUpdates (..))
import Cardano.Ledger.Shelley.Translation ()
import Cardano.Ledger.Shelley.Tx (ShelleyTx (..))
import Cardano.Ledger.Shelley.TxBody (ShelleyTxBody (..))
import Cardano.Ledger.Shelley.TxWits (ShelleyTxWits (..))
import Cardano.Ledger.UTxO (UTxO (..))
import Data.Foldable (toList)
import Lens.Micro ((^.))
import Prettyprinter (Doc, indent, viaShow, vsep)
import Test.Cardano.Ledger.Generic.PrettyCore
import Test.Cardano.Ledger.Generic.Proof
import Test.Cardano.Ledger.Shelley.Examples.Consensus (
  ShelleyLedgerExamples (..),
  ShelleyResultExamples (..),
 )
import Test.Cardano.Ledger.TerseTools

-- ===========================

instance Terse (KeyHash 'Genesis) where
  terse :: KeyHash 'Genesis -> String
terse KeyHash 'Genesis
x = forall a. Show a => a -> String
show (forall (discriminator :: KeyRole). KeyHash discriminator -> PDoc
pcKeyHash KeyHash 'Genesis
x)

instance Terse (PParamsUpdate ShelleyEra) where
  terse :: PParamsUpdate ShelleyEra -> String
terse = forall a. Show a => a -> String
show

instance Terse (PParamsUpdate AllegraEra) where
  terse :: PParamsUpdate AllegraEra -> String
terse = forall a. Show a => a -> String
show

instance Terse (PParamsUpdate MaryEra) where
  terse :: PParamsUpdate MaryEra -> String
terse = forall a. Show a => a -> String
show

instance Terse (PParamsUpdate AlonzoEra) where
  terse :: PParamsUpdate AlonzoEra -> String
terse = forall a. Show a => a -> String
show

instance Terse (PParamsUpdate BabbageEra) where
  terse :: PParamsUpdate BabbageEra -> String
terse = forall a. Show a => a -> String
show

instance Terse (PParamsUpdate ConwayEra) where
  terse :: PParamsUpdate ConwayEra -> String
terse = forall a. Show a => a -> String
show

-- ========================================
-- Helper functions

-- | Relabel by appending 's' to the front of the path
extendLabel :: String -> [(String, Maybe x)] -> [(String, Maybe x)]
extendLabel :: forall x. String -> [(String, Maybe x)] -> [(String, Maybe x)]
extendLabel String
_ [] = []
extendLabel String
s ((String
n, Maybe x
x) : [(String, Maybe x)]
xs) = (String
s forall a. [a] -> [a] -> [a]
++ String
n, Maybe x
x) forall a. a -> [a] -> [a]
: forall x. String -> [(String, Maybe x)] -> [(String, Maybe x)]
extendLabel String
s [(String, Maybe x)]
xs

-- | Dispays a difference vertically as
--   x
--     =/=
--   y
notEq :: Doc a -> Doc a -> Doc a
notEq :: forall a. Doc a -> Doc a -> Doc a
notEq Doc a
x Doc a
y = forall ann. [Doc ann] -> Doc ann
vsep [Doc a
x, forall ann. Int -> Doc ann -> Doc ann
indent Int
3 (forall ann. Text -> Doc ann
text Text
"=/="), Doc a
y]

-- | Compare for equality, and display difference using 'show'
eqByShow :: (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow :: forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow t
x t
y = if t
x forall a. Eq a => a -> a -> Bool
== t
y then forall a. Maybe a
Nothing else forall a. a -> Maybe a
Just (forall a. Doc a -> Doc a -> Doc a
notEq (forall a. String -> Doc a
ppString (forall a. Show a => a -> String
show t
x)) (forall a. String -> Doc a
ppString (forall a. Show a => a -> String
show t
y)))

-- | Compare for equality, and display differences using 'pcf'
eqVia :: Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia :: forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia t -> PDoc
pcf t
x t
y = if t
x forall a. Eq a => a -> a -> Bool
== t
y then forall a. Maybe a
Nothing else forall a. a -> Maybe a
Just (forall a. Doc a -> Doc a -> Doc a
notEq (t -> PDoc
pcf t
x) (t -> PDoc
pcf t
y))

-- ==========================================

-- | The Same class is similar to Eq but returns descriptions (paths and
--   non-matching components) for each difference in a large structure.
class Same era t where
  same :: Proof era -> t -> t -> [(String, Maybe PDoc)]

instance Same era (CertState era) where
  same :: Proof era
-> CertState era -> CertState era -> [(String, Maybe PDoc)]
same Proof era
proof (CertState VState era
d1 PState era
p1 DState era
v1) (CertState VState era
d2 PState era
p2 DState era
v2) =
    forall x. String -> [(String, Maybe x)] -> [(String, Maybe x)]
extendLabel String
"DState " (forall era t.
Same era t =>
Proof era -> t -> t -> [(String, Maybe PDoc)]
same Proof era
proof VState era
d1 VState era
d2)
      forall a. [a] -> [a] -> [a]
++ forall x. String -> [(String, Maybe x)] -> [(String, Maybe x)]
extendLabel String
"PState " (forall era t.
Same era t =>
Proof era -> t -> t -> [(String, Maybe PDoc)]
same Proof era
proof PState era
p1 PState era
p2)
      forall a. [a] -> [a] -> [a]
++ forall x. String -> [(String, Maybe x)] -> [(String, Maybe x)]
extendLabel String
"VState " (forall era t.
Same era t =>
Proof era -> t -> t -> [(String, Maybe PDoc)]
same Proof era
proof DState era
v1 DState era
v2)

instance Same era (PState era) where
  same :: Proof era -> PState era -> PState era -> [(String, Maybe PDoc)]
same Proof era
_proof (PState Map (KeyHash 'StakePool) PoolParams
pp1 Map (KeyHash 'StakePool) PoolParams
fpp1 Map (KeyHash 'StakePool) EpochNo
ret1 Map (KeyHash 'StakePool) Coin
d1) (PState Map (KeyHash 'StakePool) PoolParams
pp2 Map (KeyHash 'StakePool) PoolParams
fpp2 Map (KeyHash 'StakePool) EpochNo
ret2 Map (KeyHash 'StakePool) Coin
d2) =
    [ (String
"PoolParams", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow Map (KeyHash 'StakePool) PoolParams
pp1 Map (KeyHash 'StakePool) PoolParams
pp2)
    , (String
"FuturePoolParams", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow Map (KeyHash 'StakePool) PoolParams
fpp1 Map (KeyHash 'StakePool) PoolParams
fpp2)
    , (String
"Retiring", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow Map (KeyHash 'StakePool) EpochNo
ret1 Map (KeyHash 'StakePool) EpochNo
ret2)
    , (String
"Deposits", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow Map (KeyHash 'StakePool) Coin
d1 Map (KeyHash 'StakePool) Coin
d2)
    ]

instance Same era (DState era) where
  same :: Proof era -> DState era -> DState era -> [(String, Maybe PDoc)]
same Proof era
_proof (DState UMap
u1 Map FutureGenDeleg GenDelegPair
fgd1 GenDelegs
gd1 InstantaneousRewards
ir1) (DState UMap
u2 Map FutureGenDeleg GenDelegPair
fgd2 GenDelegs
gd2 InstantaneousRewards
ir2) =
    [ (String
"Unified", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow UMap
u1 UMap
u2)
    , (String
"FutureGenDelegs", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow Map FutureGenDeleg GenDelegPair
fgd1 Map FutureGenDeleg GenDelegPair
fgd2)
    , (String
"GenDelegs", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow GenDelegs
gd1 GenDelegs
gd2)
    , (String
"InstantaneousRewards", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow InstantaneousRewards
ir1 InstantaneousRewards
ir2)
    ]

instance Same era (VState era) where
  same :: Proof era -> VState era -> VState era -> [(String, Maybe PDoc)]
same Proof era
_proof (VState Map (Credential 'DRepRole) DRepState
dr1 CommitteeState era
cchk1 EpochNo
numDE1) (VState Map (Credential 'DRepRole) DRepState
dr2 CommitteeState era
cchk2 EpochNo
numDE2) =
    [ (String
"DReps", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow Map (Credential 'DRepRole) DRepState
dr1 Map (Credential 'DRepRole) DRepState
dr2)
    , (String
"CC Hot Keys", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow CommitteeState era
cchk1 CommitteeState era
cchk2)
    , (String
"Num Dormant Epochs", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow EpochNo
numDE1 EpochNo
numDE2)
    ]

sameUTxO :: Proof era -> UTxO era -> UTxO era -> Maybe PDoc
sameUTxO :: forall era. Proof era -> UTxO era -> UTxO era -> Maybe PDoc
sameUTxO Proof era
Shelley UTxO era
x UTxO era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow UTxO era
x UTxO era
y
sameUTxO Proof era
Allegra UTxO era
x UTxO era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow UTxO era
x UTxO era
y
sameUTxO Proof era
Mary UTxO era
x UTxO era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow UTxO era
x UTxO era
y
sameUTxO Proof era
Alonzo UTxO era
x UTxO era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow UTxO era
x UTxO era
y
sameUTxO Proof era
Babbage UTxO era
x UTxO era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow UTxO era
x UTxO era
y
sameUTxO Proof era
Conway UTxO era
x UTxO era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow UTxO era
x UTxO era
y
{-# NOINLINE sameUTxO #-}

samePPUP :: Proof era -> ShelleyGovState era -> ShelleyGovState era -> Maybe PDoc
samePPUP :: forall era.
Proof era
-> ShelleyGovState era -> ShelleyGovState era -> Maybe PDoc
samePPUP Proof era
Shelley ShelleyGovState era
x ShelleyGovState era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow ShelleyGovState era
x ShelleyGovState era
y
samePPUP Proof era
Allegra ShelleyGovState era
x ShelleyGovState era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow ShelleyGovState era
x ShelleyGovState era
y
samePPUP Proof era
Mary ShelleyGovState era
x ShelleyGovState era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow ShelleyGovState era
x ShelleyGovState era
y
samePPUP Proof era
Alonzo ShelleyGovState era
x ShelleyGovState era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow ShelleyGovState era
x ShelleyGovState era
y
samePPUP Proof era
Babbage ShelleyGovState era
x ShelleyGovState era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow ShelleyGovState era
x ShelleyGovState era
y
samePPUP Proof era
Conway ShelleyGovState era
x ShelleyGovState era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow ShelleyGovState era
x ShelleyGovState era
y
{-# NOINLINE samePPUP #-}

instance Reflect era => Same era (UTxOState era) where
  same :: Proof era
-> UTxOState era -> UTxOState era -> [(String, Maybe PDoc)]
same Proof era
proof UTxOState era
u1 UTxOState era
u2 =
    [ (String
"UTxO", forall era. Proof era -> UTxO era -> UTxO era -> Maybe PDoc
sameUTxO Proof era
proof (forall era. UTxOState era -> UTxO era
utxosUtxo UTxOState era
u1) (forall era. UTxOState era -> UTxO era
utxosUtxo UTxOState era
u2))
    , (String
"Deposited", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow (forall era. UTxOState era -> Coin
utxosDeposited UTxOState era
u1) (forall era. UTxOState era -> Coin
utxosDeposited UTxOState era
u2))
    , (String
"Fees", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow (forall era. UTxOState era -> Coin
utxosFees UTxOState era
u1) (forall era. UTxOState era -> Coin
utxosFees UTxOState era
u2))
    ]
      forall a. [a] -> [a] -> [a]
++ [(String, Maybe PDoc)]
ppu
      forall a. [a] -> [a] -> [a]
++ [(String
"StakeDistr", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow (forall era. UTxOState era -> IncrementalStake
utxosStakeDistr UTxOState era
u1) (forall era. UTxOState era -> IncrementalStake
utxosStakeDistr UTxOState era
u2))]
    where
      ppuPretty :: GovState era ~ ShelleyGovState era => [(String, Maybe PDoc)]
      ppuPretty :: (GovState era ~ ShelleyGovState era) => [(String, Maybe PDoc)]
ppuPretty = [(String
"ShelleyGovState", forall era.
Proof era
-> ShelleyGovState era -> ShelleyGovState era -> Maybe PDoc
samePPUP Proof era
proof (forall era. UTxOState era -> GovState era
utxosGovState UTxOState era
u1) (forall era. UTxOState era -> GovState era
utxosGovState UTxOState era
u2))]
      ppu :: [(String, Maybe PDoc)]
ppu = case forall era. Reflect era => Proof era
reify @era of
        Proof era
Shelley -> (GovState era ~ ShelleyGovState era) => [(String, Maybe PDoc)]
ppuPretty
        Proof era
Mary -> (GovState era ~ ShelleyGovState era) => [(String, Maybe PDoc)]
ppuPretty
        Proof era
Allegra -> (GovState era ~ ShelleyGovState era) => [(String, Maybe PDoc)]
ppuPretty
        Proof era
Alonzo -> (GovState era ~ ShelleyGovState era) => [(String, Maybe PDoc)]
ppuPretty
        Proof era
Babbage -> (GovState era ~ ShelleyGovState era) => [(String, Maybe PDoc)]
ppuPretty
        Proof era
Conway -> []

instance Reflect era => Same era (LedgerState era) where
  same :: Proof era
-> LedgerState era -> LedgerState era -> [(String, Maybe PDoc)]
same Proof era
proof LedgerState era
x1 LedgerState era
x2 =
    forall x. String -> [(String, Maybe x)] -> [(String, Maybe x)]
extendLabel String
"UTxOState " (forall era t.
Same era t =>
Proof era -> t -> t -> [(String, Maybe PDoc)]
same Proof era
proof (forall era. LedgerState era -> UTxOState era
lsUTxOState LedgerState era
x1) (forall era. LedgerState era -> UTxOState era
lsUTxOState LedgerState era
x2))
      forall a. [a] -> [a] -> [a]
++ forall x. String -> [(String, Maybe x)] -> [(String, Maybe x)]
extendLabel String
"CertState " (forall era t.
Same era t =>
Proof era -> t -> t -> [(String, Maybe PDoc)]
same Proof era
proof (forall era. LedgerState era -> CertState era
lsCertState LedgerState era
x1) (forall era. LedgerState era -> CertState era
lsCertState LedgerState era
x2))

instance Reflect era => Same era (EpochState era) where
  same :: Proof era
-> EpochState era -> EpochState era -> [(String, Maybe PDoc)]
same Proof era
proof EpochState era
e1 EpochState era
e2 =
    [ (String
"AccountState", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow (forall era. EpochState era -> AccountState
esAccountState EpochState era
e1) (forall era. EpochState era -> AccountState
esAccountState EpochState era
e2))
    , (String
"SnapShots", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow (forall era. EpochState era -> SnapShots
esSnapshots EpochState era
e1) (forall era. EpochState era -> SnapShots
esSnapshots EpochState era
e2))
    , (String
"PrevPP", forall era. Proof era -> PParams era -> PParams era -> Maybe PDoc
samePParams Proof era
proof (EpochState era
e1 forall s a. s -> Getting a s a -> a
^. forall era. EraGov era => Lens' (EpochState era) (PParams era)
prevPParamsEpochStateL) (EpochState era
e2 forall s a. s -> Getting a s a -> a
^. forall era. EraGov era => Lens' (EpochState era) (PParams era)
prevPParamsEpochStateL))
    , (String
"CurPP", forall era. Proof era -> PParams era -> PParams era -> Maybe PDoc
samePParams Proof era
proof (EpochState era
e1 forall s a. s -> Getting a s a -> a
^. forall era. EraGov era => Lens' (EpochState era) (PParams era)
curPParamsEpochStateL) (EpochState era
e2 forall s a. s -> Getting a s a -> a
^. forall era. EraGov era => Lens' (EpochState era) (PParams era)
curPParamsEpochStateL))
    , (String
"NonMyopic", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow (forall era. EpochState era -> NonMyopic
esNonMyopic EpochState era
e1) (forall era. EpochState era -> NonMyopic
esNonMyopic EpochState era
e2))
    ]
      forall a. [a] -> [a] -> [a]
++ forall x. String -> [(String, Maybe x)] -> [(String, Maybe x)]
extendLabel String
"LedgerState " (forall era t.
Same era t =>
Proof era -> t -> t -> [(String, Maybe PDoc)]
same Proof era
proof (forall era. EpochState era -> LedgerState era
esLState EpochState era
e1) (forall era. EpochState era -> LedgerState era
esLState EpochState era
e2))

sameStashedAVVMAddresses ::
  Proof era -> StashedAVVMAddresses era -> StashedAVVMAddresses era -> Maybe PDoc
sameStashedAVVMAddresses :: forall era.
Proof era
-> StashedAVVMAddresses era
-> StashedAVVMAddresses era
-> Maybe PDoc
sameStashedAVVMAddresses Proof era
proof StashedAVVMAddresses era
x StashedAVVMAddresses era
y =
  case Proof era
proof of
    Proof era
Shelley -> if StashedAVVMAddresses era
x forall a. Eq a => a -> a -> Bool
== StashedAVVMAddresses era
y then forall a. Maybe a
Nothing else forall a. a -> Maybe a
Just (forall a ann. Show a => a -> Doc ann
viaShow StashedAVVMAddresses era
x)
    Proof era
Allegra -> if StashedAVVMAddresses era
x forall a. Eq a => a -> a -> Bool
== StashedAVVMAddresses era
y then forall a. Maybe a
Nothing else forall a. a -> Maybe a
Just (forall a ann. Show a => a -> Doc ann
viaShow StashedAVVMAddresses era
x)
    Proof era
Mary -> if StashedAVVMAddresses era
x forall a. Eq a => a -> a -> Bool
== StashedAVVMAddresses era
y then forall a. Maybe a
Nothing else forall a. a -> Maybe a
Just (forall a ann. Show a => a -> Doc ann
viaShow StashedAVVMAddresses era
x)
    Proof era
Alonzo -> if StashedAVVMAddresses era
x forall a. Eq a => a -> a -> Bool
== StashedAVVMAddresses era
y then forall a. Maybe a
Nothing else forall a. a -> Maybe a
Just (forall a ann. Show a => a -> Doc ann
viaShow StashedAVVMAddresses era
x)
    Proof era
Babbage -> if StashedAVVMAddresses era
x forall a. Eq a => a -> a -> Bool
== StashedAVVMAddresses era
y then forall a. Maybe a
Nothing else forall a. a -> Maybe a
Just (forall a ann. Show a => a -> Doc ann
viaShow StashedAVVMAddresses era
x)
    Proof era
Conway -> if StashedAVVMAddresses era
x forall a. Eq a => a -> a -> Bool
== StashedAVVMAddresses era
y then forall a. Maybe a
Nothing else forall a. a -> Maybe a
Just (forall a ann. Show a => a -> Doc ann
viaShow StashedAVVMAddresses era
x)

instance
  Reflect era =>
  Same era (NewEpochState era)
  where
  same :: Proof era
-> NewEpochState era -> NewEpochState era -> [(String, Maybe PDoc)]
same Proof era
proof NewEpochState era
n1 NewEpochState era
n2 =
    [ (String
"nesEL", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow (forall era. NewEpochState era -> EpochNo
nesEL NewEpochState era
n1) (forall era. NewEpochState era -> EpochNo
nesEL NewEpochState era
n2))
    , (String
"nesBprev", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow (forall era. NewEpochState era -> BlocksMade
nesBprev NewEpochState era
n1) (forall era. NewEpochState era -> BlocksMade
nesBprev NewEpochState era
n2))
    , (String
"nesBcur", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow (forall era. NewEpochState era -> BlocksMade
nesBcur NewEpochState era
n1) (forall era. NewEpochState era -> BlocksMade
nesBcur NewEpochState era
n2))
    , (String
"nesRU", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow (forall era. NewEpochState era -> StrictMaybe PulsingRewUpdate
nesRu NewEpochState era
n1) (forall era. NewEpochState era -> StrictMaybe PulsingRewUpdate
nesRu NewEpochState era
n2))
    , (String
"nesPd", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow (forall era. NewEpochState era -> PoolDistr
nesPd NewEpochState era
n1) (forall era. NewEpochState era -> PoolDistr
nesPd NewEpochState era
n2))
    , (String
"nesStashAVVM", forall era.
Proof era
-> StashedAVVMAddresses era
-> StashedAVVMAddresses era
-> Maybe PDoc
sameStashedAVVMAddresses Proof era
proof (forall era. NewEpochState era -> StashedAVVMAddresses era
stashedAVVMAddresses NewEpochState era
n1) (forall era. NewEpochState era -> StashedAVVMAddresses era
stashedAVVMAddresses NewEpochState era
n2))
    ]
      forall a. [a] -> [a] -> [a]
++ forall x. String -> [(String, Maybe x)] -> [(String, Maybe x)]
extendLabel String
"EpochState " (forall era t.
Same era t =>
Proof era -> t -> t -> [(String, Maybe PDoc)]
same Proof era
proof (forall era. NewEpochState era -> EpochState era
nesEs NewEpochState era
n1) (forall era. NewEpochState era -> EpochState era
nesEs NewEpochState era
n2))

data SomeDepend where
  SomeD :: String -> (x -> x -> Maybe PDoc) -> x -> x -> SomeDepend
  SomeM :: String -> (x -> x -> [(String, Maybe PDoc)]) -> x -> x -> SomeDepend

-- | If x occurs in y then a difference in x forces a difference in y,
--   so only return the information on x if it has differences.
sameWithDependency :: [SomeDepend] -> [(String, Maybe PDoc)]
sameWithDependency :: [SomeDepend] -> [(String, Maybe PDoc)]
sameWithDependency [] = []
sameWithDependency (SomeD String
labx x -> x -> Maybe PDoc
actx x
x1 x
x2 : [SomeDepend]
more) =
  case x -> x -> Maybe PDoc
actx x
x1 x
x2 of
    Maybe PDoc
Nothing -> [SomeDepend] -> [(String, Maybe PDoc)]
sameWithDependency [SomeDepend]
more
    Maybe PDoc
ansx -> (String
labx, Maybe PDoc
ansx) forall a. a -> [a] -> [a]
: [SomeDepend] -> [(String, Maybe PDoc)]
sameWithDependency [SomeDepend]
more
sameWithDependency (SomeM String
labx x -> x -> [(String, Maybe PDoc)]
actx x
x1 x
x2 : [SomeDepend]
more) =
  case x -> x -> [(String, Maybe PDoc)]
actx x
x1 x
x2 of
    [] -> [SomeDepend] -> [(String, Maybe PDoc)]
sameWithDependency [SomeDepend]
more
    [(String, Maybe PDoc)]
ansx -> forall x. String -> [(String, Maybe x)] -> [(String, Maybe x)]
extendLabel (String
labx forall a. [a] -> [a] -> [a]
++ String
" ") [(String, Maybe PDoc)]
ansx forall a. [a] -> [a] -> [a]
++ [SomeDepend] -> [(String, Maybe PDoc)]
sameWithDependency [SomeDepend]
more

instance
  Reflect era =>
  Same era (ShelleyLedgerExamples era)
  where
  same :: Proof era
-> ShelleyLedgerExamples era
-> ShelleyLedgerExamples era
-> [(String, Maybe PDoc)]
same Proof era
proof ShelleyLedgerExamples era
x1 ShelleyLedgerExamples era
x2 = case (forall era.
ShelleyLedgerExamples era -> Block (BHeader StandardCrypto) era
sleBlock ShelleyLedgerExamples era
x1, forall era.
ShelleyLedgerExamples era -> Block (BHeader StandardCrypto) era
sleBlock ShelleyLedgerExamples era
x2) of
    (Block' BHeader StandardCrypto
h1 TxSeq era
a1 ByteString
_, Block' BHeader StandardCrypto
h2 TxSeq era
a2 ByteString
_) ->
      [SomeDepend] -> [(String, Maybe PDoc)]
sameWithDependency
        [ forall x.
String
-> (x -> x -> [(String, Maybe PDoc)]) -> x -> x -> SomeDepend
SomeM String
"Tx" (forall era.
Reflect era =>
Proof era -> Tx era -> Tx era -> [(String, Maybe PDoc)]
sameTx Proof era
proof) (forall era. ShelleyLedgerExamples era -> Tx era
sleTx ShelleyLedgerExamples era
x1) (forall era. ShelleyLedgerExamples era -> Tx era
sleTx ShelleyLedgerExamples era
x2)
        , forall x.
String
-> (x -> x -> [(String, Maybe PDoc)]) -> x -> x -> SomeDepend
SomeM String
"TxSeq" (forall era.
Reflect era =>
Proof era -> TxSeq era -> TxSeq era -> [(String, Maybe PDoc)]
sameTxSeq Proof era
proof) TxSeq era
a1 TxSeq era
a2
        ]
        forall a. [a] -> [a] -> [a]
++ [ (String
"BlockHeader", if BHeader StandardCrypto
h1 forall a. Eq a => a -> a -> Bool
== BHeader StandardCrypto
h2 then forall a. Maybe a
Nothing else forall a. a -> Maybe a
Just (PDoc
"UnequalBlockHeader"))
           ,
             ( String
"HashHeader"
             , if (forall era. ShelleyLedgerExamples era -> HashHeader
sleHashHeader ShelleyLedgerExamples era
x1) forall a. Eq a => a -> a -> Bool
== (forall era. ShelleyLedgerExamples era -> HashHeader
sleHashHeader ShelleyLedgerExamples era
x2)
                then forall a. Maybe a
Nothing
                else forall a. a -> Maybe a
Just (PDoc
"UnequalHashHeader")
             )
           , (String
"ApplyTxError", forall era.
Proof era -> ApplyTxError era -> ApplyTxError era -> Maybe PDoc
sameLedgerFail Proof era
proof (forall era. ShelleyLedgerExamples era -> ApplyTxError era
sleApplyTxError ShelleyLedgerExamples era
x1) (forall era. ShelleyLedgerExamples era -> ApplyTxError era
sleApplyTxError ShelleyLedgerExamples era
x2))
           , (String
"RewardsCredentials", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow (forall era.
ShelleyLedgerExamples era
-> Set (Either Coin (Credential 'Staking))
sleRewardsCredentials ShelleyLedgerExamples era
x1) (forall era.
ShelleyLedgerExamples era
-> Set (Either Coin (Credential 'Staking))
sleRewardsCredentials ShelleyLedgerExamples era
x2))
           ]
        forall a. [a] -> [a] -> [a]
++ forall x. String -> [(String, Maybe x)] -> [(String, Maybe x)]
extendLabel String
"Result " (forall era t.
Same era t =>
Proof era -> t -> t -> [(String, Maybe PDoc)]
same Proof era
proof (forall era. ShelleyLedgerExamples era -> ShelleyResultExamples era
sleResultExamples ShelleyLedgerExamples era
x1) (forall era. ShelleyLedgerExamples era -> ShelleyResultExamples era
sleResultExamples ShelleyLedgerExamples era
x2))
        forall a. [a] -> [a] -> [a]
++ forall x. String -> [(String, Maybe x)] -> [(String, Maybe x)]
extendLabel String
"NewEpochState " (forall era t.
Same era t =>
Proof era -> t -> t -> [(String, Maybe PDoc)]
same Proof era
proof (forall era. ShelleyLedgerExamples era -> NewEpochState era
sleNewEpochState ShelleyLedgerExamples era
x1) (forall era. ShelleyLedgerExamples era -> NewEpochState era
sleNewEpochState ShelleyLedgerExamples era
x2))
        forall a. [a] -> [a] -> [a]
++ [ (String
"ChainDepState", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow (forall era. ShelleyLedgerExamples era -> ChainDepState
sleChainDepState ShelleyLedgerExamples era
x1) (forall era. ShelleyLedgerExamples era -> ChainDepState
sleChainDepState ShelleyLedgerExamples era
x2))
           , (String
"TranslationContext", forall era.
Proof era
-> TranslationContext era -> TranslationContext era -> Maybe PDoc
sameTransCtx Proof era
proof (forall era. ShelleyLedgerExamples era -> TranslationContext era
sleTranslationContext ShelleyLedgerExamples era
x1) (forall era. ShelleyLedgerExamples era -> TranslationContext era
sleTranslationContext ShelleyLedgerExamples era
x2))
           ]

instance Era era => Same era (ShelleyResultExamples era) where
  same :: Proof era
-> ShelleyResultExamples era
-> ShelleyResultExamples era
-> [(String, Maybe PDoc)]
same Proof era
proof ShelleyResultExamples era
r1 ShelleyResultExamples era
r2 =
    [ (String
"PParams", forall era. Proof era -> PParams era -> PParams era -> Maybe PDoc
samePParams Proof era
proof (forall era. ShelleyResultExamples era -> PParams era
srePParams ShelleyResultExamples era
r1) (forall era. ShelleyResultExamples era -> PParams era
srePParams ShelleyResultExamples era
r2))
    ,
      ( String
"ProposedPPUpdates"
      , case Proof era
proof of
          Proof era
Shelley -> forall {era} {a}.
(Terse (PParamsUpdate era), Eq (PParamsHKD StrictMaybe era)) =>
ProposedPPUpdates era -> ProposedPPUpdates era -> Maybe (Doc a)
sameProposedPPUpdates (forall era. ShelleyResultExamples era -> ProposedPPUpdates era
sreProposedPPUpdates ShelleyResultExamples era
r1) (forall era. ShelleyResultExamples era -> ProposedPPUpdates era
sreProposedPPUpdates ShelleyResultExamples era
r2)
          Proof era
Allegra -> forall {era} {a}.
(Terse (PParamsUpdate era), Eq (PParamsHKD StrictMaybe era)) =>
ProposedPPUpdates era -> ProposedPPUpdates era -> Maybe (Doc a)
sameProposedPPUpdates (forall era. ShelleyResultExamples era -> ProposedPPUpdates era
sreProposedPPUpdates ShelleyResultExamples era
r1) (forall era. ShelleyResultExamples era -> ProposedPPUpdates era
sreProposedPPUpdates ShelleyResultExamples era
r2)
          Proof era
Mary -> forall {era} {a}.
(Terse (PParamsUpdate era), Eq (PParamsHKD StrictMaybe era)) =>
ProposedPPUpdates era -> ProposedPPUpdates era -> Maybe (Doc a)
sameProposedPPUpdates (forall era. ShelleyResultExamples era -> ProposedPPUpdates era
sreProposedPPUpdates ShelleyResultExamples era
r1) (forall era. ShelleyResultExamples era -> ProposedPPUpdates era
sreProposedPPUpdates ShelleyResultExamples era
r2)
          Proof era
Alonzo -> forall {era} {a}.
(Terse (PParamsUpdate era), Eq (PParamsHKD StrictMaybe era)) =>
ProposedPPUpdates era -> ProposedPPUpdates era -> Maybe (Doc a)
sameProposedPPUpdates (forall era. ShelleyResultExamples era -> ProposedPPUpdates era
sreProposedPPUpdates ShelleyResultExamples era
r1) (forall era. ShelleyResultExamples era -> ProposedPPUpdates era
sreProposedPPUpdates ShelleyResultExamples era
r2)
          Proof era
Babbage -> forall {era} {a}.
(Terse (PParamsUpdate era), Eq (PParamsHKD StrictMaybe era)) =>
ProposedPPUpdates era -> ProposedPPUpdates era -> Maybe (Doc a)
sameProposedPPUpdates (forall era. ShelleyResultExamples era -> ProposedPPUpdates era
sreProposedPPUpdates ShelleyResultExamples era
r1) (forall era. ShelleyResultExamples era -> ProposedPPUpdates era
sreProposedPPUpdates ShelleyResultExamples era
r2)
          Proof era
Conway -> forall {era} {a}.
(Terse (PParamsUpdate era), Eq (PParamsHKD StrictMaybe era)) =>
ProposedPPUpdates era -> ProposedPPUpdates era -> Maybe (Doc a)
sameProposedPPUpdates (forall era. ShelleyResultExamples era -> ProposedPPUpdates era
sreProposedPPUpdates ShelleyResultExamples era
r1) (forall era. ShelleyResultExamples era -> ProposedPPUpdates era
sreProposedPPUpdates ShelleyResultExamples era
r2)
      )
    , (String
"poolDistr", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow (forall era. ShelleyResultExamples era -> PoolDistr
srePoolDistr ShelleyResultExamples era
r1) (forall era. ShelleyResultExamples era -> PoolDistr
srePoolDistr ShelleyResultExamples era
r2))
    , (String
"NonMyopicRewards", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow (forall era.
ShelleyResultExamples era
-> Map
     (Either Coin (Credential 'Staking)) (Map (KeyHash 'StakePool) Coin)
sreNonMyopicRewards ShelleyResultExamples era
r1) (forall era.
ShelleyResultExamples era
-> Map
     (Either Coin (Credential 'Staking)) (Map (KeyHash 'StakePool) Coin)
sreNonMyopicRewards ShelleyResultExamples era
r2))
    , (String
"ShelleyGenesis", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow (forall era. ShelleyResultExamples era -> ShelleyGenesis
sreShelleyGenesis ShelleyResultExamples era
r1) (forall era. ShelleyResultExamples era -> ShelleyGenesis
sreShelleyGenesis ShelleyResultExamples era
r2))
    ]
    where
      getmap :: ProposedPPUpdates era -> Map (KeyHash 'Genesis) (PParamsUpdate era)
getmap (ProposedPPUpdates Map (KeyHash 'Genesis) (PParamsUpdate era)
x) = Map (KeyHash 'Genesis) (PParamsUpdate era)
x
      sameProposedPPUpdates :: ProposedPPUpdates era -> ProposedPPUpdates era -> Maybe (Doc a)
sameProposedPPUpdates ProposedPPUpdates era
x ProposedPPUpdates era
y = forall {a} {a}. Show a => [a] -> Maybe (Doc a)
ppDiff forall a b. (a -> b) -> a -> b
$ forall a b. (Ord a, Eq b) => Map a b -> Map a b -> [Case a b]
mapdiffs (forall {era}.
ProposedPPUpdates era -> Map (KeyHash 'Genesis) (PParamsUpdate era)
getmap ProposedPPUpdates era
x) (forall {era}.
ProposedPPUpdates era -> Map (KeyHash 'Genesis) (PParamsUpdate era)
getmap ProposedPPUpdates era
y)
        where
          ppDiff :: [a] -> Maybe (Doc a)
ppDiff [] = forall a. Maybe a
Nothing
          ppDiff [a]
xs = forall a. a -> Maybe a
Just (forall a. String -> Doc a
ppString (forall a. Show a => a -> String
show [a]
xs))

-- =========================================================================
-- Functions like 'same' from the 'Same' class, but which apply to type families
-- We cannot make them Same instances because they are type families.
-- We also can avoid all extra constraints by pattern matching against all current Proofs.

samePParams :: Proof era -> PParams era -> PParams era -> Maybe PDoc
samePParams :: forall era. Proof era -> PParams era -> PParams era -> Maybe PDoc
samePParams Proof era
Shelley PParams era
x PParams era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow PParams era
x PParams era
y
samePParams Proof era
Allegra PParams era
x PParams era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow PParams era
x PParams era
y
samePParams Proof era
Mary PParams era
x PParams era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow PParams era
x PParams era
y
samePParams Proof era
Alonzo PParams era
x PParams era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow PParams era
x PParams era
y
samePParams Proof era
Babbage PParams era
x PParams era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow PParams era
x PParams era
y
samePParams Proof era
Conway PParams era
x PParams era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow PParams era
x PParams era
y
{-# NOINLINE samePParams #-}

samePParamsUpdate :: Proof era -> PParamsUpdate era -> PParamsUpdate era -> Maybe PDoc
samePParamsUpdate :: forall era.
Proof era -> PParamsUpdate era -> PParamsUpdate era -> Maybe PDoc
samePParamsUpdate Proof era
Shelley PParamsUpdate era
x PParamsUpdate era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow PParamsUpdate era
x PParamsUpdate era
y
samePParamsUpdate Proof era
Allegra PParamsUpdate era
x PParamsUpdate era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow PParamsUpdate era
x PParamsUpdate era
y
samePParamsUpdate Proof era
Mary PParamsUpdate era
x PParamsUpdate era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow PParamsUpdate era
x PParamsUpdate era
y
samePParamsUpdate Proof era
Alonzo PParamsUpdate era
x PParamsUpdate era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow PParamsUpdate era
x PParamsUpdate era
y
samePParamsUpdate Proof era
Babbage PParamsUpdate era
x PParamsUpdate era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow PParamsUpdate era
x PParamsUpdate era
y
samePParamsUpdate Proof era
Conway PParamsUpdate era
x PParamsUpdate era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow PParamsUpdate era
x PParamsUpdate era
y
{-# NOINLINE samePParamsUpdate #-}

sameTxOut :: Proof era -> TxOut era -> TxOut era -> Maybe PDoc
sameTxOut :: forall era. Proof era -> TxOut era -> TxOut era -> Maybe PDoc
sameTxOut Proof era
Shelley TxOut era
x TxOut era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow TxOut era
x TxOut era
y
sameTxOut Proof era
Allegra TxOut era
x TxOut era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow TxOut era
x TxOut era
y
sameTxOut Proof era
Mary TxOut era
x TxOut era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow TxOut era
x TxOut era
y
sameTxOut Proof era
Alonzo TxOut era
x TxOut era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow TxOut era
x TxOut era
y
sameTxOut Proof era
Babbage TxOut era
x TxOut era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow TxOut era
x TxOut era
y
sameTxOut Proof era
Conway TxOut era
x TxOut era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow TxOut era
x TxOut era
y
{-# NOINLINE sameTxOut #-}

sameLedgerFail ::
  Proof era ->
  ApplyTxError era ->
  ApplyTxError era ->
  Maybe PDoc
sameLedgerFail :: forall era.
Proof era -> ApplyTxError era -> ApplyTxError era -> Maybe PDoc
sameLedgerFail Proof era
Shelley ApplyTxError era
x ApplyTxError era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow ApplyTxError era
x ApplyTxError era
y
sameLedgerFail Proof era
Allegra ApplyTxError era
x ApplyTxError era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow ApplyTxError era
x ApplyTxError era
y
sameLedgerFail Proof era
Mary ApplyTxError era
x ApplyTxError era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow ApplyTxError era
x ApplyTxError era
y
sameLedgerFail Proof era
Alonzo ApplyTxError era
x ApplyTxError era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow ApplyTxError era
x ApplyTxError era
y
sameLedgerFail Proof era
Babbage ApplyTxError era
x ApplyTxError era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow ApplyTxError era
x ApplyTxError era
y
sameLedgerFail Proof era
Conway ApplyTxError era
x ApplyTxError era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow ApplyTxError era
x ApplyTxError era
y
{-# NOINLINE sameLedgerFail #-}

sameTransCtx ::
  Proof era ->
  TranslationContext era ->
  TranslationContext era ->
  Maybe PDoc
sameTransCtx :: forall era.
Proof era
-> TranslationContext era -> TranslationContext era -> Maybe PDoc
sameTransCtx Proof era
Shelley TranslationContext era
x TranslationContext era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow TranslationContext era
x TranslationContext era
y
sameTransCtx Proof era
Allegra TranslationContext era
x TranslationContext era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow TranslationContext era
x TranslationContext era
y
sameTransCtx Proof era
Mary TranslationContext era
x TranslationContext era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow TranslationContext era
x TranslationContext era
y
sameTransCtx Proof era
Alonzo TranslationContext era
x TranslationContext era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow TranslationContext era
x TranslationContext era
y
sameTransCtx Proof era
Babbage TranslationContext era
x TranslationContext era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow TranslationContext era
x TranslationContext era
y
sameTransCtx Proof era
Conway TranslationContext era
x TranslationContext era
y = forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow TranslationContext era
x TranslationContext era
y
{-# NOINLINE sameTransCtx #-}

-- ==========================
-- Comparing witnesses for Sameness

sameShelleyTxWits ::
  forall era.
  Reflect era =>
  Proof era ->
  ShelleyTxWits era ->
  ShelleyTxWits era ->
  [(String, Maybe PDoc)]
sameShelleyTxWits :: forall era.
Reflect era =>
Proof era
-> ShelleyTxWits era -> ShelleyTxWits era -> [(String, Maybe PDoc)]
sameShelleyTxWits Proof era
proof (ShelleyTxWits Set (WitVKey 'Witness)
vk1 Map ScriptHash (Script era)
sh1 Set BootstrapWitness
boot1) (ShelleyTxWits Set (WitVKey 'Witness)
vk2 Map ScriptHash (Script era)
sh2 Set BootstrapWitness
boot2) =
  [ (String
"VKeyWits", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> Set x -> Doc ann
ppSet (forall era (keyrole :: KeyRole).
Typeable keyrole =>
Proof era -> WitVKey keyrole -> PDoc
pcWitVKey Proof era
proof)) Set (WitVKey 'Witness)
vk1 Set (WitVKey 'Witness)
vk2)
  , (String
"ScriptWits", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall k v. (k -> PDoc) -> (v -> PDoc) -> Map k v -> PDoc
ppMap ScriptHash -> PDoc
pcScriptHash (forall era. Reflect era => Proof era -> Script era -> PDoc
pcScript Proof era
proof)) Map ScriptHash (Script era)
sh1 Map ScriptHash (Script era)
sh2)
  , (String
"BootWits", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (\Set BootstrapWitness
_ -> forall a. String -> Doc a
ppString String
"BOOTWITS") Set BootstrapWitness
boot1 Set BootstrapWitness
boot2)
  ]

sameAlonzoTxWits ::
  forall era.
  (Reflect era, AlonzoEraScript era) =>
  Proof era ->
  AlonzoTxWits era ->
  AlonzoTxWits era ->
  [(String, Maybe PDoc)]
sameAlonzoTxWits :: forall era.
(Reflect era, AlonzoEraScript era) =>
Proof era
-> AlonzoTxWits era -> AlonzoTxWits era -> [(String, Maybe PDoc)]
sameAlonzoTxWits
  Proof era
proof
  (AlonzoTxWits Set (WitVKey 'Witness)
vk1 Set BootstrapWitness
boot1 Map ScriptHash (Script era)
sh1 (TxDats Map DataHash (Data era)
d1) (Redeemers Map (PlutusPurpose AsIx era) (Data era, ExUnits)
r1))
  (AlonzoTxWits Set (WitVKey 'Witness)
vk2 Set BootstrapWitness
boot2 Map ScriptHash (Script era)
sh2 (TxDats Map DataHash (Data era)
d2) (Redeemers Map (PlutusPurpose AsIx era) (Data era, ExUnits)
r2)) =
    [ (String
"VKeyWits", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> Set x -> Doc ann
ppSet (forall era (keyrole :: KeyRole).
Typeable keyrole =>
Proof era -> WitVKey keyrole -> PDoc
pcWitVKey Proof era
proof)) Set (WitVKey 'Witness)
vk1 Set (WitVKey 'Witness)
vk2)
    , (String
"BootWits", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (\Set BootstrapWitness
_ -> forall a. String -> Doc a
ppString String
"BOOTWITS") Set BootstrapWitness
boot1 Set BootstrapWitness
boot2)
    , (String
"ScriptWits", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall k v. (k -> PDoc) -> (v -> PDoc) -> Map k v -> PDoc
ppMap ScriptHash -> PDoc
pcScriptHash (forall era. Reflect era => Proof era -> Script era -> PDoc
pcScript Proof era
proof)) Map ScriptHash (Script era)
sh1 Map ScriptHash (Script era)
sh2)
    , (String
"DataWits", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall k v. (k -> PDoc) -> (v -> PDoc) -> Map k v -> PDoc
ppMap DataHash -> PDoc
pcDataHash forall era. Era era => Data era -> PDoc
pcData) Map DataHash (Data era)
d1 Map DataHash (Data era)
d2)
    , (String
"RedeemerWits", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall k v. (k -> PDoc) -> (v -> PDoc) -> Map k v -> PDoc
ppMap forall era. Reflect era => PlutusPurpose AsIx era -> PDoc
ppPlutusPurposeAsIx (forall t1 t2. (t1 -> PDoc) -> (t2 -> PDoc) -> (t1, t2) -> PDoc
pcPair forall era. Era era => Data era -> PDoc
pcData ExUnits -> PDoc
pcExUnits)) Map (PlutusPurpose AsIx era) (Data era, ExUnits)
r1 Map (PlutusPurpose AsIx era) (Data era, ExUnits)
r2)
    ]

sameTxWits :: Reflect era => Proof era -> TxWits era -> TxWits era -> [(String, Maybe PDoc)]
sameTxWits :: forall era.
Reflect era =>
Proof era -> TxWits era -> TxWits era -> [(String, Maybe PDoc)]
sameTxWits proof :: Proof era
proof@Proof era
Shelley TxWits era
x TxWits era
y = forall era.
Reflect era =>
Proof era
-> ShelleyTxWits era -> ShelleyTxWits era -> [(String, Maybe PDoc)]
sameShelleyTxWits Proof era
proof TxWits era
x TxWits era
y
sameTxWits proof :: Proof era
proof@Proof era
Allegra TxWits era
x TxWits era
y = forall era.
Reflect era =>
Proof era
-> ShelleyTxWits era -> ShelleyTxWits era -> [(String, Maybe PDoc)]
sameShelleyTxWits Proof era
proof TxWits era
x TxWits era
y
sameTxWits proof :: Proof era
proof@Proof era
Mary TxWits era
x TxWits era
y = forall era.
Reflect era =>
Proof era
-> ShelleyTxWits era -> ShelleyTxWits era -> [(String, Maybe PDoc)]
sameShelleyTxWits Proof era
proof TxWits era
x TxWits era
y
sameTxWits proof :: Proof era
proof@Proof era
Alonzo TxWits era
x TxWits era
y = forall era.
(Reflect era, AlonzoEraScript era) =>
Proof era
-> AlonzoTxWits era -> AlonzoTxWits era -> [(String, Maybe PDoc)]
sameAlonzoTxWits Proof era
proof TxWits era
x TxWits era
y
sameTxWits proof :: Proof era
proof@Proof era
Babbage TxWits era
x TxWits era
y = forall era.
(Reflect era, AlonzoEraScript era) =>
Proof era
-> AlonzoTxWits era -> AlonzoTxWits era -> [(String, Maybe PDoc)]
sameAlonzoTxWits Proof era
proof TxWits era
x TxWits era
y
sameTxWits proof :: Proof era
proof@Proof era
Conway TxWits era
x TxWits era
y = forall era.
(Reflect era, AlonzoEraScript era) =>
Proof era
-> AlonzoTxWits era -> AlonzoTxWits era -> [(String, Maybe PDoc)]
sameAlonzoTxWits Proof era
proof TxWits era
x TxWits era
y

-- =======================
-- Comparing TxBody for Sameness

sameShelleyTxBody ::
  Reflect era =>
  Proof era ->
  ShelleyTxBody era ->
  ShelleyTxBody era ->
  [(String, Maybe PDoc)]
sameShelleyTxBody :: forall era.
Reflect era =>
Proof era
-> ShelleyTxBody era -> ShelleyTxBody era -> [(String, Maybe PDoc)]
sameShelleyTxBody Proof era
proof (ShelleyTxBody Set TxIn
i1 StrictSeq (TxOut era)
o1 StrictSeq (TxCert era)
c1 (Withdrawals Map RewardAccount Coin
w1) Coin
f1 SlotNo
s1 StrictMaybe (Update era)
pu1 StrictMaybe TxAuxDataHash
d1) (ShelleyTxBody Set TxIn
i2 StrictSeq (TxOut era)
o2 StrictSeq (TxCert era)
c2 (Withdrawals Map RewardAccount Coin
w2) Coin
f2 SlotNo
s2 StrictMaybe (Update era)
pu2 StrictMaybe TxAuxDataHash
d2) =
  [ (String
"Inputs", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> Set x -> Doc ann
ppSet TxIn -> PDoc
pcTxIn) Set TxIn
i1 Set TxIn
i2)
  , (String
"Outputs", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> [x] -> Doc ann
ppList (forall era. Reflect era => Proof era -> TxOut era -> PDoc
pcTxOut Proof era
proof) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t a -> [a]
toList) StrictSeq (TxOut era)
o1 StrictSeq (TxOut era)
o2)
  , (String
"TxCert", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> [x] -> Doc ann
ppList (forall era. Proof era -> TxCert era -> PDoc
pcTxCert Proof era
proof) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t a -> [a]
toList) StrictSeq (TxCert era)
c1 StrictSeq (TxCert era)
c2)
  , (String
"WDRL", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall k v. (k -> PDoc) -> (v -> PDoc) -> Map k v -> PDoc
ppMap RewardAccount -> PDoc
pcRewardAccount Coin -> PDoc
pcCoin) Map RewardAccount Coin
w1 Map RewardAccount Coin
w2)
  , (String
"Fee", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia Coin -> PDoc
pcCoin Coin
f1 Coin
f2)
  , (String
"TimeToLive", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia SlotNo -> PDoc
pcSlotNo SlotNo
s1 SlotNo
s2)
  , (String
"PPupdate", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (\StrictMaybe (Update era)
_ -> forall a. String -> Doc a
ppString String
"Update") StrictMaybe (Update era)
pu1 StrictMaybe (Update era)
pu2)
  , (String
"TxAuxDataHash", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> StrictMaybe x -> Doc ann
ppStrictMaybe (\(TxAuxDataHash SafeHash EraIndependentTxAuxData
h) -> PDoc -> PDoc
trim (forall index. SafeHash index -> PDoc
ppSafeHash SafeHash EraIndependentTxAuxData
h))) StrictMaybe TxAuxDataHash
d1 StrictMaybe TxAuxDataHash
d2)
  ]

sameAllegraTxBody ::
  Reflect era =>
  Proof era ->
  AllegraTxBody era ->
  AllegraTxBody era ->
  [(String, Maybe PDoc)]
sameAllegraTxBody :: forall era.
Reflect era =>
Proof era
-> AllegraTxBody era -> AllegraTxBody era -> [(String, Maybe PDoc)]
sameAllegraTxBody Proof era
proof (AllegraTxBody Set TxIn
i1 StrictSeq (TxOut era)
o1 StrictSeq (TxCert era)
c1 (Withdrawals Map RewardAccount Coin
w1) Coin
f1 ValidityInterval
v1 StrictMaybe (Update era)
pu1 StrictMaybe TxAuxDataHash
d1) (AllegraTxBody Set TxIn
i2 StrictSeq (TxOut era)
o2 StrictSeq (TxCert era)
c2 (Withdrawals Map RewardAccount Coin
w2) Coin
f2 ValidityInterval
v2 StrictMaybe (Update era)
pu2 StrictMaybe TxAuxDataHash
d2) =
  [ (String
"Inputs", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> Set x -> Doc ann
ppSet TxIn -> PDoc
pcTxIn) Set TxIn
i1 Set TxIn
i2)
  , (String
"Outputs", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> [x] -> Doc ann
ppList (forall era. Reflect era => Proof era -> TxOut era -> PDoc
pcTxOut Proof era
proof) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t a -> [a]
toList) StrictSeq (TxOut era)
o1 StrictSeq (TxOut era)
o2)
  , (String
"TxCert", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> [x] -> Doc ann
ppList (forall era. Proof era -> TxCert era -> PDoc
pcTxCert Proof era
proof) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t a -> [a]
toList) StrictSeq (TxCert era)
c1 StrictSeq (TxCert era)
c2)
  , (String
"WDRL", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall k v. (k -> PDoc) -> (v -> PDoc) -> Map k v -> PDoc
ppMap RewardAccount -> PDoc
pcRewardAccount Coin -> PDoc
pcCoin) Map RewardAccount Coin
w1 Map RewardAccount Coin
w2)
  , (String
"Fee", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia Coin -> PDoc
pcCoin Coin
f1 Coin
f2)
  , (String
"ValidityInterval", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia ValidityInterval -> PDoc
ppValidityInterval ValidityInterval
v1 ValidityInterval
v2)
  , (String
"PPupdate", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (\StrictMaybe (Update era)
_ -> forall a. String -> Doc a
ppString String
"Update") StrictMaybe (Update era)
pu1 StrictMaybe (Update era)
pu2)
  , (String
"TxAuxDataHash", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> StrictMaybe x -> Doc ann
ppStrictMaybe (\(TxAuxDataHash SafeHash EraIndependentTxAuxData
h) -> PDoc -> PDoc
trim (forall index. SafeHash index -> PDoc
ppSafeHash SafeHash EraIndependentTxAuxData
h))) StrictMaybe TxAuxDataHash
d1 StrictMaybe TxAuxDataHash
d2)
  ]

sameMaryTxBody ::
  Reflect era =>
  Proof era ->
  MaryTxBody era ->
  MaryTxBody era ->
  [(String, Maybe PDoc)]
sameMaryTxBody :: forall era.
Reflect era =>
Proof era
-> MaryTxBody era -> MaryTxBody era -> [(String, Maybe PDoc)]
sameMaryTxBody Proof era
proof (MaryTxBody Set TxIn
i1 StrictSeq (TxOut era)
o1 StrictSeq (TxCert era)
c1 (Withdrawals Map RewardAccount Coin
w1) Coin
f1 ValidityInterval
v1 StrictMaybe (Update era)
pu1 StrictMaybe TxAuxDataHash
d1 MultiAsset
m1) (MaryTxBody Set TxIn
i2 StrictSeq (TxOut era)
o2 StrictSeq (TxCert era)
c2 (Withdrawals Map RewardAccount Coin
w2) Coin
f2 ValidityInterval
v2 StrictMaybe (Update era)
pu2 StrictMaybe TxAuxDataHash
d2 MultiAsset
m2) =
  [ (String
"Inputs", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> Set x -> Doc ann
ppSet TxIn -> PDoc
pcTxIn) Set TxIn
i1 Set TxIn
i2)
  , (String
"Outputs", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> [x] -> Doc ann
ppList (forall era. Reflect era => Proof era -> TxOut era -> PDoc
pcTxOut Proof era
proof) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t a -> [a]
toList) StrictSeq (TxOut era)
o1 StrictSeq (TxOut era)
o2)
  , (String
"TxCert", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> [x] -> Doc ann
ppList (forall era. Proof era -> TxCert era -> PDoc
pcTxCert Proof era
proof) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t a -> [a]
toList) StrictSeq (TxCert era)
c1 StrictSeq (TxCert era)
c2)
  , (String
"WDRL", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall k v. (k -> PDoc) -> (v -> PDoc) -> Map k v -> PDoc
ppMap RewardAccount -> PDoc
pcRewardAccount Coin -> PDoc
pcCoin) Map RewardAccount Coin
w1 Map RewardAccount Coin
w2)
  , (String
"Fee", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia Coin -> PDoc
pcCoin Coin
f1 Coin
f2)
  , (String
"ValidityInterval", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia ValidityInterval -> PDoc
ppValidityInterval ValidityInterval
v1 ValidityInterval
v2)
  , (String
"PPupdate", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (\StrictMaybe (Update era)
_ -> forall a. String -> Doc a
ppString String
"Update") StrictMaybe (Update era)
pu1 StrictMaybe (Update era)
pu2)
  , (String
"TxAuxDataHash", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> StrictMaybe x -> Doc ann
ppStrictMaybe (\(TxAuxDataHash SafeHash EraIndependentTxAuxData
h) -> PDoc -> PDoc
trim (forall index. SafeHash index -> PDoc
ppSafeHash SafeHash EraIndependentTxAuxData
h))) StrictMaybe TxAuxDataHash
d1 StrictMaybe TxAuxDataHash
d2)
  , (String
"Mint", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia MultiAsset -> PDoc
multiAssetSummary MultiAsset
m1 MultiAsset
m2)
  ]

sameAlonzoTxBody ::
  Reflect era =>
  Proof era ->
  AlonzoTxBody era ->
  AlonzoTxBody era ->
  [(String, Maybe PDoc)]
sameAlonzoTxBody :: forall era.
Reflect era =>
Proof era
-> AlonzoTxBody era -> AlonzoTxBody era -> [(String, Maybe PDoc)]
sameAlonzoTxBody
  Proof era
proof
  (AlonzoTxBody Set TxIn
i1 Set TxIn
cl1 StrictSeq (TxOut era)
o1 StrictSeq (TxCert era)
c1 (Withdrawals Map RewardAccount Coin
w1) Coin
f1 ValidityInterval
v1 StrictMaybe (Update era)
pu1 Set (KeyHash 'Witness)
r1 MultiAsset
m1 StrictMaybe (SafeHash EraIndependentScriptIntegrity)
s1 StrictMaybe TxAuxDataHash
d1 StrictMaybe Network
n1)
  (AlonzoTxBody Set TxIn
i2 Set TxIn
cl2 StrictSeq (TxOut era)
o2 StrictSeq (TxCert era)
c2 (Withdrawals Map RewardAccount Coin
w2) Coin
f2 ValidityInterval
v2 StrictMaybe (Update era)
pu2 Set (KeyHash 'Witness)
r2 MultiAsset
m2 StrictMaybe (SafeHash EraIndependentScriptIntegrity)
s2 StrictMaybe TxAuxDataHash
d2 StrictMaybe Network
n2) =
    [ (String
"Inputs", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> Set x -> Doc ann
ppSet TxIn -> PDoc
pcTxIn) Set TxIn
i1 Set TxIn
i2)
    , (String
"Collateral", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> Set x -> Doc ann
ppSet TxIn -> PDoc
pcTxIn) Set TxIn
cl1 Set TxIn
cl2)
    , (String
"Outputs", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> [x] -> Doc ann
ppList (forall era. Reflect era => Proof era -> TxOut era -> PDoc
pcTxOut Proof era
proof) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t a -> [a]
toList) StrictSeq (TxOut era)
o1 StrictSeq (TxOut era)
o2)
    , (String
"Certs", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> [x] -> Doc ann
ppList (forall era. Proof era -> TxCert era -> PDoc
pcTxCert Proof era
proof) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t a -> [a]
toList) StrictSeq (TxCert era)
c1 StrictSeq (TxCert era)
c2)
    , (String
"WDRL", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall k v. (k -> PDoc) -> (v -> PDoc) -> Map k v -> PDoc
ppMap RewardAccount -> PDoc
pcRewardAccount Coin -> PDoc
pcCoin) Map RewardAccount Coin
w1 Map RewardAccount Coin
w2)
    , (String
"Fee", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia Coin -> PDoc
pcCoin Coin
f1 Coin
f2)
    , (String
"ValidityInterval", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia ValidityInterval -> PDoc
ppValidityInterval ValidityInterval
v1 ValidityInterval
v2)
    , (String
"PPupdate", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (\StrictMaybe (Update era)
_ -> forall a. String -> Doc a
ppString String
"Update") StrictMaybe (Update era)
pu1 StrictMaybe (Update era)
pu2)
    , (String
"ReqSignerHashes", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> Set x -> Doc ann
ppSet forall (discriminator :: KeyRole). KeyHash discriminator -> PDoc
pcKeyHash) Set (KeyHash 'Witness)
r1 Set (KeyHash 'Witness)
r2)
    , (String
"Mint", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia MultiAsset -> PDoc
multiAssetSummary MultiAsset
m1 MultiAsset
m2)
    , (String
"ScriptIntegrityHash", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> StrictMaybe x -> Doc ann
ppStrictMaybe (PDoc -> PDoc
trim forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall index. SafeHash index -> PDoc
ppSafeHash)) StrictMaybe (SafeHash EraIndependentScriptIntegrity)
s1 StrictMaybe (SafeHash EraIndependentScriptIntegrity)
s2)
    , (String
"TxAuxDataHash", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> StrictMaybe x -> Doc ann
ppStrictMaybe (\(TxAuxDataHash SafeHash EraIndependentTxAuxData
h) -> PDoc -> PDoc
trim (forall index. SafeHash index -> PDoc
ppSafeHash SafeHash EraIndependentTxAuxData
h))) StrictMaybe TxAuxDataHash
d1 StrictMaybe TxAuxDataHash
d2)
    , (String
"NetworkId", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> StrictMaybe x -> Doc ann
ppStrictMaybe Network -> PDoc
pcNetwork) StrictMaybe Network
n1 StrictMaybe Network
n2)
    ]

sameBabbageTxBody ::
  ( Reflect era
  , BabbageEraTxBody era
  ) =>
  Proof era ->
  BabbageTxBody era ->
  BabbageTxBody era ->
  [(String, Maybe PDoc)]
sameBabbageTxBody :: forall era.
(Reflect era, BabbageEraTxBody era) =>
Proof era
-> BabbageTxBody era -> BabbageTxBody era -> [(String, Maybe PDoc)]
sameBabbageTxBody
  Proof era
proof
  (BabbageTxBody Set TxIn
i1 Set TxIn
cl1 Set TxIn
ri1 StrictSeq (Sized (TxOut era))
o1 StrictMaybe (Sized (TxOut era))
cr1 StrictMaybe Coin
tc1 StrictSeq (TxCert era)
c1 (Withdrawals Map RewardAccount Coin
w1) Coin
f1 ValidityInterval
v1 StrictMaybe (Update era)
pu1 Set (KeyHash 'Witness)
r1 MultiAsset
m1 StrictMaybe (SafeHash EraIndependentScriptIntegrity)
s1 StrictMaybe TxAuxDataHash
d1 StrictMaybe Network
n1)
  (BabbageTxBody Set TxIn
i2 Set TxIn
cl2 Set TxIn
ri2 StrictSeq (Sized (TxOut era))
o2 StrictMaybe (Sized (TxOut era))
cr2 StrictMaybe Coin
tc2 StrictSeq (TxCert era)
c2 (Withdrawals Map RewardAccount Coin
w2) Coin
f2 ValidityInterval
v2 StrictMaybe (Update era)
pu2 Set (KeyHash 'Witness)
r2 MultiAsset
m2 StrictMaybe (SafeHash EraIndependentScriptIntegrity)
s2 StrictMaybe TxAuxDataHash
d2 StrictMaybe Network
n2) =
    [ (String
"SpendInputs", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> Set x -> Doc ann
ppSet TxIn -> PDoc
pcTxIn) Set TxIn
i1 Set TxIn
i2)
    , (String
"ColInputs", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> Set x -> Doc ann
ppSet TxIn -> PDoc
pcTxIn) Set TxIn
cl1 Set TxIn
cl2)
    , (String
"RefInputs", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> Set x -> Doc ann
ppSet TxIn -> PDoc
pcTxIn) Set TxIn
ri1 Set TxIn
ri2)
    , (String
"Outputs", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> [x] -> Doc ann
ppList (forall era. Reflect era => Proof era -> TxOut era -> PDoc
pcTxOut Proof era
proof forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Sized a -> a
sizedValue) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t a -> [a]
toList) StrictSeq (Sized (TxOut era))
o1 StrictSeq (Sized (TxOut era))
o2)
    , (String
"ColReturn", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> StrictMaybe x -> Doc ann
ppStrictMaybe (forall era. Reflect era => Proof era -> TxOut era -> PDoc
pcTxOut Proof era
proof forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Sized a -> a
sizedValue)) StrictMaybe (Sized (TxOut era))
cr1 StrictMaybe (Sized (TxOut era))
cr2)
    , (String
"TotalCol", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> StrictMaybe x -> Doc ann
ppStrictMaybe Coin -> PDoc
pcCoin) StrictMaybe Coin
tc1 StrictMaybe Coin
tc2)
    , (String
"Certs", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> [x] -> Doc ann
ppList (forall era. Proof era -> TxCert era -> PDoc
pcTxCert Proof era
proof) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t a -> [a]
toList) StrictSeq (TxCert era)
c1 StrictSeq (TxCert era)
c2)
    , (String
"WDRL", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall k v. (k -> PDoc) -> (v -> PDoc) -> Map k v -> PDoc
ppMap RewardAccount -> PDoc
pcRewardAccount Coin -> PDoc
pcCoin) Map RewardAccount Coin
w1 Map RewardAccount Coin
w2)
    , (String
"Fee", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia Coin -> PDoc
pcCoin Coin
f1 Coin
f2)
    , (String
"ValidityInterval", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia ValidityInterval -> PDoc
ppValidityInterval ValidityInterval
v1 ValidityInterval
v2)
    , (String
"PPupdate", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (\StrictMaybe (Update era)
_ -> forall a. String -> Doc a
ppString String
"Update") StrictMaybe (Update era)
pu1 StrictMaybe (Update era)
pu2)
    , (String
"ReqSignerHashes", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> Set x -> Doc ann
ppSet forall (discriminator :: KeyRole). KeyHash discriminator -> PDoc
pcKeyHash) Set (KeyHash 'Witness)
r1 Set (KeyHash 'Witness)
r2)
    , (String
"Mint", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia MultiAsset -> PDoc
multiAssetSummary MultiAsset
m1 MultiAsset
m2)
    , (String
"ScriptIntegrityHash", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> StrictMaybe x -> Doc ann
ppStrictMaybe (PDoc -> PDoc
trim forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall index. SafeHash index -> PDoc
ppSafeHash)) StrictMaybe (SafeHash EraIndependentScriptIntegrity)
s1 StrictMaybe (SafeHash EraIndependentScriptIntegrity)
s2)
    , (String
"TxAuxDataHash", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> StrictMaybe x -> Doc ann
ppStrictMaybe (\(TxAuxDataHash SafeHash EraIndependentTxAuxData
h) -> PDoc -> PDoc
trim (forall index. SafeHash index -> PDoc
ppSafeHash SafeHash EraIndependentTxAuxData
h))) StrictMaybe TxAuxDataHash
d1 StrictMaybe TxAuxDataHash
d2)
    , (String
"NetworkId", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> StrictMaybe x -> Doc ann
ppStrictMaybe Network -> PDoc
pcNetwork) StrictMaybe Network
n1 StrictMaybe Network
n2)
    ]

sameConwayTxBody ::
  ( ConwayEraTxBody era
  , Reflect era
  ) =>
  Proof era ->
  ConwayTxBody era ->
  ConwayTxBody era ->
  [(String, Maybe PDoc)]
sameConwayTxBody :: forall era.
(ConwayEraTxBody era, Reflect era) =>
Proof era
-> ConwayTxBody era -> ConwayTxBody era -> [(String, Maybe PDoc)]
sameConwayTxBody
  Proof era
proof
  (ConwayTxBody Set TxIn
i1 Set TxIn
cl1 Set TxIn
ri1 StrictSeq (Sized (TxOut era))
o1 StrictMaybe (Sized (TxOut era))
cr1 StrictMaybe Coin
tc1 OSet (ConwayTxCert era)
c1 (Withdrawals Map RewardAccount Coin
w1) Coin
f1 ValidityInterval
v1 Set (KeyHash 'Witness)
r1 MultiAsset
m1 StrictMaybe (SafeHash EraIndependentScriptIntegrity)
s1 StrictMaybe TxAuxDataHash
d1 StrictMaybe Network
n1 VotingProcedures era
vp1 OSet (ProposalProcedure era)
pp1 StrictMaybe Coin
ctv1 Coin
td1)
  (ConwayTxBody Set TxIn
i2 Set TxIn
cl2 Set TxIn
ri2 StrictSeq (Sized (TxOut era))
o2 StrictMaybe (Sized (TxOut era))
cr2 StrictMaybe Coin
tc2 OSet (ConwayTxCert era)
c2 (Withdrawals Map RewardAccount Coin
w2) Coin
f2 ValidityInterval
v2 Set (KeyHash 'Witness)
r2 MultiAsset
m2 StrictMaybe (SafeHash EraIndependentScriptIntegrity)
s2 StrictMaybe TxAuxDataHash
d2 StrictMaybe Network
n2 VotingProcedures era
vp2 OSet (ProposalProcedure era)
pp2 StrictMaybe Coin
ctv2 Coin
td2) =
    [ (String
"SpendInputs", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> Set x -> Doc ann
ppSet TxIn -> PDoc
pcTxIn) Set TxIn
i1 Set TxIn
i2)
    , (String
"ColInputs", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> Set x -> Doc ann
ppSet TxIn -> PDoc
pcTxIn) Set TxIn
cl1 Set TxIn
cl2)
    , (String
"RefInputs", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> Set x -> Doc ann
ppSet TxIn -> PDoc
pcTxIn) Set TxIn
ri1 Set TxIn
ri2)
    , (String
"Outputs", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> [x] -> Doc ann
ppList (forall era. Reflect era => Proof era -> TxOut era -> PDoc
pcTxOut Proof era
proof forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Sized a -> a
sizedValue) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t a -> [a]
toList) StrictSeq (Sized (TxOut era))
o1 StrictSeq (Sized (TxOut era))
o2)
    , (String
"ColReturn", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> StrictMaybe x -> Doc ann
ppStrictMaybe (forall era. Reflect era => Proof era -> TxOut era -> PDoc
pcTxOut Proof era
proof forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Sized a -> a
sizedValue)) StrictMaybe (Sized (TxOut era))
cr1 StrictMaybe (Sized (TxOut era))
cr2)
    , (String
"TotalCol", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> StrictMaybe x -> Doc ann
ppStrictMaybe Coin -> PDoc
pcCoin) StrictMaybe Coin
tc1 StrictMaybe Coin
tc2)
    , (String
"Certs", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> [x] -> Doc ann
ppList forall c. ConwayTxCert c -> PDoc
pcConwayTxCert forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t a -> [a]
toList) OSet (ConwayTxCert era)
c1 OSet (ConwayTxCert era)
c2)
    , (String
"WDRL", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall k v. (k -> PDoc) -> (v -> PDoc) -> Map k v -> PDoc
ppMap RewardAccount -> PDoc
pcRewardAccount Coin -> PDoc
pcCoin) Map RewardAccount Coin
w1 Map RewardAccount Coin
w2)
    , (String
"Fee", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia Coin -> PDoc
pcCoin Coin
f1 Coin
f2)
    , (String
"ValidityInterval", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia ValidityInterval -> PDoc
ppValidityInterval ValidityInterval
v1 ValidityInterval
v2)
    , (String
"ReqSignerHashes", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> Set x -> Doc ann
ppSet forall (discriminator :: KeyRole). KeyHash discriminator -> PDoc
pcKeyHash) Set (KeyHash 'Witness)
r1 Set (KeyHash 'Witness)
r2)
    , (String
"Mint", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia MultiAsset -> PDoc
multiAssetSummary MultiAsset
m1 MultiAsset
m2)
    , (String
"ScriptIntegrityHash", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> StrictMaybe x -> Doc ann
ppStrictMaybe (PDoc -> PDoc
trim forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall index. SafeHash index -> PDoc
ppSafeHash)) StrictMaybe (SafeHash EraIndependentScriptIntegrity)
s1 StrictMaybe (SafeHash EraIndependentScriptIntegrity)
s2)
    , (String
"TxAuxDataHash", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> StrictMaybe x -> Doc ann
ppStrictMaybe (\(TxAuxDataHash SafeHash EraIndependentTxAuxData
h) -> PDoc -> PDoc
trim (forall index. SafeHash index -> PDoc
ppSafeHash SafeHash EraIndependentTxAuxData
h))) StrictMaybe TxAuxDataHash
d1 StrictMaybe TxAuxDataHash
d2)
    , (String
"NetworkId", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> StrictMaybe x -> Doc ann
ppStrictMaybe Network -> PDoc
pcNetwork) StrictMaybe Network
n1 StrictMaybe Network
n2)
    ,
      ( String
"VotingProcedures"
      , forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia
          (forall k v. (k -> PDoc) -> (v -> PDoc) -> Map k v -> PDoc
ppMap Voter -> PDoc
pcVoter (forall k v. (k -> PDoc) -> (v -> PDoc) -> Map k v -> PDoc
ppMap GovActionId -> PDoc
pcGovActionId forall era. VotingProcedure era -> PDoc
pcVotingProcedure))
          (forall era.
VotingProcedures era
-> Map Voter (Map GovActionId (VotingProcedure era))
unVotingProcedures VotingProcedures era
vp1)
          (forall era.
VotingProcedures era
-> Map Voter (Map GovActionId (VotingProcedure era))
unVotingProcedures VotingProcedures era
vp2)
      )
    , (String
"ProposalProcedures", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall a ann. (a -> Doc ann) -> OSet a -> Doc ann
ppOSet forall era. ProposalProcedure era -> PDoc
pcProposalProcedure) OSet (ProposalProcedure era)
pp1 OSet (ProposalProcedure era)
pp2)
    , (String
"CurrentTreasuryValue", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia (forall x ann. (x -> Doc ann) -> StrictMaybe x -> Doc ann
ppStrictMaybe Coin -> PDoc
pcCoin) StrictMaybe Coin
ctv1 StrictMaybe Coin
ctv2)
    , (String
"TreasuryDonation", forall t. Eq t => (t -> PDoc) -> t -> t -> Maybe PDoc
eqVia Coin -> PDoc
pcCoin Coin
td1 Coin
td2)
    ]

sameTxBody :: Reflect era => Proof era -> TxBody era -> TxBody era -> [(String, Maybe PDoc)]
sameTxBody :: forall era.
Reflect era =>
Proof era -> TxBody era -> TxBody era -> [(String, Maybe PDoc)]
sameTxBody proof :: Proof era
proof@Proof era
Shelley TxBody era
x TxBody era
y = forall era.
Reflect era =>
Proof era
-> ShelleyTxBody era -> ShelleyTxBody era -> [(String, Maybe PDoc)]
sameShelleyTxBody Proof era
proof TxBody era
x TxBody era
y
sameTxBody proof :: Proof era
proof@Proof era
Allegra TxBody era
x TxBody era
y = forall era.
Reflect era =>
Proof era
-> AllegraTxBody era -> AllegraTxBody era -> [(String, Maybe PDoc)]
sameAllegraTxBody Proof era
proof TxBody era
x TxBody era
y
sameTxBody proof :: Proof era
proof@Proof era
Mary TxBody era
x TxBody era
y = forall era.
Reflect era =>
Proof era
-> MaryTxBody era -> MaryTxBody era -> [(String, Maybe PDoc)]
sameMaryTxBody Proof era
proof TxBody era
x TxBody era
y
sameTxBody proof :: Proof era
proof@Proof era
Alonzo TxBody era
x TxBody era
y = forall era.
Reflect era =>
Proof era
-> AlonzoTxBody era -> AlonzoTxBody era -> [(String, Maybe PDoc)]
sameAlonzoTxBody Proof era
proof TxBody era
x TxBody era
y
sameTxBody proof :: Proof era
proof@Proof era
Babbage TxBody era
x TxBody era
y = forall era.
(Reflect era, BabbageEraTxBody era) =>
Proof era
-> BabbageTxBody era -> BabbageTxBody era -> [(String, Maybe PDoc)]
sameBabbageTxBody Proof era
proof TxBody era
x TxBody era
y
sameTxBody proof :: Proof era
proof@Proof era
Conway TxBody era
x TxBody era
y = forall era.
(ConwayEraTxBody era, Reflect era) =>
Proof era
-> ConwayTxBody era -> ConwayTxBody era -> [(String, Maybe PDoc)]
sameConwayTxBody Proof era
proof TxBody era
x TxBody era
y

-- =======================
-- Comparing Tx for Sameness

sameShelleyTx ::
  (Reflect era, TxWits era ~ ShelleyTxWits era) =>
  Proof era ->
  ShelleyTx era ->
  ShelleyTx era ->
  [(String, Maybe PDoc)]
sameShelleyTx :: forall era.
(Reflect era, TxWits era ~ ShelleyTxWits era) =>
Proof era
-> ShelleyTx era -> ShelleyTx era -> [(String, Maybe PDoc)]
sameShelleyTx Proof era
proof (ShelleyTx TxBody era
b1 TxWits era
w1 StrictMaybe (TxAuxData era)
aux1) (ShelleyTx TxBody era
b2 TxWits era
w2 StrictMaybe (TxAuxData era)
aux2) =
  forall x. String -> [(String, Maybe x)] -> [(String, Maybe x)]
extendLabel String
"TxBody " (forall era.
Reflect era =>
Proof era -> TxBody era -> TxBody era -> [(String, Maybe PDoc)]
sameTxBody Proof era
proof TxBody era
b1 TxBody era
b2)
    forall a. [a] -> [a] -> [a]
++ forall x. String -> [(String, Maybe x)] -> [(String, Maybe x)]
extendLabel String
"TxWits " (forall era.
Reflect era =>
Proof era
-> ShelleyTxWits era -> ShelleyTxWits era -> [(String, Maybe PDoc)]
sameShelleyTxWits Proof era
proof TxWits era
w1 TxWits era
w2)
    forall a. [a] -> [a] -> [a]
++ [ (String
"AuxData", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow StrictMaybe (TxAuxData era)
aux1 StrictMaybe (TxAuxData era)
aux2)
       ]

sameAlonzoTx ::
  ( Reflect era
  , AlonzoEraScript era
  , TxWits era ~ AlonzoTxWits era
  ) =>
  Proof era ->
  AlonzoTx era ->
  AlonzoTx era ->
  [(String, Maybe PDoc)]
sameAlonzoTx :: forall era.
(Reflect era, AlonzoEraScript era,
 TxWits era ~ AlonzoTxWits era) =>
Proof era -> AlonzoTx era -> AlonzoTx era -> [(String, Maybe PDoc)]
sameAlonzoTx Proof era
proof (AlonzoTx TxBody era
b1 TxWits era
w1 IsValid
v1 StrictMaybe (TxAuxData era)
aux1) (AlonzoTx TxBody era
b2 TxWits era
w2 IsValid
v2 StrictMaybe (TxAuxData era)
aux2) =
  forall x. String -> [(String, Maybe x)] -> [(String, Maybe x)]
extendLabel String
"TxBody " (forall era.
Reflect era =>
Proof era -> TxBody era -> TxBody era -> [(String, Maybe PDoc)]
sameTxBody Proof era
proof TxBody era
b1 TxBody era
b2)
    forall a. [a] -> [a] -> [a]
++ forall x. String -> [(String, Maybe x)] -> [(String, Maybe x)]
extendLabel String
"TxWits " (forall era.
(Reflect era, AlonzoEraScript era) =>
Proof era
-> AlonzoTxWits era -> AlonzoTxWits era -> [(String, Maybe PDoc)]
sameAlonzoTxWits Proof era
proof TxWits era
w1 TxWits era
w2)
    forall a. [a] -> [a] -> [a]
++ [ (String
"AuxData", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow StrictMaybe (TxAuxData era)
aux1 StrictMaybe (TxAuxData era)
aux2)
       , (String
"IsValid", forall t. (Eq t, Show t) => t -> t -> Maybe PDoc
eqByShow IsValid
v1 IsValid
v2)
       ]
{-# NOINLINE sameAlonzoTx #-}

sameTx :: Reflect era => Proof era -> Tx era -> Tx era -> [(String, Maybe PDoc)]
sameTx :: forall era.
Reflect era =>
Proof era -> Tx era -> Tx era -> [(String, Maybe PDoc)]
sameTx proof :: Proof era
proof@Proof era
Shelley Tx era
x Tx era
y = forall era.
(Reflect era, TxWits era ~ ShelleyTxWits era) =>
Proof era
-> ShelleyTx era -> ShelleyTx era -> [(String, Maybe PDoc)]
sameShelleyTx Proof era
proof Tx era
x Tx era
y
sameTx proof :: Proof era
proof@Proof era
Allegra Tx era
x Tx era
y = forall era.
(Reflect era, TxWits era ~ ShelleyTxWits era) =>
Proof era
-> ShelleyTx era -> ShelleyTx era -> [(String, Maybe PDoc)]
sameShelleyTx Proof era
proof Tx era
x Tx era
y
sameTx proof :: Proof era
proof@Proof era
Mary Tx era
x Tx era
y = forall era.
(Reflect era, TxWits era ~ ShelleyTxWits era) =>
Proof era
-> ShelleyTx era -> ShelleyTx era -> [(String, Maybe PDoc)]
sameShelleyTx Proof era
proof Tx era
x Tx era
y
sameTx proof :: Proof era
proof@Proof era
Alonzo Tx era
x Tx era
y = forall era.
(Reflect era, AlonzoEraScript era,
 TxWits era ~ AlonzoTxWits era) =>
Proof era -> AlonzoTx era -> AlonzoTx era -> [(String, Maybe PDoc)]
sameAlonzoTx Proof era
proof Tx era
x Tx era
y
sameTx proof :: Proof era
proof@Proof era
Babbage Tx era
x Tx era
y = forall era.
(Reflect era, AlonzoEraScript era,
 TxWits era ~ AlonzoTxWits era) =>
Proof era -> AlonzoTx era -> AlonzoTx era -> [(String, Maybe PDoc)]
sameAlonzoTx Proof era
proof Tx era
x Tx era
y
sameTx proof :: Proof era
proof@Proof era
Conway Tx era
x Tx era
y = forall era.
(Reflect era, AlonzoEraScript era,
 TxWits era ~ AlonzoTxWits era) =>
Proof era -> AlonzoTx era -> AlonzoTx era -> [(String, Maybe PDoc)]
sameAlonzoTx Proof era
proof Tx era
x Tx era
y
{-# NOINLINE sameTx #-}

-- ==========================
-- Comparing TxSeq for Sameness

ints :: [Int]
ints :: [Int]
ints = [Int
0 ..]

sameShelleyTxSeq ::
  ( Reflect era
  , Tx era ~ ShelleyTx era
  , SafeToHash (TxWits era)
  ) =>
  Proof era ->
  ShelleyTxSeq era ->
  ShelleyTxSeq era ->
  [(String, Maybe PDoc)]
sameShelleyTxSeq :: forall era.
(Reflect era, Tx era ~ ShelleyTx era, SafeToHash (TxWits era)) =>
Proof era
-> ShelleyTxSeq era -> ShelleyTxSeq era -> [(String, Maybe PDoc)]
sameShelleyTxSeq Proof era
proof (ShelleyTxSeq StrictSeq (Tx era)
ss1) (ShelleyTxSeq StrictSeq (Tx era)
ss2) =
  [SomeDepend] -> [(String, Maybe PDoc)]
sameWithDependency (forall a b c d. (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
zipWith3 Int -> ShelleyTx era -> ShelleyTx era -> SomeDepend
f [Int]
ints (forall (t :: * -> *) a. Foldable t => t a -> [a]
toList StrictSeq (Tx era)
ss1) (forall (t :: * -> *) a. Foldable t => t a -> [a]
toList StrictSeq (Tx era)
ss2))
  where
    f :: Int -> ShelleyTx era -> ShelleyTx era -> SomeDepend
f Int
n ShelleyTx era
t1 ShelleyTx era
t2 = forall x.
String
-> (x -> x -> [(String, Maybe PDoc)]) -> x -> x -> SomeDepend
SomeM (forall a. Show a => a -> String
show Int
n) (forall era.
Reflect era =>
Proof era -> Tx era -> Tx era -> [(String, Maybe PDoc)]
sameTx Proof era
proof) ShelleyTx era
t1 ShelleyTx era
t2

sameAlonzoTxSeq ::
  ( Reflect era
  , AlonzoEraTx era
  , SafeToHash (TxWits era)
  ) =>
  Proof era ->
  AlonzoTxSeq era ->
  AlonzoTxSeq era ->
  [(String, Maybe PDoc)]
sameAlonzoTxSeq :: forall era.
(Reflect era, AlonzoEraTx era, SafeToHash (TxWits era)) =>
Proof era
-> AlonzoTxSeq era -> AlonzoTxSeq era -> [(String, Maybe PDoc)]
sameAlonzoTxSeq Proof era
proof (AlonzoTxSeq StrictSeq (Tx era)
ss1) (AlonzoTxSeq StrictSeq (Tx era)
ss2) =
  [SomeDepend] -> [(String, Maybe PDoc)]
sameWithDependency (forall a b c d. (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
zipWith3 Int -> Tx era -> Tx era -> SomeDepend
f [Int]
ints (forall (t :: * -> *) a. Foldable t => t a -> [a]
toList StrictSeq (Tx era)
ss1) (forall (t :: * -> *) a. Foldable t => t a -> [a]
toList StrictSeq (Tx era)
ss2))
  where
    f :: Int -> Tx era -> Tx era -> SomeDepend
f Int
n Tx era
t1 Tx era
t2 = forall x.
String
-> (x -> x -> [(String, Maybe PDoc)]) -> x -> x -> SomeDepend
SomeM (forall a. Show a => a -> String
show Int
n) (forall era.
Reflect era =>
Proof era -> Tx era -> Tx era -> [(String, Maybe PDoc)]
sameTx Proof era
proof) Tx era
t1 Tx era
t2

sameTxSeq :: Reflect era => Proof era -> TxSeq era -> TxSeq era -> [(String, Maybe PDoc)]
sameTxSeq :: forall era.
Reflect era =>
Proof era -> TxSeq era -> TxSeq era -> [(String, Maybe PDoc)]
sameTxSeq proof :: Proof era
proof@Proof era
Shelley TxSeq era
x TxSeq era
y = forall era.
(Reflect era, Tx era ~ ShelleyTx era, SafeToHash (TxWits era)) =>
Proof era
-> ShelleyTxSeq era -> ShelleyTxSeq era -> [(String, Maybe PDoc)]
sameShelleyTxSeq Proof era
proof TxSeq era
x TxSeq era
y
sameTxSeq proof :: Proof era
proof@Proof era
Allegra TxSeq era
x TxSeq era
y = forall era.
(Reflect era, Tx era ~ ShelleyTx era, SafeToHash (TxWits era)) =>
Proof era
-> ShelleyTxSeq era -> ShelleyTxSeq era -> [(String, Maybe PDoc)]
sameShelleyTxSeq Proof era
proof TxSeq era
x TxSeq era
y
sameTxSeq proof :: Proof era
proof@Proof era
Mary TxSeq era
x TxSeq era
y = forall era.
(Reflect era, Tx era ~ ShelleyTx era, SafeToHash (TxWits era)) =>
Proof era
-> ShelleyTxSeq era -> ShelleyTxSeq era -> [(String, Maybe PDoc)]
sameShelleyTxSeq Proof era
proof TxSeq era
x TxSeq era
y
sameTxSeq proof :: Proof era
proof@Proof era
Alonzo TxSeq era
x TxSeq era
y = forall era.
(Reflect era, AlonzoEraTx era, SafeToHash (TxWits era)) =>
Proof era
-> AlonzoTxSeq era -> AlonzoTxSeq era -> [(String, Maybe PDoc)]
sameAlonzoTxSeq Proof era
proof TxSeq era
x TxSeq era
y
sameTxSeq proof :: Proof era
proof@Proof era
Babbage TxSeq era
x TxSeq era
y = forall era.
(Reflect era, AlonzoEraTx era, SafeToHash (TxWits era)) =>
Proof era
-> AlonzoTxSeq era -> AlonzoTxSeq era -> [(String, Maybe PDoc)]
sameAlonzoTxSeq Proof era
proof TxSeq era
x TxSeq era
y
sameTxSeq proof :: Proof era
proof@Proof era
Conway TxSeq era
x TxSeq era
y = forall era.
(Reflect era, AlonzoEraTx era, SafeToHash (TxWits era)) =>
Proof era
-> AlonzoTxSeq era -> AlonzoTxSeq era -> [(String, Maybe PDoc)]
sameAlonzoTxSeq Proof era
proof TxSeq era
x TxSeq era
y
{-# NOINLINE sameTxSeq #-}