{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}
{-# OPTIONS_GHC -Wno-redundant-constraints #-}

module Byron.Spec.Ledger.UTxO where

import Byron.Spec.Ledger.Core hiding ((<|))
import Byron.Spec.Ledger.Update (FactorA (..), FactorB (..), PParams (PParams), _factorA, _factorB)
import Data.AbstractSize (HasTypeReps, abstractSize)
import Data.Data (Data)
import Data.Hashable (Hashable)
import qualified Data.Hashable as H
import Data.Map.Strict (Map)
import qualified Data.Map.Strict as Map
import Data.Maybe (fromMaybe)
import Data.Typeable (typeOf)
import GHC.Generics (Generic)
import NoThunks.Class (NoThunks (..))
import Numeric.Natural (Natural)

-- | A unique ID of a transaction, which is computable from the transaction.
newtype TxId = TxId {TxId -> Hash
getTxId :: Hash}
  deriving stock (Int -> TxId -> ShowS
[TxId] -> ShowS
TxId -> String
(Int -> TxId -> ShowS)
-> (TxId -> String) -> ([TxId] -> ShowS) -> Show TxId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TxId -> ShowS
showsPrec :: Int -> TxId -> ShowS
$cshow :: TxId -> String
show :: TxId -> String
$cshowList :: [TxId] -> ShowS
showList :: [TxId] -> ShowS
Show, (forall x. TxId -> Rep TxId x)
-> (forall x. Rep TxId x -> TxId) -> Generic TxId
forall x. Rep TxId x -> TxId
forall x. TxId -> Rep TxId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TxId -> Rep TxId x
from :: forall x. TxId -> Rep TxId x
$cto :: forall x. Rep TxId x -> TxId
to :: forall x. Rep TxId x -> TxId
Generic, Typeable TxId
Typeable TxId =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TxId -> c TxId)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TxId)
-> (TxId -> Constr)
-> (TxId -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TxId))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TxId))
-> ((forall b. Data b => b -> b) -> TxId -> TxId)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TxId -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TxId -> r)
-> (forall u. (forall d. Data d => d -> u) -> TxId -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TxId -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TxId -> m TxId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TxId -> m TxId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TxId -> m TxId)
-> Data TxId
TxId -> Constr
TxId -> DataType
(forall b. Data b => b -> b) -> TxId -> TxId
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> TxId -> u
forall u. (forall d. Data d => d -> u) -> TxId -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TxId -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TxId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TxId -> m TxId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TxId -> m TxId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TxId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TxId -> c TxId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TxId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TxId)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TxId -> c TxId
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TxId -> c TxId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TxId
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TxId
$ctoConstr :: TxId -> Constr
toConstr :: TxId -> Constr
$cdataTypeOf :: TxId -> DataType
dataTypeOf :: TxId -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TxId)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TxId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TxId)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TxId)
$cgmapT :: (forall b. Data b => b -> b) -> TxId -> TxId
gmapT :: (forall b. Data b => b -> b) -> TxId -> TxId
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TxId -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TxId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TxId -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TxId -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TxId -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TxId -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TxId -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TxId -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TxId -> m TxId
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TxId -> m TxId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TxId -> m TxId
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TxId -> m TxId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TxId -> m TxId
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TxId -> m TxId
Data)
  deriving newtype (TxId -> TxId -> Bool
(TxId -> TxId -> Bool) -> (TxId -> TxId -> Bool) -> Eq TxId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TxId -> TxId -> Bool
== :: TxId -> TxId -> Bool
$c/= :: TxId -> TxId -> Bool
/= :: TxId -> TxId -> Bool
Eq, Eq TxId
Eq TxId =>
(TxId -> TxId -> Ordering)
-> (TxId -> TxId -> Bool)
-> (TxId -> TxId -> Bool)
-> (TxId -> TxId -> Bool)
-> (TxId -> TxId -> Bool)
-> (TxId -> TxId -> TxId)
-> (TxId -> TxId -> TxId)
-> Ord TxId
TxId -> TxId -> Bool
TxId -> TxId -> Ordering
TxId -> TxId -> TxId
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TxId -> TxId -> Ordering
compare :: TxId -> TxId -> Ordering
$c< :: TxId -> TxId -> Bool
< :: TxId -> TxId -> Bool
$c<= :: TxId -> TxId -> Bool
<= :: TxId -> TxId -> Bool
$c> :: TxId -> TxId -> Bool
> :: TxId -> TxId -> Bool
$c>= :: TxId -> TxId -> Bool
>= :: TxId -> TxId -> Bool
$cmax :: TxId -> TxId -> TxId
max :: TxId -> TxId -> TxId
$cmin :: TxId -> TxId -> TxId
min :: TxId -> TxId -> TxId
Ord, Eq TxId
Eq TxId => (Int -> TxId -> Int) -> (TxId -> Int) -> Hashable TxId
Int -> TxId -> Int
TxId -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> TxId -> Int
hashWithSalt :: Int -> TxId -> Int
$chash :: TxId -> Int
hash :: TxId -> Int
Hashable, Context -> TxId -> IO (Maybe ThunkInfo)
Proxy TxId -> String
(Context -> TxId -> IO (Maybe ThunkInfo))
-> (Context -> TxId -> IO (Maybe ThunkInfo))
-> (Proxy TxId -> String)
-> NoThunks TxId
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> TxId -> IO (Maybe ThunkInfo)
noThunks :: Context -> TxId -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> TxId -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> TxId -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy TxId -> String
showTypeOf :: Proxy TxId -> String
NoThunks)
  deriving anyclass (TxId -> Seq TypeRep
(TxId -> Seq TypeRep) -> HasTypeReps TxId
forall a. (a -> Seq TypeRep) -> HasTypeReps a
$ctypeReps :: TxId -> Seq TypeRep
typeReps :: TxId -> Seq TypeRep
HasTypeReps)

