{-# 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 (
  DecCBOR (..),
  DecCBORGroup (..),
  Decoder,
  DecoderError,
  EncCBOR (..),
  EncCBORGroup (..),
  Tokens (..),
  byronProtVer,
  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 (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.Binary.Annotator
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 = Decoder s (Annotator ScriptHash)
-> Decoder s (Annotator (MultiSig ShelleyEra))
-> Decoder s (Annotator MultiSigMap)
forall a (t :: * -> *) s b.
(Ord a, Applicative t) =>
Decoder s (t a) -> Decoder s (t b) -> Decoder s (t (Map a b))
decodeMapTraverse (ScriptHash -> Annotator ScriptHash
forall a. a -> Annotator a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ScriptHash -> Annotator ScriptHash)
-> Decoder s ScriptHash -> Decoder s (Annotator ScriptHash)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Decoder s ScriptHash
forall s. Decoder s ScriptHash
forall a s. DecCBOR a => Decoder s a
decCBOR) Decoder s (Annotator (MultiSig ShelleyEra))
forall s. Decoder s (Annotator (MultiSig ShelleyEra))
forall a s. DecCBOR a => Decoder s a
decCBOR

deserializeMultiSigMap :: BSL.ByteString -> Either DecoderError MultiSigMap
deserializeMultiSigMap :: ByteString -> Either DecoderError MultiSigMap
deserializeMultiSigMap =
  Version
-> Text
-> (forall s. Decoder s (Annotator MultiSigMap))
-> ByteString
-> Either DecoderError MultiSigMap
forall a.
Version
-> Text
-> (forall s. Decoder s (Annotator a))
-> ByteString
-> Either DecoderError a
decodeFullAnnotator Version
shelleyProtVer Text
"Map ScriptHash MultiSig" Decoder s (Annotator MultiSigMap)
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 = Version
-> Text
-> (forall s. Decoder s a)
-> ByteString
-> Either DecoderError a
forall a.
Version
-> Text
-> (forall s. Decoder s a)
-> ByteString
-> Either DecoderError a
decodeFullDecoder Version
shelleyProtVer (String -> Text
forall a. IsString a => String -> a
fromString String
name) Decoder s a
forall s. Decoder s a
forall a s. DecCBORGroup a => Decoder s a
decCBORGroup
   in Version
-> (a -> Encoding)
-> (ByteString -> Either DecoderError a)
-> String
-> a
-> ToTokens
-> TestTree
forall a.
(HasCallStack, Show a, Eq a) =>
Version
-> (a -> Encoding)
-> (ByteString -> Either DecoderError a)
-> String
-> a
-> ToTokens
-> TestTree
checkEncoding Version
shelleyProtVer a -> Encoding
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) = Hash ADDRHASH (VerKeyDSIGN DSIGN) -> ByteString
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) = Hash HASH Nonce -> ByteString
forall h a. Hash h a -> ByteString
Hash.hashToBytes Hash HASH Nonce
hsh
getRawNonce Nonce
NeutralNonce = String -> ByteString
forall a. HasCallStack => String -> a
error String
"The neutral nonce has no bytes"

testGKey :: GenesisKeyPair c
testGKey :: forall c. GenesisKeyPair c
testGKey = VKey 'Genesis -> SignKeyDSIGN DSIGN -> GenesisKeyPair c
forall (kd :: KeyRole). VKey kd -> SignKeyDSIGN DSIGN -> KeyPair kd
KeyPair VKey 'Genesis
forall {kd :: KeyRole}. VKey kd
vk SignKeyDSIGN DSIGN
sk
  where
    (SignKeyDSIGN DSIGN
sk, VKey kd
vk) = RawSeed -> (SignKeyDSIGN DSIGN, VKey kd)
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 = VKey 'Genesis -> KeyHash 'Genesis
forall (kd :: KeyRole). VKey kd -> KeyHash kd
hashKey (VKey 'Genesis -> KeyHash 'Genesis)
-> VKey 'Genesis -> KeyHash 'Genesis
forall a b. (a -> b) -> a -> b
$ GenesisKeyPair c -> VKey 'Genesis
forall (kd :: KeyRole). KeyPair kd -> VKey kd
vKey GenesisKeyPair c
forall c. GenesisKeyPair c
testGKey

testVRF :: VRFKeyPair MockCrypto
testVRF :: VRFKeyPair MockCrypto
testVRF = RawSeed -> VRFKeyPair MockCrypto
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 (VerKeyVRF (VRF MockCrypto) -> VRFVerKeyHash r)
-> VerKeyVRF (VRF MockCrypto) -> VRFVerKeyHash r
forall a b. (a -> b) -> a -> b
$ VRFKeyPair MockCrypto -> VerKeyVRF (VRF MockCrypto)
forall c. VRFKeyPair c -> VerKeyVRF (VRF c)
vrfVerKey VRFKeyPair MockCrypto
testVRF

