{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE OverloadedLists #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeOperators #-}
{-# OPTIONS_GHC -Wno-orphans #-}

-- | Golden tests that check CBOR token encoding.
module Test.Cardano.Ledger.Shelley.Serialisation.Golden.Encoding (tests) where

import Cardano.Crypto.DSIGN (SignedDSIGN)
import qualified Cardano.Crypto.Hash as Hash
import Cardano.Crypto.KES (SignedKES, unsoundPureSignedKES)
import Cardano.Crypto.VRF (CertifiedVRF)
import Cardano.Ledger.Address (Addr (..), RewardAccount (..))
import Cardano.Ledger.BaseTypes (
  BoundedRational (..),
  EpochInterval (..),
  Network (..),
  Nonce (..),
  ProtVer (..),
  StrictMaybe (..),
  UnitInterval,
  mkNonceFromNumber,
  mkTxIxPartial,
  textToDns,
  textToUrl,
 )
import Cardano.Ledger.Binary (
  Annotator,
  DecCBOR (..),
  DecCBORGroup (..),
  Decoder,
  DecoderError,
  EncCBOR (..),
  EncCBORGroup (..),
  Tokens (..),
  byronProtVer,
  decodeFullAnnotator,
  decodeFullDecoder,
  decodeMapTraverse,
  encCBOR,
  fromPlainEncoding,
  hashWithEncoder,
  ipv4ToBytes,
  shelleyProtVer,
  toCBOR,
  toPlainEncoding,
 )
import Cardano.Ledger.Binary.Crypto (
  encodeSignedDSIGN,
  encodeSignedKES,
  encodeVerKeyDSIGN,
 )
import qualified Cardano.Ledger.Binary.Plain as Plain
import Cardano.Ledger.Block (Block (..))
import Cardano.Ledger.Coin (Coin (..), DeltaCoin (..))
import Cardano.Ledger.Credential (Credential (..), StakeReference (..))
import Cardano.Ledger.Keys (
  DSIGN,
  VKey (..),
  WitVKey (..),
  asWitness,
  signedDSIGN,
 )
import Cardano.Ledger.PoolParams (
  PoolMetadata (..),
  PoolParams (..),
  StakePoolRelay (..),
 )
import Cardano.Ledger.Shelley (ShelleyEra)
import Cardano.Ledger.Shelley.API (MultiSig)
import Cardano.Ledger.Shelley.BlockChain (ShelleyTxSeq (..), bbHash)
import Cardano.Ledger.Shelley.Core
import Cardano.Ledger.Shelley.PParams (
  ProposedPPUpdates (..),
  pattern ProposedPPUpdates,
  pattern Update,
 )
import Cardano.Ledger.Shelley.Rewards ()
import Cardano.Ledger.Shelley.Scripts (pattern RequireSignature)
import Cardano.Ledger.Shelley.Tx (ShelleyTx (..))
import qualified Cardano.Ledger.Shelley.TxAuxData as TxAuxData
import Cardano.Ledger.Shelley.TxBody (ShelleyTxBody (..))
import Cardano.Ledger.Shelley.TxOut (ShelleyTxOut (..))
import Cardano.Ledger.Shelley.TxWits (ShelleyTxWits, addrWits)
import Cardano.Ledger.Slot (BlockNo (..), EpochNo (..), SlotNo (..))
import Cardano.Ledger.TxIn (TxId, TxIn (..))
import Cardano.Protocol.Crypto
import Cardano.Protocol.TPraos.BHeader (
  BHBody (..),
  BHeader (..),
  HashHeader (..),
  PrevHash (..),
  bhash,
  bheaderBlockNo,
  bheaderEta,
  bheaderL,
  bheaderOCert,
  bheaderPrev,
  bheaderSlotNo,
  bheaderVk,
  bheaderVrfVk,
  bprotver,
  bsize,
  mkSeed,
  seedEta,
  seedL,
 )
import Cardano.Protocol.TPraos.OCert (
  KESPeriod (..),
  OCert,
  OCertSignable (..),
  pattern OCert,
 )
import qualified Codec.CBOR.Encoding as CBOR (Encoding (..))
import Control.Monad
import Data.ByteString (ByteString)
import qualified Data.ByteString.Base16 as B16
import qualified Data.ByteString.Char8 as BS (pack)
import qualified Data.ByteString.Lazy as BSL (ByteString)
import Data.Coerce (coerce)
import Data.IP (toIPv4)
import qualified Data.Map.Strict as Map
import qualified Data.Maybe as Maybe (fromJust)
import Data.Ratio ((%))
import qualified Data.Sequence.Strict as StrictSeq
import qualified Data.Set as Set
import Data.String (fromString)
import Data.Word (Word64)
import Lens.Micro ((&), (.~))
import Numeric.Natural (Natural)
import qualified Prettyprinter as Pretty
import Test.Cardano.Ledger.Binary.TreeDiff (CBORBytes (CBORBytes), ansiDocToString, diffExpr)
import Test.Cardano.Ledger.Core.KeyPair (KeyPair (..), mkWitnessVKey, sKey, vKey)
import Test.Cardano.Ledger.Shelley.ConcreteCryptoTypes (C, MockCrypto)
import Test.Cardano.Ledger.Shelley.Examples.Consensus as Ex (
  ledgerExamplesShelley,
  sleNewEpochState,
 )
import Test.Cardano.Ledger.Shelley.Generator.Core (KESKeyPair (..), PreAlonzo, VRFKeyPair (..))
import Test.Cardano.Ledger.Shelley.Generator.EraGen (genesisId)
import Test.Cardano.Ledger.Shelley.Serialisation.GoldenUtils (
  ToTokens (..),
  checkEncoding,
  checkEncodingCBOR,
  checkEncodingCBORAnnotated,
 )
import Test.Cardano.Ledger.Shelley.Utils
import Test.Cardano.Protocol.Crypto.VRF.Fake (WithResult (..))
import Test.Tasty (TestTree, testGroup)
import Test.Tasty.HUnit (assertFailure, testCase)

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

type MultiSigMap = Map.Map ScriptHash (MultiSig ShelleyEra)

decodeMultiSigMap :: Decoder s (Annotator MultiSigMap)
decodeMultiSigMap :: forall s. Decoder s (Annotator MultiSigMap)
decodeMultiSigMap = forall a (t :: * -> *) s b.
(Ord a, Applicative t) =>
Decoder s (t a) -> Decoder s (t b) -> Decoder s (t (Map a b))
decodeMapTraverse (forall (f :: * -> *) a. Applicative f => a -> f a
pure forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a s. DecCBOR a => Decoder s a
decCBOR) forall a s. DecCBOR a => Decoder s a
decCBOR

deserializeMultiSigMap :: BSL.ByteString -> Either DecoderError MultiSigMap
deserializeMultiSigMap :: ByteString -> Either DecoderError MultiSigMap
deserializeMultiSigMap =
  forall a.
Version
-> Text
-> (forall s. Decoder s (Annotator a))
-> ByteString
-> Either DecoderError a
decodeFullAnnotator Version
shelleyProtVer Text
"Map ScriptHash MultiSig" forall s. Decoder s (Annotator MultiSigMap)
decodeMultiSigMap

checkEncodingCBORCBORGroup ::
  (DecCBORGroup a, EncCBORGroup a, Show a, Eq a) =>
  String ->
  a ->
  ToTokens ->
  TestTree
checkEncodingCBORCBORGroup :: forall a.
(DecCBORGroup a, EncCBORGroup a, Show a, Eq a) =>
String -> a -> ToTokens -> TestTree
checkEncodingCBORCBORGroup String
name a
x ToTokens
t =
  let d :: ByteString -> Either DecoderError a
d = forall a.
Version
-> Text
-> (forall s. Decoder s a)
-> ByteString
-> Either DecoderError a
decodeFullDecoder Version
shelleyProtVer (forall a. IsString a => String -> a
fromString String
name) forall a s. DecCBORGroup a => Decoder s a
decCBORGroup
   in forall a.
(HasCallStack, Show a, Eq a) =>
Version
-> (a -> Encoding)
-> (ByteString -> Either DecoderError a)
-> String
-> a
-> ToTokens
-> TestTree
checkEncoding Version
shelleyProtVer forall a. EncCBORGroup a => a -> Encoding
encCBORGroup ByteString -> Either DecoderError a
d String
name a
x ToTokens
t

getRawKeyHash :: KeyHash 'Payment -> ByteString
getRawKeyHash :: KeyHash 'Payment -> ByteString
getRawKeyHash (KeyHash Hash ADDRHASH (VerKeyDSIGN DSIGN)
hsh) = forall h a. Hash h a -> ByteString
Hash.hashToBytes Hash ADDRHASH (VerKeyDSIGN DSIGN)
hsh

getRawNonce :: Nonce -> ByteString
getRawNonce :: Nonce -> ByteString
getRawNonce (Nonce Hash HASH Nonce
hsh) = forall h a. Hash h a -> ByteString
Hash.hashToBytes Hash HASH Nonce
hsh
getRawNonce Nonce
NeutralNonce = forall a. HasCallStack => String -> a
error String
"The neutral nonce has no bytes"

testGKey :: GenesisKeyPair c
testGKey :: forall c. GenesisKeyPair c
testGKey = forall (kd :: KeyRole). VKey kd -> SignKeyDSIGN DSIGN -> KeyPair kd
KeyPair forall {kd :: KeyRole}. VKey kd
vk SignKeyDSIGN DSIGN
sk
  where
    (SignKeyDSIGN DSIGN
sk, VKey kd
vk) = forall (kd :: KeyRole). RawSeed -> (SignKeyDSIGN DSIGN, VKey kd)
mkGenKey (Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> RawSeed
RawSeed Word64
0 Word64
0 Word64
0 Word64
0 Word64
0)

testGKeyHash :: KeyHash 'Genesis
testGKeyHash :: KeyHash 'Genesis
testGKeyHash = forall (kd :: KeyRole). VKey kd -> KeyHash kd
hashKey forall a b. (a -> b) -> a -> b
$ forall (kd :: KeyRole). KeyPair kd -> VKey kd
vKey forall c. GenesisKeyPair c
testGKey

testVRF :: VRFKeyPair MockCrypto
testVRF :: VRFKeyPair MockCrypto
testVRF = forall c. Crypto c => RawSeed -> VRFKeyPair c
mkVRFKeyPair (Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> RawSeed
RawSeed Word64
0 Word64
0 Word64
0 Word64
0 Word64
5)

testVRFKH :: VRFVerKeyHash r
testVRFKH :: forall (r :: KeyRoleVRF). VRFVerKeyHash r
testVRFKH = forall c (r :: KeyRoleVRF).
Crypto c =>
VerKeyVRF (VRF c) -> VRFVerKeyHash r
hashVerKeyVRF @MockCrypto forall a b. (a -> b) -> a -> b
$ forall c. VRFKeyPair c -> VerKeyVRF (VRF c)
vrfVerKey VRFKeyPair MockCrypto
testVRF

testTxb :: (EraTxOut era, EraTxCert era) => ShelleyTxBody era
testTxb :: forall era. (EraTxOut era, EraTxCert era) => ShelleyTxBody era
testTxb =
  forall era.
(EraTxOut era, EncCBOR (TxCert era)) =>
Set TxIn
-> StrictSeq (TxOut era)
-> StrictSeq (TxCert era)
-> Withdrawals
-> Coin
-> SlotNo
-> StrictMaybe (Update era)
-> StrictMaybe TxAuxDataHash
-> ShelleyTxBody era
ShelleyTxBody
    forall a. Set a
Set.empty
    forall a. StrictSeq a
StrictSeq.empty
    forall a. StrictSeq a
StrictSeq.empty
    (Map RewardAccount Coin -> Withdrawals
Withdrawals forall k a. Map k a
Map.empty)
    (Integer -> Coin
Coin Integer
0)
    (Word64 -> SlotNo
SlotNo Word64
0)
    forall a. StrictMaybe a
SNothing
    forall a. StrictMaybe a
SNothing

testTxbHash ::
  forall era.
  (EraTxOut era, EraTxCert era) =>
  SafeHash EraIndependentTxBody
testTxbHash :: forall era.
(EraTxOut era, EraTxCert era) =>
SafeHash EraIndependentTxBody
testTxbHash = forall x i. HashAnnotated x i => x -> SafeHash i
hashAnnotated forall a b. (a -> b) -> a -> b
$ forall era. (EraTxOut era, EraTxCert era) => ShelleyTxBody era
testTxb @era

testKey1 :: KeyPair 'Payment
testKey1 :: KeyPair 'Payment
testKey1 = forall (kd :: KeyRole). VKey kd -> SignKeyDSIGN DSIGN -> KeyPair kd
KeyPair forall {kd :: KeyRole}. VKey kd
vk SignKeyDSIGN DSIGN
sk
  where
    (SignKeyDSIGN DSIGN
sk, VKey kd
vk) = forall (kd :: KeyRole). RawSeed -> (SignKeyDSIGN DSIGN, VKey kd)
mkKeyPair (Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> RawSeed
RawSeed Word64
0 Word64
0 Word64
0 Word64
0 Word64
1)

testKey2 :: KeyPair kr
testKey2 :: forall (kr :: KeyRole). KeyPair kr
testKey2 = forall (kd :: KeyRole). VKey kd -> SignKeyDSIGN DSIGN -> KeyPair kd
KeyPair forall {kd :: KeyRole}. VKey kd
vk SignKeyDSIGN DSIGN
sk
  where
    (SignKeyDSIGN DSIGN
sk, VKey kd
vk) = forall (kd :: KeyRole). RawSeed -> (SignKeyDSIGN DSIGN, VKey kd)
mkKeyPair (Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> RawSeed
RawSeed Word64
0 Word64
0 Word64
0 Word64
0 Word64
2)

testBlockIssuerKey :: KeyPair 'BlockIssuer
testBlockIssuerKey :: KeyPair 'BlockIssuer
testBlockIssuerKey = forall (kd :: KeyRole). VKey kd -> SignKeyDSIGN DSIGN -> KeyPair kd
KeyPair forall {kd :: KeyRole}. VKey kd
vk SignKeyDSIGN DSIGN
sk
  where
    (SignKeyDSIGN DSIGN
sk, VKey kd
vk) = forall (kd :: KeyRole). RawSeed -> (SignKeyDSIGN DSIGN, VKey kd)
mkKeyPair (Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> RawSeed
RawSeed Word64
0 Word64
0 Word64
0 Word64
0 Word64
4)

testStakePoolKey :: KeyPair 'StakePool
testStakePoolKey :: KeyPair 'StakePool
testStakePoolKey = forall (kd :: KeyRole). VKey kd -> SignKeyDSIGN DSIGN -> KeyPair kd
KeyPair forall {kd :: KeyRole}. VKey kd
vk SignKeyDSIGN DSIGN
sk
  where
    (SignKeyDSIGN DSIGN
sk, VKey kd
vk) = forall (kd :: KeyRole). RawSeed -> (SignKeyDSIGN DSIGN, VKey kd)
mkKeyPair (Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> RawSeed
RawSeed Word64
0 Word64
0 Word64
0 Word64
0 Word64
5)

testGenesisDelegateKey :: KeyPair 'GenesisDelegate
testGenesisDelegateKey :: KeyPair 'GenesisDelegate
testGenesisDelegateKey = forall (kd :: KeyRole). VKey kd -> SignKeyDSIGN DSIGN -> KeyPair kd
KeyPair forall {kd :: KeyRole}. VKey kd
vk SignKeyDSIGN DSIGN
sk
  where
    (SignKeyDSIGN DSIGN
sk, VKey kd
vk) = forall (kd :: KeyRole). RawSeed -> (SignKeyDSIGN DSIGN, VKey kd)
mkKeyPair (Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> RawSeed
RawSeed Word64
0 Word64
0 Word64
0 Word64
0 Word64
6)

testBlockIssuerKeyTokens :: Tokens -> Tokens
testBlockIssuerKeyTokens :: Tokens -> Tokens
testBlockIssuerKeyTokens = Tokens -> Tokens
e
  where
    VKey VerKeyDSIGN DSIGN
vk = forall (kd :: KeyRole). KeyPair kd -> VKey kd
vKey KeyPair 'BlockIssuer
testBlockIssuerKey
    CBOR.Encoding Tokens -> Tokens
e = Version -> Encoding -> Encoding
toPlainEncoding Version
shelleyProtVer (forall v. DSIGNAlgorithm v => VerKeyDSIGN v -> Encoding
encodeVerKeyDSIGN VerKeyDSIGN DSIGN
vk)

testKey1SigToken ::
  forall era.
  (EraTxOut era, EraTxCert era) =>
  Tokens ->
  Tokens
testKey1SigToken :: forall era. (EraTxOut era, EraTxCert era) => Tokens -> Tokens
testKey1SigToken = Tokens -> Tokens
e
  where
    s :: SignedDSIGN DSIGN (Hash HASH EraIndependentTxBody)
s =
      forall a.
Signable DSIGN a =>
SignKeyDSIGN DSIGN -> a -> SignedDSIGN DSIGN a
signedDSIGN
        (forall (kd :: KeyRole). KeyPair kd -> SignKeyDSIGN DSIGN
sKey KeyPair 'Payment
testKey1)
        (forall i. SafeHash i -> Hash HASH i
extractHash (forall era.
(EraTxOut era, EraTxCert era) =>
SafeHash EraIndependentTxBody
testTxbHash @era)) ::
        SignedDSIGN DSIGN (Hash HASH EraIndependentTxBody)
    CBOR.Encoding Tokens -> Tokens
e = Version -> Encoding -> Encoding
toPlainEncoding Version
shelleyProtVer (forall v a. DSIGNAlgorithm v => SignedDSIGN v a -> Encoding
encodeSignedDSIGN SignedDSIGN DSIGN (Hash HASH EraIndependentTxBody)
s)

testOpCertSigTokens ::
  Tokens ->
  Tokens
testOpCertSigTokens :: Tokens -> Tokens
testOpCertSigTokens = Tokens -> Tokens
e
  where
    s :: SignedDSIGN DSIGN (OCertSignable MockCrypto)
s =
      forall a.
Signable DSIGN a =>
SignKeyDSIGN DSIGN -> a -> SignedDSIGN DSIGN a
signedDSIGN
        (forall (kd :: KeyRole). KeyPair kd -> SignKeyDSIGN DSIGN
sKey KeyPair 'Payment
testKey1)
        (forall c.
VerKeyKES (KES c) -> Word64 -> KESPeriod -> OCertSignable c
OCertSignable @MockCrypto (forall c. KESKeyPair c -> VerKeyKES (KES c)
kesVerKey KESKeyPair MockCrypto
testKESKeys) Word64
0 (Word -> KESPeriod
KESPeriod Word
0))
    CBOR.Encoding Tokens -> Tokens
e = Version -> Encoding -> Encoding
toPlainEncoding Version
shelleyProtVer (forall v a. DSIGNAlgorithm v => SignedDSIGN v a -> Encoding
encodeSignedDSIGN SignedDSIGN DSIGN (OCertSignable MockCrypto)
s)

testKeyHash1 :: KeyHash 'Payment
testKeyHash1 :: KeyHash 'Payment
testKeyHash1 = forall (kd :: KeyRole). VKey kd -> KeyHash kd
hashKey forall a b. (a -> b) -> a -> b
$ forall (kd :: KeyRole). KeyPair kd -> VKey kd
vKey KeyPair 'Payment
testKey1

testKeyHash2 :: KeyHash 'Staking
testKeyHash2 :: KeyHash 'Staking
testKeyHash2 = forall (kd :: KeyRole). VKey kd -> KeyHash kd
hashKey forall a b. (a -> b) -> a -> b
$ forall (kd :: KeyRole). KeyPair kd -> VKey kd
vKey forall (kr :: KeyRole). KeyPair kr
testKey2

testKESKeys :: KESKeyPair MockCrypto
testKESKeys :: KESKeyPair MockCrypto
testKESKeys = forall c. Crypto c => RawSeed -> KESKeyPair c
mkKESKeyPair (Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> RawSeed
RawSeed Word64
0 Word64
0 Word64
0 Word64
0 Word64
3)

testAddrE :: Addr
testAddrE :: Addr
testAddrE =
  Network -> Credential 'Payment -> StakeReference -> Addr
Addr
    Network
Testnet
    (forall (kr :: KeyRole). KeyHash kr -> Credential kr
KeyHashObj KeyHash 'Payment
testKeyHash1)
    StakeReference
StakeRefNull

testPayCred :: Credential 'Payment
testPayCred :: Credential 'Payment
testPayCred = forall (kr :: KeyRole). KeyHash kr -> Credential kr
KeyHashObj KeyHash 'Payment
testKeyHash1

testStakeCred :: Credential 'Staking
testStakeCred :: Credential 'Staking
testStakeCred = forall (kr :: KeyRole). KeyHash kr -> Credential kr
KeyHashObj KeyHash 'Staking
testKeyHash2

testScript :: MultiSig ShelleyEra
testScript :: MultiSig ShelleyEra
testScript = forall era.
ShelleyEraScript era =>
KeyHash 'Witness -> NativeScript era
RequireSignature forall a b. (a -> b) -> a -> b
$ forall (a :: KeyRole -> *) (r :: KeyRole).
HasKeyRole a =>
a r -> a 'Witness
asWitness KeyHash 'Payment
testKeyHash1

testScriptHash :: ScriptHash
testScriptHash :: ScriptHash
testScriptHash = forall era. EraScript era => Script era -> ScriptHash
hashScript @ShelleyEra MultiSig ShelleyEra
testScript

testScript2 :: MultiSig ShelleyEra
testScript2 :: MultiSig ShelleyEra
testScript2 = forall era.
ShelleyEraScript era =>
KeyHash 'Witness -> NativeScript era
RequireSignature forall a b. (a -> b) -> a -> b
$ forall (a :: KeyRole -> *) (r :: KeyRole).
HasKeyRole a =>
a r -> a 'Witness
asWitness KeyHash 'Staking
testKeyHash2

testHeaderHash :: HashHeader
testHeaderHash :: HashHeader
testHeaderHash =
  Hash HASH EraIndependentBlockHeader -> HashHeader
HashHeader forall a b. (a -> b) -> a -> b
$ coerce :: forall a b. Coercible a b => a -> b
coerce (forall h a.
HashAlgorithm h =>
Version -> (a -> Encoding) -> a -> Hash h a
hashWithEncoder Version
shelleyProtVer forall a. EncCBOR a => a -> Encoding
encCBOR Int
0 :: Hash HASH Int)

testBHB ::
  forall era.
  ( EraTx era
  , PreAlonzo era
  , Tx era ~ ShelleyTx era
  ) =>
  BHBody MockCrypto
testBHB :: forall era.
(EraTx era, PreAlonzo era, Tx era ~ ShelleyTx era) =>
BHBody MockCrypto
testBHB =
  BHBody
    { bheaderBlockNo :: BlockNo
bheaderBlockNo = Word64 -> BlockNo
BlockNo Word64
44
    , bheaderSlotNo :: SlotNo
bheaderSlotNo = Word64 -> SlotNo
SlotNo Word64
33
    , bheaderPrev :: PrevHash
bheaderPrev = HashHeader -> PrevHash
BlockHash HashHeader
testHeaderHash
    , bheaderVk :: VKey 'BlockIssuer
bheaderVk = forall (kd :: KeyRole). KeyPair kd -> VKey kd
vKey KeyPair 'BlockIssuer
testBlockIssuerKey
    , bheaderVrfVk :: VerKeyVRF (VRF MockCrypto)
bheaderVrfVk = forall c. VRFKeyPair c -> VerKeyVRF (VRF c)
vrfVerKey VRFKeyPair MockCrypto
testVRF
    , bheaderEta :: CertifiedVRF (VRF MockCrypto) Nonce
bheaderEta =
        forall v a b.
(Signable v a, VRFAlgorithm v, ContextVRF v ~ (),
 Coercible b (CertifiedVRF v a)) =>
a -> SignKeyVRF v -> b
mkCertifiedVRF
          ( forall a. a -> Word64 -> WithResult a
WithResult
              (Nonce -> SlotNo -> Nonce -> Seed
mkSeed Nonce
seedEta (Word64 -> SlotNo
SlotNo Word64
33) (Word64 -> Nonce
mkNonceFromNumber Word64
0))
              Word64
1
          )
          (forall c. VRFKeyPair c -> SignKeyVRF (VRF c)
vrfSignKey VRFKeyPair MockCrypto
testVRF)
    , bheaderL :: CertifiedVRF (VRF MockCrypto) Natural
bheaderL =
        forall v a b.
(Signable v a, VRFAlgorithm v, ContextVRF v ~ (),
 Coercible b (CertifiedVRF v a)) =>
a -> SignKeyVRF v -> b
mkCertifiedVRF
          ( forall a. a -> Word64 -> WithResult a
WithResult
              (Nonce -> SlotNo -> Nonce -> Seed
mkSeed Nonce
seedL (Word64 -> SlotNo
SlotNo Word64
33) (Word64 -> Nonce
mkNonceFromNumber Word64
0))
              Word64
1
          )
          (forall c. VRFKeyPair c -> SignKeyVRF (VRF c)
vrfSignKey VRFKeyPair MockCrypto
testVRF)
    , bsize :: Word32
bsize = Word32
0
    , bhash :: Hash HASH EraIndependentBlockBody
bhash = forall era. ShelleyTxSeq era -> Hash HASH EraIndependentBlockBody
bbHash @era forall a b. (a -> b) -> a -> b
$ forall era.
(EraTx era, Tx era ~ ShelleyTx era, SafeToHash (TxWits era)) =>
StrictSeq (Tx era) -> ShelleyTxSeq era
ShelleyTxSeq @era forall a. StrictSeq a
StrictSeq.empty
    , bheaderOCert :: OCert MockCrypto
bheaderOCert =
        forall c.
VerKeyKES (KES c)
-> Word64
-> KESPeriod
-> SignedDSIGN DSIGN (OCertSignable c)
-> OCert c
OCert
          (forall c. KESKeyPair c -> VerKeyKES (KES c)
kesVerKey KESKeyPair MockCrypto
testKESKeys)
          Word64
0
          (Word -> KESPeriod
KESPeriod Word
0)
          ( forall a.
Signable DSIGN a =>
SignKeyDSIGN DSIGN -> a -> SignedDSIGN DSIGN a
signedDSIGN
              (forall (kd :: KeyRole). KeyPair kd -> SignKeyDSIGN DSIGN
sKey KeyPair 'Payment
testKey1)
              (forall c.
VerKeyKES (KES c) -> Word64 -> KESPeriod -> OCertSignable c
OCertSignable (forall c. KESKeyPair c -> VerKeyKES (KES c)
kesVerKey KESKeyPair MockCrypto
testKESKeys) Word64
0 (Word -> KESPeriod
KESPeriod Word
0))
          )
    , bprotver :: ProtVer
bprotver = Version -> Natural -> ProtVer
ProtVer forall a. Bounded a => a
minBound Natural
0
    }

testBHBSigTokens ::
  forall era.
  ( EraTx era
  , PreAlonzo era
  , Tx era ~ ShelleyTx era
  ) =>
  Tokens ->
  Tokens
testBHBSigTokens :: forall era.
(EraTx era, PreAlonzo era, Tx era ~ ShelleyTx era) =>
Tokens -> Tokens
testBHBSigTokens = Tokens -> Tokens
e
  where
    s :: SignedKES (KES MockCrypto) (BHBody MockCrypto)
s =
      forall v a.
(UnsoundPureKESAlgorithm v, Signable v a) =>
ContextKES v
-> Word -> a -> UnsoundPureSignKeyKES v -> SignedKES v a
unsoundPureSignedKES @(KES MockCrypto)
        ()
        Word
0
        (forall era.
(EraTx era, PreAlonzo era, Tx era ~ ShelleyTx era) =>
BHBody MockCrypto
testBHB @era)
        (forall c. KESKeyPair c -> UnsoundPureSignKeyKES (KES c)
kesSignKey KESKeyPair MockCrypto
testKESKeys)
    CBOR.Encoding Tokens -> Tokens
e = Version -> Encoding -> Encoding
toPlainEncoding Version
shelleyProtVer (forall v a. KESAlgorithm v => SignedKES v a -> Encoding
encodeSignedKES SignedKES (KES MockCrypto) (BHBody MockCrypto)
s)

tests :: TestTree
tests :: TestTree
tests =
  String -> [TestTree] -> TestTree
testGroup
    String
"CBOR Serialization Tests (Encoding)"
    [ forall a.
(HasCallStack, DecCBOR a, EncCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBOR
        Version
byronProtVer
        String
"list (Byron)"
        ([Integer
1] :: [Integer])
        ((Tokens -> Tokens) -> ToTokens
T (Tokens -> Tokens
TkListBegin forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Tokens -> Tokens
TkInteger Integer
1 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Tokens -> Tokens
TkBreak))
    , forall a.
(HasCallStack, DecCBOR a, EncCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBOR
        Version
shelleyProtVer
        String
"list (Shelley)"
        ([Integer
1] :: [Integer])
        ((Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
1 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Tokens -> Tokens
TkInteger Integer
1))
    , forall a.
(HasCallStack, DecCBOR a, EncCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBOR
        Version
byronProtVer
        String
"set (Byron)"
        (forall a. a -> Set a
Set.singleton (Integer
1 :: Integer))
        ((Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkTag Word
258 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Tokens -> Tokens
TkListLen Word
1 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Tokens -> Tokens
TkInteger Integer
1))
    , forall a.
(HasCallStack, DecCBOR a, EncCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBOR
        Version
shelleyProtVer
        String
"set (Shelley)"
        (forall a. a -> Set a
Set.singleton (Integer
1 :: Integer))
        ((Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
1 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Tokens -> Tokens
TkInteger Integer
1))
    , forall a.
(HasCallStack, DecCBOR a, EncCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBOR
        Version
shelleyProtVer
        String
"map"
        (forall k a. k -> a -> Map k a
Map.singleton (Integer
1 :: Integer) (Integer
1 :: Integer))
        ((Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkMapLen Word
1 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Tokens -> Tokens
TkInteger Integer
1 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Tokens -> Tokens
TkInteger Integer
1))
    , forall a.
(HasCallStack, DecCBOR a, EncCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBOR
        Version
shelleyProtVer
        String
"coin"
        (Integer -> Coin
Coin Integer
30)
        ((Tokens -> Tokens) -> ToTokens
T (Word64 -> Tokens -> Tokens
TkWord64 Word64
30))
    , forall a.
(HasCallStack, DecCBOR a, EncCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBOR
        Version
shelleyProtVer
        String
"rational"
        (forall r.
(HasCallStack, Typeable r, BoundedRational r) =>
Rational -> r
unsafeBoundRational (Integer
1 forall a. Integral a => a -> a -> Ratio a
% Integer
2) :: UnitInterval)
        ((Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkTag Word
30 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Tokens -> Tokens
TkListLen Word
2 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64 -> Tokens -> Tokens
TkWord64 Word64
1 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64 -> Tokens -> Tokens
TkWord64 Word64
2))
    , forall a.
(HasCallStack, DecCBOR a, EncCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBOR
        Version
shelleyProtVer
        String
"slot"
        (Word64 -> SlotNo
SlotNo Word64
7)
        ((Tokens -> Tokens) -> ToTokens
T (Word64 -> Tokens -> Tokens
TkWord64 Word64
7))
    , forall a.
(HasCallStack, DecCBOR a, EncCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBOR
        Version
shelleyProtVer
        String
"neutral_nonce"
        Nonce
NeutralNonce
        ((Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
1 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Tokens -> Tokens
TkWord Word
0))
    , forall a.
(HasCallStack, DecCBOR a, EncCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBOR
        Version
shelleyProtVer
        String
"nonce"
        (Word64 -> Nonce
mkNonceFromNumber Word64
99)
        ((Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
2 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Tokens -> Tokens
TkWord Word
1 forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Tokens -> Tokens
TkBytes (Nonce -> ByteString
getRawNonce forall a b. (a -> b) -> a -> b
$ Word64 -> Nonce
mkNonceFromNumber Word64
99)))
    , forall a.
(HasCallStack, DecCBOR a, EncCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBOR
        Version
shelleyProtVer
        String
"key_hash"
        KeyHash 'Payment
testKeyHash1
        ((Tokens -> Tokens) -> ToTokens
T (ByteString -> Tokens -> Tokens
TkBytes (KeyHash 'Payment -> ByteString
getRawKeyHash KeyHash 'Payment
testKeyHash1)))
    , forall a.
(HasCallStack, DecCBOR a, EncCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBOR
        Version
shelleyProtVer
        String
"credential_key_hash"
        Credential 'Payment
testPayCred
        ((Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
2 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Tokens -> Tokens
TkWord Word
0) forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S KeyHash 'Payment
testKeyHash1)
    , forall a.
(HasCallStack, DecCBOR a, EncCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBOR
        Version
shelleyProtVer
        String
"txin"
        (TxId -> TxIx -> TxIn
TxIn TxId
genesisId forall a. Bounded a => a
minBound)
        ((Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
2) forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S (TxId
genesisId :: TxId) forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word64 -> Tokens -> Tokens
TkWord64 Word64
0))
    , let a :: Addr
a = Network -> Credential 'Payment -> StakeReference -> Addr
Addr Network
Testnet Credential 'Payment
testPayCred StakeReference
StakeRefNull
       in forall a.
(HasCallStack, DecCBOR a, EncCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBOR
            Version
shelleyProtVer
            String
"txout"
            (forall era.
(HasCallStack, Era era, Val (Value era)) =>
Addr -> Value era -> ShelleyTxOut era
ShelleyTxOut @C Addr
a (Integer -> Coin
Coin Integer
2))
            ( (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
2)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S Addr
a
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S (Integer -> Coin
Coin Integer
2)
            )
    , case forall (kr :: KeyRole).
SafeHash EraIndependentTxBody -> KeyPair kr -> WitVKey 'Witness
mkWitnessVKey (forall era.
(EraTxOut era, EraTxCert era) =>
SafeHash EraIndependentTxBody
testTxbHash @C) KeyPair 'Payment
testKey1 of
        w :: WitVKey 'Witness
w@(WitVKey VKey 'Witness
vk SignedDSIGN DSIGN (Hash HASH EraIndependentTxBody)
_sig) ->
          forall a.
(HasCallStack, DecCBOR (Annotator a), ToCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBORAnnotated
            Version
shelleyProtVer
            String
"vkey_witnesses"
            WitVKey 'Witness
w -- Transaction _witnessVKeySet element
            ( (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
2)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S VKey 'Witness
vk -- vkey
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (forall era. (EraTxOut era, EraTxCert era) => Tokens -> Tokens
testKey1SigToken @C) -- signature
            )
    , forall a.
(HasCallStack, Show a, Eq a) =>
Version
-> (a -> Encoding)
-> (ByteString -> Either DecoderError a)
-> String
-> a
-> ToTokens
-> TestTree
checkEncoding
        Version
shelleyProtVer
        (Encoding -> Encoding
fromPlainEncoding forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. ToCBOR a => a -> Encoding
toCBOR)
        ByteString -> Either DecoderError MultiSigMap
deserializeMultiSigMap
        String
"script_hash_to_scripts"
        (forall k a. k -> a -> Map k a
Map.singleton (forall era. EraScript era => Script era -> ScriptHash
hashScript @C MultiSig ShelleyEra
testScript) MultiSig ShelleyEra
testScript) -- Transaction _witnessMSigMap
        ( (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkMapLen Word
1)
            forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S (forall era. EraScript era => Script era -> ScriptHash
hashScript @C MultiSig ShelleyEra
testScript)
            forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S MultiSig ShelleyEra
testScript
        )
    , -- checkEncodingCBOR "withdrawal_key"
      let r :: RewardAccount
r = Network -> Credential 'Staking -> RewardAccount
RewardAccount Network
Testnet Credential 'Staking
testStakeCred
       in forall a.
(HasCallStack, DecCBOR a, EncCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBOR
            Version
shelleyProtVer
            String
"withdrawal"
            (forall k a. k -> a -> Map k a
Map.singleton RewardAccount
r (Integer -> Coin
Coin Integer
123))
            ( ((Tokens -> Tokens) -> ToTokens
T forall a b. (a -> b) -> a -> b
$ Word -> Tokens -> Tokens
TkMapLen Word
1)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S RewardAccount
r
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S (Integer -> Coin
Coin Integer
123)
            )
    , -- checkEncodingCBOR "withdrawal_script"
      --
      let r :: RewardAccount
r = Network -> Credential 'Staking -> RewardAccount
RewardAccount Network
Testnet (forall (kr :: KeyRole). ScriptHash -> Credential kr
ScriptHashObj ScriptHash
testScriptHash)
       in forall a.
(HasCallStack, DecCBOR a, EncCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBOR
            Version
shelleyProtVer
            String
"withdrawal"
            (forall k a. k -> a -> Map k a
Map.singleton RewardAccount
r (Integer -> Coin
Coin Integer
123))
            ( ((Tokens -> Tokens) -> ToTokens
T forall a b. (a -> b) -> a -> b
$ Word -> Tokens -> Tokens
TkMapLen Word
1)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S RewardAccount
r
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S (Integer -> Coin
Coin Integer
123)
            )
    , forall a.
(HasCallStack, DecCBOR a, EncCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBOR
        Version
shelleyProtVer
        String
"register_stake_reference"
        (forall era.
ShelleyEraTxCert era =>
Credential 'Staking -> TxCert era
RegTxCert @C Credential 'Staking
testStakeCred)
        ( (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
2)
            forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkWord Word
0) -- Reg cert
            forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S Credential 'Staking
testStakeCred -- keyhash
        )
    , forall a.
(HasCallStack, DecCBOR a, EncCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBOR
        Version
shelleyProtVer
        String
"deregister_stake_reference"
        (forall era.
ShelleyEraTxCert era =>
Credential 'Staking -> TxCert era
UnRegTxCert @C Credential 'Staking
testStakeCred)
        ( (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
2)
            forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkWord Word
1) -- DeReg cert
            forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S Credential 'Staking
testStakeCred -- keyhash
        )
    , forall a.
(HasCallStack, DecCBOR a, EncCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBOR
        Version
shelleyProtVer
        String
"stake_delegation"
        (forall era.
ShelleyEraTxCert era =>
Credential 'Staking -> KeyHash 'StakePool -> TxCert era
DelegStakeTxCert @C Credential 'Staking
testStakeCred (forall (kd :: KeyRole). VKey kd -> KeyHash kd
hashKey forall a b. (a -> b) -> a -> b
$ forall (kd :: KeyRole). KeyPair kd -> VKey kd
vKey KeyPair 'StakePool
testStakePoolKey))
        ( (Tokens -> Tokens) -> ToTokens
T
            ( Word -> Tokens -> Tokens
TkListLen Word
3
                forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Tokens -> Tokens
TkWord Word
2 -- delegation cert with key
            )
            forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S Credential 'Staking
testStakeCred
            forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S (forall (kd :: KeyRole). VKey kd -> KeyHash kd
hashKey forall a b. (a -> b) -> a -> b
$ forall (kd :: KeyRole). KeyPair kd -> VKey kd
vKey KeyPair 'StakePool
testStakePoolKey)
        )
    , -- checkEncodingCBOR "register-pool"
      let poolOwner :: KeyHash 'Staking
poolOwner = KeyHash 'Staking
testKeyHash2
          poolMargin :: UnitInterval
poolMargin = forall r.
(HasCallStack, Typeable r, BoundedRational r) =>
Rational -> r
unsafeBoundRational Rational
0.7
          poolRAcnt :: RewardAccount
poolRAcnt = Network -> Credential 'Staking -> RewardAccount
RewardAccount Network
Testnet Credential 'Staking
testStakeCred
          poolPledge :: Coin
poolPledge = Integer -> Coin
Coin Integer
11
          poolCost :: Coin
poolCost = Integer -> Coin
Coin Integer
55
          poolUrl :: Text
poolUrl = Text
"pool.io"
          poolMDHash :: ByteString
poolMDHash = String -> ByteString
BS.pack String
"{}"
          ipv4 :: IPv4
ipv4 = [Int] -> IPv4
toIPv4 [Int
127, Int
0, Int
0, Int
1]
          ipv4Bytes :: ByteString
ipv4Bytes = IPv4 -> ByteString
ipv4ToBytes forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Int] -> IPv4
toIPv4 forall a b. (a -> b) -> a -> b
$ [Int
127, Int
0, Int
0, Int
1]
          poolRelays :: StrictSeq StakePoolRelay
poolRelays =
            forall a. [a] -> StrictSeq a
StrictSeq.fromList
              [ StrictMaybe Port
-> StrictMaybe IPv4 -> StrictMaybe IPv6 -> StakePoolRelay
SingleHostAddr forall a. StrictMaybe a
SNothing (forall a. a -> StrictMaybe a
SJust IPv4
ipv4) forall a. StrictMaybe a
SNothing
              , StrictMaybe Port -> DnsName -> StakePoolRelay
SingleHostName (forall a. a -> StrictMaybe a
SJust Port
42) forall a b. (a -> b) -> a -> b
$ forall a. HasCallStack => Maybe a -> a
Maybe.fromJust forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). MonadFail m => Int -> Text -> m DnsName
textToDns Int
64 Text
"singlehost.relay.com"
              , DnsName -> StakePoolRelay
MultiHostName forall a b. (a -> b) -> a -> b
$ forall a. HasCallStack => Maybe a -> a
Maybe.fromJust forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). MonadFail m => Int -> Text -> m DnsName
textToDns Int
64 Text
"multihost.relay.com"
              ]
          vrfKeyHash :: VRFVerKeyHash 'StakePoolVRF
          vrfKeyHash :: VRFVerKeyHash 'StakePoolVRF
vrfKeyHash = forall (r :: KeyRoleVRF). VRFVerKeyHash r
testVRFKH
       in forall a.
(HasCallStack, DecCBOR a, EncCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBOR
            Version
shelleyProtVer
            String
"register_pool"
            ( forall era. EraTxCert era => PoolParams -> TxCert era
RegPoolTxCert @C
                ( PoolParams
                    { ppId :: KeyHash 'StakePool
ppId = forall (kd :: KeyRole). VKey kd -> KeyHash kd
hashKey forall a b. (a -> b) -> a -> b
$ forall (kd :: KeyRole). KeyPair kd -> VKey kd
vKey KeyPair 'StakePool
testStakePoolKey
                    , ppVrf :: VRFVerKeyHash 'StakePoolVRF
ppVrf = VRFVerKeyHash 'StakePoolVRF
vrfKeyHash
                    , ppPledge :: Coin
ppPledge = Coin
poolPledge
                    , ppCost :: Coin
ppCost = Coin
poolCost
                    , ppMargin :: UnitInterval
ppMargin = UnitInterval
poolMargin
                    , ppRewardAccount :: RewardAccount
ppRewardAccount = RewardAccount
poolRAcnt
                    , ppOwners :: Set (KeyHash 'Staking)
ppOwners = forall a. a -> Set a
Set.singleton KeyHash 'Staking
poolOwner
                    , ppRelays :: StrictSeq StakePoolRelay
ppRelays = StrictSeq StakePoolRelay
poolRelays
                    , ppMetadata :: StrictMaybe PoolMetadata
ppMetadata =
                        forall a. a -> StrictMaybe a
SJust forall a b. (a -> b) -> a -> b
$
                          PoolMetadata
                            { pmUrl :: Url
pmUrl = forall a. HasCallStack => Maybe a -> a
Maybe.fromJust forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). MonadFail m => Int -> Text -> m Url
textToUrl Int
64 Text
poolUrl
                            , pmHash :: ByteString
pmHash = ByteString
poolMDHash
                            }
                    }
                )
            )
            ( (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
10)
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkWord Word
3) -- Reg Pool
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S (forall (kd :: KeyRole). VKey kd -> KeyHash kd
hashKey forall a b. (a -> b) -> a -> b
$ forall (kd :: KeyRole). KeyPair kd -> VKey kd
vKey KeyPair 'StakePool
testStakePoolKey) -- operator
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S VRFVerKeyHash 'StakePoolVRF
vrfKeyHash
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S Coin
poolPledge -- pledge
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S Coin
poolCost -- cost
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S UnitInterval
poolMargin -- margin
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S RewardAccount
poolRAcnt -- reward acct
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
1)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S KeyHash 'Staking
poolOwner -- owners
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
3) -- relays
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
4 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Tokens -> Tokens
TkWord Word
0 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Tokens -> Tokens
TkNull forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Tokens -> Tokens
TkBytes ByteString
ipv4Bytes forall b c a. (b -> c) -> (a -> b) -> a -> c
. Tokens -> Tokens
TkNull)
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
3 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Tokens -> Tokens
TkWord Word
1 forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Word -> Tokens -> Tokens
TkWord Word
42) forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Tokens -> Tokens
TkString (Text
"singlehost.relay.com"))
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
2 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Tokens -> Tokens
TkWord Word
2 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Tokens -> Tokens
TkString (Text
"multihost.relay.com"))
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
2) -- metadata present
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S Text
poolUrl -- metadata url
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S ByteString
poolMDHash -- metadata hash
            )
    , forall a.
(HasCallStack, DecCBOR a, EncCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBOR
        Version
shelleyProtVer
        String
"retire_pool"
        ( forall era.
EraTxCert era =>
KeyHash 'StakePool -> EpochNo -> TxCert era
RetirePoolTxCert @C
            (forall (kd :: KeyRole). VKey kd -> KeyHash kd
hashKey forall a b. (a -> b) -> a -> b
$ forall (kd :: KeyRole). KeyPair kd -> VKey kd
vKey KeyPair 'StakePool
testStakePoolKey)
            (Word64 -> EpochNo
EpochNo Word64
1729)
        )
        ( (Tokens -> Tokens) -> ToTokens
T
            ( Word -> Tokens -> Tokens
TkListLen Word
3
                forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Tokens -> Tokens
TkWord Word
4 -- Pool Retire
            )
            forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S (forall (kd :: KeyRole). VKey kd -> KeyHash kd
hashKey forall a b. (a -> b) -> a -> b
$ forall (kd :: KeyRole). KeyPair kd -> VKey kd
vKey KeyPair 'StakePool
testStakePoolKey) -- key hash
            forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S (Word64 -> EpochNo
EpochNo Word64
1729) -- epoch
        )
    , let vrfKeyHash :: VRFVerKeyHash 'GenDelegVRF
          vrfKeyHash :: VRFVerKeyHash 'GenDelegVRF
vrfKeyHash = forall (r :: KeyRoleVRF). VRFVerKeyHash r
testVRFKH
          genesisDelegate :: KeyHash 'GenesisDelegate
          genesisDelegate :: KeyHash 'GenesisDelegate
genesisDelegate = forall (kd :: KeyRole). VKey kd -> KeyHash kd
hashKey forall a b. (a -> b) -> a -> b
$ forall (kd :: KeyRole). KeyPair kd -> VKey kd
vKey KeyPair 'GenesisDelegate
testGenesisDelegateKey
       in forall a.
(HasCallStack, DecCBOR a, EncCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBOR
            Version
shelleyProtVer
            String
"genesis_delegation"
            (forall era.
(ShelleyEraTxCert era, ProtVerAtMost era 8) =>
KeyHash 'Genesis
-> KeyHash 'GenesisDelegate
-> VRFVerKeyHash 'GenDelegVRF
-> TxCert era
GenesisDelegTxCert @C KeyHash 'Genesis
testGKeyHash KeyHash 'GenesisDelegate
genesisDelegate VRFVerKeyHash 'GenDelegVRF
vrfKeyHash)
            ( (Tokens -> Tokens) -> ToTokens
T
                (Word -> Tokens -> Tokens
TkListLen Word
4 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Tokens -> Tokens
TkWord Word
5) -- genesis delegation cert
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S KeyHash 'Genesis
testGKeyHash -- delegator credential
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S KeyHash 'GenesisDelegate
genesisDelegate -- delegatee key hash
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S VRFVerKeyHash 'GenDelegVRF
vrfKeyHash
            )
    , -- checkEncodingCBOR "mir"
      let rws :: MIRTarget
rws = Map (Credential 'Staking) DeltaCoin -> MIRTarget
StakeAddressesMIR forall a b. (a -> b) -> a -> b
$ forall k a. k -> a -> Map k a
Map.singleton Credential 'Staking
testStakeCred (Integer -> DeltaCoin
DeltaCoin Integer
77)
       in forall a.
(HasCallStack, DecCBOR a, EncCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBOR
            Version
shelleyProtVer
            String
"mir"
            (forall era.
(ShelleyEraTxCert era, ProtVerAtMost era 8) =>
MIRCert -> TxCert era
MirTxCert @C (MIRPot -> MIRTarget -> MIRCert
MIRCert MIRPot
ReservesMIR MIRTarget
rws))
            ( (Tokens -> Tokens) -> ToTokens
T
                ( Word -> Tokens -> Tokens
TkListLen Word
2
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Tokens -> Tokens
TkWord Word
6 -- make instantaneous rewards cert
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Tokens -> Tokens
TkListLen Word
2
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Tokens -> Tokens
TkWord Word
0 -- take from the reserves
                )
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S MIRTarget
rws
            )
    , forall a.
(HasCallStack, DecCBOR a, EncCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBOR
        Version
shelleyProtVer
        String
"pparams_update_key_deposit_only"
        (forall era. EraPParams era => PParamsUpdate era
emptyPParamsUpdate @ShelleyEra forall a b. a -> (a -> b) -> b
& forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe Coin)
ppuKeyDepositL forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall a. a -> StrictMaybe a
SJust (Integer -> Coin
Coin Integer
5))
        (((Tokens -> Tokens) -> ToTokens
T forall a b. (a -> b) -> a -> b
$ Word -> Tokens -> Tokens
TkMapLen Word
1 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Tokens -> Tokens
TkWord Word
5) forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S (Integer -> Coin
Coin Integer
5))
    , -- checkEncodingCBOR "pparams_update_all"
      let minfeea :: Coin
minfeea = Integer -> Coin
Coin Integer
0
          minfeeb :: Coin
minfeeb = Integer -> Coin
Coin Integer
1
          maxbbsize :: Word32
maxbbsize = Word32
2
          maxtxsize :: Word32
maxtxsize = Word32
3
          maxbhsize :: Word16
maxbhsize = Word16
4
          keydeposit :: Coin
keydeposit = Integer -> Coin
Coin Integer
5
          pooldeposit :: Coin
pooldeposit = Integer -> Coin
Coin Integer
6
          emax :: EpochInterval
emax = Word32 -> EpochInterval
EpochInterval Word32
7
          nopt :: Word16
nopt = Word16
8
          a0 :: NonNegativeInterval
a0 = forall r.
(HasCallStack, Typeable r, BoundedRational r) =>
Rational -> r
unsafeBoundRational forall a b. (a -> b) -> a -> b
$ Integer
1 forall a. Integral a => a -> a -> Ratio a
% Integer
6
          rho :: UnitInterval
rho = forall r.
(HasCallStack, Typeable r, BoundedRational r) =>
Rational -> r
unsafeBoundRational forall a b. (a -> b) -> a -> b
$ Integer
1 forall a. Integral a => a -> a -> Ratio a
% Integer
6
          tau :: UnitInterval
tau = forall r.
(HasCallStack, Typeable r, BoundedRational r) =>
Rational -> r
unsafeBoundRational forall a b. (a -> b) -> a -> b
$ Integer
1 forall a. Integral a => a -> a -> Ratio a
% Integer
7
          d :: UnitInterval
d = forall r.
(HasCallStack, Typeable r, BoundedRational r) =>
Rational -> r
unsafeBoundRational forall a b. (a -> b) -> a -> b
$ Integer
1 forall a. Integral a => a -> a -> Ratio a
% Integer
9
          extraEntropy :: Nonce
extraEntropy = Nonce
NeutralNonce
          protocolVersion :: ProtVer
protocolVersion = Version -> Natural -> ProtVer
ProtVer forall a. Bounded a => a
minBound Natural
1
          minUTxOValue :: Coin
minUTxOValue = Integer -> Coin
Coin Integer
121
          minPoolCost :: Coin
minPoolCost = Integer -> Coin
Coin Integer
987
       in forall a.
(HasCallStack, DecCBOR a, EncCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBOR
            Version
shelleyProtVer
            String
"pparams_update_all"
            ( forall era. EraPParams era => PParamsUpdate era
emptyPParamsUpdate @ShelleyEra
                forall a b. a -> (a -> b) -> b
& forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe Coin)
ppuMinFeeAL forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall a. a -> StrictMaybe a
SJust Coin
minfeea
                forall a b. a -> (a -> b) -> b
& forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe Coin)
ppuMinFeeBL forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall a. a -> StrictMaybe a
SJust Coin
minfeeb
                forall a b. a -> (a -> b) -> b
& forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe Word32)
ppuMaxBBSizeL forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall a. a -> StrictMaybe a
SJust Word32
maxbbsize
                forall a b. a -> (a -> b) -> b
& forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe Word32)
ppuMaxTxSizeL forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall a. a -> StrictMaybe a
SJust Word32
maxtxsize
                forall a b. a -> (a -> b) -> b
& forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe Word16)
ppuMaxBHSizeL forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall a. a -> StrictMaybe a
SJust Word16
maxbhsize
                forall a b. a -> (a -> b) -> b
& forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe Coin)
ppuKeyDepositL forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall a. a -> StrictMaybe a
SJust Coin
keydeposit
                forall a b. a -> (a -> b) -> b
& forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe Coin)
ppuPoolDepositL forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall a. a -> StrictMaybe a
SJust Coin
pooldeposit
                forall a b. a -> (a -> b) -> b
& forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe EpochInterval)
ppuEMaxL forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall a. a -> StrictMaybe a
SJust EpochInterval
emax
                forall a b. a -> (a -> b) -> b
& forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe Word16)
ppuNOptL forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall a. a -> StrictMaybe a
SJust Word16
nopt
                forall a b. a -> (a -> b) -> b
& forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe NonNegativeInterval)
ppuA0L forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall a. a -> StrictMaybe a
SJust NonNegativeInterval
a0
                forall a b. a -> (a -> b) -> b
& forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe UnitInterval)
ppuRhoL forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall a. a -> StrictMaybe a
SJust UnitInterval
rho
                forall a b. a -> (a -> b) -> b
& forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe UnitInterval)
ppuTauL forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall a. a -> StrictMaybe a
SJust UnitInterval
tau
                forall a b. a -> (a -> b) -> b
& forall era.
(EraPParams era, ProtVerAtMost era 6) =>
Lens' (PParamsUpdate era) (StrictMaybe UnitInterval)
ppuDL forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall a. a -> StrictMaybe a
SJust UnitInterval
d
                forall a b. a -> (a -> b) -> b
& forall era.
(EraPParams era, ProtVerAtMost era 6) =>
Lens' (PParamsUpdate era) (StrictMaybe Nonce)
ppuExtraEntropyL forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall a. a -> StrictMaybe a
SJust Nonce
extraEntropy
                forall a b. a -> (a -> b) -> b
& forall era.
(EraPParams era, ProtVerAtMost era 8) =>
Lens' (PParamsUpdate era) (StrictMaybe ProtVer)
ppuProtocolVersionL forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall a. a -> StrictMaybe a
SJust ProtVer
protocolVersion
                forall a b. a -> (a -> b) -> b
& forall era.
(EraPParams era, ProtVerAtMost era 4) =>
Lens' (PParamsUpdate era) (StrictMaybe Coin)
ppuMinUTxOValueL forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall a. a -> StrictMaybe a
SJust Coin
minUTxOValue
                forall a b. a -> (a -> b) -> b
& forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe Coin)
ppuMinPoolCostL forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall a. a -> StrictMaybe a
SJust Coin
minPoolCost
            )
            ( ((Tokens -> Tokens) -> ToTokens
T forall a b. (a -> b) -> a -> b
$ Word -> Tokens -> Tokens
TkMapLen Word
17)
                forall a. Semigroup a => a -> a -> a
<> ((Tokens -> Tokens) -> ToTokens
T forall a b. (a -> b) -> a -> b
$ Word -> Tokens -> Tokens
TkWord Word
0)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S Coin
minfeea
                forall a. Semigroup a => a -> a -> a
<> ((Tokens -> Tokens) -> ToTokens
T forall a b. (a -> b) -> a -> b
$ Word -> Tokens -> Tokens
TkWord Word
1)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S Coin
minfeeb
                forall a. Semigroup a => a -> a -> a
<> ((Tokens -> Tokens) -> ToTokens
T forall a b. (a -> b) -> a -> b
$ Word -> Tokens -> Tokens
TkWord Word
2)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S Word32
maxbbsize
                forall a. Semigroup a => a -> a -> a
<> ((Tokens -> Tokens) -> ToTokens
T forall a b. (a -> b) -> a -> b
$ Word -> Tokens -> Tokens
TkWord Word
3)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S Word32
maxtxsize
                forall a. Semigroup a => a -> a -> a
<> ((Tokens -> Tokens) -> ToTokens
T forall a b. (a -> b) -> a -> b
$ Word -> Tokens -> Tokens
TkWord Word
4)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S Word16
maxbhsize
                forall a. Semigroup a => a -> a -> a
<> ((Tokens -> Tokens) -> ToTokens
T forall a b. (a -> b) -> a -> b
$ Word -> Tokens -> Tokens
TkWord Word
5)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S Coin
keydeposit
                forall a. Semigroup a => a -> a -> a
<> ((Tokens -> Tokens) -> ToTokens
T forall a b. (a -> b) -> a -> b
$ Word -> Tokens -> Tokens
TkWord Word
6)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S Coin
pooldeposit
                forall a. Semigroup a => a -> a -> a
<> ((Tokens -> Tokens) -> ToTokens
T forall a b. (a -> b) -> a -> b
$ Word -> Tokens -> Tokens
TkWord Word
7)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S EpochInterval
emax
                forall a. Semigroup a => a -> a -> a
<> ((Tokens -> Tokens) -> ToTokens
T forall a b. (a -> b) -> a -> b
$ Word -> Tokens -> Tokens
TkWord Word
8)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S Word16
nopt
                forall a. Semigroup a => a -> a -> a
<> ((Tokens -> Tokens) -> ToTokens
T forall a b. (a -> b) -> a -> b
$ Word -> Tokens -> Tokens
TkWord Word
9 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Tokens -> Tokens
TkTag Word
30)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S (forall r. BoundedRational r => r -> Rational
unboundRational NonNegativeInterval
a0)
                forall a. Semigroup a => a -> a -> a
<> ((Tokens -> Tokens) -> ToTokens
T forall a b. (a -> b) -> a -> b
$ Word -> Tokens -> Tokens
TkWord Word
10)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S UnitInterval
rho
                forall a. Semigroup a => a -> a -> a
<> ((Tokens -> Tokens) -> ToTokens
T forall a b. (a -> b) -> a -> b
$ Word -> Tokens -> Tokens
TkWord Word
11)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S UnitInterval
tau
                forall a. Semigroup a => a -> a -> a
<> ((Tokens -> Tokens) -> ToTokens
T forall a b. (a -> b) -> a -> b
$ Word -> Tokens -> Tokens
TkWord Word
12)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S UnitInterval
d
                forall a. Semigroup a => a -> a -> a
<> ((Tokens -> Tokens) -> ToTokens
T forall a b. (a -> b) -> a -> b
$ Word -> Tokens -> Tokens
TkWord Word
13)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S Nonce
extraEntropy
                forall a. Semigroup a => a -> a -> a
<> ((Tokens -> Tokens) -> ToTokens
T forall a b. (a -> b) -> a -> b
$ Word -> Tokens -> Tokens
TkWord Word
14)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S ProtVer
protocolVersion
                forall a. Semigroup a => a -> a -> a
<> ((Tokens -> Tokens) -> ToTokens
T forall a b. (a -> b) -> a -> b
$ Word -> Tokens -> Tokens
TkWord Word
15)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S Coin
minUTxOValue
                forall a. Semigroup a => a -> a -> a
<> ((Tokens -> Tokens) -> ToTokens
T forall a b. (a -> b) -> a -> b
$ Word -> Tokens -> Tokens
TkWord Word
16)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S Coin
minPoolCost
            )
    , -- checkEncodingCBOR "full_update"
      let ppup :: ProposedPPUpdates ShelleyEra
ppup =
            forall era.
Map (KeyHash 'Genesis) (PParamsUpdate era) -> ProposedPPUpdates era
ProposedPPUpdates @C
              ( forall k a. k -> a -> Map k a
Map.singleton
                  KeyHash 'Genesis
testGKeyHash
                  (forall era. EraPParams era => PParamsUpdate era
emptyPParamsUpdate forall a b. a -> (a -> b) -> b
& forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe Word16)
ppuNOptL forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall a. a -> StrictMaybe a
SJust Word16
100)
              )
          e :: EpochNo
e = Word64 -> EpochNo
EpochNo Word64
0
       in forall a.
(HasCallStack, DecCBOR a, EncCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBOR
            Version
shelleyProtVer
            String
"full_update"
            (forall era. ProposedPPUpdates era -> EpochNo -> Update era
Update ProposedPPUpdates ShelleyEra
ppup EpochNo
e)
            ( (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
2)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S ProposedPPUpdates ShelleyEra
ppup
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S EpochNo
e
            )
    , -- checkEncodingCBOR "minimal_txn_body"
      let tout :: ShelleyTxOut ShelleyEra
tout = forall era.
(HasCallStack, Era era, Val (Value era)) =>
Addr -> Value era -> ShelleyTxOut era
ShelleyTxOut @C Addr
testAddrE (Integer -> Coin
Coin Integer
2)
       in forall a.
(HasCallStack, DecCBOR (Annotator a), ToCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBORAnnotated
            Version
shelleyProtVer
            String
"txbody"
            ( forall era.
(EraTxOut era, EncCBOR (TxCert era)) =>
Set TxIn
-> StrictSeq (TxOut era)
-> StrictSeq (TxCert era)
-> Withdrawals
-> Coin
-> SlotNo
-> StrictMaybe (Update era)
-> StrictMaybe TxAuxDataHash
-> ShelleyTxBody era
ShelleyTxBody @C -- minimal transaction body
                (forall a. Ord a => [a] -> Set a
Set.fromList [TxIn
genesisTxIn1])
                (forall a. a -> StrictSeq a
StrictSeq.singleton ShelleyTxOut ShelleyEra
tout)
                forall a. StrictSeq a
StrictSeq.empty
                (Map RewardAccount Coin -> Withdrawals
Withdrawals forall k a. Map k a
Map.empty)
                (Integer -> Coin
Coin Integer
9)
                (Word64 -> SlotNo
SlotNo Word64
500)
                forall a. StrictMaybe a
SNothing
                forall a. StrictMaybe a
SNothing
            )
            ( (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkMapLen Word
4)
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkWord Word
0) -- Tx Ins
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
1)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S TxIn
genesisTxIn1
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkWord Word
1) -- Tx Outs
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
1)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S ShelleyTxOut ShelleyEra
tout
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkWord Word
2) -- Tx Fee
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word64 -> Tokens -> Tokens
TkWord64 Word64
9)
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkWord Word
3) -- Tx TTL
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word64 -> Tokens -> Tokens
TkWord64 Word64
500)
            )
    , -- checkEncodingCBOR "transaction_mixed"
      let tout :: ShelleyTxOut ShelleyEra