-- | The input of a UTxO.
--
--      * __TODO__ - is it okay to use list indices instead of implementing the Ix Type?
data TxIn = TxIn TxId Natural
  deriving
    ( Int -> TxIn -> ShowS
[TxIn] -> ShowS
TxIn -> String
(Int -> TxIn -> ShowS)
-> (TxIn -> String) -> ([TxIn] -> ShowS) -> Show TxIn
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TxIn -> ShowS
showsPrec :: Int -> TxIn -> ShowS
$cshow :: TxIn -> String
show :: TxIn -> String
$cshowList :: [TxIn] -> ShowS
showList :: [TxIn] -> ShowS
Show
    , TxIn -> TxIn -> Bool
(TxIn -> TxIn -> Bool) -> (TxIn -> TxIn -> Bool) -> Eq TxIn
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TxIn -> TxIn -> Bool
== :: TxIn -> TxIn -> Bool
$c/= :: TxIn -> TxIn -> Bool
/= :: TxIn -> TxIn -> Bool
Eq
    , Eq TxIn
Eq TxIn =>
(TxIn -> TxIn -> Ordering)
-> (TxIn -> TxIn -> Bool)
-> (TxIn -> TxIn -> Bool)
-> (TxIn -> TxIn -> Bool)
-> (TxIn -> TxIn -> Bool)
-> (TxIn -> TxIn -> TxIn)
-> (TxIn -> TxIn -> TxIn)
-> Ord TxIn
TxIn -> TxIn -> Bool
TxIn -> TxIn -> Ordering
TxIn -> TxIn -> TxIn
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TxIn -> TxIn -> Ordering
compare :: TxIn -> TxIn -> Ordering
$c< :: TxIn -> TxIn -> Bool
< :: TxIn -> TxIn -> Bool
$c<= :: TxIn -> TxIn -> Bool
<= :: TxIn -> TxIn -> Bool
$c> :: TxIn -> TxIn -> Bool
> :: TxIn -> TxIn -> Bool
$c>= :: TxIn -> TxIn -> Bool
>= :: TxIn -> TxIn -> Bool
$cmax :: TxIn -> TxIn -> TxIn
max :: TxIn -> TxIn -> TxIn
$cmin :: TxIn -> TxIn -> TxIn
min :: TxIn -> TxIn -> TxIn
Ord
    , (forall x. TxIn -> Rep TxIn x)
-> (forall x. Rep TxIn x -> TxIn) -> Generic TxIn
forall x. Rep TxIn x -> TxIn
forall x. TxIn -> Rep TxIn x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TxIn -> Rep TxIn x
from :: forall x. TxIn -> Rep TxIn x
$cto :: forall x. Rep TxIn x -> TxIn
to :: forall x. Rep TxIn x -> TxIn
Generic
    , Eq TxIn
Eq TxIn => (Int -> TxIn -> Int) -> (TxIn -> Int) -> Hashable TxIn
Int -> TxIn -> Int
TxIn -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> TxIn -> Int
hashWithSalt :: Int -> TxIn -> Int
$chash :: TxIn -> Int
hash :: TxIn -> Int
Hashable
    , TxIn -> Seq TypeRep
(TxIn -> Seq TypeRep) -> HasTypeReps TxIn
forall a. (a -> Seq TypeRep) -> HasTypeReps a
$ctypeReps :: TxIn -> Seq TypeRep
typeReps :: TxIn -> Seq TypeRep
HasTypeReps
    , Typeable TxIn
Typeable TxIn =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TxIn -> c TxIn)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TxIn)
-> (TxIn -> Constr)
-> (TxIn -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TxIn))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TxIn))
-> ((forall b. Data b => b -> b) -> TxIn -> TxIn)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TxIn -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TxIn -> r)
-> (forall u. (forall d. Data d => d -> u) -> TxIn -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TxIn -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TxIn -> m TxIn)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TxIn -> m TxIn)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TxIn -> m TxIn)
-> Data TxIn
TxIn -> Constr
TxIn -> DataType
(forall b. Data b => b -> b) -> TxIn -> TxIn
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> TxIn -> u
forall u. (forall d. Data d => d -> u) -> TxIn -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TxIn -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TxIn -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TxIn -> m TxIn
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TxIn -> m TxIn
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TxIn
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TxIn -> c TxIn
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TxIn)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TxIn)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TxIn -> c TxIn
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TxIn -> c TxIn
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TxIn
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TxIn
$ctoConstr :: TxIn -> Constr
toConstr :: TxIn -> Constr
$cdataTypeOf :: TxIn -> DataType
dataTypeOf :: TxIn -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TxIn)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TxIn)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TxIn)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TxIn)
$cgmapT :: (forall b. Data b => b -> b) -> TxIn -> TxIn
gmapT :: (forall b. Data b => b -> b) -> TxIn -> TxIn
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TxIn -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TxIn -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TxIn -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TxIn -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TxIn -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TxIn -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TxIn -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TxIn -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TxIn -> m TxIn
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TxIn -> m TxIn
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TxIn -> m TxIn
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TxIn -> m TxIn
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TxIn -> m TxIn
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TxIn -> m TxIn
Data
    , Context -> TxIn -> IO (Maybe ThunkInfo)
Proxy TxIn -> String
(Context -> TxIn -> IO (Maybe ThunkInfo))
-> (Context -> TxIn -> IO (Maybe ThunkInfo))
-> (Proxy TxIn -> String)
-> NoThunks TxIn
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> TxIn -> IO (Maybe ThunkInfo)
noThunks :: Context -> TxIn -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> TxIn -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> TxIn -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy TxIn -> String
showTypeOf :: Proxy TxIn -> String
NoThunks
    )