testTxb :: TxBody ShelleyEra
testTxb :: TxBody ShelleyEra
testTxb =
  Set TxIn
-> StrictSeq (TxOut ShelleyEra)
-> StrictSeq (TxCert ShelleyEra)
-> Withdrawals
-> Coin
-> SlotNo
-> StrictMaybe (Update ShelleyEra)
-> StrictMaybe TxAuxDataHash
-> TxBody ShelleyEra
ShelleyTxBody
    Set TxIn
forall a. Set a
Set.empty
    StrictSeq (TxOut ShelleyEra)
StrictSeq (ShelleyTxOut ShelleyEra)
forall a. StrictSeq a
StrictSeq.empty
    StrictSeq (TxCert ShelleyEra)
StrictSeq (ShelleyTxCert ShelleyEra)
forall a. StrictSeq a
StrictSeq.empty
    (Map RewardAccount Coin -> Withdrawals
Withdrawals Map RewardAccount Coin
forall k a. Map k a
Map.empty)
    (Integer -> Coin
Coin Integer
0)
    (Word64 -> SlotNo
SlotNo Word64
0)
    StrictMaybe (Update ShelleyEra)
forall a. StrictMaybe a
SNothing
    StrictMaybe TxAuxDataHash
forall a. StrictMaybe a
SNothing

testTxbHash ::
  SafeHash EraIndependentTxBody
testTxbHash :: SafeHash EraIndependentTxBody
testTxbHash = TxBody ShelleyEra -> SafeHash EraIndependentTxBody
forall x i. HashAnnotated x i => x -> SafeHash i
hashAnnotated TxBody ShelleyEra
testTxb

testKey1 :: KeyPair 'Payment
testKey1 :: KeyPair 'Payment
testKey1 = VKey 'Payment -> SignKeyDSIGN DSIGN -> KeyPair 'Payment
forall (kd :: KeyRole). VKey kd -> SignKeyDSIGN DSIGN -> KeyPair kd
KeyPair VKey 'Payment
forall {kd :: KeyRole}. VKey kd
vk SignKeyDSIGN DSIGN
sk
  where
    (SignKeyDSIGN DSIGN
sk, VKey kd
vk) = RawSeed -> (SignKeyDSIGN DSIGN, VKey kd)
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 = VKey kr -> SignKeyDSIGN DSIGN -> KeyPair kr
forall (kd :: KeyRole). VKey kd -> SignKeyDSIGN DSIGN -> KeyPair kd
KeyPair VKey kr
forall {kd :: KeyRole}. VKey kd
vk SignKeyDSIGN DSIGN
sk
  where
    (SignKeyDSIGN DSIGN
sk, VKey kd
vk) = RawSeed -> (SignKeyDSIGN DSIGN, VKey kd)
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 = VKey 'BlockIssuer -> SignKeyDSIGN DSIGN -> KeyPair 'BlockIssuer
forall (kd :: KeyRole). VKey kd -> SignKeyDSIGN DSIGN -> KeyPair kd
KeyPair VKey 'BlockIssuer
forall {kd :: KeyRole}. VKey kd
vk SignKeyDSIGN DSIGN
sk
  where
    (SignKeyDSIGN DSIGN
sk, VKey kd
vk) = RawSeed -> (SignKeyDSIGN DSIGN, VKey kd)
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 = VKey 'StakePool -> SignKeyDSIGN DSIGN -> KeyPair 'StakePool
forall (kd :: KeyRole). VKey kd -> SignKeyDSIGN DSIGN -> KeyPair kd
KeyPair VKey 'StakePool
forall {kd :: KeyRole}. VKey kd
vk SignKeyDSIGN DSIGN
sk
  where
    (SignKeyDSIGN DSIGN
sk, VKey kd
vk) = RawSeed -> (SignKeyDSIGN DSIGN, VKey kd)
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 = VKey 'GenesisDelegate
-> SignKeyDSIGN DSIGN -> KeyPair 'GenesisDelegate
forall (kd :: KeyRole). VKey kd -> SignKeyDSIGN DSIGN -> KeyPair kd
KeyPair VKey 'GenesisDelegate
forall {kd :: KeyRole}. VKey kd
vk SignKeyDSIGN DSIGN
sk
  where
    (SignKeyDSIGN DSIGN
sk, VKey kd
vk) = RawSeed -> (SignKeyDSIGN DSIGN, VKey kd)
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 = KeyPair 'BlockIssuer -> VKey 'BlockIssuer
forall (kd :: KeyRole). KeyPair kd -> VKey kd
vKey KeyPair 'BlockIssuer
testBlockIssuerKey
    CBOR.Encoding Tokens -> Tokens