tout = forall era.
(HasCallStack, Era era, Val (Value era)) =>
Addr -> Value era -> ShelleyTxOut era
ShelleyTxOut @C Addr
testAddrE (Integer -> Coin
Coin Integer
2)
          ra :: RewardAccount
ra = Network -> Credential 'Staking -> RewardAccount
RewardAccount Network
Testnet (forall (kr :: KeyRole). KeyHash kr -> Credential kr
KeyHashObj KeyHash 'Staking
testKeyHash2)
          ras :: Map RewardAccount Coin
ras = forall k a. k -> a -> Map k a
Map.singleton RewardAccount
ra (Integer -> Coin
Coin Integer
123)
          up :: Update ShelleyEra
up =
            forall era. ProposedPPUpdates era -> EpochNo -> Update era
Update
              ( forall era.
Map (KeyHash 'Genesis) (PParamsUpdate era) -> ProposedPPUpdates era
ProposedPPUpdates forall a b. (a -> b) -> a -> b
$
                  forall k a. k -> a -> Map k a
Map.singleton KeyHash 'Genesis
testGKeyHash forall a b. (a -> b) -> a -> b
$
                    forall era. EraPParams era => PParamsUpdate era
emptyPParamsUpdate forall a b. a -> (a -> b) -> b
& forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe Word16)
ppuNOptL forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall a. a -> StrictMaybe a
SJust Word16
100
              )
              (Word64 -> EpochNo
EpochNo Word64
0)
       in forall a.