-- | The output of a UTxO.
data TxOut = TxOut
  { TxOut -> Addr
addr :: Addr
  , TxOut -> Lovelace
value :: Lovelace
  }
  deriving
    ( Int -> TxOut -> ShowS
[TxOut] -> ShowS
TxOut -> String
(Int -> TxOut -> ShowS)
-> (TxOut -> String) -> ([TxOut] -> ShowS) -> Show TxOut
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TxOut -> ShowS
showsPrec :: Int -> TxOut -> ShowS
$cshow :: TxOut -> String
show :: TxOut -> String
$cshowList :: [TxOut] -> ShowS
showList :: [TxOut] -> ShowS
Show
    , TxOut -> TxOut -> Bool
(TxOut -> TxOut -> Bool) -> (TxOut -> TxOut -> Bool) -> Eq TxOut
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TxOut -> TxOut -> Bool
== :: TxOut -> TxOut -> Bool
$c/= :: TxOut -> TxOut -> Bool
/= :: TxOut -> TxOut -> Bool
Eq
    , Eq TxOut
Eq TxOut =>
(TxOut -> TxOut -> Ordering)
-> (TxOut -> TxOut -> Bool)
-> (TxOut -> TxOut -> Bool)
-> (TxOut -> TxOut -> Bool)
-> (TxOut -> TxOut -> Bool)
-> (TxOut -> TxOut -> TxOut)
-> (TxOut -> TxOut -> TxOut)
-> Ord TxOut
TxOut -> TxOut -> Bool
TxOut -> TxOut -> Ordering
TxOut -> TxOut -> TxOut
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TxOut -> TxOut -> Ordering
compare :: TxOut -> TxOut -> Ordering
$c< :: TxOut -> TxOut -> Bool
< :: TxOut -> TxOut -> Bool
$c<= :: TxOut -> TxOut -> Bool
<= :: TxOut -> TxOut -> Bool
$c> :: TxOut -> TxOut -> Bool
> :: TxOut -> TxOut -> Bool
$c>= :: TxOut -> TxOut -> Bool
>= :: TxOut -> TxOut -> Bool
$cmax :: TxOut -> TxOut -> TxOut
max :: TxOut -> TxOut -> TxOut
$cmin :: TxOut -> TxOut -> TxOut
min :: TxOut -> TxOut -> TxOut
Ord
    , (forall x. TxOut -> Rep TxOut x)
-> (forall x. Rep TxOut x -> TxOut) -> Generic TxOut
forall x. Rep TxOut x -> TxOut
forall x. TxOut -> Rep TxOut x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TxOut -> Rep TxOut x
from :: forall x. TxOut -> Rep TxOut x
$cto :: forall x. Rep TxOut x -> TxOut
to :: forall x. Rep TxOut x -> TxOut
Generic
    , Eq TxOut
Eq TxOut =>
(Int -> TxOut -> Int) -> (TxOut -> Int) -> Hashable TxOut
Int -> TxOut -> Int
TxOut -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> TxOut -> Int
hashWithSalt :: Int -> TxOut -> Int
$chash :: TxOut -> Int
hash :: TxOut -> Int
Hashable
    , TxOut -> Seq TypeRep
(TxOut -> Seq TypeRep) -> HasTypeReps TxOut
forall a. (a -> Seq TypeRep) -> HasTypeReps a
$ctypeReps :: TxOut -> Seq TypeRep
typeReps :: TxOut -> Seq TypeRep
HasTypeReps
    , Typeable TxOut
Typeable TxOut =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TxOut -> c TxOut)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TxOut)
-> (TxOut -> Constr)
-> (TxOut -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TxOut))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TxOut))
-> ((forall b. Data b => b -> b) -> TxOut -> TxOut)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TxOut -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TxOut -> r)
-> (forall u. (forall d. Data d => d -> u) -> TxOut -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TxOut -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TxOut -> m TxOut)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TxOut -> m TxOut)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TxOut -> m TxOut)
-> Data TxOut
TxOut -> Constr
TxOut -> DataType
(forall b. Data b => b -> b) -> TxOut -> TxOut
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> TxOut -> u
forall u. (forall d. Data d => d -> u) -> TxOut -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TxOut -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TxOut -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TxOut -> m TxOut
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TxOut -> m TxOut
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TxOut
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TxOut -> c TxOut
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TxOut)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TxOut)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TxOut -> c TxOut
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TxOut -> c TxOut
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TxOut
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TxOut
$ctoConstr :: TxOut -> Constr
toConstr :: TxOut -> Constr
$cdataTypeOf :: TxOut -> DataType
dataTypeOf :: TxOut -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TxOut)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TxOut)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TxOut)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TxOut)
$cgmapT :: (forall b. Data b => b -> b) -> TxOut -> TxOut
gmapT :: (forall b. Data b => b -> b) -> TxOut -> TxOut
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TxOut -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TxOut -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TxOut -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TxOut -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TxOut -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TxOut -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TxOut -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TxOut -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TxOut -> m TxOut
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TxOut -> m TxOut
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TxOut -> m TxOut
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TxOut -> m TxOut
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TxOut -> m TxOut
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TxOut -> m TxOut
Data
    , Context -> TxOut -> IO (Maybe ThunkInfo)
Proxy TxOut -> String
(Context -> TxOut -> IO (Maybe ThunkInfo))
-> (Context -> TxOut -> IO (Maybe ThunkInfo))
-> (Proxy TxOut -> String)
-> NoThunks TxOut
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> TxOut -> IO (Maybe ThunkInfo)
noThunks :: Context -> TxOut -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> TxOut -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> TxOut -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy TxOut -> String
showTypeOf :: Proxy TxOut -> String
NoThunks
    )

