{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# OPTIONS_GHC -Wno-deprecations #-}

module Test.Cardano.Ledger.Shelley.Fees (
  sizeTests,
)
where

import Cardano.Ledger.Address (Withdrawals (..))
import Cardano.Ledger.BaseTypes (
  Network (..),
  StrictMaybe (..),
  textToDns,
  textToUrl,
 )
import Cardano.Ledger.Binary.Plain as Plain (serialize)
import Cardano.Ledger.Coin (Coin (..))
import Cardano.Ledger.Core
import Cardano.Ledger.Crypto
import Cardano.Ledger.Keys (
  KeyHash,
  KeyRole (..),
  asWitness,
  hashKey,
 )
import Cardano.Ledger.PoolParams (PoolMetadata (..), StakePoolRelay (..))
import Cardano.Ledger.SafeHash (hashAnnotated)
import Cardano.Ledger.Shelley (Shelley)
import Cardano.Ledger.Shelley.API (
  Addr,
  Credential (..),
  PoolParams (..),
  RewardAccount (..),
  ShelleyTxBody (..),
  ShelleyTxOut (..),
  TxIn (..),
  hashVerKeyVRF,
 )
import Cardano.Ledger.Shelley.Scripts (
  ShelleyEraScript,
  pattern RequireMOf,
  pattern RequireSignature,
 )
import Cardano.Ledger.Shelley.Tx (
  ShelleyTx (..),
 )
import Cardano.Ledger.Shelley.TxAuxData
import Cardano.Ledger.Shelley.TxCert (
  pattern DelegStakeTxCert,
  pattern RegTxCert,
  pattern UnRegTxCert,
 )
import Cardano.Ledger.Shelley.TxWits (
  addrWits,
 )
import Cardano.Ledger.Shelley.UTxO (getShelleyMinFeeTxUtxo)
import Cardano.Ledger.Slot (EpochNo (..), SlotNo (..))
import Cardano.Ledger.Tools (estimateMinFeeTx)
import Cardano.Ledger.TxIn (mkTxInPartial)
import qualified Cardano.Ledger.Val as Val
import qualified Data.ByteString.Base16.Lazy as Base16
import qualified Data.ByteString.Char8 as BS (pack)
import qualified Data.ByteString.Lazy as BSL
import qualified Data.Map.Strict as Map (empty, singleton)
import Data.Maybe (fromJust)
import qualified Data.Sequence.Strict as StrictSeq
import qualified Data.Set as Set
import GHC.Stack (HasCallStack)
import Lens.Micro
import Test.Cardano.Ledger.Core.KeyPair (KeyPair (..), mkAddr, mkWitnessesVKey, vKey)
import Test.Cardano.Ledger.Shelley.Generator.Core (VRFKeyPair (..))
import Test.Cardano.Ledger.Shelley.Generator.EraGen (genesisId)
import Test.Cardano.Ledger.Shelley.Generator.ShelleyEraGen ()
import Test.Cardano.Ledger.Shelley.Utils (
  RawSeed (..),
  mkKeyPair,
  mkVRFKeyPair,
  unsafeBoundRational,
 )
import Test.Tasty (TestTree, testGroup)
import Test.Tasty.HUnit (Assertion, testCase, (@?=))

sizeTest :: HasCallStack => BSL.ByteString -> ShelleyTx Shelley -> Assertion
sizeTest :: HasCallStack => ByteString -> ShelleyTx Shelley -> Assertion
sizeTest ByteString
b16 ShelleyTx Shelley
tx = do
  ByteString -> ByteString
Base16.encode (forall a. ToCBOR a => a -> ByteString
Plain.serialize ShelleyTx Shelley
tx) forall a. (Eq a, Show a, HasCallStack) => a -> a -> Assertion
@?= ByteString
b16
  (ShelleyTx Shelley
tx forall s a. s -> Getting a s a -> a
^. forall era. EraTx era => SimpleGetter (Tx era) Integer
sizeTxF) forall a. (Eq a, Show a, HasCallStack) => a -> a -> Assertion
@?= forall a. Integral a => a -> Integer
toInteger (ByteString -> Int64
BSL.length ByteString
b16 forall a. Integral a => a -> a -> a
`div` Int64
2)

alicePay :: forall c. Crypto c => KeyPair 'Payment c
alicePay :: forall c. Crypto c => KeyPair 'Payment c
alicePay = forall (kd :: KeyRole) c.
VKey kd c -> SignKeyDSIGN (DSIGN c) -> KeyPair kd c
KeyPair @'Payment @c VKey 'Payment c
vk SignKeyDSIGN (DSIGN c)
sk
  where
    (SignKeyDSIGN (DSIGN c)
sk, VKey 'Payment c
vk) = forall c (kd :: KeyRole).
DSIGNAlgorithm (DSIGN c) =>
RawSeed -> (SignKeyDSIGN (DSIGN c), VKey kd c)
mkKeyPair @c (Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> RawSeed
RawSeed Word64
0 Word64
0 Word64
0 Word64
0 Word64
0)

aliceStake :: forall c. Crypto c => KeyPair 'Staking c
aliceStake :: forall c. Crypto c => KeyPair 'Staking c
aliceStake = forall (kd :: KeyRole) c.
VKey kd c -> SignKeyDSIGN (DSIGN c) -> KeyPair kd c
KeyPair VKey 'Staking c
vk SignKeyDSIGN (DSIGN c)
sk
  where
    (SignKeyDSIGN (DSIGN c)
sk, VKey 'Staking c
vk) = forall c (kd :: KeyRole).
DSIGNAlgorithm (DSIGN c) =>
RawSeed -> (SignKeyDSIGN (DSIGN c), VKey kd c)
mkKeyPair @c (Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> RawSeed
RawSeed Word64
0 Word64
0 Word64
0 Word64
0 Word64
1)

aliceSHK :: forall c. Crypto c => Credential 'Staking c
aliceSHK :: forall c. Crypto c => Credential 'Staking c
aliceSHK = (forall (kr :: KeyRole) c. KeyHash kr c -> Credential kr c
KeyHashObj forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c (kd :: KeyRole). Crypto c => VKey kd c -> KeyHash kd c
hashKey forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (kd :: KeyRole) c. KeyPair kd c -> VKey kd c
vKey) forall c. Crypto c => KeyPair 'Staking c
aliceStake

alicePool :: forall c. Crypto c => KeyPair 'StakePool c
alicePool :: forall c. Crypto c => KeyPair 'StakePool c
alicePool = forall (kd :: KeyRole) c.
VKey kd c -> SignKeyDSIGN (DSIGN c) -> KeyPair kd c
KeyPair VKey 'StakePool c
vk SignKeyDSIGN (DSIGN c)
sk
  where
    (SignKeyDSIGN (DSIGN c)
sk, VKey 'StakePool c
vk) = forall c (kd :: KeyRole).
DSIGNAlgorithm (DSIGN c) =>
RawSeed -> (SignKeyDSIGN (DSIGN c), VKey kd c)
mkKeyPair @c (Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> RawSeed
RawSeed Word64
0 Word64
0 Word64
0 Word64
0 Word64
2)

alicePoolKH :: forall c. Crypto c => KeyHash 'StakePool c
alicePoolKH :: forall c. Crypto c => KeyHash 'StakePool c
alicePoolKH = (forall c (kd :: KeyRole). Crypto c => VKey kd c -> KeyHash kd c
hashKey forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (kd :: KeyRole) c. KeyPair kd c -> VKey kd c
vKey) forall c. Crypto c => KeyPair 'StakePool c
alicePool

aliceVRF :: forall c. Crypto c => VRFKeyPair c
aliceVRF :: forall c. Crypto c => VRFKeyPair c
aliceVRF = forall c. Crypto c => RawSeed -> VRFKeyPair c
mkVRFKeyPair (Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> RawSeed
RawSeed Word64
0 Word64
0 Word64
0 Word64
0 Word64
3)

alicePoolParams :: forall c. Crypto c => PoolParams c
alicePoolParams :: forall c. Crypto c => PoolParams c
alicePoolParams =
  PoolParams
    { ppId :: KeyHash 'StakePool c
ppId = forall c. Crypto c => KeyHash 'StakePool c
alicePoolKH
    , ppVrf :: Hash c (VerKeyVRF c)
ppVrf = forall v h.
(VRFAlgorithm v, HashAlgorithm h) =>
VerKeyVRF v -> Hash h (VerKeyVRF v)
hashVerKeyVRF forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c. VRFKeyPair c -> VerKeyVRF c
vrfVerKey forall a b. (a -> b) -> a -> b
$ forall c. Crypto c => VRFKeyPair c
aliceVRF @c
    , ppPledge :: Coin
ppPledge = Integer -> Coin
Coin Integer
1
    , ppCost :: Coin
ppCost = Integer -> Coin
Coin Integer
5
    , ppMargin :: UnitInterval
ppMargin = forall r.
(HasCallStack, Typeable r, BoundedRational r) =>
Rational -> r
unsafeBoundRational Rational
0.1
    , ppRewardAccount :: RewardAccount c
ppRewardAccount = forall c. Network -> Credential 'Staking c -> RewardAccount c
RewardAccount Network
Testnet forall c. Crypto c => Credential 'Staking c
aliceSHK
    , ppOwners :: Set (KeyHash 'Staking c)
ppOwners = forall a. a -> Set a
Set.singleton forall a b. (a -> b) -> a -> b
$ (forall c (kd :: KeyRole). Crypto c => VKey kd c -> KeyHash kd c
hashKey forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (kd :: KeyRole) c. KeyPair kd c -> VKey kd c
vKey) forall c. Crypto c => KeyPair 'Staking c
aliceStake
    , ppRelays :: StrictSeq StakePoolRelay
ppRelays =
        forall a. a -> StrictSeq a
StrictSeq.singleton forall a b. (a -> b) -> a -> b
$
          StrictMaybe Port -> DnsName -> StakePoolRelay
SingleHostName forall a. StrictMaybe a
SNothing forall a b. (a -> b) -> a -> b
$
            forall a. HasCallStack => Maybe a -> a
fromJust forall a b. (a -> b) -> a -> b
$
              forall (m :: * -> *). MonadFail m => Int -> Text -> m DnsName
textToDns Int
64 Text
"relay.io"
    , ppMetadata :: StrictMaybe PoolMetadata
ppMetadata =
        forall a. a -> StrictMaybe a
SJust forall a b. (a -> b) -> a -> b
$
          PoolMetadata
            { pmUrl :: Url
pmUrl = forall a. HasCallStack => Maybe a -> a
fromJust forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). MonadFail m => Int -> Text -> m Url
textToUrl Int
64 Text
"alice.pool"
            , pmHash :: ByteString
pmHash = String -> ByteString
BS.pack String
"{}"
            }
    }

aliceAddr :: forall c. Crypto c => Addr c
aliceAddr :: forall c. Crypto c => Addr c
aliceAddr = forall c.
Crypto c =>
(KeyPair 'Payment c, KeyPair 'Staking c) -> Addr c
mkAddr (forall c. Crypto c => KeyPair 'Payment c
alicePay, forall c. Crypto c => KeyPair 'Staking c
aliceStake)

bobPay :: forall c. Crypto c => KeyPair 'Payment c
bobPay :: forall c. Crypto c => KeyPair 'Payment c
bobPay = forall (kd :: KeyRole) c.
VKey kd c -> SignKeyDSIGN (DSIGN c) -> KeyPair kd c
KeyPair VKey 'Payment c
vk SignKeyDSIGN (DSIGN c)
sk
  where
    (SignKeyDSIGN (DSIGN c)
sk, VKey 'Payment c
vk) = forall c (kd :: KeyRole).
DSIGNAlgorithm (DSIGN c) =>
RawSeed -> (SignKeyDSIGN (DSIGN c), VKey kd c)
mkKeyPair @c (Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> RawSeed
RawSeed Word64
1 Word64
0 Word64
0 Word64
0 Word64
0)

bobStake :: forall c. Crypto c => KeyPair 'Staking c
bobStake :: forall c. Crypto c => KeyPair 'Staking c
bobStake = forall (kd :: KeyRole) c.
VKey kd c -> SignKeyDSIGN (DSIGN c) -> KeyPair kd c
KeyPair VKey 'Staking c
vk SignKeyDSIGN (DSIGN c)
sk
  where
    (SignKeyDSIGN (DSIGN c)
sk, VKey 'Staking c
vk) = forall c (kd :: KeyRole).
DSIGNAlgorithm (DSIGN c) =>
RawSeed -> (SignKeyDSIGN (DSIGN c), VKey kd c)
mkKeyPair @c (Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> RawSeed
RawSeed Word64
1 Word64
0 Word64
0 Word64
0 Word64
1)

bobSHK :: forall c. Crypto c => Credential 'Staking c
bobSHK :: forall c. Crypto c => Credential 'Staking c
bobSHK = (forall (kr :: KeyRole) c. KeyHash kr c -> Credential kr c
KeyHashObj forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c (kd :: KeyRole). Crypto c => VKey kd c -> KeyHash kd c
hashKey forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (kd :: KeyRole) c. KeyPair kd c -> VKey kd c
vKey) forall c. Crypto c => KeyPair 'Staking c
bobStake

bobAddr :: forall c. Crypto c => Addr c
bobAddr :: forall c. Crypto c => Addr c
bobAddr = forall c.
Crypto c =>
(KeyPair 'Payment c, KeyPair 'Staking c) -> Addr c
mkAddr (forall c. Crypto c => KeyPair 'Payment c
bobPay, forall c. Crypto c => KeyPair 'Staking c
bobStake)

carlPay :: forall c. Crypto c => KeyPair 'Payment c
carlPay :: forall c. Crypto c => KeyPair 'Payment c
carlPay = forall (kd :: KeyRole) c.
VKey kd c -> SignKeyDSIGN (DSIGN c) -> KeyPair kd c
KeyPair forall {kd :: KeyRole}. VKey kd c
vk SignKeyDSIGN (DSIGN c)
sk
  where
    (SignKeyDSIGN (DSIGN c)
sk, VKey kd c
vk) = forall c (kd :: KeyRole).
DSIGNAlgorithm (DSIGN c) =>
RawSeed -> (SignKeyDSIGN (DSIGN c), VKey kd c)
mkKeyPair (Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> RawSeed
RawSeed Word64
2 Word64
0 Word64
0 Word64
0 Word64
0)

-- | Simple Transaction which consumes one UTxO and creates one UTxO
-- | and has one witness
txbSimpleUTxO :: ShelleyTxBody Shelley
txbSimpleUTxO :: ShelleyTxBody Shelley
txbSimpleUTxO =
  ShelleyTxBody
    { stbInputs :: Set (TxIn (EraCrypto Shelley))
stbInputs = forall a. Ord a => [a] -> Set a
Set.fromList [forall c. TxId c -> TxIx -> TxIn c
TxIn forall c. HashAlgorithm (HASH c) => TxId c
genesisId forall a. Bounded a => a
minBound]
    , stbOutputs :: StrictSeq (TxOut Shelley)
stbOutputs = forall a. [a] -> StrictSeq a
StrictSeq.fromList [forall era.
(HasCallStack, Era era, Val (Value era)) =>
Addr (EraCrypto era) -> Value era -> ShelleyTxOut era
ShelleyTxOut forall c. Crypto c => Addr c
aliceAddr (forall t s. Inject t s => t -> s
Val.inject forall a b. (a -> b) -> a -> b
$ Integer -> Coin
Coin Integer
10)]
    , stbCerts :: StrictSeq (TxCert Shelley)
stbCerts = forall a. StrictSeq a
StrictSeq.empty
    , stbWithdrawals :: Withdrawals (EraCrypto Shelley)
stbWithdrawals = forall c. Map (RewardAcnt c) Coin -> Withdrawals c
Withdrawals forall k a. Map k a
Map.empty
    , stbTxFee :: Coin
stbTxFee = Integer -> Coin
Coin Integer
94
    , stbTTL :: SlotNo
stbTTL = Word64 -> SlotNo
SlotNo Word64
10
    , stbUpdate :: StrictMaybe (Update Shelley)
stbUpdate = forall a. StrictMaybe a
SNothing
    , stbMDHash :: StrictMaybe (AuxiliaryDataHash (EraCrypto Shelley))
stbMDHash = forall a. StrictMaybe a
SNothing
    }

txSimpleUTxO :: ShelleyTx Shelley
txSimpleUTxO :: ShelleyTx Shelley
txSimpleUTxO =
  ShelleyTx
    { body :: TxBody Shelley
body = ShelleyTxBody Shelley
txbSimpleUTxO
    , wits :: TxWits Shelley
wits =
        forall a. Monoid a => a
mempty
          { addrWits :: Set (WitVKey 'Witness (EraCrypto Shelley))
addrWits = forall c (kr :: KeyRole).
(Crypto c, DSignable c (Hash (HASH c) EraIndependentTxBody)) =>
SafeHash c EraIndependentTxBody
-> [KeyPair kr c] -> Set (WitVKey 'Witness c)
mkWitnessesVKey (forall x index c.
(HashAnnotated x index c, HashAlgorithm (HASH c)) =>
x -> SafeHash c index
hashAnnotated ShelleyTxBody Shelley
txbSimpleUTxO) [forall c. Crypto c => KeyPair 'Payment c
alicePay]
          }
    , auxiliaryData :: StrictMaybe (TxAuxData Shelley)
auxiliaryData = forall a. StrictMaybe a
SNothing
    }

txSimpleUTxOBytes16 :: BSL.ByteString
txSimpleUTxOBytes16 :: ByteString
txSimpleUTxOBytes16 =
  ByteString
"83a4008182582003170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c11131400018182583900e9686d801fa32aeb4390c2f2a53bb0314a9c744c46a2cada394a371fc6852b6aaed73bcf346a57ef99adae3000b51c7c59faaeb15993df760a02185e030aa100818258204628aaf16d6e1baa061d1296419542cb09287c639163d0fdbdac0ff23699797e584089c20cb6246483bbd0b2006f658597eff3e8ab3b8a6e9b22cb3c5b95cf0d3a2b96107acef88319fa2dd0fb28adcfdb330bb99f1f0058918a75d951ca9b73660cf6"

-- | Transaction which consumes two UTxO and creates five UTxO
-- | and has two witness
txbMutiUTxO :: ShelleyTxBody Shelley
txbMutiUTxO :: ShelleyTxBody Shelley
txbMutiUTxO =
  ShelleyTxBody
    { stbInputs :: Set (TxIn (EraCrypto Shelley))
stbInputs =
        forall a. Ord a => [a] -> Set a
Set.fromList
          [ forall c. HasCallStack => TxId c -> Integer -> TxIn c
mkTxInPartial forall c. HashAlgorithm (HASH c) => TxId c
genesisId Integer
0
          , forall c. HasCallStack => TxId c -> Integer -> TxIn c
mkTxInPartial forall c. HashAlgorithm (HASH c) => TxId c
genesisId Integer
1
          ]
    , stbOutputs :: StrictSeq (TxOut Shelley)
stbOutputs =
        forall a. [a] -> StrictSeq a
StrictSeq.fromList
          [ forall era.
(HasCallStack, Era era, Val (Value era)) =>
Addr (EraCrypto era) -> Value era -> ShelleyTxOut era
ShelleyTxOut forall c. Crypto c => Addr c
aliceAddr (forall t s. Inject t s => t -> s
Val.inject forall a b. (a -> b) -> a -> b
$ Integer -> Coin
Coin Integer
10)
          , forall era.
(HasCallStack, Era era, Val (Value era)) =>
Addr (EraCrypto era) -> Value era -> ShelleyTxOut era
ShelleyTxOut forall c. Crypto c => Addr c
aliceAddr (forall t s. Inject t s => t -> s
Val.inject forall a b. (a -> b) -> a -> b
$ Integer -> Coin
Coin Integer
20)
          , forall era.
(HasCallStack, Era era, Val (Value era)) =>
Addr (EraCrypto era) -> Value era -> ShelleyTxOut era
ShelleyTxOut forall c. Crypto c => Addr c
aliceAddr (forall t s. Inject t s => t -> s
Val.inject forall a b. (a -> b) -> a -> b
$ Integer -> Coin
Coin Integer
30)
          , forall era.
(HasCallStack, Era era, Val (Value era)) =>
Addr (EraCrypto era) -> Value era -> ShelleyTxOut era
ShelleyTxOut forall c. Crypto c => Addr c
bobAddr (forall t s. Inject t s => t -> s
Val.inject forall a b. (a -> b) -> a -> b
$ Integer -> Coin
Coin Integer
40)
          , forall era.
(HasCallStack, Era era, Val (Value era)) =>
Addr (EraCrypto era) -> Value era -> ShelleyTxOut era
ShelleyTxOut forall c. Crypto c => Addr c
bobAddr (forall t s. Inject t s => t -> s
Val.inject forall a b. (a -> b) -> a -> b
$ Integer -> Coin
Coin Integer
50)
          ]
    , stbCerts :: StrictSeq (TxCert Shelley)
stbCerts = forall a. StrictSeq a
StrictSeq.empty
    , stbWithdrawals :: Withdrawals (EraCrypto Shelley)
stbWithdrawals = forall c. Map (RewardAcnt c) Coin -> Withdrawals c
Withdrawals forall k a. Map k a
Map.empty
    , stbTxFee :: Coin
stbTxFee = Integer -> Coin
Coin Integer
199
    , stbTTL :: SlotNo
stbTTL = Word64 -> SlotNo
SlotNo Word64
10
    , stbUpdate :: StrictMaybe (Update Shelley)
stbUpdate = forall a. StrictMaybe a
SNothing
    , stbMDHash :: StrictMaybe (AuxiliaryDataHash (EraCrypto Shelley))
stbMDHash = forall a. StrictMaybe a
SNothing
    }

txMutiUTxO :: ShelleyTx Shelley
txMutiUTxO :: ShelleyTx Shelley
txMutiUTxO =
  ShelleyTx
    { body :: TxBody Shelley
body = ShelleyTxBody Shelley
txbMutiUTxO
    , wits :: TxWits Shelley
wits =
        forall a. Monoid a => a
mempty
          { addrWits :: Set (WitVKey 'Witness (EraCrypto Shelley))
addrWits =
              forall c (kr :: KeyRole).
(Crypto c, DSignable c (Hash (HASH c) EraIndependentTxBody)) =>
SafeHash c EraIndependentTxBody
-> [KeyPair kr c] -> Set (WitVKey 'Witness c)
mkWitnessesVKey
                (forall x index c.
(HashAnnotated x index c, HashAlgorithm (HASH c)) =>
x -> SafeHash c index
hashAnnotated ShelleyTxBody Shelley
txbMutiUTxO)
                [ forall c. Crypto c => KeyPair 'Payment c
alicePay
                , forall c. Crypto c => KeyPair 'Payment c
bobPay
                ]
          }
    , auxiliaryData :: StrictMaybe (TxAuxData Shelley)
auxiliaryData = forall a. StrictMaybe a
SNothing
    }

txMutiUTxOBytes16 :: BSL.ByteString
txMutiUTxOBytes16 :: ByteString
txMutiUTxOBytes16 =
  ByteString
"83a4008282582003170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c1113140082582003170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c11131401018582583900e9686d801fa32aeb4390c2f2a53bb0314a9c744c46a2cada394a371fc6852b6aaed73bcf346a57ef99adae3000b51c7c59faaeb15993df760a82583900e9686d801fa32aeb4390c2f2a53bb0314a9c744c46a2cada394a371fc6852b6aaed73bcf346a57ef99adae3000b51c7c59faaeb15993df761482583900e9686d801fa32aeb4390c2f2a53bb0314a9c744c46a2cada394a371fc6852b6aaed73bcf346a57ef99adae3000b51c7c59faaeb15993df76181e825839000d2a471489a90f2910ec67ded8e215bfcd669bae77e7f9ab15850abd4e130c0bdeb7768edf2e8f85007fd52073e3dc1871f4c47f9dfca92e1828825839000d2a471489a90f2910ec67ded8e215bfcd669bae77e7f9ab15850abd4e130c0bdeb7768edf2e8f85007fd52073e3dc1871f4c47f9dfca92e18320218c7030aa1008282582037139648f2c22bbf1d0ef9af37cfebc9014b1e0e2a55be87c4b3b231a8d84d2658405ef09b22172cd28678e76e600e899886852e03567e2e72b4815629471e736a0cd424dc71cdaa0d0403371d79ea3d0cb7f28cb0740ebfcd8947343eba99a6aa088258204628aaf16d6e1baa061d1296419542cb09287c639163d0fdbdac0ff23699797e5840ea98ef8052776aa5c182621cfd2ec91011d327527fc2531be9e1a8356c10f25f3fe5a5a7f549a0dc3b17c4ad8e4b8673b63a87977ac899b675f3ce3d6badae01f6"

-- | Transaction which registers a stake key
txbRegisterStake :: ShelleyTxBody Shelley
txbRegisterStake :: ShelleyTxBody Shelley
txbRegisterStake =
  ShelleyTxBody
    { stbInputs :: Set (TxIn (EraCrypto Shelley))
stbInputs = forall a. Ord a => [a] -> Set a
Set.fromList [forall c. TxId c -> TxIx -> TxIn c
TxIn forall c. HashAlgorithm (HASH c) => TxId c
genesisId forall a. Bounded a => a
minBound]
    , stbOutputs :: StrictSeq (TxOut Shelley)
stbOutputs = forall a. [a] -> StrictSeq a
StrictSeq.fromList [forall era.
(HasCallStack, Era era, Val (Value era)) =>
Addr (EraCrypto era) -> Value era -> ShelleyTxOut era
ShelleyTxOut forall c. Crypto c => Addr c
aliceAddr (forall t s. Inject t s => t -> s
Val.inject forall a b. (a -> b) -> a -> b
$ Integer -> Coin
Coin Integer
10)]
    , stbCerts :: StrictSeq (TxCert Shelley)
stbCerts = forall a. [a] -> StrictSeq a
StrictSeq.fromList [forall era.
ShelleyEraTxCert era =>
StakeCredential (EraCrypto era) -> TxCert era
RegTxCert forall c. Crypto c => Credential 'Staking c
aliceSHK]
    , stbWithdrawals :: Withdrawals (EraCrypto Shelley)
stbWithdrawals = forall c. Map (RewardAcnt c) Coin -> Withdrawals c
Withdrawals forall k a. Map k a
Map.empty
    , stbTxFee :: Coin
stbTxFee = Integer -> Coin
Coin Integer
94
    , stbTTL :: SlotNo
stbTTL = Word64 -> SlotNo
SlotNo Word64
10
    , stbUpdate :: StrictMaybe (Update Shelley)
stbUpdate = forall a. StrictMaybe a
SNothing
    , stbMDHash :: StrictMaybe (AuxiliaryDataHash (EraCrypto Shelley))
stbMDHash = forall a. StrictMaybe a
SNothing
    }

txRegisterStake :: ShelleyTx Shelley
txRegisterStake :: ShelleyTx Shelley
txRegisterStake =
  ShelleyTx
    { body :: TxBody Shelley
body = ShelleyTxBody Shelley
txbRegisterStake
    , wits :: TxWits Shelley
wits =
        forall a. Monoid a => a
mempty
          { addrWits :: Set (WitVKey 'Witness (EraCrypto Shelley))
addrWits = forall c (kr :: KeyRole).
(Crypto c, DSignable c (Hash (HASH c) EraIndependentTxBody)) =>
SafeHash c EraIndependentTxBody
-> [KeyPair kr c] -> Set (WitVKey 'Witness c)
mkWitnessesVKey (forall x index c.
(HashAnnotated x index c, HashAlgorithm (HASH c)) =>
x -> SafeHash c index
hashAnnotated ShelleyTxBody Shelley
txbRegisterStake) [forall c. Crypto c => KeyPair 'Payment c
alicePay]
          }
    , auxiliaryData :: StrictMaybe (TxAuxData Shelley)
auxiliaryData = forall a. StrictMaybe a
SNothing
    }

txRegisterStakeBytes16 :: BSL.ByteString
txRegisterStakeBytes16 :: ByteString
txRegisterStakeBytes16 =
  ByteString
"83a5008182582003170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c11131400018182583900e9686d801fa32aeb4390c2f2a53bb0314a9c744c46a2cada394a371fc6852b6aaed73bcf346a57ef99adae3000b51c7c59faaeb15993df760a02185e030a048182008200581cc6852b6aaed73bcf346a57ef99adae3000b51c7c59faaeb15993df76a100818258204628aaf16d6e1baa061d1296419542cb09287c639163d0fdbdac0ff23699797e58403271792b002eb39bcb133668e851a5ffba9c13ad2b5c5a7bbc850a17de8309cbb9649d9e90eb4c9cc82f28f204408d513ccc575ce1f61808f67793429ff1880ef6"

-- | Transaction which delegates a stake key
txbDelegateStake :: ShelleyTxBody Shelley
txbDelegateStake :: ShelleyTxBody Shelley
txbDelegateStake =
  ShelleyTxBody
    { stbInputs :: Set (TxIn (EraCrypto Shelley))
stbInputs = forall a. Ord a => [a] -> Set a
Set.fromList [forall c. TxId c -> TxIx -> TxIn c
TxIn forall c. HashAlgorithm (HASH c) => TxId c
genesisId forall a. Bounded a => a
minBound]
    , stbOutputs :: StrictSeq (TxOut Shelley)
stbOutputs = forall a. [a] -> StrictSeq a
StrictSeq.fromList [forall era.
(HasCallStack, Era era, Val (Value era)) =>
Addr (EraCrypto era) -> Value era -> ShelleyTxOut era
ShelleyTxOut forall c. Crypto c => Addr c
aliceAddr (forall t s. Inject t s => t -> s
Val.inject forall a b. (a -> b) -> a -> b
$ Integer -> Coin
Coin Integer
10)]
    , stbCerts :: StrictSeq (TxCert Shelley)
stbCerts =
        forall a. [a] -> StrictSeq a
StrictSeq.fromList
          [ forall era.
ShelleyEraTxCert era =>
StakeCredential (EraCrypto era)
-> KeyHash 'StakePool (EraCrypto era) -> TxCert era
DelegStakeTxCert forall c. Crypto c => Credential 'Staking c
bobSHK forall c. Crypto c => KeyHash 'StakePool c
alicePoolKH
          ]
    , stbWithdrawals :: Withdrawals (EraCrypto Shelley)
stbWithdrawals = forall c. Map (RewardAcnt c) Coin -> Withdrawals c
Withdrawals forall k a. Map k a
Map.empty
    , stbTxFee :: Coin
stbTxFee = Integer -> Coin
Coin Integer
94
    , stbTTL :: SlotNo
stbTTL = Word64 -> SlotNo
SlotNo Word64
10
    , stbUpdate :: StrictMaybe (Update Shelley)
stbUpdate = forall a. StrictMaybe a
SNothing
    , stbMDHash :: StrictMaybe (AuxiliaryDataHash (EraCrypto Shelley))
stbMDHash = forall a. StrictMaybe a
SNothing
    }

txDelegateStake :: ShelleyTx Shelley
txDelegateStake :: ShelleyTx Shelley
txDelegateStake =
  ShelleyTx
    { body :: TxBody Shelley
body = ShelleyTxBody Shelley
txbDelegateStake
    , wits :: TxWits Shelley
wits =
        forall a. Monoid a => a
mempty
          { addrWits :: Set (WitVKey 'Witness (EraCrypto Shelley))
addrWits =
              forall c (kr :: KeyRole).
(Crypto c, DSignable c (Hash (HASH c) EraIndependentTxBody)) =>
SafeHash c EraIndependentTxBody
-> [KeyPair kr c] -> Set (WitVKey 'Witness c)
mkWitnessesVKey
                (forall x index c.
(HashAnnotated x index c, HashAlgorithm (HASH c)) =>
x -> SafeHash c index
hashAnnotated ShelleyTxBody Shelley
txbDelegateStake)
                [forall (a :: KeyRole -> * -> *) (r :: KeyRole) c.
HasKeyRole a =>
a r c -> a 'Witness c
asWitness forall c. Crypto c => KeyPair 'Payment c
alicePay, forall (a :: KeyRole -> * -> *) (r :: KeyRole) c.
HasKeyRole a =>
a r c -> a 'Witness c
asWitness forall c. Crypto c => KeyPair 'Staking c
bobStake]
          }
    , auxiliaryData :: StrictMaybe (TxAuxData Shelley)
auxiliaryData = forall a. StrictMaybe a
SNothing
    }

txDelegateStakeBytes16 :: BSL.ByteString
txDelegateStakeBytes16 :: ByteString
txDelegateStakeBytes16 =
  ByteString
"83a5008182582003170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c11131400018182583900e9686d801fa32aeb4390c2f2a53bb0314a9c744c46a2cada394a371fc6852b6aaed73bcf346a57ef99adae3000b51c7c59faaeb15993df760a02185e030a048183028200581c4e130c0bdeb7768edf2e8f85007fd52073e3dc1871f4c47f9dfca92e581c5d43e1f1048b2619f51abc0cf505e4d4f9cb84becefd468d1a2fe335a100828258209921fa37a7d167aab519bb937d7ac6e522ad6d259a6173523357b971e05f41ff58403bad563c201b4f62448db12711af2d916776194b5176e9d312d07a328ce7780a63032dce887abc67985629b7aeabb0c334e84094f44d7e51ae51b5c799a83c0d8258204628aaf16d6e1baa061d1296419542cb09287c639163d0fdbdac0ff23699797e584064aef85b046d2d0072cd64844e9f13d86651a1db74d356a10ecd7fb35a664fc466e543ea55cfbffd74025dc092d62c4b22d7e2de4decb4f049df354cfae9790af6"

-- | Transaction which de-registers a stake key
txbDeregisterStake :: ShelleyTxBody Shelley
txbDeregisterStake :: ShelleyTxBody Shelley
txbDeregisterStake =
  ShelleyTxBody
    { stbInputs :: Set (TxIn (EraCrypto Shelley))
stbInputs = forall a. Ord a => [a] -> Set a
Set.fromList [forall c. TxId c -> TxIx -> TxIn c
TxIn forall c. HashAlgorithm (HASH c) => TxId c
genesisId forall a. Bounded a => a
minBound]
    , stbOutputs :: StrictSeq (TxOut Shelley)
stbOutputs = forall a. [a] -> StrictSeq a
StrictSeq.fromList [forall era.
(HasCallStack, Era era, Val (Value era)) =>
Addr (EraCrypto era) -> Value era -> ShelleyTxOut era
ShelleyTxOut forall c. Crypto c => Addr c
aliceAddr (forall t s. Inject t s => t -> s
Val.inject forall a b. (a -> b) -> a -> b
$ Integer -> Coin
Coin Integer
10)]
    , stbCerts :: StrictSeq (TxCert Shelley)
stbCerts = forall a. [a] -> StrictSeq a
StrictSeq.fromList [forall era.
ShelleyEraTxCert era =>
StakeCredential (EraCrypto era) -> TxCert era
UnRegTxCert forall c. Crypto c => Credential 'Staking c
aliceSHK]
    , stbWithdrawals :: Withdrawals (EraCrypto Shelley)
stbWithdrawals = forall c. Map (RewardAcnt c) Coin -> Withdrawals c
Withdrawals forall k a. Map k a
Map.empty
    , stbTxFee :: Coin
stbTxFee = Integer -> Coin
Coin Integer
94
    , stbTTL :: SlotNo
stbTTL = Word64 -> SlotNo
SlotNo Word64
10
    , stbUpdate :: StrictMaybe (Update Shelley)
stbUpdate = forall a. StrictMaybe a
SNothing
    , stbMDHash :: StrictMaybe (AuxiliaryDataHash (EraCrypto Shelley))
stbMDHash = forall a. StrictMaybe a
SNothing
    }

txDeregisterStake :: ShelleyTx Shelley
txDeregisterStake :: ShelleyTx Shelley
txDeregisterStake =
  ShelleyTx
    { body :: TxBody Shelley
body = ShelleyTxBody Shelley
txbDeregisterStake
    , wits :: TxWits Shelley
wits =
        forall a. Monoid a => a
mempty
          { addrWits :: Set (WitVKey 'Witness (EraCrypto Shelley))
addrWits =
              forall c (kr :: KeyRole).
(Crypto c, DSignable c (Hash (HASH c) EraIndependentTxBody)) =>
SafeHash c EraIndependentTxBody
-> [KeyPair kr c] -> Set (WitVKey 'Witness c)
mkWitnessesVKey
                (forall x index c.
(HashAnnotated x index c, HashAlgorithm (HASH c)) =>
x -> SafeHash c index
hashAnnotated ShelleyTxBody Shelley
txbDeregisterStake)
                [forall c. Crypto c => KeyPair 'Payment c
alicePay @(EraCrypto Shelley)]
          }
    , auxiliaryData :: StrictMaybe (TxAuxData Shelley)
auxiliaryData = forall a. StrictMaybe a
SNothing
    }

txDeregisterStakeBytes16 :: BSL.ByteString
txDeregisterStakeBytes16 :: ByteString
txDeregisterStakeBytes16 =
  ByteString
"83a5008182582003170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c11131400018182583900e9686d801fa32aeb4390c2f2a53bb0314a9c744c46a2cada394a371fc6852b6aaed73bcf346a57ef99adae3000b51c7c59faaeb15993df760a02185e030a048182018200581cc6852b6aaed73bcf346a57ef99adae3000b51c7c59faaeb15993df76a100818258204628aaf16d6e1baa061d1296419542cb09287c639163d0fdbdac0ff23699797e5840409db925fa592b7f4c76e44d738789f4b0ffb2b9cf4567af127121d635491b4eb736e8c92571f1329f14d06aad7ec42ca654ae65eb63b0b01d30cc4454aee80cf6"

-- | Transaction which registers a stake pool
txbRegisterPool :: ShelleyTxBody Shelley
txbRegisterPool :: ShelleyTxBody Shelley
txbRegisterPool =
  ShelleyTxBody
    { stbInputs :: Set (TxIn (EraCrypto Shelley))
stbInputs = forall a. Ord a => [a] -> Set a
Set.fromList [forall c. TxId c -> TxIx -> TxIn c
TxIn forall c. HashAlgorithm (HASH c) => TxId c
genesisId forall a. Bounded a => a
minBound]
    , stbOutputs :: StrictSeq (TxOut Shelley)
stbOutputs = forall a. [a] -> StrictSeq a
StrictSeq.fromList [forall era.
(HasCallStack, Era era, Val (Value era)) =>
Addr (EraCrypto era) -> Value era -> ShelleyTxOut era
ShelleyTxOut forall c. Crypto c => Addr c
aliceAddr (forall t s. Inject t s => t -> s
Val.inject forall a b. (a -> b) -> a -> b
$ Integer -> Coin
Coin Integer
10)]
    , stbCerts :: StrictSeq (TxCert Shelley)
stbCerts = forall a. [a] -> StrictSeq a
StrictSeq.fromList [forall era.
EraTxCert era =>
PoolParams (EraCrypto era) -> TxCert era
RegPoolTxCert forall c. Crypto c => PoolParams c
alicePoolParams]
    , stbWithdrawals :: Withdrawals (EraCrypto Shelley)
stbWithdrawals = forall c. Map (RewardAcnt c) Coin -> Withdrawals c
Withdrawals forall k a. Map k a
Map.empty
    , stbTxFee :: Coin
stbTxFee = Integer -> Coin
Coin Integer
94
    , stbTTL :: SlotNo
stbTTL = Word64 -> SlotNo
SlotNo Word64
10
    , stbUpdate :: StrictMaybe (Update Shelley)
stbUpdate = forall a. StrictMaybe a
SNothing
    , stbMDHash :: StrictMaybe (AuxiliaryDataHash (EraCrypto Shelley))
stbMDHash = forall a. StrictMaybe a
SNothing
    }

txRegisterPool :: ShelleyTx Shelley
txRegisterPool :: ShelleyTx Shelley
txRegisterPool =
  ShelleyTx
    { body :: TxBody Shelley
body = ShelleyTxBody Shelley
txbRegisterPool
    , wits :: TxWits Shelley
wits =
        forall a. Monoid a => a
mempty
          { addrWits :: Set (WitVKey 'Witness (EraCrypto Shelley))
addrWits = forall c (kr :: KeyRole).
(Crypto c, DSignable c (Hash (HASH c) EraIndependentTxBody)) =>
SafeHash c EraIndependentTxBody
-> [KeyPair kr c] -> Set (WitVKey 'Witness c)
mkWitnessesVKey (forall x index c.
(HashAnnotated x index c, HashAlgorithm (HASH c)) =>
x -> SafeHash c index
hashAnnotated ShelleyTxBody Shelley
txbRegisterPool) [forall c. Crypto c => KeyPair 'Payment c
alicePay]
          }
    , auxiliaryData :: StrictMaybe (TxAuxData Shelley)
auxiliaryData = forall a. StrictMaybe a
SNothing
    }

txRegisterPoolBytes16 :: BSL.ByteString
txRegisterPoolBytes16 :: ByteString
txRegisterPoolBytes16 =
  ByteString
"83a5008182582003170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c11131400018182583900e9686d801fa32aeb4390c2f2a53bb0314a9c744c46a2cada394a371fc6852b6aaed73bcf346a57ef99adae3000b51c7c59faaeb15993df760a02185e030a04818a03581c5d43e1f1048b2619f51abc0cf505e4d4f9cb84becefd468d1a2fe33558208e61e1fa4855ea3aa0b8881a9e2e453c8c73536bdaabb64d36de86ee5a02519a0105d81e82010a581de0c6852b6aaed73bcf346a57ef99adae3000b51c7c59faaeb15993df7681581cc6852b6aaed73bcf346a57ef99adae3000b51c7c59faaeb15993df76818301f66872656c61792e696f826a616c6963652e706f6f6c427b7da100818258204628aaf16d6e1baa061d1296419542cb09287c639163d0fdbdac0ff23699797e5840165c6aa107571daafb1f9093d3cdc184a4068e8ff9243715c13335feb3652dc0d817b3b015a9929c9d83a0dd406fe71658fdccbf7925d2fff316237b499c2003f6"

-- | Transaction which retires a stake pool
txbRetirePool :: ShelleyTxBody Shelley
txbRetirePool :: ShelleyTxBody Shelley
txbRetirePool =
  ShelleyTxBody
    { stbInputs :: Set (TxIn (EraCrypto Shelley))
stbInputs = forall a. Ord a => [a] -> Set a
Set.fromList [forall c. TxId c -> TxIx -> TxIn c
TxIn forall c. HashAlgorithm (HASH c) => TxId c
genesisId forall a. Bounded a => a
minBound]
    , stbOutputs :: StrictSeq (TxOut Shelley)
stbOutputs = forall a. [a] -> StrictSeq a
StrictSeq.fromList [forall era.
(HasCallStack, Era era, Val (Value era)) =>
Addr (EraCrypto era) -> Value era -> ShelleyTxOut era
ShelleyTxOut forall c. Crypto c => Addr c
aliceAddr (forall t s. Inject t s => t -> s
Val.inject forall a b. (a -> b) -> a -> b
$ Integer -> Coin
Coin Integer
10)]
    , stbCerts :: StrictSeq (TxCert Shelley)
stbCerts = forall a. [a] -> StrictSeq a
StrictSeq.fromList [forall era.
EraTxCert era =>
KeyHash 'StakePool (EraCrypto era) -> EpochNo -> TxCert era
RetirePoolTxCert forall c. Crypto c => KeyHash 'StakePool c
alicePoolKH (Word64 -> EpochNo
EpochNo Word64
5)]
    , stbWithdrawals :: Withdrawals (EraCrypto Shelley)
stbWithdrawals = forall c. Map (RewardAcnt c) Coin -> Withdrawals c
Withdrawals forall k a. Map k a
Map.empty
    , stbTxFee :: Coin
stbTxFee = Integer -> Coin
Coin Integer
94
    , stbTTL :: SlotNo
stbTTL = Word64 -> SlotNo
SlotNo Word64
10
    , stbUpdate :: StrictMaybe (Update Shelley)
stbUpdate = forall a. StrictMaybe a
SNothing
    , stbMDHash :: StrictMaybe (AuxiliaryDataHash (EraCrypto Shelley))
stbMDHash = forall a. StrictMaybe a
SNothing
    }

txRetirePool :: ShelleyTx Shelley
txRetirePool :: ShelleyTx Shelley
txRetirePool =
  ShelleyTx
    { body :: TxBody Shelley
body = ShelleyTxBody Shelley
txbRetirePool
    , wits :: TxWits Shelley
wits =
        forall a. Monoid a => a
mempty
          { addrWits :: Set (WitVKey 'Witness (EraCrypto Shelley))
addrWits = forall c (kr :: KeyRole).
(Crypto c, DSignable c (Hash (HASH c) EraIndependentTxBody)) =>
SafeHash c EraIndependentTxBody
-> [KeyPair kr c] -> Set (WitVKey 'Witness c)
mkWitnessesVKey (forall x index c.
(HashAnnotated x index c, HashAlgorithm (HASH c)) =>
x -> SafeHash c index
hashAnnotated ShelleyTxBody Shelley
txbRetirePool) [forall c. Crypto c => KeyPair 'Payment c
alicePay]
          }
    , auxiliaryData :: StrictMaybe (TxAuxData Shelley)
auxiliaryData = forall a. StrictMaybe a
SNothing
    }

txRetirePoolBytes16 :: BSL.ByteString
txRetirePoolBytes16 :: ByteString
txRetirePoolBytes16 =
  ByteString
"83a5008182582003170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c11131400018182583900e9686d801fa32aeb4390c2f2a53bb0314a9c744c46a2cada394a371fc6852b6aaed73bcf346a57ef99adae3000b51c7c59faaeb15993df760a02185e030a04818304581c5d43e1f1048b2619f51abc0cf505e4d4f9cb84becefd468d1a2fe33505a100818258204628aaf16d6e1baa061d1296419542cb09287c639163d0fdbdac0ff23699797e58404ad8f782368857f26db548d4ef6eca276639db9f1e8536f505c049ec94e0f6325c5f9f62a5187eb077f51bcd51cdff7d142415796442f2631081b90bf74f7204f6"

-- | Simple Transaction which consumes one UTxO and creates one UTxO
-- | and has one witness
md :: Era era => ShelleyTxAuxData era
md :: forall era. Era era => ShelleyTxAuxData era
md = forall era. Era era => Map Word64 Metadatum -> ShelleyTxAuxData era
ShelleyTxAuxData forall a b. (a -> b) -> a -> b
$ forall k a. k -> a -> Map k a
Map.singleton Word64
0 ([Metadatum] -> Metadatum
List [Integer -> Metadatum
I Integer
5, Text -> Metadatum
S Text
"hello"])

txbWithMD :: ShelleyTxBody Shelley
txbWithMD :: ShelleyTxBody Shelley
txbWithMD =
  ShelleyTxBody
    { stbInputs :: Set (TxIn (EraCrypto Shelley))
stbInputs = forall a. Ord a => [a] -> Set a
Set.fromList [forall c. TxId c -> TxIx -> TxIn c
TxIn forall c. HashAlgorithm (HASH c) => TxId c
genesisId forall a. Bounded a => a
minBound]
    , stbOutputs :: StrictSeq (TxOut Shelley)
stbOutputs = forall a. [a] -> StrictSeq a
StrictSeq.fromList [forall era.
(HasCallStack, Era era, Val (Value era)) =>
Addr (EraCrypto era) -> Value era -> ShelleyTxOut era
ShelleyTxOut forall c. Crypto c => Addr c
aliceAddr (forall t s. Inject t s => t -> s
Val.inject forall a b. (a -> b) -> a -> b
$ Integer -> Coin
Coin Integer
10)]
    , stbCerts :: StrictSeq (TxCert Shelley)
stbCerts = forall a. StrictSeq a
StrictSeq.empty
    , stbWithdrawals :: Withdrawals (EraCrypto Shelley)
stbWithdrawals = forall c. Map (RewardAcnt c) Coin -> Withdrawals c
Withdrawals forall k a. Map k a
Map.empty
    , stbTxFee :: Coin
stbTxFee = Integer -> Coin
Coin Integer
94
    , stbTTL :: SlotNo
stbTTL = Word64 -> SlotNo
SlotNo Word64
10
    , stbUpdate :: StrictMaybe (Update Shelley)
stbUpdate = forall a. StrictMaybe a
SNothing
    , stbMDHash :: StrictMaybe (AuxiliaryDataHash (EraCrypto Shelley))
stbMDHash = forall a. a -> StrictMaybe a
SJust forall a b. (a -> b) -> a -> b
$ forall era.
EraTxAuxData era =>
TxAuxData era -> AuxiliaryDataHash (EraCrypto era)
hashTxAuxData @Shelley forall era. Era era => ShelleyTxAuxData era
md
    }

txWithMD :: ShelleyTx Shelley
txWithMD :: ShelleyTx Shelley
txWithMD =
  ShelleyTx
    { body :: TxBody Shelley
body = ShelleyTxBody Shelley
txbWithMD
    , wits :: TxWits Shelley
wits =
        forall a. Monoid a => a
mempty
          { addrWits :: Set (WitVKey 'Witness (EraCrypto Shelley))
addrWits = forall c (kr :: KeyRole).
(Crypto c, DSignable c (Hash (HASH c) EraIndependentTxBody)) =>
SafeHash c EraIndependentTxBody
-> [KeyPair kr c] -> Set (WitVKey 'Witness c)
mkWitnessesVKey (forall x index c.
(HashAnnotated x index c, HashAlgorithm (HASH c)) =>
x -> SafeHash c index
hashAnnotated ShelleyTxBody Shelley
txbWithMD) [forall c. Crypto c => KeyPair 'Payment c
alicePay]
          }
    , auxiliaryData :: StrictMaybe (TxAuxData Shelley)
auxiliaryData = forall a. a -> StrictMaybe a
SJust forall era. Era era => ShelleyTxAuxData era
md
    }

txWithMDBytes16 :: BSL.ByteString
txWithMDBytes16 :: ByteString
txWithMDBytes16 =
  ByteString
"83a5008182582003170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c11131400018182583900e9686d801fa32aeb4390c2f2a53bb0314a9c744c46a2cada394a371fc6852b6aaed73bcf346a57ef99adae3000b51c7c59faaeb15993df760a02185e030a075820e2d7de09439ab222111cecd21545c5f9c338fd6653539031eb311d34fc97e718a100818258204628aaf16d6e1baa061d1296419542cb09287c639163d0fdbdac0ff23699797e5840ab05c3933f5c7281386309a374f45eeee28b6f3a01bc76a5fa3bc9efdc603dd63059d0aebfd198e23bf848dae43a23be3e6f85149bca2f27d0e7f4f63be38e02a10082056568656c6c6f"

-- | Spending from a multi-sig address
msig :: forall era. ShelleyEraScript era => NativeScript era
msig :: forall era. ShelleyEraScript era => NativeScript era
msig =
  forall era.
ShelleyEraScript era =>
Int -> StrictSeq (NativeScript era) -> NativeScript era
RequireMOf
    Int
2
    ( forall a. [a] -> StrictSeq a
StrictSeq.fromList
        [ (forall era.
ShelleyEraScript era =>
KeyHash 'Witness (EraCrypto era) -> NativeScript era
RequireSignature forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (a :: KeyRole -> * -> *) (r :: KeyRole) c.
HasKeyRole a =>
a r c -> a 'Witness c
asWitness forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c (kd :: KeyRole). Crypto c => VKey kd c -> KeyHash kd c
hashKey forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (kd :: KeyRole) c. KeyPair kd c -> VKey kd c
vKey) forall c. Crypto c => KeyPair 'Payment c
alicePay
        , (forall era.
ShelleyEraScript era =>
KeyHash 'Witness (EraCrypto era) -> NativeScript era
RequireSignature forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (a :: KeyRole -> * -> *) (r :: KeyRole) c.
HasKeyRole a =>
a r c -> a 'Witness c
asWitness forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c (kd :: KeyRole). Crypto c => VKey kd c -> KeyHash kd c
hashKey forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (kd :: KeyRole) c. KeyPair kd c -> VKey kd c
vKey) forall c. Crypto c => KeyPair 'Payment c
bobPay
        , (forall era.
ShelleyEraScript era =>
KeyHash 'Witness (EraCrypto era) -> NativeScript era
RequireSignature forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (a :: KeyRole -> * -> *) (r :: KeyRole) c.
HasKeyRole a =>
a r c -> a 'Witness c
asWitness forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c (kd :: KeyRole). Crypto c => VKey kd c -> KeyHash kd c
hashKey forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (kd :: KeyRole) c. KeyPair kd c -> VKey kd c
vKey) forall c. Crypto c => KeyPair 'Payment c
carlPay
        ]
    )

txbWithMultiSig :: ShelleyTxBody Shelley
txbWithMultiSig :: ShelleyTxBody Shelley
txbWithMultiSig =
  ShelleyTxBody
    { stbInputs :: Set (TxIn (EraCrypto Shelley))
stbInputs = forall a. Ord a => [a] -> Set a
Set.fromList [forall c. TxId c -> TxIx -> TxIn c
TxIn forall c. HashAlgorithm (HASH c) => TxId c
genesisId forall a. Bounded a => a
minBound] -- acting as if this is multi-sig
    , stbOutputs :: StrictSeq (TxOut Shelley)
stbOutputs = forall a. [a] -> StrictSeq a
StrictSeq.fromList [forall era.
(HasCallStack, Era era, Val (Value era)) =>
Addr (EraCrypto era) -> Value era -> ShelleyTxOut era
ShelleyTxOut forall c. Crypto c => Addr c
aliceAddr (forall t s. Inject t s => t -> s
Val.inject forall a b. (a -> b) -> a -> b
$ Integer -> Coin
Coin Integer
10)]
    , stbCerts :: StrictSeq (TxCert Shelley)
stbCerts = forall a. StrictSeq a
StrictSeq.empty
    , stbWithdrawals :: Withdrawals (EraCrypto Shelley)
stbWithdrawals = forall c. Map (RewardAcnt c) Coin -> Withdrawals c
Withdrawals forall k a. Map k a
Map.empty
    , stbTxFee :: Coin
stbTxFee = Integer -> Coin
Coin Integer
94
    , stbTTL :: SlotNo
stbTTL = Word64 -> SlotNo
SlotNo Word64
10
    , stbUpdate :: StrictMaybe (Update Shelley)
stbUpdate = forall a. StrictMaybe a
SNothing
    , stbMDHash :: StrictMaybe (AuxiliaryDataHash (EraCrypto Shelley))
stbMDHash = forall a. StrictMaybe a
SNothing
    }

txWithMultiSig :: ShelleyTx Shelley
txWithMultiSig :: ShelleyTx Shelley
txWithMultiSig =
  ShelleyTx
    { body :: TxBody Shelley
body = ShelleyTxBody Shelley
txbWithMultiSig
    , wits :: TxWits Shelley
wits =
        forall era. EraTxWits era => TxWits era
mkBasicTxWits
          forall a b. a -> (a -> b) -> b
& forall era.
EraTxWits era =>
Lens' (TxWits era) (Set (WitVKey 'Witness (EraCrypto era)))
addrTxWitsL forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall c (kr :: KeyRole).
(Crypto c, DSignable c (Hash (HASH c) EraIndependentTxBody)) =>
SafeHash c EraIndependentTxBody
-> [KeyPair kr c] -> Set (WitVKey 'Witness c)
mkWitnessesVKey (forall x index c.
(HashAnnotated x index c, HashAlgorithm (HASH c)) =>
x -> SafeHash c index
hashAnnotated ShelleyTxBody Shelley
txbWithMultiSig) [forall c. Crypto c => KeyPair 'Payment c
alicePay, forall c. Crypto c => KeyPair 'Payment c
bobPay]
          forall a b. a -> (a -> b) -> b
& forall era.
EraTxWits era =>
Lens' (TxWits era) (Map (ScriptHash (EraCrypto era)) (Script era))
scriptTxWitsL forall s t a b. ASetter s t a b -> b -> s -> t
.~ forall k a. k -> a -> Map k a
Map.singleton (forall era.
EraScript era =>
Script era -> ScriptHash (EraCrypto era)
hashScript @Shelley forall era. ShelleyEraScript era => NativeScript era
msig) forall era. ShelleyEraScript era => NativeScript era
msig
    , auxiliaryData :: StrictMaybe (TxAuxData Shelley)
auxiliaryData = forall a. StrictMaybe a
SNothing
    }

txWithMultiSigBytes16 :: BSL.ByteString
txWithMultiSigBytes16 :: ByteString
txWithMultiSigBytes16 =
  ByteString
"83a4008182582003170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c11131400018182583900e9686d801fa32aeb4390c2f2a53bb0314a9c744c46a2cada394a371fc6852b6aaed73bcf346a57ef99adae3000b51c7c59faaeb15993df760a02185e030aa2008282582037139648f2c22bbf1d0ef9af37cfebc9014b1e0e2a55be87c4b3b231a8d84d265840e3b8f50632325fbd1f82202ce5a8b4672bd96c50a338d70c0aa96720f6f7fbf60e0ce708f3a7e28faa0d78dc437a0b61e02205ddb1db22d02ba35b37a7fe03068258204628aaf16d6e1baa061d1296419542cb09287c639163d0fdbdac0ff23699797e584089c20cb6246483bbd0b2006f658597eff3e8ab3b8a6e9b22cb3c5b95cf0d3a2b96107acef88319fa2dd0fb28adcfdb330bb99f1f0058918a75d951ca9b73660c0181830302838200581ce9686d801fa32aeb4390c2f2a53bb0314a9c744c46a2cada394a371f8200581c0d2a471489a90f2910ec67ded8e215bfcd669bae77e7f9ab15850abd8200581cd0671052191a58c554eee27808b2b836a03ca369ca7a847f8c37d6f9f6"

-- | Transaction with a Reward Withdrawal
txbWithWithdrawal :: ShelleyTxBody Shelley
txbWithWithdrawal :: ShelleyTxBody Shelley
txbWithWithdrawal =
  ShelleyTxBody
    { stbInputs :: Set (TxIn (EraCrypto Shelley))
stbInputs = forall a. Ord a => [a] -> Set a
Set.fromList [forall c. TxId c -> TxIx -> TxIn c
TxIn forall c. HashAlgorithm (HASH c) => TxId c
genesisId forall a. Bounded a => a
minBound]
    , stbOutputs :: StrictSeq (TxOut Shelley)
stbOutputs = forall a. [a] -> StrictSeq a
StrictSeq.fromList [forall era.
(HasCallStack, Era era, Val (Value era)) =>
Addr (EraCrypto era) -> Value era -> ShelleyTxOut era
ShelleyTxOut forall c. Crypto c => Addr c
aliceAddr (forall t s. Inject t s => t -> s
Val.inject forall a b. (a -> b) -> a -> b
$ Integer -> Coin
Coin Integer
10)]
    , stbCerts :: StrictSeq (TxCert Shelley)
stbCerts = forall a. StrictSeq a
StrictSeq.empty
    , stbWithdrawals :: Withdrawals (EraCrypto Shelley)
stbWithdrawals =
        forall c. Map (RewardAcnt c) Coin -> Withdrawals c
Withdrawals forall a b. (a -> b) -> a -> b
$ forall k a. k -> a -> Map k a
Map.singleton (forall c. Network -> Credential 'Staking c -> RewardAccount c
RewardAccount Network
Testnet forall c. Crypto c => Credential 'Staking c
aliceSHK) (forall t s. Inject t s => t -> s
Val.inject forall a b. (a -> b) -> a -> b
$ Integer -> Coin
Coin Integer
100)
    , stbTxFee :: Coin
stbTxFee = Integer -> Coin
Coin Integer
94
    , stbTTL :: SlotNo
stbTTL = Word64 -> SlotNo
SlotNo Word64
10
    , stbUpdate :: StrictMaybe (Update Shelley)
stbUpdate = forall a. StrictMaybe a
SNothing
    , stbMDHash :: StrictMaybe (AuxiliaryDataHash (EraCrypto Shelley))
stbMDHash = forall a. StrictMaybe a
SNothing
    }

txWithWithdrawal :: ShelleyTx Shelley
txWithWithdrawal :: ShelleyTx Shelley
txWithWithdrawal =
  ShelleyTx
    { body :: TxBody Shelley
body = ShelleyTxBody Shelley
txbWithWithdrawal
    , wits :: TxWits Shelley
wits =
        forall a. Monoid a => a
mempty
          { addrWits :: Set (WitVKey 'Witness (EraCrypto Shelley))
addrWits =
              forall c (kr :: KeyRole).
(Crypto c, DSignable c (Hash (HASH c) EraIndependentTxBody)) =>
SafeHash c EraIndependentTxBody
-> [KeyPair kr c] -> Set (WitVKey 'Witness c)
mkWitnessesVKey
                (forall x index c.
(HashAnnotated x index c, HashAlgorithm (HASH c)) =>
x -> SafeHash c index
hashAnnotated ShelleyTxBody Shelley
txbWithWithdrawal)
                [forall (a :: KeyRole -> * -> *) (r :: KeyRole) c.
HasKeyRole a =>
a r c -> a 'Witness c
asWitness forall c. Crypto c => KeyPair 'Payment c
alicePay, forall (a :: KeyRole -> * -> *) (r :: KeyRole) c.
HasKeyRole a =>
a r c -> a 'Witness c
asWitness forall c. Crypto c => KeyPair 'Staking c
aliceStake]
          }
    , auxiliaryData :: StrictMaybe (TxAuxData Shelley)
auxiliaryData = forall a. StrictMaybe a
SNothing
    }

txWithWithdrawalBytes16 :: BSL.ByteString
txWithWithdrawalBytes16 :: ByteString
txWithWithdrawalBytes16 =
  ByteString
"83a5008182582003170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c11131400018182583900e9686d801fa32aeb4390c2f2a53bb0314a9c744c46a2cada394a371fc6852b6aaed73bcf346a57ef99adae3000b51c7c59faaeb15993df760a02185e030a05a1581de0c6852b6aaed73bcf346a57ef99adae3000b51c7c59faaeb15993df761864a100828258208f40b25c9987eeb9c7f75eaf4f461f16384872a94dc353a4fb5c95bb657c59f85840c52adcbc184a497d1746ee962a762427e79e3f600a356378ffda6294c658ed91c0f0c7815cbaefb22bdabc09c5bf6c5f6724c0136701da26c77882f739f109038258204628aaf16d6e1baa061d1296419542cb09287c639163d0fdbdac0ff23699797e584012d30a6d3dbe0223e772dc183c138779449cd5fd9aac817b63af945b0a8e9f85be3bcc4457ad1a27f08fd36205717f8bafea1b1328f3a074febcfc62b6b99f06f6"

-- | The transaction fee of txSimpleUTxO if one key witness were to be added,
-- given minfeeA and minfeeB are set to 1.
testEstimateMinFee :: Assertion
testEstimateMinFee :: Assertion
testEstimateMinFee =
  forall era.
EraTx era =>
PParams era -> Tx era -> Int -> Int -> Int -> Coin
estimateMinFeeTx @Shelley
    PParams Shelley
pp
    ShelleyTx Shelley
txSimpleUTxONoWit
    Int
1
    Int
0
    Int
0
    forall a. (Eq a, Show a, HasCallStack) => a -> a -> Assertion
@?= forall era. EraTx era => PParams era -> Tx era -> Coin
getShelleyMinFeeTxUtxo PParams Shelley
pp ShelleyTx Shelley
txSimpleUTxO
  where
    pp :: PParams Shelley
pp =
      forall era. EraPParams era => PParams era
emptyPParams
        forall a b. a -> (a -> b) -> b
& forall era. EraPParams era => Lens' (PParams era) Coin
ppMinFeeAL forall s t a b. ASetter s t a b -> b -> s -> t
.~ Integer -> Coin
Coin Integer
1
        forall a b. a -> (a -> b) -> b
& forall era. EraPParams era => Lens' (PParams era) Coin
ppMinFeeBL forall s t a b. ASetter s t a b -> b -> s -> t
.~ Integer -> Coin
Coin Integer
1

    txSimpleUTxONoWit :: ShelleyTx Shelley
txSimpleUTxONoWit =
      ShelleyTx
        { body :: TxBody Shelley
body = ShelleyTxBody Shelley
txbSimpleUTxO
        , wits :: TxWits Shelley
wits = forall a. Monoid a => a
mempty
        , auxiliaryData :: StrictMaybe (TxAuxData Shelley)
auxiliaryData = forall a. StrictMaybe a
SNothing
        }

-- NOTE the txsize function takes into account which actual crypto parameter is in use.
-- These tests are using Blake2b and Ed25519 so that:
--       the regular hash length is ----> 32
--       the address hash length is ----> 28
--       the verification key size is --> 32
--       the signature size is ---------> 64

sizeTests :: TestTree
sizeTests :: TestTree
sizeTests =
  String -> [TestTree] -> TestTree
testGroup
    String
"Fee Tests"
    [ String -> Assertion -> TestTree
testCase String
"simple utxo" forall a b. (a -> b) -> a -> b
$ HasCallStack => ByteString -> ShelleyTx Shelley -> Assertion
sizeTest ByteString
txSimpleUTxOBytes16 ShelleyTx Shelley
txSimpleUTxO
    , String -> Assertion -> TestTree
testCase String
"multiple utxo" forall a b. (a -> b) -> a -> b
$ HasCallStack => ByteString -> ShelleyTx Shelley -> Assertion
sizeTest ByteString
txMutiUTxOBytes16 ShelleyTx Shelley
txMutiUTxO
    , String -> Assertion -> TestTree
testCase String
"register stake key" forall a b. (a -> b) -> a -> b
$ HasCallStack => ByteString -> ShelleyTx Shelley -> Assertion
sizeTest ByteString
txRegisterStakeBytes16 ShelleyTx Shelley
txRegisterStake
    , String -> Assertion -> TestTree
testCase String
"delegate stake key" forall a b. (a -> b) -> a -> b
$ HasCallStack => ByteString -> ShelleyTx Shelley -> Assertion
sizeTest ByteString
txDelegateStakeBytes16 ShelleyTx Shelley
txDelegateStake
    , String -> Assertion -> TestTree
testCase String
"deregister stake key" forall a b. (a -> b) -> a -> b
$ HasCallStack => ByteString -> ShelleyTx Shelley -> Assertion
sizeTest ByteString
txDeregisterStakeBytes16 ShelleyTx Shelley
txDeregisterStake
    , String -> Assertion -> TestTree
testCase String
"register stake pool" forall a b. (a -> b) -> a -> b
$ HasCallStack => ByteString -> ShelleyTx Shelley -> Assertion
sizeTest ByteString
txRegisterPoolBytes16 ShelleyTx Shelley
txRegisterPool
    , String -> Assertion -> TestTree
testCase String
"retire stake pool" forall a b. (a -> b) -> a -> b
$ HasCallStack => ByteString -> ShelleyTx Shelley -> Assertion
sizeTest ByteString
txRetirePoolBytes16 ShelleyTx Shelley
txRetirePool
    , String -> Assertion -> TestTree
testCase String
"auxiliaryData" forall a b. (a -> b) -> a -> b
$ HasCallStack => ByteString -> ShelleyTx Shelley -> Assertion
sizeTest ByteString
txWithMDBytes16 ShelleyTx Shelley
txWithMD
    , String -> Assertion -> TestTree
testCase String
"multisig" forall a b. (a -> b) -> a -> b
$ HasCallStack => ByteString -> ShelleyTx Shelley -> Assertion
sizeTest ByteString
txWithMultiSigBytes16 ShelleyTx Shelley
txWithMultiSig
    , String -> Assertion -> TestTree
testCase String
"reward withdrawal" forall a b. (a -> b) -> a -> b
$ HasCallStack => ByteString -> ShelleyTx Shelley -> Assertion
sizeTest ByteString
txWithWithdrawalBytes16 ShelleyTx Shelley
txWithWithdrawal
    , String -> Assertion -> TestTree
testCase String
"estimate transaction fee" Assertion
testEstimateMinFee
    ]