(HasCallStack, DecCBOR (Annotator a), ToCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBORAnnotated
            Version
shelleyProtVer
            String
"txbody_partial"
            ( forall era.
(EraTxOut era, EncCBOR (TxCert era)) =>
Set TxIn
-> StrictSeq (TxOut era)
-> StrictSeq (TxCert era)
-> Withdrawals
-> Coin
-> SlotNo
-> StrictMaybe (Update era)
-> StrictMaybe TxAuxDataHash
-> ShelleyTxBody era
ShelleyTxBody @C -- transaction body with some optional components
                (forall a. Ord a => [a] -> Set a
Set.fromList [TxIn
genesisTxIn1])
                (forall a. a -> StrictSeq a
StrictSeq.singleton ShelleyTxOut ShelleyEra
tout)
                forall a. StrictSeq a
StrictSeq.Empty
                (Map RewardAccount Coin -> Withdrawals
Withdrawals Map RewardAccount Coin
ras)
                (Integer -> Coin
Coin Integer
9)
                (Word64 -> SlotNo
SlotNo Word64
500)
                (forall a. a -> StrictMaybe a
SJust Update ShelleyEra
up)
                forall a. StrictMaybe a
SNothing
            )
            ( (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkMapLen Word
6)
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkWord Word
0) -- Tx Ins
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
1)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S TxIn
genesisTxIn1
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkWord Word
1) -- Tx Outs
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
1)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S ShelleyTxOut ShelleyEra
tout
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkWord Word
2) -- Tx Fee
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S (Integer -> Coin
Coin Integer
9)
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkWord Word
3) -- Tx TTL
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S (Word64 -> SlotNo
SlotNo Word64
500)
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkWord Word
5) -- Tx Reward Withdrawals
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S Map RewardAccount Coin
ras
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkWord Word
6) -- Tx Update
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S Update ShelleyEra
up
            )
    , -- checkEncodingCBOR "full_txn_body"
      let tout :: ShelleyTxOut ShelleyEra