-- | The unspent transaction outputs.
newtype UTxO = UTxO
  { UTxO -> Map TxIn TxOut
unUTxO :: Map TxIn TxOut
  }
  deriving stock (Int -> UTxO -> ShowS
[UTxO] -> ShowS
UTxO -> String
(Int -> UTxO -> ShowS)
-> (UTxO -> String) -> ([UTxO] -> ShowS) -> Show UTxO
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UTxO -> ShowS
showsPrec :: Int -> UTxO -> ShowS
$cshow :: UTxO -> String
show :: UTxO -> String
$cshowList :: [UTxO] -> ShowS
showList :: [UTxO] -> ShowS
Show, Typeable UTxO
Typeable UTxO =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> UTxO -> c UTxO)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c UTxO)
-> (UTxO -> Constr)
-> (UTxO -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c UTxO))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UTxO))
-> ((forall b. Data b => b -> b) -> UTxO -> UTxO)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UTxO -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UTxO -> r)
-> (forall u. (forall d. Data d => d -> u) -> UTxO -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> UTxO -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> UTxO -> m UTxO)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> UTxO -> m UTxO)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> UTxO -> m UTxO)
-> Data UTxO
UTxO -> Constr
UTxO -> DataType
(forall b. Data b => b -> b) -> UTxO -> UTxO
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> UTxO -> u
forall u. (forall d. Data d => d -> u) -> UTxO -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UTxO -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UTxO -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UTxO -> m UTxO
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UTxO -> m UTxO
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UTxO
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UTxO -> c UTxO
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UTxO)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UTxO)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UTxO -> c UTxO
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UTxO -> c UTxO
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UTxO
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UTxO
$ctoConstr :: UTxO -> Constr
toConstr :: UTxO -> Constr
$cdataTypeOf :: UTxO -> DataType
dataTypeOf :: UTxO -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UTxO)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UTxO)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UTxO)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UTxO)
$cgmapT :: (forall b. Data b => b -> b) -> UTxO -> UTxO
gmapT :: (forall b. Data b => b -> b) -> UTxO -> UTxO
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UTxO -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UTxO -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UTxO -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UTxO -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> UTxO -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> UTxO -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UTxO -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UTxO -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UTxO -> m UTxO
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UTxO -> m UTxO
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UTxO -> m UTxO
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UTxO -> m UTxO
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UTxO -> m UTxO
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UTxO -> m UTxO
Data)
  deriving newtype (UTxO -> UTxO -> Bool
(UTxO -> UTxO -> Bool) -> (UTxO -> UTxO -> Bool) -> Eq UTxO
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UTxO -> UTxO -> Bool
== :: UTxO -> UTxO -> Bool
$c/= :: UTxO -> UTxO -> Bool
/= :: UTxO -> UTxO -> Bool
Eq, (Ord (Domain UTxO), Ord (Range UTxO)) => UTxO -> UTxO -> UTxO
Ord (Domain UTxO) => Domain UTxO -> UTxO -> UTxO
Ord (Domain UTxO) => UTxO -> Set (Domain UTxO)
Ord (Range UTxO) => UTxO -> Set (Range UTxO)
Ord (Range UTxO) => UTxO -> Set (Range UTxO) -> UTxO
Ord (Range UTxO) => UTxO -> Range UTxO -> UTxO
Domain UTxO -> Range UTxO -> UTxO
(Domain UTxO -> Range UTxO -> UTxO)
-> (Ord (Domain UTxO) => UTxO -> Set (Domain UTxO))
-> (Ord (Range UTxO) => UTxO -> Set (Range UTxO))
-> (forall (f :: * -> *).
    (Ord (Domain UTxO), Foldable f) =>
    f (Domain UTxO) -> UTxO -> UTxO)
-> (forall (f :: * -> *).
    (Ord (Domain UTxO), Foldable f) =>
    f (Domain UTxO) -> UTxO -> UTxO)
-> (forall (f :: * -> *).
    (Ord (Domain UTxO), Foldable f) =>
    f (Domain UTxO) -> UTxO -> UTxO)
-> (forall (f :: * -> *).
    (Ord (Domain UTxO), Foldable f) =>
    f (Domain UTxO) -> UTxO -> UTxO)
-> (Ord (Range UTxO) => UTxO -> Set (Range UTxO) -> UTxO)
-> (Ord (Range UTxO) => UTxO -> Set (Range UTxO) -> UTxO)
-> (Ord (Range UTxO) => UTxO -> Set (Range UTxO) -> UTxO)
-> (Ord (Range UTxO) => UTxO -> Set (Range UTxO) -> UTxO)
-> ((Ord (Domain UTxO), Ord (Range UTxO)) => UTxO -> UTxO -> UTxO)
-> (forall (f :: * -> *).
    (Ord (Domain UTxO), Ord (Range UTxO), Foldable f) =>
    UTxO -> f (Domain UTxO, Range UTxO) -> UTxO)
-> (Ord (Domain UTxO) => Domain UTxO -> UTxO -> UTxO)
-> (Ord (Range UTxO) => UTxO -> Range UTxO -> UTxO)
-> (Ord (Range UTxO) => UTxO -> Range UTxO -> UTxO)
-> (forall n. Integral n => UTxO -> n)
-> Relation UTxO
forall n. Integral n => UTxO -> n
forall m.
(Domain m -> Range m -> m)
-> (Ord (Domain m) => m -> Set (Domain m))
-> (Ord (Range m) => m -> Set (Range m))
-> (forall (f :: * -> *).
    (Ord (Domain m), Foldable f) =>
    f (Domain m) -> m -> m)
-> (forall (f :: * -> *).
    (Ord (Domain m), Foldable f) =>
    f (Domain m) -> m -> m)
-> (forall (f :: * -> *).
    (Ord (Domain m), Foldable f) =>
    f (Domain m) -> m -> m)
-> (forall (f :: * -> *).
    (Ord (Domain m), Foldable f) =>
    f (Domain m) -> m -> m)
-> (Ord (Range m) => m -> Set (Range m) -> m)
-> (Ord (Range m) => m -> Set (Range m) -> m)
-> (Ord (Range m) => m -> Set (Range m) -> m)
-> (Ord (Range m) => m -> Set (Range m) -> m)
-> ((Ord (Domain m), Ord (Range m)) => m -> m -> m)
-> (forall (f :: * -> *).
    (Ord (Domain m), Ord (Range m), Foldable f) =>
    m -> f (Domain m, Range m) -> m)
-> (Ord (Domain m) => Domain m -> m -> m)
-> (Ord (Range m) => m -> Range m -> m)
-> (Ord (Range m) => m -> Range m -> m)
-> (forall n. Integral n => m -> n)
-> Relation m
forall (f :: * -> *).
(Ord (Domain UTxO), Ord (Range UTxO), Foldable f) =>
UTxO -> f (Domain UTxO, Range UTxO) -> UTxO
forall (f :: * -> *).
(Ord (Domain UTxO), Foldable f) =>
f (Domain UTxO) -> UTxO -> UTxO
$csingleton :: Domain UTxO -> Range UTxO -> UTxO
singleton :: Domain UTxO -> Range UTxO -> UTxO
$cdom :: Ord (Domain UTxO) => UTxO -> Set (Domain UTxO)
dom :: Ord (Domain UTxO) => UTxO -> Set (Domain UTxO)
$crange :: Ord (Range UTxO) => UTxO -> Set (Range UTxO)
range :: Ord (Range UTxO) => UTxO -> Set (Range UTxO)
$c◁ :: forall (f :: * -> *).
(Ord (Domain UTxO), Foldable f) =>
f (Domain UTxO) -> UTxO -> UTxO
◁ :: forall (f :: * -> *).
(Ord (Domain UTxO), Foldable f) =>
f (Domain UTxO) -> UTxO -> UTxO
$c<| :: forall (f :: * -> *).
(Ord (Domain UTxO), Foldable f) =>
f (Domain UTxO) -> UTxO -> UTxO
<| :: forall (f :: * -> *).
(Ord (Domain UTxO), Foldable f) =>
f (Domain UTxO) -> UTxO -> UTxO
$c⋪ :: forall (f :: * -> *).
(Ord (Domain UTxO), Foldable f) =>
f (Domain UTxO) -> UTxO -> UTxO
⋪ :: forall (f :: * -> *).
(Ord (Domain UTxO), Foldable f) =>
f (Domain UTxO) -> UTxO -> UTxO
$c</| :: forall (f :: * -> *).
(Ord (Domain UTxO), Foldable f) =>
f (Domain UTxO) -> UTxO -> UTxO
</| :: forall (f :: * -> *).
(Ord (Domain UTxO), Foldable f) =>
f (Domain UTxO) -> UTxO -> UTxO
$c▷ :: Ord (Range UTxO) => UTxO -> Set (Range UTxO) -> UTxO
▷ :: Ord (Range UTxO) => UTxO -> Set (Range UTxO) -> UTxO
$c|> :: Ord (Range UTxO) => UTxO -> Set (Range UTxO) -> UTxO
|> :: Ord (Range UTxO) => UTxO -> Set (Range UTxO) -> UTxO
$c⋫ :: Ord (Range UTxO) => UTxO -> Set (Range UTxO) -> UTxO
⋫ :: Ord (Range UTxO) => UTxO -> Set (Range UTxO) -> UTxO
$c|/> :: Ord (Range UTxO) => UTxO -> Set (Range UTxO) -> UTxO
|/> :: Ord (Range UTxO) => UTxO -> Set (Range UTxO) -> UTxO
$c∪ :: (Ord (Domain UTxO), Ord (Range UTxO)) => UTxO -> UTxO -> UTxO
∪ :: (Ord (Domain UTxO), Ord (Range UTxO)) => UTxO -> UTxO -> UTxO
$c⨃ :: forall (f :: * -> *).
(Ord (Domain UTxO), Ord (Range UTxO), Foldable f) =>
UTxO -> f (Domain UTxO, Range UTxO) -> UTxO
⨃ :: forall (f :: * -> *).
(Ord (Domain UTxO), Ord (Range UTxO), Foldable f) =>
UTxO -> f (Domain UTxO, Range UTxO) -> UTxO
$c<=◁ :: Ord (Domain UTxO) => Domain UTxO -> UTxO -> UTxO
<=◁ :: Ord (Domain UTxO) => Domain UTxO -> UTxO -> UTxO
$c▷<= :: Ord (Range UTxO) => UTxO -> Range UTxO -> UTxO
▷<= :: Ord (Range UTxO) => UTxO -> Range UTxO -> UTxO
$c▷>= :: Ord (Range UTxO) => UTxO -> Range UTxO -> UTxO
▷>= :: Ord (Range UTxO) => UTxO -> Range UTxO -> UTxO
$csize :: forall n. Integral n => UTxO -> n
size :: forall n. Integral n => UTxO -> n
Relation, NonEmpty UTxO -> UTxO
UTxO -> UTxO -> UTxO
(UTxO -> UTxO -> UTxO)
-> (NonEmpty UTxO -> UTxO)
-> (forall b. Integral b => b -> UTxO -> UTxO)
-> Semigroup UTxO
forall b. Integral b => b -> UTxO -> UTxO
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: UTxO -> UTxO -> UTxO
<> :: UTxO -> UTxO -> UTxO
$csconcat :: NonEmpty UTxO -> UTxO
sconcat :: NonEmpty UTxO -> UTxO
$cstimes :: forall b. Integral b => b -> UTxO -> UTxO
stimes :: forall b. Integral b => b -> UTxO -> UTxO
Semigroup, Semigroup UTxO
UTxO
Semigroup UTxO =>
UTxO -> (UTxO -> UTxO -> UTxO) -> ([UTxO] -> UTxO) -> Monoid UTxO
[UTxO] -> UTxO
UTxO -> UTxO -> UTxO
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
$cmempty :: UTxO
mempty :: UTxO
$cmappend :: UTxO -> UTxO -> UTxO
mappend :: UTxO -> UTxO -> UTxO
$cmconcat :: [UTxO] -> UTxO
mconcat :: [UTxO] -> UTxO
Monoid, Context -> UTxO -> IO (Maybe ThunkInfo)
Proxy UTxO -> String
(Context -> UTxO -> IO (Maybe ThunkInfo))
-> (Context -> UTxO -> IO (Maybe ThunkInfo))
-> (Proxy UTxO -> String)
-> NoThunks UTxO
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> UTxO -> IO (Maybe ThunkInfo)
noThunks :: Context -> UTxO -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> UTxO -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> UTxO -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy UTxO -> String
showTypeOf :: Proxy UTxO -> String
NoThunks)