e = Version -> Encoding -> Encoding
toPlainEncoding Version
shelleyProtVer (VerKeyDSIGN DSIGN -> Encoding
forall v. DSIGNAlgorithm v => VerKeyDSIGN v -> Encoding
encodeVerKeyDSIGN VerKeyDSIGN DSIGN
vk)

testKey1SigToken :: Tokens -> Tokens
testKey1SigToken :: Tokens -> Tokens
testKey1SigToken = Tokens -> Tokens
e
  where
    s :: SignedDSIGN DSIGN (Hash HASH EraIndependentTxBody)
s =
      SignKeyDSIGN DSIGN
-> Hash HASH EraIndependentTxBody
-> SignedDSIGN DSIGN (Hash HASH EraIndependentTxBody)
forall a.
Signable DSIGN a =>
SignKeyDSIGN DSIGN -> a -> SignedDSIGN DSIGN a
signedDSIGN
        (KeyPair 'Payment -> SignKeyDSIGN DSIGN
forall (kd :: KeyRole). KeyPair kd -> SignKeyDSIGN DSIGN
sKey KeyPair 'Payment
testKey1)
        (SafeHash EraIndependentTxBody -> Hash HASH EraIndependentTxBody
forall i. SafeHash i -> Hash HASH i
extractHash SafeHash EraIndependentTxBody
testTxbHash) ::
        SignedDSIGN DSIGN (Hash HASH EraIndependentTxBody)
    CBOR.Encoding Tokens -> Tokens