tout = forall era.
(HasCallStack, Era era, Val (Value era)) =>
Addr -> Value era -> ShelleyTxOut era
ShelleyTxOut @C Addr
testAddrE (Integer -> Coin
Coin Integer
2)
          reg :: TxCert ShelleyEra
reg = forall era.
ShelleyEraTxCert era =>
Credential 'Staking -> TxCert era
RegTxCert Credential 'Staking
testStakeCred
          ra :: RewardAccount
ra = Network -> Credential 'Staking -> RewardAccount
RewardAccount Network
Testnet (forall (kr :: KeyRole). KeyHash kr -> Credential kr
KeyHashObj KeyHash 'Staking
testKeyHash2)
          ras :: Map RewardAccount Coin
ras = forall k a. k -> a -> Map k a
Map.singleton RewardAccount
ra (Integer -> Coin
Coin Integer
123)
          up :: Update ShelleyEra
up =
            forall era. ProposedPPUpdates era -> EpochNo -> Update era
Update
              ( forall era.
Map (KeyHash 'Genesis) (PParamsUpdate era) -> ProposedPPUpdates era
ProposedPPUpdates forall a b. (a -> b) -> a -> b
$
                  forall k a. k -> a -> Map k a
Map.singleton KeyHash 'Genesis
testGKeyHash forall a b. (a -> b) -> a -> b
$
                    forall era. EraPParams era => PParamsUpdate era
emptyPParamsUpdate forall a b. a -> (a -> b) -> b
& forall era.
EraPParams era =>
Lens' (PParamsUpdate era) (StrictMaybe Word16)
ppuNOptL forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall a. a -> StrictMaybe a
SJust Word16
100
              )
              (Word64 -> EpochNo
EpochNo Word64
0)
          mdh :: TxAuxDataHash
mdh = forall era. EraTxAuxData era => TxAuxData era -> TxAuxDataHash
hashTxAuxData @C forall a b. (a -> b) -> a -> b
$ forall era. Era era => Map Word64 Metadatum -> ShelleyTxAuxData era
TxAuxData.ShelleyTxAuxData forall a b. (a -> b) -> a -> b
$ forall k a. k -> a -> Map k a
Map.singleton Word64
13 (Integer -> Metadatum
TxAuxData.I Integer
17)
       in forall a.
(HasCallStack, DecCBOR (Annotator a), ToCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBORAnnotated
            Version
shelleyProtVer
            String
"txbody_full"
            ( forall era.
(EraTxOut era, EncCBOR (TxCert era)) =>
Set TxIn
-> StrictSeq (TxOut era)
-> StrictSeq (TxCert era)
-> Withdrawals
-> Coin
-> SlotNo
-> StrictMaybe (Update era)
-> StrictMaybe TxAuxDataHash
-> ShelleyTxBody era
ShelleyTxBody @C -- transaction body with all components
                (forall a. Ord a => [a] -> Set a
Set.fromList [TxIn
genesisTxIn1])
                (forall a. a -> StrictSeq a
StrictSeq.singleton ShelleyTxOut ShelleyEra
tout)
                (forall a. [a] -> StrictSeq a
StrictSeq.fromList [TxCert ShelleyEra
reg])
                (Map RewardAccount Coin -> Withdrawals
Withdrawals Map RewardAccount Coin
ras)
                (Integer -> Coin
Coin Integer
9)
                (Word64 -> SlotNo
SlotNo Word64
500)
                (forall a. a -> StrictMaybe a
SJust Update ShelleyEra
up)
                (forall a. a -> StrictMaybe a
SJust TxAuxDataHash
mdh)
            )
            ( (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkMapLen Word
8)
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkWord Word
0) -- Tx Ins
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
1)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S TxIn
genesisTxIn1
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkWord Word
1) -- Tx Outs
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
1)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S ShelleyTxOut ShelleyEra
tout
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkWord Word
2) -- Tx Fee
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S (Integer -> Coin
Coin Integer
9)
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkWord Word
3) -- Tx TTL
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S (Word64 -> SlotNo
SlotNo Word64
500)
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkWord Word
4) -- Tx Certs
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
1) -- Seq list begin
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S TxCert ShelleyEra
reg
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkWord Word
5) -- Tx Reward Withdrawals
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S Map RewardAccount Coin
ras
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkWord Word
6) -- Tx Update
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S Update ShelleyEra
up
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkWord Word
7) -- Tx Metadata
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S TxAuxDataHash
mdh
            )
    , -- checkEncodingCBOR "minimal_txn"
      let txb :: ShelleyTxBody ShelleyEra
