{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE ViewPatterns #-}
{-# OPTIONS_GHC -Wno-orphans #-}
module Shelley.Spec.Ledger.UTxO
(
UTxO (..),
txid,
txins,
txinLookup,
txouts,
txup,
balance,
totalDeposits,
makeWitnessVKey,
makeWitnessesVKey,
makeWitnessesFromScriptKeys,
verifyWitVKey,
getScriptHash,
scriptsNeeded,
scriptCred,
scriptStakeCred,
txinsScript,
)
where
import Cardano.Binary (FromCBOR (..), ToCBOR (..))
import qualified Cardano.Ledger.Core as Core
import qualified Cardano.Ledger.Crypto as CC (Crypto)
import Cardano.Ledger.Era
import Cardano.Ledger.Shelley.Constraints (ShelleyBased, TxBodyConstraints)
import Cardano.Ledger.Val ((<+>), (<×>))
import Control.DeepSeq (NFData)
import Control.Iterate.SetAlgebra
( BaseRep (MapR),
Embed (..),
Exp (Base),
HasExp (toExp),
)
import Data.Coerce (coerce)
import Data.Foldable (toList)
import Data.Map.Strict (Map)
import qualified Data.Map.Strict as Map
import qualified Data.Maybe as Maybe
import Data.Relation (Relation (..))
import Data.Sequence.Strict (StrictSeq)
import Data.Set (Set)
import qualified Data.Set as Set
import Data.Typeable (Typeable)
import GHC.Generics (Generic)
import GHC.Records (HasField (..))
import NoThunks.Class (NoThunks (..))
import Quiet
import Shelley.Spec.Ledger.Address (Addr (..))
import Shelley.Spec.Ledger.BaseTypes (StrictMaybe, strictMaybeToMaybe)
import Shelley.Spec.Ledger.Coin (Coin (..))
import Shelley.Spec.Ledger.Credential (Credential (..))
import Shelley.Spec.Ledger.Delegation.Certificates
( DCert (..),
isRegKey,
requiresVKeyWitness,
)
import Shelley.Spec.Ledger.Hashing (hashAnnotated)
import Shelley.Spec.Ledger.Keys
( DSignable,
Hash,
KeyHash (..),
KeyPair (..),
KeyRole (StakePool, Witness),
asWitness,
signedDSIGN,
verifySignedDSIGN,
)
import Shelley.Spec.Ledger.PParams (PParams, Update, _keyDeposit, _poolDeposit)
import Shelley.Spec.Ledger.Scripts
import Shelley.Spec.Ledger.Tx (Tx (..))
import Shelley.Spec.Ledger.TxBody
( EraIndependentTxBody,
PoolCert (..),
PoolParams (..),
TxId (..),
TxIn (..),
TxOut (..),
Wdrl (..),
WitVKey (..),
getRwdCred,
pattern DeRegKey,
pattern Delegate,
pattern Delegation,
)
instance Crypto era ~ crypto => HasExp (UTxO era) (Map (TxIn crypto) (TxOut era)) where
toExp :: UTxO era -> Exp (Map (TxIn crypto) (TxOut era))
toExp (UTxO Map (TxIn (Crypto era)) (TxOut era)
x) = BaseRep Map (TxIn crypto) (TxOut era)
-> Map (TxIn crypto) (TxOut era)
-> Exp (Map (TxIn crypto) (TxOut era))
forall k (f :: * -> * -> *) v.
(Ord k, Basic f) =>
BaseRep f k v -> f k v -> Exp (f k v)
Base BaseRep Map (TxIn crypto) (TxOut era)
forall k v. Basic Map => BaseRep Map k v
MapR Map (TxIn crypto) (TxOut era)
Map (TxIn (Crypto era)) (TxOut era)
x
instance Crypto era ~ crypto => Embed (UTxO era) (Map (TxIn crypto) (TxOut era)) where
toBase :: UTxO era -> Map (TxIn crypto) (TxOut era)
toBase (UTxO Map (TxIn (Crypto era)) (TxOut era)
x) = Map (TxIn crypto) (TxOut era)
Map (TxIn (Crypto era)) (TxOut era)
x
fromBase :: Map (TxIn crypto) (TxOut era) -> UTxO era
fromBase Map (TxIn crypto) (TxOut era)
x = (Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
forall era. Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
UTxO Map (TxIn crypto) (TxOut era)
Map (TxIn (Crypto era)) (TxOut era)
x)
newtype UTxO era = UTxO {UTxO era -> Map (TxIn (Crypto era)) (TxOut era)
unUTxO :: Map (TxIn (Crypto era)) (TxOut era)}
deriving (Context -> UTxO era -> IO (Maybe ThunkInfo)
Proxy (UTxO era) -> String
(Context -> UTxO era -> IO (Maybe ThunkInfo))
-> (Context -> UTxO era -> IO (Maybe ThunkInfo))
-> (Proxy (UTxO era) -> String)
-> NoThunks (UTxO era)
forall era. Context -> UTxO era -> IO (Maybe ThunkInfo)
forall era. Proxy (UTxO era) -> String
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
showTypeOf :: Proxy (UTxO era) -> String
$cshowTypeOf :: forall era. Proxy (UTxO era) -> String
wNoThunks :: Context -> UTxO era -> IO (Maybe ThunkInfo)
$cwNoThunks :: forall era. Context -> UTxO era -> IO (Maybe ThunkInfo)
noThunks :: Context -> UTxO era -> IO (Maybe ThunkInfo)
$cnoThunks :: forall era. Context -> UTxO era -> IO (Maybe ThunkInfo)
NoThunks, (forall x. UTxO era -> Rep (UTxO era) x)
-> (forall x. Rep (UTxO era) x -> UTxO era) -> Generic (UTxO era)
forall x. Rep (UTxO era) x -> UTxO era
forall x. UTxO era -> Rep (UTxO era) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall era x. Rep (UTxO era) x -> UTxO era
forall era x. UTxO era -> Rep (UTxO era) x
$cto :: forall era x. Rep (UTxO era) x -> UTxO era
$cfrom :: forall era x. UTxO era -> Rep (UTxO era) x
Generic)
deriving instance Era era => NFData (UTxO era)
deriving newtype instance
ShelleyBased era =>
Eq (UTxO era)
deriving newtype instance
ShelleyBased era =>
ToCBOR (UTxO era)
deriving newtype instance
ShelleyBased era =>
FromCBOR (UTxO era)
deriving via
Quiet (UTxO era)
instance
ShelleyBased era =>
Show (UTxO era)
instance Relation (UTxO era) where
type Domain (UTxO era) = TxIn (Crypto era)
type Range (UTxO era) = TxOut era
singleton :: Domain (UTxO era) -> Range (UTxO era) -> UTxO era
singleton Domain (UTxO era)
k Range (UTxO era)
v = Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
forall era. Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
UTxO (Map (TxIn (Crypto era)) (TxOut era) -> UTxO era)
-> Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
forall a b. (a -> b) -> a -> b
$ TxIn (Crypto era)
-> TxOut era -> Map (TxIn (Crypto era)) (TxOut era)
forall k a. k -> a -> Map k a
Map.singleton Domain (UTxO era)
TxIn (Crypto era)
k Range (UTxO era)
TxOut era
v
dom :: UTxO era -> Set (Domain (UTxO era))
dom (UTxO Map (TxIn (Crypto era)) (TxOut era)
utxo) = Map (TxIn (Crypto era)) (TxOut era)
-> Set (Domain (Map (TxIn (Crypto era)) (TxOut era)))
forall m. (Relation m, Ord (Domain m)) => m -> Set (Domain m)
dom Map (TxIn (Crypto era)) (TxOut era)
utxo
range :: UTxO era -> Set (Range (UTxO era))
range (UTxO Map (TxIn (Crypto era)) (TxOut era)
utxo) = Map (TxIn (Crypto era)) (TxOut era)
-> Set (Range (Map (TxIn (Crypto era)) (TxOut era)))
forall m. (Relation m, Ord (Range m)) => m -> Set (Range m)
range Map (TxIn (Crypto era)) (TxOut era)
utxo
Set (Domain (UTxO era))
s ◁ :: Set (Domain (UTxO era)) -> UTxO era -> UTxO era
◁ (UTxO Map (TxIn (Crypto era)) (TxOut era)
utxo) = Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
forall era. Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
UTxO (Map (TxIn (Crypto era)) (TxOut era) -> UTxO era)
-> Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
forall a b. (a -> b) -> a -> b
$ Set (Domain (Map (TxIn (Crypto era)) (TxOut era)))
Set (Domain (UTxO era))
s Set (Domain (Map (TxIn (Crypto era)) (TxOut era)))
-> Map (TxIn (Crypto era)) (TxOut era)
-> Map (TxIn (Crypto era)) (TxOut era)
forall m. (Relation m, Ord (Domain m)) => Set (Domain m) -> m -> m
◁ Map (TxIn (Crypto era)) (TxOut era)
utxo
Set (Domain (UTxO era))
s ⋪ :: Set (Domain (UTxO era)) -> UTxO era -> UTxO era
⋪ (UTxO Map (TxIn (Crypto era)) (TxOut era)
utxo) = Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
forall era. Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
UTxO (Map (TxIn (Crypto era)) (TxOut era) -> UTxO era)
-> Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
forall a b. (a -> b) -> a -> b
$ Set (Domain (Map (TxIn (Crypto era)) (TxOut era)))
Set (Domain (UTxO era))
s Set (Domain (Map (TxIn (Crypto era)) (TxOut era)))
-> Map (TxIn (Crypto era)) (TxOut era)
-> Map (TxIn (Crypto era)) (TxOut era)
forall m. (Relation m, Ord (Domain m)) => Set (Domain m) -> m -> m
⋪ Map (TxIn (Crypto era)) (TxOut era)
utxo
(UTxO Map (TxIn (Crypto era)) (TxOut era)
utxo) ▷ :: UTxO era -> Set (Range (UTxO era)) -> UTxO era
▷ Set (Range (UTxO era))
s = Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
forall era. Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
UTxO (Map (TxIn (Crypto era)) (TxOut era) -> UTxO era)
-> Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
forall a b. (a -> b) -> a -> b
$ Map (TxIn (Crypto era)) (TxOut era)
utxo Map (TxIn (Crypto era)) (TxOut era)
-> Set (Range (Map (TxIn (Crypto era)) (TxOut era)))
-> Map (TxIn (Crypto era)) (TxOut era)
forall m. (Relation m, Ord (Range m)) => m -> Set (Range m) -> m
▷ Set (Range (Map (TxIn (Crypto era)) (TxOut era)))
Set (Range (UTxO era))
s
(UTxO Map (TxIn (Crypto era)) (TxOut era)
utxo) ⋫ :: UTxO era -> Set (Range (UTxO era)) -> UTxO era
⋫ Set (Range (UTxO era))
s = Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
forall era. Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
UTxO (Map (TxIn (Crypto era)) (TxOut era) -> UTxO era)
-> Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
forall a b. (a -> b) -> a -> b
$ Map (TxIn (Crypto era)) (TxOut era)
utxo Map (TxIn (Crypto era)) (TxOut era)
-> Set (Range (Map (TxIn (Crypto era)) (TxOut era)))
-> Map (TxIn (Crypto era)) (TxOut era)
forall m. (Relation m, Ord (Range m)) => m -> Set (Range m) -> m
⋫ Set (Range (Map (TxIn (Crypto era)) (TxOut era)))
Set (Range (UTxO era))
s
(UTxO Map (TxIn (Crypto era)) (TxOut era)
a) ∪ :: UTxO era -> UTxO era -> UTxO era
∪ (UTxO Map (TxIn (Crypto era)) (TxOut era)
b) = Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
forall era. Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
UTxO (Map (TxIn (Crypto era)) (TxOut era) -> UTxO era)
-> Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
forall a b. (a -> b) -> a -> b
$ Map (TxIn (Crypto era)) (TxOut era)
a Map (TxIn (Crypto era)) (TxOut era)
-> Map (TxIn (Crypto era)) (TxOut era)
-> Map (TxIn (Crypto era)) (TxOut era)
forall m.
(Relation m, Ord (Domain m), Ord (Range m)) =>
m -> m -> m
∪ Map (TxIn (Crypto era)) (TxOut era)
b
(UTxO Map (TxIn (Crypto era)) (TxOut era)
a) ⨃ :: UTxO era -> UTxO era -> UTxO era
⨃ (UTxO Map (TxIn (Crypto era)) (TxOut era)
b) = Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
forall era. Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
UTxO (Map (TxIn (Crypto era)) (TxOut era) -> UTxO era)
-> Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
forall a b. (a -> b) -> a -> b
$ Map (TxIn (Crypto era)) (TxOut era)
a Map (TxIn (Crypto era)) (TxOut era)
-> Map (TxIn (Crypto era)) (TxOut era)
-> Map (TxIn (Crypto era)) (TxOut era)
forall m.
(Relation m, Ord (Domain m), Ord (Range m)) =>
m -> m -> m
⨃ Map (TxIn (Crypto era)) (TxOut era)
b
size :: UTxO era -> n
size (UTxO Map (TxIn (Crypto era)) (TxOut era)
utxo) = Map (TxIn (Crypto era)) (TxOut era) -> n
forall m n. (Relation m, Integral n) => m -> n
size Map (TxIn (Crypto era)) (TxOut era)
utxo
{-# INLINE haskey #-}
haskey :: Domain (UTxO era) -> UTxO era -> Bool
haskey Domain (UTxO era)
k (UTxO Map (TxIn (Crypto era)) (TxOut era)
x) = case TxIn (Crypto era)
-> Map (TxIn (Crypto era)) (TxOut era) -> Maybe (TxOut era)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Domain (UTxO era)
TxIn (Crypto era)
k Map (TxIn (Crypto era)) (TxOut era)
x of Just TxOut era
_ -> Bool
True; Maybe (TxOut era)
Nothing -> Bool
False
{-# INLINE addpair #-}
addpair :: Domain (UTxO era) -> Range (UTxO era) -> UTxO era -> UTxO era
addpair Domain (UTxO era)
k Range (UTxO era)
v (UTxO Map (TxIn (Crypto era)) (TxOut era)
x) = Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
forall era. Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
UTxO ((TxOut era -> TxOut era -> TxOut era)
-> TxIn (Crypto era)
-> TxOut era
-> Map (TxIn (Crypto era)) (TxOut era)
-> Map (TxIn (Crypto era)) (TxOut era)
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith (\TxOut era
y TxOut era
_z -> TxOut era
y) Domain (UTxO era)
TxIn (Crypto era)
k Range (UTxO era)
TxOut era
v Map (TxIn (Crypto era)) (TxOut era)
x)
{-# INLINE removekey #-}
removekey :: Domain (UTxO era) -> UTxO era -> UTxO era
removekey Domain (UTxO era)
k (UTxO Map (TxIn (Crypto era)) (TxOut era)
m) = Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
forall era. Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
UTxO (TxIn (Crypto era)
-> Map (TxIn (Crypto era)) (TxOut era)
-> Map (TxIn (Crypto era)) (TxOut era)
forall k a. Ord k => k -> Map k a -> Map k a
Map.delete Domain (UTxO era)
TxIn (Crypto era)
k Map (TxIn (Crypto era)) (TxOut era)
m)
txid ::
forall era.
TxBodyConstraints era =>
Core.TxBody era ->
TxId (Crypto era)
txid :: TxBody era -> TxId (Crypto era)
txid = Hash (HASH (Crypto era)) EraIndependentTxBody -> TxId (Crypto era)
forall crypto. Hash crypto EraIndependentTxBody -> TxId crypto
TxId (Hash (HASH (Crypto era)) EraIndependentTxBody
-> TxId (Crypto era))
-> (TxBody era -> Hash (HASH (Crypto era)) EraIndependentTxBody)
-> TxBody era
-> TxId (Crypto era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HashAnnotated (TxBody era) era =>
TxBody era -> Hash (HASH (Crypto era)) (HashIndex (TxBody era))
forall a e.
HashAnnotated a e =>
a -> Hash (HASH (Crypto e)) (HashIndex a)
hashAnnotated @(Core.TxBody era) @era
txins ::
( HasField "inputs" (Core.TxBody era) (Set (TxIn (Crypto era)))
) =>
Core.TxBody era ->
Set (TxIn (Crypto era))
txins :: TxBody era -> Set (TxIn (Crypto era))
txins = forall k (x :: k) r a. HasField x r a => r -> a
forall r a. HasField "inputs" r a => r -> a
getField @"inputs"
txouts ::
( ShelleyBased era,
HasField "outputs" (Core.TxBody era) (StrictSeq (TxOut era))
) =>
Core.TxBody era ->
UTxO era
txouts :: TxBody era -> UTxO era
txouts TxBody era
tx =
Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
forall era. Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
UTxO (Map (TxIn (Crypto era)) (TxOut era) -> UTxO era)
-> Map (TxIn (Crypto era)) (TxOut era) -> UTxO era
forall a b. (a -> b) -> a -> b
$
[(TxIn (Crypto era), TxOut era)]
-> Map (TxIn (Crypto era)) (TxOut era)
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
[ (TxId (Crypto era) -> Natural -> TxIn (Crypto era)
forall crypto.
Crypto crypto =>
TxId crypto -> Natural -> TxIn crypto
TxIn TxId (Crypto era)
transId Natural
idx, TxOut era
out)
| (TxOut era
out, Natural
idx) <- [TxOut era] -> [Natural] -> [(TxOut era, Natural)]
forall a b. [a] -> [b] -> [(a, b)]
zip (StrictSeq (TxOut era) -> [TxOut era]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList (StrictSeq (TxOut era) -> [TxOut era])
-> StrictSeq (TxOut era) -> [TxOut era]
forall a b. (a -> b) -> a -> b
$ TxBody era -> StrictSeq (TxOut era)
forall k (x :: k) r a. HasField x r a => r -> a
getField @"outputs" TxBody era
tx) [Natural
0 ..]
]
where
transId :: TxId (Crypto era)
transId = TxBody era -> TxId (Crypto era)
forall era.
TxBodyConstraints era =>
TxBody era -> TxId (Crypto era)
txid TxBody era
tx
txinLookup ::
TxIn (Crypto era) ->
UTxO era ->
Maybe (TxOut era)
txinLookup :: TxIn (Crypto era) -> UTxO era -> Maybe (TxOut era)
txinLookup TxIn (Crypto era)
txin (UTxO Map (TxIn (Crypto era)) (TxOut era)
utxo') = TxIn (Crypto era)
-> Map (TxIn (Crypto era)) (TxOut era) -> Maybe (TxOut era)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup TxIn (Crypto era)
txin Map (TxIn (Crypto era)) (TxOut era)
utxo'
verifyWitVKey ::
( Typeable kr,
CC.Crypto crypto,
DSignable crypto (Hash crypto EraIndependentTxBody)
) =>
Hash crypto EraIndependentTxBody ->
WitVKey kr crypto ->
Bool
verifyWitVKey :: Hash crypto EraIndependentTxBody -> WitVKey kr crypto -> Bool
verifyWitVKey Hash crypto EraIndependentTxBody
txbodyHash (WitVKey VKey kr crypto
vkey SignedDSIGN crypto (Hash crypto EraIndependentTxBody)
sig) = VKey kr crypto
-> Hash crypto EraIndependentTxBody
-> SignedDSIGN crypto (Hash crypto EraIndependentTxBody)
-> Bool
forall crypto a (kd :: KeyRole).
(Crypto crypto, Signable (DSIGN crypto) a) =>
VKey kd crypto -> a -> SignedDSIGN crypto a -> Bool
verifySignedDSIGN VKey kr crypto
vkey Hash crypto EraIndependentTxBody
txbodyHash (SignedDSIGN crypto (Hash crypto EraIndependentTxBody)
-> SignedDSIGN crypto (Hash crypto EraIndependentTxBody)
coerce SignedDSIGN crypto (Hash crypto EraIndependentTxBody)
sig)
makeWitnessVKey ::
forall crypto kr.
( CC.Crypto crypto,
DSignable crypto (Hash crypto EraIndependentTxBody)
) =>
Hash crypto EraIndependentTxBody ->
KeyPair kr crypto ->
WitVKey 'Witness crypto
makeWitnessVKey :: Hash crypto EraIndependentTxBody
-> KeyPair kr crypto -> WitVKey 'Witness crypto
makeWitnessVKey Hash crypto EraIndependentTxBody
txbodyHash KeyPair kr crypto
keys =
VKey 'Witness crypto
-> SignedDSIGN crypto (Hash crypto EraIndependentTxBody)
-> WitVKey 'Witness crypto
forall (kr :: KeyRole) crypto.
(Typeable kr, Crypto crypto) =>
VKey kr crypto
-> SignedDSIGN crypto (Hash crypto EraIndependentTxBody)
-> WitVKey kr crypto
WitVKey (VKey kr crypto -> VKey 'Witness crypto
forall (a :: KeyRole -> * -> *) (r :: KeyRole) crypto.
HasKeyRole a =>
a r crypto -> a 'Witness crypto
asWitness (VKey kr crypto -> VKey 'Witness crypto)
-> VKey kr crypto -> VKey 'Witness crypto
forall a b. (a -> b) -> a -> b
$ KeyPair kr crypto -> VKey kr crypto
forall (kd :: KeyRole) crypto. KeyPair kd crypto -> VKey kd crypto
vKey KeyPair kr crypto
keys) (SignedDSIGN crypto (Hash crypto EraIndependentTxBody)
-> SignedDSIGN crypto (Hash crypto EraIndependentTxBody)
coerce (SignedDSIGN crypto (Hash crypto EraIndependentTxBody)
-> SignedDSIGN crypto (Hash crypto EraIndependentTxBody))
-> SignedDSIGN crypto (Hash crypto EraIndependentTxBody)
-> SignedDSIGN crypto (Hash crypto EraIndependentTxBody)
forall a b. (a -> b) -> a -> b
$ SignKeyDSIGN (DSIGN crypto)
-> Hash crypto EraIndependentTxBody
-> SignedDSIGN crypto (Hash crypto EraIndependentTxBody)
forall crypto a.
(Crypto crypto, Signable (DSIGN crypto) a) =>
SignKeyDSIGN (DSIGN crypto) -> a -> SignedDSIGN crypto a
signedDSIGN @crypto (KeyPair kr crypto -> SignKeyDSIGN (DSIGN crypto)
forall (kd :: KeyRole) crypto.
KeyPair kd crypto -> SignKeyDSIGN (DSIGN crypto)
sKey KeyPair kr crypto
keys) Hash crypto EraIndependentTxBody
txbodyHash)
makeWitnessesVKey ::
forall crypto kr.
( CC.Crypto crypto,
DSignable crypto (Hash crypto EraIndependentTxBody)
) =>
Hash crypto EraIndependentTxBody ->
[KeyPair kr crypto] ->
Set (WitVKey 'Witness crypto)
makeWitnessesVKey :: Hash crypto EraIndependentTxBody
-> [KeyPair kr crypto] -> Set (WitVKey 'Witness crypto)
makeWitnessesVKey Hash crypto EraIndependentTxBody
txbodyHash = [WitVKey 'Witness crypto] -> Set (WitVKey 'Witness crypto)
forall a. Ord a => [a] -> Set a
Set.fromList ([WitVKey 'Witness crypto] -> Set (WitVKey 'Witness crypto))
-> ([KeyPair kr crypto] -> [WitVKey 'Witness crypto])
-> [KeyPair kr crypto]
-> Set (WitVKey 'Witness crypto)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (KeyPair kr crypto -> WitVKey 'Witness crypto)
-> [KeyPair kr crypto] -> [WitVKey 'Witness crypto]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Hash crypto EraIndependentTxBody
-> KeyPair kr crypto -> WitVKey 'Witness crypto
forall crypto (kr :: KeyRole).
(Crypto crypto,
DSignable crypto (Hash crypto EraIndependentTxBody)) =>
Hash crypto EraIndependentTxBody
-> KeyPair kr crypto -> WitVKey 'Witness crypto
makeWitnessVKey Hash crypto EraIndependentTxBody
txbodyHash)
makeWitnessesFromScriptKeys ::
( CC.Crypto crypto,
DSignable crypto (Hash crypto EraIndependentTxBody)
) =>
Hash crypto EraIndependentTxBody ->
Map (KeyHash kr crypto) (KeyPair kr crypto) ->
Set (KeyHash kr crypto) ->
Set (WitVKey 'Witness crypto)
makeWitnessesFromScriptKeys :: Hash crypto EraIndependentTxBody
-> Map (KeyHash kr crypto) (KeyPair kr crypto)
-> Set (KeyHash kr crypto)
-> Set (WitVKey 'Witness crypto)
makeWitnessesFromScriptKeys Hash crypto EraIndependentTxBody
txbodyHash Map (KeyHash kr crypto) (KeyPair kr crypto)
hashKeyMap Set (KeyHash kr crypto)
scriptHashes =
let witKeys :: Map (KeyHash kr crypto) (KeyPair kr crypto)
witKeys = Map (KeyHash kr crypto) (KeyPair kr crypto)
-> Set (KeyHash kr crypto)
-> Map (KeyHash kr crypto) (KeyPair kr crypto)
forall k a. Ord k => Map k a -> Set k -> Map k a
Map.restrictKeys Map (KeyHash kr crypto) (KeyPair kr crypto)
hashKeyMap Set (KeyHash kr crypto)
scriptHashes
in Hash crypto EraIndependentTxBody
-> [KeyPair kr crypto] -> Set (WitVKey 'Witness crypto)
forall crypto (kr :: KeyRole).
(Crypto crypto,
DSignable crypto (Hash crypto EraIndependentTxBody)) =>
Hash crypto EraIndependentTxBody
-> [KeyPair kr crypto] -> Set (WitVKey 'Witness crypto)
makeWitnessesVKey Hash crypto EraIndependentTxBody
txbodyHash (Map (KeyHash kr crypto) (KeyPair kr crypto) -> [KeyPair kr crypto]
forall k a. Map k a -> [a]
Map.elems Map (KeyHash kr crypto) (KeyPair kr crypto)
witKeys)
balance ::
ShelleyBased era =>
UTxO era ->
Core.Value era
balance :: UTxO era -> Value era
balance (UTxO Map (TxIn (Crypto era)) (TxOut era)
utxo) = (Value era -> TxOut era -> Value era)
-> Value era -> Map (TxIn (Crypto era)) (TxOut era) -> Value era
forall a b k. (a -> b -> a) -> a -> Map k b -> a
Map.foldl' Value era -> TxOut era -> Value era
forall era.
(Torsor (Value era), DecodeNonNegative (Value era),
Compactible (Value era), HashAnnotated (TxBody era) era,
FromCBOR (Delta (Value era)), FromCBOR (Value era),
FromCBOR (CompactForm (Value era)),
FromCBOR (Annotator (TxBody era)),
FromCBOR (Annotator (Script era)),
FromCBOR (Annotator (AuxiliaryData era)),
ToCBOR (Delta (Value era)), ToCBOR (Value era),
ToCBOR (TxBody era), ToCBOR (Script era),
ToCBOR (AuxiliaryData era), ToCBOR (CompactForm (Value era)),
Val (Value era), Show (Delta (Value era)), Show (Value era),
Show (TxBody era), Show (Script era), Show (AuxiliaryData era),
Eq (Delta (Value era)), Eq (TxBody era), Eq (Script era),
Eq (AuxiliaryData era), Eq (CompactForm (Value era)),
NoThunks (Delta (Value era)), NoThunks (Value era),
NoThunks (TxBody era), NoThunks (Script era),
NoThunks (AuxiliaryData era),
HashIndex (TxBody era) ~ EraIndependentTxBody) =>
Value era -> TxOut era -> Value era
addTxOuts Value era
forall a. Monoid a => a
mempty Map (TxIn (Crypto era)) (TxOut era)
utxo
where
addTxOuts :: Value era -> TxOut era -> Value era
addTxOuts !Value era
b (TxOut Addr (Crypto era)
_ Value era
a) = Value era
a Value era -> Value era -> Value era
forall t. Val t => t -> t -> t
<+> Value era
b
totalDeposits ::
PParams era ->
Map (KeyHash 'StakePool (Crypto era)) (PoolParams (Crypto era)) ->
[DCert (Crypto era)] ->
Coin
totalDeposits :: PParams era
-> Map (KeyHash 'StakePool (Crypto era)) (PoolParams (Crypto era))
-> [DCert (Crypto era)]
-> Coin
totalDeposits PParams era
pp Map (KeyHash 'StakePool (Crypto era)) (PoolParams (Crypto era))
stpools [DCert (Crypto era)]
cs =
(Int
numKeys Int -> Coin -> Coin
forall t i. (Val t, Integral i) => i -> t -> t
<×> PParams era -> HKD Identity Coin
forall (f :: * -> *) era. PParams' f era -> HKD f Coin
_keyDeposit PParams era
pp) Coin -> Coin -> Coin
forall t. Val t => t -> t -> t
<+> (Int
numNewPools Int -> Coin -> Coin
forall t i. (Val t, Integral i) => i -> t -> t
<×> PParams era -> HKD Identity Coin
forall (f :: * -> *) era. PParams' f era -> HKD f Coin
_poolDeposit PParams era
pp)
where
numKeys :: Int
numKeys = [DCert (Crypto era)] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([DCert (Crypto era)] -> Int) -> [DCert (Crypto era)] -> Int
forall a b. (a -> b) -> a -> b
$ (DCert (Crypto era) -> Bool)
-> [DCert (Crypto era)] -> [DCert (Crypto era)]
forall a. (a -> Bool) -> [a] -> [a]
filter DCert (Crypto era) -> Bool
forall crypto. DCert crypto -> Bool
isRegKey [DCert (Crypto era)]
cs
pools :: Set (KeyHash 'StakePool (Crypto era))
pools = [KeyHash 'StakePool (Crypto era)]
-> Set (KeyHash 'StakePool (Crypto era))
forall a. Ord a => [a] -> Set a
Set.fromList ([KeyHash 'StakePool (Crypto era)]
-> Set (KeyHash 'StakePool (Crypto era)))
-> ([Maybe (KeyHash 'StakePool (Crypto era))]
-> [KeyHash 'StakePool (Crypto era)])
-> [Maybe (KeyHash 'StakePool (Crypto era))]
-> Set (KeyHash 'StakePool (Crypto era))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Maybe (KeyHash 'StakePool (Crypto era))]
-> [KeyHash 'StakePool (Crypto era)]
forall a. [Maybe a] -> [a]
Maybe.catMaybes ([Maybe (KeyHash 'StakePool (Crypto era))]
-> Set (KeyHash 'StakePool (Crypto era)))
-> [Maybe (KeyHash 'StakePool (Crypto era))]
-> Set (KeyHash 'StakePool (Crypto era))
forall a b. (a -> b) -> a -> b
$ (DCert (Crypto era) -> Maybe (KeyHash 'StakePool (Crypto era)))
-> [DCert (Crypto era)]
-> [Maybe (KeyHash 'StakePool (Crypto era))]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap DCert (Crypto era) -> Maybe (KeyHash 'StakePool (Crypto era))
forall crypto. DCert crypto -> Maybe (KeyHash 'StakePool crypto)
getKeyHashFromRegPool [DCert (Crypto era)]
cs
numNewPools :: Int
numNewPools = Set (KeyHash 'StakePool (Crypto era)) -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (Set (KeyHash 'StakePool (Crypto era)) -> Int)
-> Set (KeyHash 'StakePool (Crypto era)) -> Int
forall a b. (a -> b) -> a -> b
$ Set (KeyHash 'StakePool (Crypto era))
pools Set (KeyHash 'StakePool (Crypto era))
-> Set (KeyHash 'StakePool (Crypto era))
-> Set (KeyHash 'StakePool (Crypto era))
forall a. Ord a => Set a -> Set a -> Set a
`Set.difference` (Map (KeyHash 'StakePool (Crypto era)) (PoolParams (Crypto era))
-> Set (KeyHash 'StakePool (Crypto era))
forall k a. Map k a -> Set k
Map.keysSet Map (KeyHash 'StakePool (Crypto era)) (PoolParams (Crypto era))
stpools)
getKeyHashFromRegPool :: DCert crypto -> Maybe (KeyHash 'StakePool crypto)
getKeyHashFromRegPool :: DCert crypto -> Maybe (KeyHash 'StakePool crypto)
getKeyHashFromRegPool (DCertPool (RegPool PoolParams crypto
p)) = KeyHash 'StakePool crypto -> Maybe (KeyHash 'StakePool crypto)
forall a. a -> Maybe a
Just (KeyHash 'StakePool crypto -> Maybe (KeyHash 'StakePool crypto))
-> (PoolParams crypto -> KeyHash 'StakePool crypto)
-> PoolParams crypto
-> Maybe (KeyHash 'StakePool crypto)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PoolParams crypto -> KeyHash 'StakePool crypto
forall crypto. PoolParams crypto -> KeyHash 'StakePool crypto
_poolId (PoolParams crypto -> Maybe (KeyHash 'StakePool crypto))
-> PoolParams crypto -> Maybe (KeyHash 'StakePool crypto)
forall a b. (a -> b) -> a -> b
$ PoolParams crypto
p
getKeyHashFromRegPool DCert crypto
_ = Maybe (KeyHash 'StakePool crypto)
forall a. Maybe a
Nothing
txup ::
( ShelleyBased era,
HasField "update" (Core.TxBody era) (StrictMaybe (Update era))
) =>
Tx era ->
Maybe (Update era)
txup :: Tx era -> Maybe (Update era)
txup (Tx TxBody era
txbody WitnessSet era
_ StrictMaybe (AuxiliaryData era)
_) = StrictMaybe (Update era) -> Maybe (Update era)
forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe (TxBody era -> StrictMaybe (Update era)
forall k (x :: k) r a. HasField x r a => r -> a
getField @"update" TxBody era
txbody)
getScriptHash :: Addr crypto -> Maybe (ScriptHash crypto)
getScriptHash :: Addr crypto -> Maybe (ScriptHash crypto)
getScriptHash (Addr Network
_ (ScriptHashObj ScriptHash crypto
hs) StakeReference crypto
_) = ScriptHash crypto -> Maybe (ScriptHash crypto)
forall a. a -> Maybe a
Just ScriptHash crypto
hs
getScriptHash Addr crypto
_ = Maybe (ScriptHash crypto)
forall a. Maybe a
Nothing
scriptStakeCred ::
DCert crypto ->
Maybe (ScriptHash crypto)
scriptStakeCred :: DCert crypto -> Maybe (ScriptHash crypto)
scriptStakeCred (DCertDeleg (DeRegKey (KeyHashObj KeyHash 'Staking crypto
_))) = Maybe (ScriptHash crypto)
forall a. Maybe a
Nothing
scriptStakeCred (DCertDeleg (DeRegKey (ScriptHashObj ScriptHash crypto
hs))) = ScriptHash crypto -> Maybe (ScriptHash crypto)
forall a. a -> Maybe a
Just ScriptHash crypto
hs
scriptStakeCred (DCertDeleg (Delegate (Delegation (KeyHashObj KeyHash 'Staking crypto
_) KeyHash 'StakePool crypto
_))) = Maybe (ScriptHash crypto)
forall a. Maybe a
Nothing
scriptStakeCred (DCertDeleg (Delegate (Delegation (ScriptHashObj ScriptHash crypto
hs) KeyHash 'StakePool crypto
_))) = ScriptHash crypto -> Maybe (ScriptHash crypto)
forall a. a -> Maybe a
Just ScriptHash crypto
hs
scriptStakeCred DCert crypto
_ = Maybe (ScriptHash crypto)
forall a. Maybe a
Nothing
scriptCred ::
Credential kr crypto ->
Maybe (ScriptHash crypto)
scriptCred :: Credential kr crypto -> Maybe (ScriptHash crypto)
scriptCred (KeyHashObj KeyHash kr crypto
_) = Maybe (ScriptHash crypto)
forall a. Maybe a
Nothing
scriptCred (ScriptHashObj ScriptHash crypto
hs) = ScriptHash crypto -> Maybe (ScriptHash crypto)
forall a. a -> Maybe a
Just ScriptHash crypto
hs
scriptsNeeded ::
( ShelleyBased era,
HasField "certs" (Core.TxBody era) (StrictSeq (DCert (Crypto era))),
HasField "wdrls" (Core.TxBody era) (Wdrl (Crypto era)),
HasField "inputs" (Core.TxBody era) (Set (TxIn (Crypto era)))
) =>
UTxO era ->
Tx era ->
Set (ScriptHash (Crypto era))
scriptsNeeded :: UTxO era -> Tx era -> Set (ScriptHash (Crypto era))
scriptsNeeded UTxO era
u Tx era
tx =
[ScriptHash (Crypto era)] -> Set (ScriptHash (Crypto era))
forall a. Ord a => [a] -> Set a
Set.fromList (Map (TxIn (Crypto era)) (ScriptHash (Crypto era))
-> [ScriptHash (Crypto era)]
forall k a. Map k a -> [a]
Map.elems (Map (TxIn (Crypto era)) (ScriptHash (Crypto era))
-> [ScriptHash (Crypto era)])
-> Map (TxIn (Crypto era)) (ScriptHash (Crypto era))
-> [ScriptHash (Crypto era)]
forall a b. (a -> b) -> a -> b
$ (TxOut era -> Maybe (ScriptHash (Crypto era)))
-> Map (TxIn (Crypto era)) (TxOut era)
-> Map (TxIn (Crypto era)) (ScriptHash (Crypto era))
forall a b k. (a -> Maybe b) -> Map k a -> Map k b
Map.mapMaybe (Addr (Crypto era) -> Maybe (ScriptHash (Crypto era))
forall crypto. Addr crypto -> Maybe (ScriptHash crypto)
getScriptHash (Addr (Crypto era) -> Maybe (ScriptHash (Crypto era)))
-> (TxOut era -> Addr (Crypto era))
-> TxOut era
-> Maybe (ScriptHash (Crypto era))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxOut era -> Addr (Crypto era)
forall era.
(Torsor (Value era), DecodeNonNegative (Value era),
Compactible (Value era), Val (Value era),
HashAnnotated (TxBody era) era, FromCBOR (Delta (Value era)),
FromCBOR (Value era), FromCBOR (CompactForm (Value era)),
FromCBOR (Annotator (TxBody era)),
FromCBOR (Annotator (Script era)),
FromCBOR (Annotator (AuxiliaryData era)),
ToCBOR (Delta (Value era)), ToCBOR (Value era),
ToCBOR (TxBody era), ToCBOR (Script era),
ToCBOR (AuxiliaryData era), ToCBOR (CompactForm (Value era)),
Show (Delta (Value era)), Show (Value era), Show (TxBody era),
Show (Script era), Show (AuxiliaryData era),
Eq (Delta (Value era)), Eq (TxBody era), Eq (Script era),
Eq (AuxiliaryData era), Eq (CompactForm (Value era)),
NoThunks (Delta (Value era)), NoThunks (Value era),
NoThunks (TxBody era), NoThunks (Script era),
NoThunks (AuxiliaryData era),
HashIndex (TxBody era) ~ EraIndependentTxBody) =>
TxOut era -> Addr (Crypto era)
unTxOut) Map (TxIn (Crypto era)) (TxOut era)
u'')
Set (ScriptHash (Crypto era))
-> Set (ScriptHash (Crypto era)) -> Set (ScriptHash (Crypto era))
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` [ScriptHash (Crypto era)] -> Set (ScriptHash (Crypto era))
forall a. Ord a => [a] -> Set a
Set.fromList
( (RewardAcnt (Crypto era) -> Maybe (ScriptHash (Crypto era)))
-> [RewardAcnt (Crypto era)] -> [ScriptHash (Crypto era)]
forall a b. (a -> Maybe b) -> [a] -> [b]
Maybe.mapMaybe (Credential 'Staking (Crypto era) -> Maybe (ScriptHash (Crypto era))
forall (kr :: KeyRole) crypto.
Credential kr crypto -> Maybe (ScriptHash crypto)
scriptCred (Credential 'Staking (Crypto era)
-> Maybe (ScriptHash (Crypto era)))
-> (RewardAcnt (Crypto era) -> Credential 'Staking (Crypto era))
-> RewardAcnt (Crypto era)
-> Maybe (ScriptHash (Crypto era))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RewardAcnt (Crypto era) -> Credential 'Staking (Crypto era)
forall crypto. RewardAcnt crypto -> Credential 'Staking crypto
getRwdCred) ([RewardAcnt (Crypto era)] -> [ScriptHash (Crypto era)])
-> [RewardAcnt (Crypto era)] -> [ScriptHash (Crypto era)]
forall a b. (a -> b) -> a -> b
$
Map (RewardAcnt (Crypto era)) Coin -> [RewardAcnt (Crypto era)]
forall k a. Map k a -> [k]
Map.keys Map (RewardAcnt (Crypto era)) Coin
withdrawals
)
Set (ScriptHash (Crypto era))
-> Set (ScriptHash (Crypto era)) -> Set (ScriptHash (Crypto era))
forall a. Ord a => Set a -> Set a -> Set a
`Set.union` [ScriptHash (Crypto era)] -> Set (ScriptHash (Crypto era))
forall a. Ord a => [a] -> Set a
Set.fromList
( (DCert (Crypto era) -> Maybe (ScriptHash (Crypto era)))
-> [DCert (Crypto era)] -> [ScriptHash (Crypto era)]
forall a b. (a -> Maybe b) -> [a] -> [b]
Maybe.mapMaybe
DCert (Crypto era) -> Maybe (ScriptHash (Crypto era))
forall crypto. DCert crypto -> Maybe (ScriptHash crypto)
scriptStakeCred
((DCert (Crypto era) -> Bool)
-> [DCert (Crypto era)] -> [DCert (Crypto era)]
forall a. (a -> Bool) -> [a] -> [a]
filter DCert (Crypto era) -> Bool
forall crypto. DCert crypto -> Bool
requiresVKeyWitness [DCert (Crypto era)]
certificates)
)
where
unTxOut :: TxOut era -> Addr (Crypto era)
unTxOut (TxOut Addr (Crypto era)
a Value era
_) = Addr (Crypto era)
a
withdrawals :: Map (RewardAcnt (Crypto era)) Coin
withdrawals = Wdrl (Crypto era) -> Map (RewardAcnt (Crypto era)) Coin
forall crypto. Wdrl crypto -> Map (RewardAcnt crypto) Coin
unWdrl (Wdrl (Crypto era) -> Map (RewardAcnt (Crypto era)) Coin)
-> Wdrl (Crypto era) -> Map (RewardAcnt (Crypto era)) Coin
forall a b. (a -> b) -> a -> b
$ forall k (x :: k) r a. HasField x r a => r -> a
forall r a. HasField "wdrls" r a => r -> a
getField @"wdrls" (TxBody era -> Wdrl (Crypto era))
-> TxBody era -> Wdrl (Crypto era)
forall a b. (a -> b) -> a -> b
$ Tx era
-> (TxBodyConstraints era, ToCBOR (AuxiliaryData era)) =>
TxBody era
forall era.
Tx era
-> (TxBodyConstraints era, ToCBOR (AuxiliaryData era)) =>
TxBody era
_body Tx era
tx
UTxO Map (TxIn (Crypto era)) (TxOut era)
u'' = (Set (TxIn (Crypto era)) -> UTxO era -> Set (TxIn (Crypto era))
forall era.
ShelleyBased era =>
Set (TxIn (Crypto era)) -> UTxO era -> Set (TxIn (Crypto era))
txinsScript (forall k (x :: k) r a. HasField x r a => r -> a
forall r a. HasField "inputs" r a => r -> a
getField @"inputs" (TxBody era -> Set (TxIn (Crypto era)))
-> TxBody era -> Set (TxIn (Crypto era))
forall a b. (a -> b) -> a -> b
$ Tx era
-> (TxBodyConstraints era, ToCBOR (AuxiliaryData era)) =>
TxBody era
forall era.
Tx era
-> (TxBodyConstraints era, ToCBOR (AuxiliaryData era)) =>
TxBody era
_body Tx era
tx) UTxO era
u) Set (Domain (UTxO era)) -> UTxO era -> UTxO era
forall m. (Relation m, Ord (Domain m)) => Set (Domain m) -> m -> m
◁ UTxO era
u
certificates :: [DCert (Crypto era)]
certificates = (StrictSeq (DCert (Crypto era)) -> [DCert (Crypto era)]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList (StrictSeq (DCert (Crypto era)) -> [DCert (Crypto era)])
-> (Tx era -> StrictSeq (DCert (Crypto era)))
-> Tx era
-> [DCert (Crypto era)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k (x :: k) r a. HasField x r a => r -> a
forall r a. HasField "certs" r a => r -> a
getField @"certs" (TxBody era -> StrictSeq (DCert (Crypto era)))
-> (Tx era -> TxBody era)
-> Tx era
-> StrictSeq (DCert (Crypto era))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Tx era -> TxBody era
forall era.
Tx era
-> (TxBodyConstraints era, ToCBOR (AuxiliaryData era)) =>
TxBody era
_body) Tx era
tx
txinsScript ::
ShelleyBased era =>
Set (TxIn (Crypto era)) ->
UTxO era ->
Set (TxIn (Crypto era))
txinsScript :: Set (TxIn (Crypto era)) -> UTxO era -> Set (TxIn (Crypto era))
txinsScript Set (TxIn (Crypto era))
txInps (UTxO Map (TxIn (Crypto era)) (TxOut era)
u) = (TxIn (Crypto era)
-> Set (TxIn (Crypto era)) -> Set (TxIn (Crypto era)))
-> Set (TxIn (Crypto era))
-> Set (TxIn (Crypto era))
-> Set (TxIn (Crypto era))
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr TxIn (Crypto era)
-> Set (TxIn (Crypto era)) -> Set (TxIn (Crypto era))
add Set (TxIn (Crypto era))
forall a. Set a
Set.empty Set (TxIn (Crypto era))
txInps
where
add :: TxIn (Crypto era)
-> Set (TxIn (Crypto era)) -> Set (TxIn (Crypto era))
add TxIn (Crypto era)
input Set (TxIn (Crypto era))
ans = case TxIn (Crypto era)
-> Map (TxIn (Crypto era)) (TxOut era) -> Maybe (TxOut era)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup TxIn (Crypto era)
input Map (TxIn (Crypto era)) (TxOut era)
u of
Just (TxOut (Addr Network
_ (ScriptHashObj ScriptHash (Crypto era)
_) StakeReference (Crypto era)
_) Value era
_) -> TxIn (Crypto era)
-> Set (TxIn (Crypto era)) -> Set (TxIn (Crypto era))
forall a. Ord a => a -> Set a -> Set a
Set.insert TxIn (Crypto era)
input Set (TxIn (Crypto era))
ans
Just TxOut era
_ -> Set (TxIn (Crypto era))
ans
Maybe (TxOut era)
Nothing -> Set (TxIn (Crypto era))
ans