-- | Apply function uniformly across all outputs
mapUTxOValues :: (Lovelace -> Lovelace) -> UTxO -> UTxO
mapUTxOValues :: (Lovelace -> Lovelace) -> UTxO -> UTxO
mapUTxOValues Lovelace -> Lovelace
f (UTxO Map TxIn TxOut
utxo) = Map TxIn TxOut -> UTxO
UTxO (TxOut -> TxOut
f' (TxOut -> TxOut) -> Map TxIn TxOut -> Map TxIn TxOut
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map TxIn TxOut
utxo)
  where
    f' :: TxOut -> TxOut
    f' :: TxOut -> TxOut
f' (TxOut Addr
addr Lovelace
value) = Addr -> Lovelace -> TxOut
TxOut Addr
addr (Lovelace -> Lovelace
f Lovelace
value)

addValue :: TxOut -> Lovelace -> TxOut
addValue :: TxOut -> Lovelace -> TxOut
addValue tx :: TxOut
tx@TxOut {Lovelace
value :: TxOut -> Lovelace
value :: Lovelace
value} Lovelace
d = TxOut
tx {value = value + d}

-- | Construct a UTxO from initial TxOuts
fromTxOuts :: [TxOut] -> UTxO
fromTxOuts :: [TxOut] -> UTxO
fromTxOuts = Map TxIn TxOut -> UTxO
UTxO (Map TxIn TxOut -> UTxO)
-> ([TxOut] -> Map TxIn TxOut) -> [TxOut] -> UTxO
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(TxIn, TxOut)] -> Map TxIn TxOut
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(TxIn, TxOut)] -> Map TxIn TxOut)
-> ([TxOut] -> [(TxIn, TxOut)]) -> [TxOut] -> Map TxIn TxOut
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TxOut -> (TxIn, TxOut)) -> [TxOut] -> [(TxIn, TxOut)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\TxOut
out -> (TxId -> Natural -> TxIn
TxIn (TxOut -> TxId
mkId TxOut
out) Natural
0, TxOut
out))
  where
    mkId :: TxOut -> TxId
mkId = Hash -> TxId
TxId (Hash -> TxId) -> (TxOut -> Hash) -> TxOut -> TxId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Addr -> Hash
forall a. HasHash a => a -> Hash
hash (Addr -> Hash) -> (TxOut -> Addr) -> TxOut -> Hash
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxOut -> Addr
addr