txb =
            forall era.
(EraTxOut era, EncCBOR (TxCert era)) =>
Set TxIn
-> StrictSeq (TxOut era)
-> StrictSeq (TxCert era)
-> Withdrawals
-> Coin
-> SlotNo
-> StrictMaybe (Update era)
-> StrictMaybe TxAuxDataHash
-> ShelleyTxBody era
ShelleyTxBody @C
              (forall a. Ord a => [a] -> Set a
Set.fromList [TxId -> TxIx -> TxIn
TxIn TxId
genesisId (HasCallStack => Integer -> TxIx
mkTxIxPartial Integer
1)])
              (forall a. a -> StrictSeq a
StrictSeq.singleton forall a b. (a -> b) -> a -> b
$ forall era.
(HasCallStack, Era era, Val (Value era)) =>
Addr -> Value era -> ShelleyTxOut era
ShelleyTxOut @C Addr
testAddrE (Integer -> Coin
Coin Integer
2))
              forall a. StrictSeq a
StrictSeq.empty
              (Map RewardAccount Coin -> Withdrawals
Withdrawals forall k a. Map k a
Map.empty)
              (Integer -> Coin
Coin Integer
9)
              (Word64 -> SlotNo
SlotNo Word64
500)
              forall a. StrictMaybe a