e = Version -> Encoding -> Encoding
toPlainEncoding Version
shelleyProtVer (SignedDSIGN DSIGN (Hash HASH EraIndependentTxBody) -> Encoding
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 =
      SignKeyDSIGN DSIGN
-> OCertSignable MockCrypto
-> SignedDSIGN DSIGN (OCertSignable MockCrypto)
forall a.
Signable DSIGN a =>
SignKeyDSIGN DSIGN -> a -> SignedDSIGN DSIGN a
signedDSIGN
        (KeyPair 'Payment -> SignKeyDSIGN DSIGN
forall (kd :: KeyRole). KeyPair kd -> SignKeyDSIGN DSIGN
sKey KeyPair 'Payment
testKey1)
        (forall c.
VerKeyKES (KES c) -> Word64 -> KESPeriod -> OCertSignable c
OCertSignable @MockCrypto (KESKeyPair MockCrypto -> VerKeyKES (KES 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 (SignedDSIGN DSIGN (OCertSignable MockCrypto) -> Encoding
forall v a. DSIGNAlgorithm v => SignedDSIGN v a -> Encoding
encodeSignedDSIGN SignedDSIGN DSIGN (OCertSignable MockCrypto)
s)

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

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

testKESKeys :: KESKeyPair MockCrypto
testKESKeys :: KESKeyPair MockCrypto
testKESKeys = RawSeed -> KESKeyPair MockCrypto
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
    (KeyHash 'Payment -> Credential 'Payment
forall (kr :: KeyRole). KeyHash kr -> Credential kr
KeyHashObj KeyHash 'Payment
testKeyHash1)
    StakeReference
StakeRefNull

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

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

testScript :: MultiSig ShelleyEra
testScript :: MultiSig ShelleyEra
testScript = KeyHash 'Witness -> NativeScript ShelleyEra
forall era.
ShelleyEraScript era =>
KeyHash 'Witness -> NativeScript era
RequireSignature (KeyHash 'Witness -> NativeScript ShelleyEra)
-> KeyHash 'Witness -> NativeScript ShelleyEra
forall a b. (a -> b) -> a -> b
$ KeyHash 'Payment -> KeyHash 'Witness
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 Script ShelleyEra
MultiSig ShelleyEra
testScript

testScript2 :: MultiSig ShelleyEra
testScript2 :: MultiSig ShelleyEra
testScript2 = KeyHash 'Witness -> NativeScript ShelleyEra
forall era.
ShelleyEraScript era =>
KeyHash 'Witness -> NativeScript era
RequireSignature (KeyHash 'Witness -> NativeScript ShelleyEra)
-> KeyHash 'Witness -> NativeScript ShelleyEra
forall a b. (a -> b) -> a -> b
$ KeyHash 'Staking -> KeyHash 'Witness
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 (Hash HASH EraIndependentBlockHeader -> HashHeader)
-> Hash HASH EraIndependentBlockHeader -> HashHeader
forall a b. (a -> b) -> a -> b
$ Hash HASH Int -> Hash HASH EraIndependentBlockHeader
forall a b. Coercible a b => a -> b
coerce (Version -> (Int -> Encoding) -> Int -> Hash HASH Int
forall h a.
HashAlgorithm h =>
Version -> (a -> Encoding) -> a -> Hash h a
hashWithEncoder Version
shelleyProtVer Int -> Encoding
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 = KeyPair 'BlockIssuer -> VKey 'BlockIssuer
forall (kd :: KeyRole). KeyPair kd -> VKey kd
vKey KeyPair 'BlockIssuer
testBlockIssuerKey
    , bheaderVrfVk :: VerKeyVRF (VRF MockCrypto)
bheaderVrfVk = VRFKeyPair MockCrypto -> VerKeyVRF (VRF MockCrypto)
forall c. VRFKeyPair c -> VerKeyVRF (VRF c)
vrfVerKey VRFKeyPair MockCrypto
testVRF
    , bheaderEta :: CertifiedVRF (VRF MockCrypto) Nonce
bheaderEta =
        WithResult Seed -> SignKeyVRF FakeVRF -> CertifiedVRF FakeVRF Nonce
forall v a b.
(Signable v a, VRFAlgorithm v, ContextVRF v ~ (),
 Coercible b (CertifiedVRF v a)) =>
a -> SignKeyVRF v -> b
mkCertifiedVRF
          ( Seed -> Word64 -> WithResult Seed
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
          )
          (VRFKeyPair MockCrypto -> SignKeyVRF (VRF MockCrypto)
forall c. VRFKeyPair c -> SignKeyVRF (VRF c)
vrfSignKey VRFKeyPair MockCrypto
testVRF)
    , bheaderL :: CertifiedVRF (VRF MockCrypto) Natural
bheaderL =
        WithResult Seed
-> SignKeyVRF FakeVRF -> CertifiedVRF FakeVRF Natural
forall v a b.
(Signable v a, VRFAlgorithm v, ContextVRF v ~ (),
 Coercible b (CertifiedVRF v a)) =>
a -> SignKeyVRF v -> b
mkCertifiedVRF
          ( Seed -> Word64 -> WithResult Seed
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
          )
          (VRFKeyPair MockCrypto -> SignKeyVRF (VRF MockCrypto)
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 (ShelleyTxSeq era -> Hash HASH EraIndependentBlockBody)
-> ShelleyTxSeq era -> Hash HASH EraIndependentBlockBody
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 StrictSeq (Tx era)
StrictSeq (ShelleyTx era)
forall a. StrictSeq a
StrictSeq.empty
    , bheaderOCert :: OCert MockCrypto
bheaderOCert =
        VerKeyKES (KES MockCrypto)
-> Word64
-> KESPeriod
-> SignedDSIGN DSIGN (OCertSignable MockCrypto)
-> OCert MockCrypto
forall c.
VerKeyKES (KES c)
-> Word64
-> KESPeriod
-> SignedDSIGN DSIGN (OCertSignable c)
-> OCert c
OCert
          (KESKeyPair MockCrypto -> VerKeyKES (KES MockCrypto)
forall c. KESKeyPair c -> VerKeyKES (KES c)
kesVerKey KESKeyPair MockCrypto
testKESKeys)
          Word64
0
          (Word -> KESPeriod
KESPeriod Word
0)
          ( SignKeyDSIGN DSIGN
-> OCertSignable MockCrypto
-> SignedDSIGN DSIGN (OCertSignable MockCrypto)
forall a.
Signable DSIGN a =>
SignKeyDSIGN DSIGN -> a -> SignedDSIGN DSIGN a
signedDSIGN
              (KeyPair 'Payment -> SignKeyDSIGN DSIGN
forall (kd :: KeyRole). KeyPair kd -> SignKeyDSIGN DSIGN
sKey KeyPair 'Payment
testKey1)
              (VerKeyKES (KES MockCrypto)
-> Word64 -> KESPeriod -> OCertSignable MockCrypto
forall c.
VerKeyKES (KES c) -> Word64 -> KESPeriod -> OCertSignable c
OCertSignable (KESKeyPair MockCrypto -> VerKeyKES (KES MockCrypto)
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 Version
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)
        (KESKeyPair MockCrypto -> UnsoundPureSignKeyKES (KES MockCrypto)
forall c. KESKeyPair c -> UnsoundPureSignKeyKES (KES c)
kesSignKey KESKeyPair MockCrypto
testKESKeys)
    CBOR.Encoding Tokens -> Tokens
e = Version -> Encoding -> Encoding
toPlainEncoding Version
shelleyProtVer (SignedKES (MockKES 10) (BHBody MockCrypto) -> Encoding
forall v a. KESAlgorithm v => SignedKES v a -> Encoding
encodeSignedKES SignedKES (MockKES 10) (BHBody MockCrypto)
SignedKES (KES MockCrypto) (BHBody MockCrypto)
s)

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