-- | A raw transaction
data TxBody = TxBody
  { TxBody -> [TxIn]
inputs :: [TxIn]
  , TxBody -> [TxOut]
outputs :: [TxOut]
  }
  deriving
    ( TxBody -> TxBody -> Bool
(TxBody -> TxBody -> Bool)
-> (TxBody -> TxBody -> Bool) -> Eq TxBody
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TxBody -> TxBody -> Bool
== :: TxBody -> TxBody -> Bool
$c/= :: TxBody -> TxBody -> Bool
/= :: TxBody -> TxBody -> Bool
Eq
    , Int -> TxBody -> ShowS
[TxBody] -> ShowS
TxBody -> String
(Int -> TxBody -> ShowS)
-> (TxBody -> String) -> ([TxBody] -> ShowS) -> Show TxBody
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TxBody -> ShowS
showsPrec :: Int -> TxBody -> ShowS
$cshow :: TxBody -> String
show :: TxBody -> String
$cshowList :: [TxBody] -> ShowS
showList :: [TxBody] -> ShowS
Show
    , Eq TxBody
Eq TxBody =>
(TxBody -> TxBody -> Ordering)
-> (TxBody -> TxBody -> Bool)
-> (TxBody -> TxBody -> Bool)
-> (TxBody -> TxBody -> Bool)
-> (TxBody -> TxBody -> Bool)
-> (TxBody -> TxBody -> TxBody)
-> (TxBody -> TxBody -> TxBody)
-> Ord TxBody
TxBody -> TxBody -> Bool
TxBody -> TxBody -> Ordering
TxBody -> TxBody -> TxBody
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TxBody -> TxBody -> Ordering
compare :: TxBody -> TxBody -> Ordering
$c< :: TxBody -> TxBody -> Bool
< :: TxBody -> TxBody -> Bool
$c<= :: TxBody -> TxBody -> Bool
<= :: TxBody -> TxBody -> Bool
$c> :: TxBody -> TxBody -> Bool
> :: TxBody -> TxBody -> Bool
$c>= :: TxBody -> TxBody -> Bool
>= :: TxBody -> TxBody -> Bool
$cmax :: TxBody -> TxBody -> TxBody
max :: TxBody -> TxBody -> TxBody
$cmin :: TxBody -> TxBody -> TxBody
min :: TxBody -> TxBody -> TxBody
Ord
    , (forall x. TxBody -> Rep TxBody x)
-> (forall x. Rep TxBody x -> TxBody) -> Generic TxBody
forall x. Rep TxBody x -> TxBody
forall x. TxBody -> Rep TxBody x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TxBody -> Rep TxBody x
from :: forall x. TxBody -> Rep TxBody x
$cto :: forall x. Rep TxBody x -> TxBody
to :: forall x. Rep TxBody x -> TxBody
Generic
    , Eq TxBody
Eq TxBody =>
(Int -> TxBody -> Int) -> (TxBody -> Int) -> Hashable TxBody
Int -> TxBody -> Int
TxBody -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> TxBody -> Int
hashWithSalt :: Int -> TxBody -> Int
$chash :: TxBody -> Int
hash :: TxBody -> Int
Hashable
    , TxBody -> Seq TypeRep
(TxBody -> Seq TypeRep) -> HasTypeReps TxBody
forall a. (a -> Seq TypeRep) -> HasTypeReps a
$ctypeReps :: TxBody -> Seq TypeRep
typeReps :: TxBody -> Seq TypeRep
HasTypeReps
    , Typeable TxBody
Typeable TxBody =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TxBody -> c TxBody)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TxBody)
-> (TxBody -> Constr)
-> (TxBody -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TxBody))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TxBody))
-> ((forall b. Data b => b -> b) -> TxBody -> TxBody)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TxBody -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TxBody -> r)
-> (forall u. (forall d. Data d => d -> u) -> TxBody -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TxBody -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TxBody -> m TxBody)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TxBody -> m TxBody)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TxBody -> m TxBody)
-> Data TxBody
TxBody -> Constr
TxBody -> DataType
(forall b. Data b => b -> b) -> TxBody -> TxBody
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> TxBody -> u
forall u. (forall d. Data d => d -> u) -> TxBody -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TxBody -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TxBody -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TxBody -> m TxBody
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TxBody -> m TxBody
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TxBody
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TxBody -> c TxBody
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TxBody)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TxBody)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TxBody -> c TxBody
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TxBody -> c TxBody
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TxBody
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TxBody
$ctoConstr :: TxBody -> Constr
toConstr :: TxBody -> Constr
$cdataTypeOf :: TxBody -> DataType
dataTypeOf :: TxBody -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TxBody)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TxBody)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TxBody)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TxBody)
$cgmapT :: (forall b. Data b => b -> b) -> TxBody -> TxBody
gmapT :: (forall b. Data b => b -> b) -> TxBody -> TxBody
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TxBody -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TxBody -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TxBody -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TxBody -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TxBody -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TxBody -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TxBody -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TxBody -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TxBody -> m TxBody
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TxBody -> m TxBody
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TxBody -> m TxBody
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TxBody -> m TxBody
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TxBody -> m TxBody
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TxBody -> m TxBody
Data
    , Context -> TxBody -> IO (Maybe ThunkInfo)
Proxy TxBody -> String
(Context -> TxBody -> IO (Maybe ThunkInfo))
-> (Context -> TxBody -> IO (Maybe ThunkInfo))
-> (Proxy TxBody -> String)
-> NoThunks TxBody
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> TxBody -> IO (Maybe ThunkInfo)
noThunks :: Context -> TxBody -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> TxBody -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> TxBody -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy TxBody -> String
showTypeOf :: Proxy TxBody -> String
NoThunks
    )

txid :: TxBody -> TxId
txid :: TxBody -> TxId
txid = Hash -> TxId
TxId (Hash -> TxId) -> (TxBody -> Hash) -> TxBody -> TxId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxBody -> Hash
forall a. HasHash a => a -> Hash
hash

-- | Total value of a transaction.
txValue :: TxBody -> Lovelace
txValue :: TxBody -> Lovelace
txValue TxBody {[TxOut]
outputs :: TxBody -> [TxOut]
outputs :: [TxOut]
outputs} = [Lovelace] -> Lovelace
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Lovelace] -> Lovelace) -> [Lovelace] -> Lovelace
forall a b. (a -> b) -> a -> b
$ (TxOut -> Lovelace) -> [TxOut] -> [Lovelace]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap TxOut -> Lovelace
value [TxOut]
outputs

-- | Compute the UTxO inputs of a transaction.
txins :: TxBody -> [TxIn]
txins :: TxBody -> [TxIn]
txins = TxBody -> [TxIn]
inputs

-- | Compute the UTxO outputs of a transaction.
txouts :: TxBody -> UTxO
txouts :: TxBody -> UTxO
txouts TxBody
tx =
  Map TxIn TxOut -> UTxO
UTxO (Map TxIn TxOut -> UTxO) -> Map TxIn TxOut -> UTxO
forall a b. (a -> b) -> a -> b
$
    [(TxIn, TxOut)] -> Map TxIn TxOut
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
      [(TxId -> Natural -> TxIn
TxIn TxId
transId Natural
idx, TxOut
out) | (TxOut
out, Natural
idx) <- [TxOut] -> [Natural] -> [(TxOut, Natural)]
forall a b. [a] -> [b] -> [(a, b)]
zip (TxBody -> [TxOut]
outputs TxBody
tx) [Natural
0 ..]]
  where
    transId :: TxId
transId = TxBody -> TxId
txid TxBody
tx

-- | Determine the total balance contained in the UTxO.
balance :: UTxO -> Lovelace
balance :: UTxO -> Lovelace
balance (UTxO Map TxIn TxOut
utxo) = (Lovelace -> TxOut -> Lovelace)
-> Lovelace -> Map TxIn TxOut -> Lovelace
forall a b k. (a -> b -> a) -> a -> Map k b -> a
Map.foldl' Lovelace -> TxOut -> Lovelace
addValues Lovelace
forall a. Monoid a => a
mempty Map TxIn TxOut
utxo
  where
    addValues :: Lovelace -> TxOut -> Lovelace
addValues Lovelace
b (TxOut Addr
_ Lovelace
a) = Lovelace
b Lovelace -> Lovelace -> Lovelace
forall a. Semigroup a => a -> a -> a
<> Lovelace
a

instance Byron.Spec.Ledger.Core.HasHash TxBody where
  hash :: TxBody -> Hash