SNothing
              forall a. StrictMaybe a
SNothing
          txbh :: SafeHash EraIndependentTxBody
txbh = (forall x i. HashAnnotated x i => x -> SafeHash i
hashAnnotated ShelleyTxBody ShelleyEra
txb)
          w :: WitVKey 'Witness
w = forall (kr :: KeyRole).
SafeHash EraIndependentTxBody -> KeyPair kr -> WitVKey 'Witness
mkWitnessVKey SafeHash EraIndependentTxBody
txbh KeyPair 'Payment
testKey1
       in forall a.
(HasCallStack, DecCBOR (Annotator a), ToCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBORAnnotated
            Version
shelleyProtVer
            String
"tx_min"
            ( forall era.
EraTx era =>
TxBody era
-> TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx era
ShelleyTx @(ShelleyEra)
                ShelleyTxBody ShelleyEra
txb
                (forall a. Monoid a => a
mempty {addrWits :: Set (WitVKey 'Witness)
addrWits = forall a. a -> Set a
Set.singleton WitVKey 'Witness
w} :: ShelleyTxWits C)
                forall a. StrictMaybe a
SNothing
            )
            ( (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
3)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S ShelleyTxBody ShelleyEra
txb
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkMapLen Word
1)
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkWord Word
0)
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
1)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S WitVKey 'Witness
w
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T Tokens -> Tokens
TkNull
            )
    , -- checkEncodingCBOR "full_txn"
      let txb :: ShelleyTxBody ShelleyEra
txb =
            forall era.
(EraTxOut era, EncCBOR (TxCert era)) =>
Set TxIn
-> StrictSeq (TxOut era)
-> StrictSeq (TxCert era)
-> Withdrawals
-> Coin
-> SlotNo
-> StrictMaybe (Update era)
-> StrictMaybe TxAuxDataHash
-> ShelleyTxBody era
ShelleyTxBody @C
              (forall a. Ord a => [a] -> Set a
Set.fromList [TxIn
genesisTxIn1])
              (forall a. a -> StrictSeq a
StrictSeq.singleton forall a b. (a -> b) -> a -> b
$ forall era.
(HasCallStack, Era era, Val (Value era)) =>
Addr -> Value era -> ShelleyTxOut era
ShelleyTxOut @C Addr
testAddrE (Integer -> Coin
Coin Integer
2))
              forall a. StrictSeq a
StrictSeq.empty
              (Map RewardAccount Coin -> Withdrawals
Withdrawals forall k a. Map k a
Map.empty)
              (Integer -> Coin
Coin Integer
9)
              (Word64 -> SlotNo
SlotNo Word64
500)
              forall a. StrictMaybe a
SNothing
              forall a. StrictMaybe a
SNothing
          txbh :: SafeHash EraIndependentTxBody
txbh = forall x i. HashAnnotated x i => x -> SafeHash i
hashAnnotated ShelleyTxBody ShelleyEra
txb
          w :: WitVKey 'Witness
w = forall (kr :: KeyRole).
SafeHash EraIndependentTxBody -> KeyPair kr -> WitVKey 'Witness
mkWitnessVKey SafeHash EraIndependentTxBody
txbh KeyPair 'Payment
testKey1
          s :: MultiSigMap
s = forall k a. k -> a -> Map k a
Map.singleton (forall era. EraScript era => Script era -> ScriptHash
hashScript @C MultiSig ShelleyEra
testScript) MultiSig ShelleyEra
testScript
          txwits :: ShelleyTxWits C
          txwits :: ShelleyTxWits ShelleyEra
txwits = forall era. EraTxWits era => TxWits era
mkBasicTxWits @C forall a b. a -> (a -> b) -> b
& forall era.
EraTxWits era =>
Lens' (TxWits era) (Set (WitVKey 'Witness))
addrTxWitsL forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall a. a -> Set a
Set.singleton WitVKey 'Witness
w forall a b. a -> (a -> b) -> b
& forall era.
EraTxWits era =>
Lens' (TxWits era) (Map ScriptHash (Script era))
scriptTxWitsL forall s t a b. ASetter s t a b -> b -> s -> t
.~ MultiSigMap
s
          md :: ShelleyTxAuxData ShelleyEra
md = (forall era. Era era => Map Word64 Metadatum -> ShelleyTxAuxData era
TxAuxData.ShelleyTxAuxData @C) forall a b. (a -> b) -> a -> b
$ forall k a. k -> a -> Map k a
Map.singleton Word64
17 (Integer -> Metadatum
TxAuxData.I Integer
42)
       in forall a.
(HasCallStack, DecCBOR (Annotator a), ToCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBORAnnotated
            Version
shelleyProtVer
            String
"tx_full"
            (forall era.
EraTx era =>
TxBody era
-> TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx era
ShelleyTx @ShelleyEra ShelleyTxBody ShelleyEra
txb ShelleyTxWits ShelleyEra
txwits (forall a. a -> StrictMaybe a
SJust ShelleyTxAuxData ShelleyEra
md))
            ( (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
3)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S ShelleyTxBody ShelleyEra
txb
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkMapLen Word
2)
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkWord Word
0)
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
1)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S WitVKey 'Witness
w
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkWord Word
1)
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
1)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S MultiSig ShelleyEra
testScript
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S ShelleyTxAuxData ShelleyEra
md
            )
    , -- checkEncodingCBOR "block_header_body"
      let prevhash :: PrevHash
prevhash = HashHeader -> PrevHash
BlockHash HashHeader
testHeaderHash
          vrfVkey :: VerKeyVRF (VRF MockCrypto)
vrfVkey = forall c. VRFKeyPair c -> VerKeyVRF (VRF c)
vrfVerKey VRFKeyPair MockCrypto
testVRF
          slot :: SlotNo
slot = Word64 -> SlotNo
SlotNo Word64
33
          nonce :: Seed
nonce = Nonce -> SlotNo -> Nonce -> Seed
mkSeed Nonce
seedEta (Word64 -> SlotNo
SlotNo Word64
33) (Word64 -> Nonce
mkNonceFromNumber Word64
0)
          nonceProof :: CertifiedVRF (VRF MockCrypto) Nonce
          nonceProof :: CertifiedVRF (VRF MockCrypto) Nonce
nonceProof =
            forall v a b.
(Signable v a, VRFAlgorithm v, ContextVRF v ~ (),
 Coercible b (CertifiedVRF v a)) =>
a -> SignKeyVRF v -> b
mkCertifiedVRF
              (forall a. a -> Word64 -> WithResult a
WithResult Seed
nonce Word64
1)
              (forall c. VRFKeyPair c -> SignKeyVRF (VRF c)
vrfSignKey VRFKeyPair MockCrypto
testVRF)
          leaderValue :: Seed
leaderValue = Nonce -> SlotNo -> Nonce -> Seed
mkSeed Nonce
seedL (Word64 -> SlotNo
SlotNo Word64
33) (Word64 -> Nonce
mkNonceFromNumber Word64
0)
          leaderProof :: CertifiedVRF (VRF MockCrypto) Natural
          leaderProof :: CertifiedVRF (VRF MockCrypto) Natural
leaderProof =
            forall v a b.
(Signable v a, VRFAlgorithm v, ContextVRF v ~ (),
 Coercible b (CertifiedVRF v a)) =>
a -> SignKeyVRF v -> b
mkCertifiedVRF
              (forall a. a -> Word64 -> WithResult a
WithResult Seed
leaderValue Word64
1)
              (forall c. VRFKeyPair c -> SignKeyVRF (VRF c)
vrfSignKey VRFKeyPair MockCrypto
testVRF)
          size :: Word32