hash = Maybe Int -> Hash
Hash (Maybe Int -> Hash) -> (TxBody -> Maybe Int) -> TxBody -> Hash
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Maybe Int
forall a. a -> Maybe a
Just (Int -> Maybe Int) -> (TxBody -> Int) -> TxBody -> Maybe Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxBody -> Int
forall a. Hashable a => a -> Int
H.hash

---------------------------------------------------------------------------------
-- UTxO transitions
---------------------------------------------------------------------------------

pcMinFee :: PParams -> Tx -> Lovelace
pcMinFee :: PParams -> Tx -> Lovelace
pcMinFee PParams {_factorA :: PParams -> FactorA
_factorA = FactorA Int
a, _factorB :: PParams -> FactorB
_factorB = FactorB Int
b} Tx
tx =
  Int -> Lovelace
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Lovelace) -> Int -> Lovelace
forall a b. (a -> b) -> a -> b
$ Int
a Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
b Int -> Int -> Int
forall a. Num a => a -> a -> a
* Tx -> Int
txsize Tx
tx

txsize :: Tx -> Int
txsize :: Tx -> Int
txsize = AccountingMap -> Tx -> Int
forall a. HasTypeReps a => AccountingMap -> a -> Int
abstractSize AccountingMap
costs
  where
    costs :: AccountingMap
costs =
      [(TypeRep, Int)] -> AccountingMap
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
        [ (TxIn -> TypeRep
forall a. Typeable a => a -> TypeRep
typeOf (TxIn
forall a. HasCallStack => a
undefined :: TxIn), Int
1)
        , (TxOut -> TypeRep
forall a. Typeable a => a -> TypeRep
typeOf (TxOut
forall a. HasCallStack => a
undefined :: TxOut), Int
1)
        , (Wit -> TypeRep
forall a. Typeable a => a -> TypeRep
typeOf (Wit
forall a. HasCallStack => a
undefined :: Wit), Int
1)
        ]

---------------------------------------------------------------------------------
-- UTxO transitions
---------------------------------------------------------------------------------

-- | Proof/Witness that a transaction is authorized by the given key holder.
data Wit = Wit VKey (Sig TxBody)
  deriving
    ( Int -> Wit -> ShowS
[Wit] -> ShowS
Wit -> String
(Int -> Wit -> ShowS)
-> (Wit -> String) -> ([Wit] -> ShowS) -> Show Wit
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Wit -> ShowS
showsPrec :: Int -> Wit -> ShowS
$cshow :: Wit -> String
show :: Wit -> String
$cshowList :: [Wit] -> ShowS
showList :: [Wit] -> ShowS
Show
    , Wit -> Wit -> Bool
(Wit -> Wit -> Bool) -> (Wit -> Wit -> Bool) -> Eq Wit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Wit -> Wit -> Bool
== :: Wit -> Wit -> Bool
$c/= :: Wit -> Wit -> Bool
/= :: Wit -> Wit -> Bool
Eq
    , Eq Wit
Eq Wit =>
(Wit -> Wit -> Ordering)
-> (Wit -> Wit -> Bool)
-> (Wit -> Wit -> Bool)
-> (Wit -> Wit -> Bool)
-> (Wit -> Wit -> Bool)
-> (Wit -> Wit -> Wit)
-> (Wit -> Wit -> Wit)
-> Ord Wit
Wit -> Wit -> Bool
Wit -> Wit -> Ordering
Wit -> Wit -> Wit
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Wit -> Wit -> Ordering
compare :: Wit -> Wit -> Ordering
$c< :: Wit -> Wit -> Bool
< :: Wit -> Wit -> Bool
$c<= :: Wit -> Wit -> Bool
<= :: Wit -> Wit -> Bool
$c> :: Wit -> Wit -> Bool
> :: Wit -> Wit -> Bool
$c>= :: Wit -> Wit -> Bool
>= :: Wit -> Wit -> Bool
$cmax :: Wit -> Wit -> Wit
max :: Wit -> Wit -> Wit
$cmin :: Wit -> Wit -> Wit
min :: Wit -> Wit -> Wit
Ord
    , (forall x. Wit -> Rep Wit x)
-> (forall x. Rep Wit x -> Wit) -> Generic Wit
forall x. Rep Wit x -> Wit
forall x. Wit -> Rep Wit x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Wit -> Rep Wit x
from :: forall x. Wit -> Rep Wit x
$cto :: forall x. Rep Wit x -> Wit
to :: forall x. Rep Wit x -> Wit
Generic
    , Eq Wit
Eq Wit => (Int -> Wit -> Int) -> (Wit -> Int) -> Hashable Wit
Int -> Wit -> Int
Wit -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> Wit -> Int
hashWithSalt :: Int -> Wit -> Int
$chash :: Wit -> Int
hash :: Wit -> Int
Hashable
    , Wit -> Seq TypeRep
(Wit -> Seq TypeRep) -> HasTypeReps Wit
forall a. (a -> Seq TypeRep) -> HasTypeReps a
$ctypeReps :: Wit -> Seq TypeRep
typeReps :: Wit -> Seq TypeRep
HasTypeReps
    , Typeable Wit
Typeable Wit =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Wit -> c Wit)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Wit)
-> (Wit -> Constr)
-> (Wit -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Wit))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Wit))
-> ((forall b. Data b => b -> b) -> Wit -> Wit)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Wit -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Wit -> r)
-> (forall u. (forall d. Data d => d -> u) -> Wit -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Wit -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Wit -> m Wit)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Wit -> m Wit)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Wit -> m Wit)
-> Data Wit
Wit -> Constr
Wit -> DataType
(forall b. Data b => b -> b) -> Wit -> Wit
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Wit -> u
forall u. (forall d. Data d => d -> u) -> Wit -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Wit -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Wit -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Wit -> m Wit
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Wit -> m Wit
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Wit
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Wit -> c Wit
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Wit)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Wit)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Wit -> c Wit
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Wit -> c Wit
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Wit
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Wit
$ctoConstr :: Wit -> Constr
toConstr :: Wit -> Constr
$cdataTypeOf :: Wit -> DataType
dataTypeOf :: Wit -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Wit)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Wit)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Wit)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Wit)
$cgmapT :: (forall b. Data b => b -> b) -> Wit -> Wit
gmapT :: (forall b. Data b => b -> b) -> Wit -> Wit
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Wit -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Wit -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Wit -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Wit -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Wit -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Wit -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Wit -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Wit -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Wit -> m Wit
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Wit -> m Wit
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Wit -> m Wit
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Wit -> m Wit
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Wit -> m Wit
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Wit -> m Wit
Data
    , Context -> Wit -> IO (Maybe ThunkInfo)
Proxy Wit -> String
(Context -> Wit -> IO (Maybe ThunkInfo))
-> (Context -> Wit -> IO (Maybe ThunkInfo))
-> (Proxy Wit -> String)
-> NoThunks Wit
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> Wit -> IO (Maybe ThunkInfo)
noThunks :: Context -> Wit -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> Wit -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> Wit -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy Wit -> String
showTypeOf :: Proxy Wit -> String
NoThunks
    )