size = Word32
0
          blockNo :: BlockNo
blockNo = Word64 -> BlockNo
BlockNo Word64
44
          bbhash :: Hash HASH EraIndependentBlockBody
bbhash = forall era. ShelleyTxSeq era -> Hash HASH EraIndependentBlockBody
bbHash @C forall a b. (a -> b) -> a -> b
$ forall era.
(EraTx era, Tx era ~ ShelleyTx era, SafeToHash (TxWits era)) =>
StrictSeq (Tx era) -> ShelleyTxSeq era
ShelleyTxSeq forall a. StrictSeq a
StrictSeq.empty
          ocert :: OCert MockCrypto
          ocert :: OCert MockCrypto
ocert =
            forall c.
VerKeyKES (KES c)
-> Word64
-> KESPeriod
-> SignedDSIGN DSIGN (OCertSignable c)
-> OCert c
OCert
              (forall c. KESKeyPair c -> VerKeyKES (KES c)
kesVerKey KESKeyPair MockCrypto
testKESKeys)
              Word64
0
              (Word -> KESPeriod
KESPeriod Word
0)
              ( forall a.
Signable DSIGN a =>
SignKeyDSIGN DSIGN -> a -> SignedDSIGN DSIGN a
signedDSIGN
                  (forall (kd :: KeyRole). KeyPair kd -> SignKeyDSIGN DSIGN
sKey KeyPair 'BlockIssuer
testBlockIssuerKey)
                  (forall c.
VerKeyKES (KES c) -> Word64 -> KESPeriod -> OCertSignable c
OCertSignable (forall c. KESKeyPair c -> VerKeyKES (KES c)
kesVerKey KESKeyPair MockCrypto
testKESKeys) Word64
0 (Word -> KESPeriod
KESPeriod Word
0))
              )
          protover :: ProtVer
protover = Version -> Natural -> ProtVer
ProtVer forall a. Bounded a => a
minBound Natural
0
       in forall a.
(HasCallStack, DecCBOR a, EncCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBOR
            Version
shelleyProtVer
            String
"block_header_body"
            ( BHBody
                { bheaderBlockNo :: BlockNo
bheaderBlockNo = BlockNo
blockNo
                , bheaderSlotNo :: SlotNo
bheaderSlotNo = SlotNo
slot
                , bheaderPrev :: PrevHash
bheaderPrev = PrevHash
prevhash
                , bheaderVk :: VKey 'BlockIssuer
bheaderVk = forall (kd :: KeyRole). KeyPair kd -> VKey kd
vKey KeyPair 'BlockIssuer
testBlockIssuerKey
                , bheaderVrfVk :: VerKeyVRF (VRF MockCrypto)
bheaderVrfVk = VerKeyVRF FakeVRF
vrfVkey
                , bheaderEta :: CertifiedVRF (VRF MockCrypto) Nonce
bheaderEta = CertifiedVRF (VRF MockCrypto) Nonce
nonceProof
                , bheaderL :: CertifiedVRF (VRF MockCrypto) Natural
bheaderL = CertifiedVRF (VRF MockCrypto) Natural
leaderProof
                , bsize :: Word32
bsize = Word32
size
                , bhash :: Hash HASH EraIndependentBlockBody
bhash = Hash HASH EraIndependentBlockBody
bbhash
                , bheaderOCert :: OCert MockCrypto
bheaderOCert = OCert MockCrypto
ocert
                , bprotver :: ProtVer
bprotver = ProtVer
protover
                }
            )
            ( (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen forall a b. (a -> b) -> a -> b
$ Word
9 forall a. Num a => a -> a -> a
+ Word
4 forall a. Num a => a -> a -> a
+ Word
2)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S BlockNo
blockNo
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S SlotNo
slot
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S PrevHash
prevhash
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T Tokens -> Tokens
testBlockIssuerKeyTokens
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S VerKeyVRF FakeVRF
vrfVkey
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S CertifiedVRF (VRF MockCrypto) Nonce
nonceProof
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S CertifiedVRF (VRF MockCrypto) Natural
leaderProof
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S Word32
size
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S Hash HASH EraIndependentBlockBody
bbhash
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBORGroup a => a -> ToTokens
G OCert MockCrypto
ocert -- 5
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBORGroup a => a -> ToTokens
G ProtVer
protover -- 3
            )
    , -- checkEncodingCBOR "operational_cert"
      let vkHot :: VerKeyKES (KES MockCrypto)
vkHot = forall c. KESKeyPair c -> VerKeyKES (KES c)
kesVerKey KESKeyPair MockCrypto
testKESKeys
          counter :: Word64
counter = Word64
0
          kesperiod :: KESPeriod
kesperiod = Word -> KESPeriod
KESPeriod Word
0
          signature :: SignedDSIGN DSIGN (OCertSignable MockCrypto)
signature =
            forall a.
Signable DSIGN a =>
SignKeyDSIGN DSIGN -> a -> SignedDSIGN DSIGN a
signedDSIGN
              (forall (kd :: KeyRole). KeyPair kd -> SignKeyDSIGN DSIGN
sKey KeyPair 'Payment
testKey1)
              (forall c.
VerKeyKES (KES c) -> Word64 -> KESPeriod -> OCertSignable c
OCertSignable (forall c. KESKeyPair c -> VerKeyKES (KES c)
kesVerKey KESKeyPair MockCrypto
testKESKeys) Word64
0 (Word -> KESPeriod
KESPeriod Word
0))
       in forall a.
(DecCBORGroup a, EncCBORGroup a, Show a, Eq a) =>
String -> a -> ToTokens -> TestTree
checkEncodingCBORCBORGroup
            String
"operational_cert"
            ( forall c.
VerKeyKES (KES c)
-> Word64
-> KESPeriod
-> SignedDSIGN DSIGN (OCertSignable c)
-> OCert c
OCert @MockCrypto
                VerKeyKES (MockKES 10)
vkHot
                Word64
counter
                KESPeriod
kesperiod
                SignedDSIGN DSIGN (OCertSignable MockCrypto)
signature
            )
            ( forall a. EncCBOR a => a -> ToTokens
S VerKeyKES (MockKES 10)
vkHot
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S Word64
counter
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S KESPeriod
kesperiod
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T Tokens -> Tokens
testOpCertSigTokens
            )
    , -- checkEncodingCBOR "block_header"
      let sig :: (SignedKES (KES MockCrypto) (BHBody MockCrypto))
          sig :: SignedKES (KES MockCrypto) (BHBody MockCrypto)
sig = forall v a.
(UnsoundPureKESAlgorithm v, Signable v a) =>
ContextKES v
-> Word -> a -> UnsoundPureSignKeyKES v -> SignedKES v a
unsoundPureSignedKES () Word
0 (forall era.
(EraTx era, PreAlonzo era, Tx era ~ ShelleyTx era) =>
BHBody MockCrypto
testBHB @C) (forall c. KESKeyPair c -> UnsoundPureSignKeyKES (KES c)
kesSignKey KESKeyPair MockCrypto
testKESKeys)
       in forall a.
(HasCallStack, DecCBOR (Annotator a), ToCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBORAnnotated
            Version
shelleyProtVer
            String
"block_header"
            (forall c.
Crypto c =>
BHBody c -> SignedKES (KES c) (BHBody c) -> BHeader c
BHeader (forall era.
(EraTx era, PreAlonzo era, Tx era ~ ShelleyTx era) =>
BHBody MockCrypto
testBHB @C) SignedKES (KES MockCrypto) (BHBody MockCrypto)
sig)
            ( ((Tokens -> Tokens) -> ToTokens
T forall a b. (a -> b) -> a -> b
$ Word -> Tokens -> Tokens
TkListLen Word
2)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S (forall era.
(EraTx era, PreAlonzo era, Tx era ~ ShelleyTx era) =>
BHBody MockCrypto
testBHB @C)
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (forall era.
(EraTx era, PreAlonzo era, Tx era ~ ShelleyTx era) =>
Tokens -> Tokens
testBHBSigTokens @C)
            )
    , -- checkEncodingCBOR "empty_block"
      let sig :: (SignedKES (KES MockCrypto) (BHBody MockCrypto))
          sig :: SignedKES (KES MockCrypto) (BHBody MockCrypto)
sig = forall v a.
(UnsoundPureKESAlgorithm v, Signable v a) =>
ContextKES v
-> Word -> a -> UnsoundPureSignKeyKES v -> SignedKES v a
unsoundPureSignedKES () Word
0 (forall era.
(EraTx era, PreAlonzo era, Tx era ~ ShelleyTx era) =>
BHBody MockCrypto
testBHB @C) (forall c. KESKeyPair c -> UnsoundPureSignKeyKES (KES c)
kesSignKey KESKeyPair MockCrypto
testKESKeys)
          bh :: BHeader MockCrypto
bh = forall c.
Crypto c =>
BHBody c -> SignedKES (KES c) (BHBody c) -> BHeader c
BHeader (forall era.
(EraTx era, PreAlonzo era, Tx era ~ ShelleyTx era) =>
BHBody MockCrypto
testBHB @C) SignedKES (KES MockCrypto) (BHBody MockCrypto)
sig
          txns :: ShelleyTxSeq ShelleyEra
txns = forall era.
(EraTx era, Tx era ~ ShelleyTx era, SafeToHash (TxWits era)) =>
StrictSeq (Tx era) -> ShelleyTxSeq era
ShelleyTxSeq forall a. StrictSeq a
StrictSeq.Empty
       in forall a.
(HasCallStack, DecCBOR (Annotator a), ToCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBORAnnotated
            Version
shelleyProtVer
            String
"empty_block"
            (forall era h.
(Era era, EncCBORGroup (TxSeq era), EncCBOR h) =>
h -> TxSeq era -> Block h era
Block @C BHeader MockCrypto
bh ShelleyTxSeq ShelleyEra
txns)
            ( ((Tokens -> Tokens) -> ToTokens
T forall a b. (a -> b) -> a -> b
$ Word -> Tokens -> Tokens
TkListLen Word
4)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S BHeader MockCrypto
bh
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
0 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Tokens -> Tokens
TkListLen Word
0 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Tokens -> Tokens
TkMapLen Word
0)
            )
    , -- checkEncodingCBOR "rich_block"
      let sig :: SignedKES (KES MockCrypto) (BHBody MockCrypto)
          sig :: SignedKES (KES MockCrypto) (BHBody MockCrypto)
sig = forall v a.
(UnsoundPureKESAlgorithm v, Signable v a) =>
ContextKES v
-> Word -> a -> UnsoundPureSignKeyKES v -> SignedKES v a
unsoundPureSignedKES () Word
0 (forall era.
(EraTx era, PreAlonzo era, Tx era ~ ShelleyTx era) =>
BHBody MockCrypto
testBHB @C) (forall c. KESKeyPair c -> UnsoundPureSignKeyKES (KES c)
kesSignKey KESKeyPair MockCrypto
testKESKeys)
          bh :: BHeader MockCrypto
bh = forall c.
Crypto c =>
BHBody c -> SignedKES (KES c) (BHBody c) -> BHeader c
BHeader (forall era.
(EraTx era, PreAlonzo era, Tx era ~ ShelleyTx era) =>
BHBody MockCrypto
testBHB @C) SignedKES (KES MockCrypto) (BHBody MockCrypto)
sig
          tout :: StrictSeq (ShelleyTxOut ShelleyEra)
tout = forall a. a -> StrictSeq a
StrictSeq.singleton forall a b. (a -> b) -> a -> b
$ forall era.
(HasCallStack, Era era, Val (Value era)) =>
Addr -> Value era -> ShelleyTxOut era
ShelleyTxOut @C Addr
testAddrE (Integer -> Coin
Coin Integer
2)
          txb :: Word64 -> ShelleyTxBody C
          txb :: Word64 -> ShelleyTxBody ShelleyEra
txb Word64
s =
            forall era.
(EraTxOut era, EncCBOR (TxCert era)) =>
Set TxIn
-> StrictSeq (TxOut era)
-> StrictSeq (TxCert era)
-> Withdrawals
-> Coin
-> SlotNo
-> StrictMaybe (Update era)
-> StrictMaybe TxAuxDataHash
-> ShelleyTxBody era
ShelleyTxBody @C
              (forall a. Ord a => [a] -> Set a
Set.fromList [TxIn
genesisTxIn1])
              StrictSeq (ShelleyTxOut ShelleyEra)
tout
              forall a. StrictSeq a
StrictSeq.empty
              (Map RewardAccount Coin -> Withdrawals
Withdrawals forall k a. Map k a
Map.empty)
              (Integer -> Coin
Coin Integer
9)
              (Word64 -> SlotNo
SlotNo Word64
s)
              forall a. StrictMaybe a
SNothing
              forall a. StrictMaybe a
SNothing
          txb1, txb2, txb3, txb4, txb5 :: ShelleyTxBody C
          txb1 :: ShelleyTxBody ShelleyEra
txb1 = Word64 -> ShelleyTxBody ShelleyEra
txb Word64
500
          txb2 :: ShelleyTxBody ShelleyEra
txb2 = Word64 -> ShelleyTxBody ShelleyEra
txb Word64
501
          txb3 :: ShelleyTxBody ShelleyEra
txb3 = Word64 -> ShelleyTxBody ShelleyEra
txb Word64
502
          txb4 :: ShelleyTxBody ShelleyEra
txb4 = Word64 -> ShelleyTxBody ShelleyEra
txb Word64
503
          txb5 :: ShelleyTxBody ShelleyEra
txb5 = Word64 -> ShelleyTxBody ShelleyEra
txb Word64
504
          w1 :: WitVKey 'Witness
w1 = forall (kr :: KeyRole).
SafeHash EraIndependentTxBody -> KeyPair kr -> WitVKey 'Witness
mkWitnessVKey (forall x i. HashAnnotated x i => x -> SafeHash i
hashAnnotated ShelleyTxBody ShelleyEra
txb1) KeyPair 'Payment
testKey1
          w2 :: WitVKey 'Witness
w2 = forall (kr :: KeyRole).
SafeHash EraIndependentTxBody -> KeyPair kr -> WitVKey 'Witness
mkWitnessVKey (forall x i. HashAnnotated x i => x -> SafeHash i
hashAnnotated ShelleyTxBody ShelleyEra
txb1) forall (kr :: KeyRole). KeyPair kr
testKey2
          ws :: Set (WitVKey 'Witness)
ws = forall a. Ord a => [a] -> Set a
Set.fromList [WitVKey 'Witness
w1, WitVKey 'Witness
w2]
          tx1, tx2, tx3, tx4, tx5 :: ShelleyTx C
          tx1 :: ShelleyTx ShelleyEra
tx1 =
            forall era. EraTx era => TxBody era -> Tx era
mkBasicTx ShelleyTxBody ShelleyEra
txb1
              forall a b. a -> (a -> b) -> b
& forall era. EraTx era => Lens' (Tx era) (TxWits era)
witsTxL @C forall s t a b. ASetter s t a b -> b -> s -> t
.~ (forall era. EraTxWits era => TxWits era
mkBasicTxWits @C forall a b. a -> (a -> b) -> b
& forall era.
EraTxWits era =>
Lens' (TxWits era) (Set (WitVKey 'Witness))
addrTxWitsL forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall a. a -> Set a
Set.singleton WitVKey 'Witness
w1)
          tx2 :: ShelleyTx ShelleyEra
tx2 =
            forall era. EraTx era => TxBody era -> Tx era
mkBasicTx ShelleyTxBody ShelleyEra
txb2
              forall a b. a -> (a -> b) -> b
& forall era. EraTx era => Lens' (Tx era) (TxWits era)
witsTxL @C forall s t a b. ASetter s t a b -> b -> s -> t
.~ (forall era. EraTxWits era => TxWits era
mkBasicTxWits @C forall a b. a -> (a -> b) -> b
& forall era.
EraTxWits era =>
Lens' (TxWits era) (Set (WitVKey 'Witness))
addrTxWitsL forall s t a b. ASetter s t a b -> b -> s -> t
.~ Set (WitVKey 'Witness)
ws)
          tx3 :: ShelleyTx ShelleyEra