-- | A fully formed transaction.
data Tx = Tx
  { Tx -> TxBody
body :: TxBody
  , Tx -> [Wit]
witnesses :: [Wit]
  }
  deriving
    ( Int -> Tx -> ShowS
[Tx] -> ShowS
Tx -> String
(Int -> Tx -> ShowS)
-> (Tx -> String) -> ([Tx] -> ShowS) -> Show Tx
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Tx -> ShowS
showsPrec :: Int -> Tx -> ShowS
$cshow :: Tx -> String
show :: Tx -> String
$cshowList :: [Tx] -> ShowS
showList :: [Tx] -> ShowS
Show
    , Tx -> Tx -> Bool
(Tx -> Tx -> Bool) -> (Tx -> Tx -> Bool) -> Eq Tx
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Tx -> Tx -> Bool
== :: Tx -> Tx -> Bool
$c/= :: Tx -> Tx -> Bool
/= :: Tx -> Tx -> Bool
Eq
    , (forall x. Tx -> Rep Tx x)
-> (forall x. Rep Tx x -> Tx) -> Generic Tx
forall x. Rep Tx x -> Tx
forall x. Tx -> Rep Tx x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Tx -> Rep Tx x
from :: forall x. Tx -> Rep Tx x
$cto :: forall x. Rep Tx x -> Tx
to :: forall x. Rep Tx x -> Tx
Generic
    , Eq Tx
Eq Tx => (Int -> Tx -> Int) -> (Tx -> Int) -> Hashable Tx
Int -> Tx -> Int
Tx -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> Tx -> Int
hashWithSalt :: Int -> Tx -> Int
$chash :: Tx -> Int
hash :: Tx -> Int
Hashable
    , Tx -> Seq TypeRep
(Tx -> Seq TypeRep) -> HasTypeReps Tx
forall a. (a -> Seq TypeRep) -> HasTypeReps a
$ctypeReps :: Tx -> Seq TypeRep
typeReps :: Tx -> Seq TypeRep
HasTypeReps
    , Typeable Tx
Typeable Tx =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Tx -> c Tx)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Tx)
-> (Tx -> Constr)
-> (Tx -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Tx))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tx))
-> ((forall b. Data b => b -> b) -> Tx -> Tx)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tx -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tx -> r)
-> (forall u. (forall d. Data d => d -> u) -> Tx -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Tx -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Tx -> m Tx)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Tx -> m Tx)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Tx -> m Tx)
-> Data Tx
Tx -> Constr
Tx -> DataType
(forall b. Data b => b -> b) -> Tx -> Tx
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Tx -> u
forall u. (forall d. Data d => d -> u) -> Tx -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tx -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tx -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Tx -> m Tx
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tx -> m Tx
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Tx
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tx -> c Tx
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Tx)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tx)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tx -> c Tx
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tx -> c Tx
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Tx
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Tx
$ctoConstr :: Tx -> Constr
toConstr :: Tx -> Constr
$cdataTypeOf :: Tx -> DataType
dataTypeOf :: Tx -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Tx)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Tx)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tx)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tx)
$cgmapT :: (forall b. Data b => b -> b) -> Tx -> Tx
gmapT :: (forall b. Data b => b -> b) -> Tx -> Tx
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tx -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tx -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tx -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tx -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Tx -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Tx -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Tx -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Tx -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Tx -> m Tx
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Tx -> m Tx
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tx -> m Tx
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tx -> m Tx
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tx -> m Tx
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tx -> m Tx
Data
    , Context -> Tx -> IO (Maybe ThunkInfo)
Proxy Tx -> String
(Context -> Tx -> IO (Maybe ThunkInfo))
-> (Context -> Tx -> IO (Maybe ThunkInfo))
-> (Proxy Tx -> String)
-> NoThunks Tx
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> Tx -> IO (Maybe ThunkInfo)
noThunks :: Context -> Tx -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> Tx -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> Tx -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy Tx -> String
showTypeOf :: Proxy Tx -> String
NoThunks
    )

instance HasHash [Tx] where
  hash :: [Tx] -> Hash
hash = Maybe Int -> Hash
Hash (Maybe Int -> Hash) -> ([Tx] -> Maybe Int) -> [Tx] -> Hash
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Maybe Int
forall a. a -> Maybe a
Just (Int -> Maybe Int) -> ([Tx] -> Int) -> [Tx] -> Maybe Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Tx] -> Int
forall a. Hashable a => a -> Int
H.hash

-- | Create a witness for transaction
makeWitness :: KeyPair -> TxBody -> Wit
makeWitness :: KeyPair -> TxBody -> Wit
makeWitness KeyPair
keys TxBody
tx = VKey -> Sig TxBody -> Wit
Wit (KeyPair -> VKey
vKey KeyPair
keys) (SKey -> TxBody -> Sig TxBody
forall a. SKey -> a -> Sig a
sign (KeyPair -> SKey
sKey KeyPair
keys) TxBody
tx)

makeTxWits :: UTxO -> TxBody -> Tx
makeTxWits :: UTxO -> TxBody -> Tx
makeTxWits (UTxO Map TxIn TxOut
utxo) TxBody
tx =
  Tx
    { body :: TxBody
body = TxBody
tx
    , witnesses :: [Wit]
witnesses = [Wit]
wits
    }
  where
    getKey :: TxIn -> KeyPair
getKey TxIn
txin =
      let TxOut (Addr (VKey Owner
o)) Lovelace
_ =
            TxOut -> Maybe TxOut -> TxOut
forall a. a -> Maybe a -> a
fromMaybe
              (String -> TxOut
forall a. HasCallStack => String -> a
error String
"makeTxWits: Missing output for transaction input")
              (Maybe TxOut -> TxOut) -> Maybe TxOut -> TxOut
forall a b. (a -> b) -> a -> b
$ TxIn -> Map TxIn TxOut -> Maybe TxOut
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup TxIn
txin Map TxIn TxOut
utxo
       in SKey -> VKey -> KeyPair
KeyPair (Owner -> SKey
SKey Owner
o) (Owner -> VKey
VKey Owner
o)
    keys :: [KeyPair]
keys = TxIn -> KeyPair
getKey (TxIn -> KeyPair) -> [TxIn] -> [KeyPair]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TxBody -> [TxIn]
inputs TxBody
tx
    wits :: [Wit]
wits = KeyPair -> TxBody -> Wit
makeWitness (KeyPair -> TxBody -> Wit) -> [KeyPair] -> [TxBody -> Wit]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [KeyPair]
keys [TxBody -> Wit] -> [TxBody] -> [Wit]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TxBody -> [TxBody]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure TxBody
tx