tx3 =
            forall era. EraTx era => TxBody era -> Tx era
mkBasicTx ShelleyTxBody ShelleyEra
txb3
              forall a b. a -> (a -> b) -> b
& forall era. EraTx era => Lens' (Tx era) (TxWits era)
witsTxL @C
                forall s t a b. ASetter s t a b -> b -> s -> t
.~ ( forall era. EraTxWits era => TxWits era
mkBasicTxWits @C
                      forall a b. a -> (a -> b) -> b
& forall era.
EraTxWits era =>
Lens' (TxWits era) (Map ScriptHash (Script era))
scriptTxWitsL
                        forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall k a. k -> a -> Map k a
Map.singleton (forall era. EraScript era => Script era -> ScriptHash
hashScript @C MultiSig ShelleyEra
testScript) MultiSig ShelleyEra
testScript
                   )
          ss :: MultiSigMap
ss =
            forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
              [ (forall era. EraScript era => Script era -> ScriptHash
hashScript @C MultiSig ShelleyEra
testScript, MultiSig ShelleyEra
testScript)
              , (forall era. EraScript era => Script era -> ScriptHash
hashScript @C MultiSig ShelleyEra
testScript2, MultiSig ShelleyEra
testScript2)
              ]
          tx4 :: ShelleyTx ShelleyEra
tx4 =
            forall era. EraTx era => TxBody era -> Tx era
mkBasicTx ShelleyTxBody ShelleyEra
txb4
              forall a b. a -> (a -> b) -> b
& forall era. EraTx era => Lens' (Tx era) (TxWits era)
witsTxL @C forall s t a b. ASetter s t a b -> b -> s -> t
.~ (forall era. EraTxWits era => TxWits era
mkBasicTxWits @C forall a b. a -> (a -> b) -> b
& forall era.
EraTxWits era =>
Lens' (TxWits era) (Map ScriptHash (Script era))
scriptTxWitsL forall s t a b. ASetter s t a b -> b -> s -> t
.~ MultiSigMap
ss)
          tx5MD :: ShelleyTxAuxData ShelleyEra
tx5MD = forall era. Era era => Map Word64 Metadatum -> ShelleyTxAuxData era
TxAuxData.ShelleyTxAuxData @C forall a b. (a -> b) -> a -> b
$ forall k a. k -> a -> Map k a
Map.singleton Word64
17 (Integer -> Metadatum
TxAuxData.I Integer
42)
          tx5 :: ShelleyTx ShelleyEra
tx5 =
            forall era. EraTx era => TxBody era -> Tx era
mkBasicTx ShelleyTxBody ShelleyEra
txb5
              forall a b. a -> (a -> b) -> b
& forall era. EraTx era => Lens' (Tx era) (TxWits era)
witsTxL @C forall s t a b. ASetter s t a b -> b -> s -> t
.~ (forall era. EraTxWits era => TxWits era
mkBasicTxWits @C forall a b. a -> (a -> b) -> b
& forall era.
EraTxWits era =>
Lens' (TxWits era) (Set (WitVKey 'Witness))
addrTxWitsL forall s t a b. ASetter s t a b -> b -> s -> t
.~ Set (WitVKey 'Witness)
ws forall a b. a -> (a -> b) -> b
& forall era.
EraTxWits era =>
Lens' (TxWits era) (Map ScriptHash (Script era))
scriptTxWitsL forall s t a b. ASetter s t a b -> b -> s -> t
.~ MultiSigMap
ss)
              forall a b. a -> (a -> b) -> b
& forall era.
EraTx era =>
Lens' (Tx era) (StrictMaybe (TxAuxData era))
auxDataTxL @C forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall a. a -> StrictMaybe a
SJust ShelleyTxAuxData ShelleyEra
tx5MD
          txns :: ShelleyTxSeq ShelleyEra
txns = forall era.
(EraTx era, Tx era ~ ShelleyTx era, SafeToHash (TxWits era)) =>
StrictSeq (Tx era) -> ShelleyTxSeq era
ShelleyTxSeq forall a b. (a -> b) -> a -> b
$ forall a. [a] -> StrictSeq a
StrictSeq.fromList [ShelleyTx ShelleyEra
tx1, ShelleyTx ShelleyEra
tx2, ShelleyTx ShelleyEra
tx3, ShelleyTx ShelleyEra
tx4, ShelleyTx ShelleyEra
tx5]
       in forall a.
(HasCallStack, DecCBOR (Annotator a), ToCBOR a, Show a, Eq a) =>
Version -> String -> a -> ToTokens -> TestTree
checkEncodingCBORAnnotated
            Version
shelleyProtVer
            String
"rich_block"
            (forall era h.
(Era era, EncCBORGroup (TxSeq era), EncCBOR h) =>
h -> TxSeq era -> Block h era
Block @C BHeader MockCrypto
bh ShelleyTxSeq ShelleyEra
txns)
            ( ((Tokens -> Tokens) -> ToTokens
T forall a b. (a -> b) -> a -> b
$ Word -> Tokens -> Tokens
TkListLen Word
4)
                -- header
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S BHeader MockCrypto
bh
                -- bodies
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
5)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S ShelleyTxBody ShelleyEra
txb1
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S ShelleyTxBody ShelleyEra
txb2
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S ShelleyTxBody ShelleyEra
txb3
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S ShelleyTxBody ShelleyEra
txb4
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S ShelleyTxBody ShelleyEra
txb5
                -- witnesses
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
5)
                -- tx 1, one key
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkMapLen Word
1 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Tokens -> Tokens
TkWord Word
0)
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
1)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S WitVKey 'Witness
w1
                -- tx 2, two keys
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkMapLen Word
1 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Tokens -> Tokens
TkWord Word
0)
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
2)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S WitVKey 'Witness
w2
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S WitVKey 'Witness
w1
                -- tx 3, one script
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkMapLen Word
1 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Tokens -> Tokens
TkWord Word
1)
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
1)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S MultiSig ShelleyEra
testScript
                -- tx 4, two scripts
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkMapLen Word
1 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Tokens -> Tokens
TkWord Word
1)
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
2)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S MultiSig ShelleyEra
testScript
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S MultiSig ShelleyEra
testScript2
                -- tx 5, two keys and two scripts
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkMapLen Word
2)
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkWord Word
0)
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
2)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S WitVKey 'Witness
w2
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S WitVKey 'Witness
w1
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkWord Word
1)
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkListLen Word
2)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S MultiSig ShelleyEra
testScript
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S MultiSig ShelleyEra
testScript2
                -- metadata
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Word -> Tokens -> Tokens
TkMapLen Word
1)
                forall a. Semigroup a => a -> a -> a
<> (Tokens -> Tokens) -> ToTokens
T (Int -> Tokens -> Tokens
TkInt Int
4)
                forall a. Semigroup a => a -> a -> a
<> forall a. EncCBOR a => a -> ToTokens
S ShelleyTxAuxData ShelleyEra
tx5MD
            )
    , let actual :: ByteString
actual =
            forall a. ToCBOR a => a -> ByteString
Plain.serialize' forall a b. (a -> b) -> a -> b
$ forall era. ShelleyLedgerExamples era -> NewEpochState era
Ex.sleNewEpochState ShelleyLedgerExamples ShelleyEra
Ex.ledgerExamplesShelley
          expected :: ByteString
expected = forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. HasCallStack => String -> a
error forall a. a -> a
id forall a b. (a -> b) -> a -> b
$ ByteString -> Either String ByteString
B16.decode ByteString
expectedHex
          actualHex :: ByteString
actualHex = ByteString -> ByteString
B16.encode ByteString
actual
          expectedHex :: ByteString
expectedHex =
            forall a. Monoid a => [a] -> a
mconcat
              [ ByteString
"8700a1581ce0a714319812c3f773ba04ec5d6b3ffcd5aad85006805b047b0825410aa158"
              , ByteString
"1ca646474b8f5431261506b6c273d307c7569a4eb6c96b42dd4a29520a03848219271019"
              , ByteString
"03e8828383a0a00084a0a0a0a08482a0a0a0a084a0a0000086a15822ee155ace9c402920"
              , ByteString
"74cb6aff8c9ccdd273c81648ff1149ef36bcea6ebb8a3e250000583d003900cb9358529d"
              , ByteString
"f4729c3246a2a033cb9821abbfd16de4888005904abc410d6a577e9441ad8ed966393190"
              , ByteString
"6e4d43ece8f82c712b1d0235affb06000a1903e80185a0a0920000001908000000000018"
              , ByteString
"64d81e820001d81e820001d81e820001d81e820001810002000100920000001908000000"
              , ByteString
"00001864d81e820001d81e820001d81e820001d81e820001810002000000810082a0a000"
              , ByteString
"8483a0a0a083a0a0a083a0a0a00082a000818300880082020082a000000000a0a0840185"
              , ByteString
"a08000820200a0a082a0a082a1581ce0a714319812c3f773ba04ec5d6b3ffcd5aad85006"
              , ByteString
"805b047b08254183820101015820c5e21ab1c9f6022d81c3b25e3436cb7f1df77f9652ae"
              , ByteString
"3e1310c28e621dd87b4c01a0"
              ]
       in String -> Assertion -> TestTree
testCase String
"ledger state golden test" forall a b. (a -> b) -> a -> b
$
            forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (ByteString
actual forall a. Eq a => a -> a -> Bool
== ByteString
expected) forall a b. (a -> b) -> a -> b
$
              forall a. HasCallStack => String -> IO a
assertFailure forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc AnsiStyle -> String
ansiDocToString forall a b. (a -> b) -> a -> b
$
                forall ann. [Doc ann] -> Doc ann
Pretty.vsep
                  [ Doc AnsiStyle
"Expected: " forall a. Semigroup a => a -> a -> a
<> forall a ann. Show a => a -> Doc ann
Pretty.viaShow ByteString
expectedHex
                  , Doc AnsiStyle
"Actual:   " forall a. Semigroup a => a -> a -> a
<> forall a ann. Show a => a -> Doc ann
Pretty.viaShow ByteString
actualHex
                  , Doc AnsiStyle
"Difference:"
                  , forall ann. Int -> Doc ann -> Doc ann
Pretty.indent Int
2 forall a b. (a -> b) -> a -> b
$ forall a. ToExpr a => a -> a -> Doc AnsiStyle
diffExpr (ByteString -> CBORBytes
CBORBytes ByteString
expected) (ByteString -> CBORBytes
CBORBytes ByteString
actual)
                  ]
    ]
  where
    genesisTxIn1 :: TxIn
genesisTxIn1 = TxId -> TxIx -> TxIn
TxIn TxId
genesisId (HasCallStack => Integer -> TxIx
mkTxIxPartial Integer
1)