{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoImplicitPrelude #-}

module Cardano.Api.UTxO
  ( -- * UTxO type
    UTxO (..)

    -- * Operators
  , (\\)

    -- * Query
  , lookup
  , resolveTxIn

    -- * Construction
  , empty
  , singleton

    -- ** Insertion
  , insert

    -- ** Delete/Update
  , delete
  , adjust

    -- * Combine

    -- ** Union
  , union
  , unions

    -- ** Difference
  , difference

    -- ** Intersection
  , intersection

    -- * Traversal

    -- ** Map
  , map
  , mapWithKey
  , mapKeys

    -- ** Fold
  , foldMap

    -- * Conversion
  , inputSet
  , txOutputs

    -- ** Lists
  , fromList
  , toList

    -- ** Maps
  , toMap
  , fromMap

    -- ** Shelley
  , fromShelleyUTxO
  , toShelleyUTxO

    -- * Filter
  , Cardano.Api.UTxO.filter
  , filterWithKey

    -- * Find
  , find
  , findWithKey
  )
where

import Cardano.Api.Era.Internal.Core (IsCardanoEra)
import Cardano.Api.Era.Internal.Eon.ShelleyBasedEra
  ( IsShelleyBasedEra
  , ShelleyBasedEra
  , ShelleyLedgerEra
  )
import Cardano.Api.Tx.Internal.Output (CtxUTxO, TxOut (..), fromShelleyTxOut, toShelleyTxOut)
import Cardano.Api.Tx.Internal.TxIn (TxIn (..), fromShelleyTxIn, toShelleyTxIn)

import Cardano.Ledger.Babbage ()
import Cardano.Ledger.Shelley.UTxO qualified as Ledger

import Prelude qualified

import Control.Applicative hiding (empty)
import Control.Monad
import Data.Aeson (FromJSON (..), ToJSON (..))
import Data.Aeson qualified as Aeson
import Data.Aeson.KeyMap qualified as KeyMap
import Data.Aeson.Types (Parser)
import Data.Bool
import Data.Eq
import Data.Function
import Data.List qualified
import Data.Map (Map)
import Data.Map qualified as Map
import Data.Maybe
import Data.MonoTraversable
import Data.Monoid
import Data.Semigroup
import Data.Set (Set)
import Data.Text (Text)
import Data.Tuple (uncurry)
import GHC.Exts qualified as GHC
import Text.Show

newtype UTxO era = UTxO {forall era. UTxO era -> Map TxIn (TxOut CtxUTxO era)
unUTxO :: Map TxIn (TxOut CtxUTxO era)}
  deriving stock (UTxO era -> UTxO era -> Bool
(UTxO era -> UTxO era -> Bool)
-> (UTxO era -> UTxO era -> Bool) -> Eq (UTxO era)
forall era. UTxO era -> UTxO era -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall era. UTxO era -> UTxO era -> Bool
== :: UTxO era -> UTxO era -> Bool
$c/= :: forall era. UTxO era -> UTxO era -> Bool
/= :: UTxO era -> UTxO era -> Bool
Eq, Int -> UTxO era -> ShowS
[UTxO era] -> ShowS
UTxO era -> String
(Int -> UTxO era -> ShowS)
-> (UTxO era -> String) -> ([UTxO era] -> ShowS) -> Show (UTxO era)
forall era. Int -> UTxO era -> ShowS
forall era. [UTxO era] -> ShowS
forall era. UTxO era -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall era. Int -> UTxO era -> ShowS
showsPrec :: Int -> UTxO era -> ShowS
$cshow :: forall era. UTxO era -> String
show :: UTxO era -> String
$cshowList :: forall era. [UTxO era] -> ShowS
showList :: [UTxO era] -> ShowS
Show)
  deriving newtype (NonEmpty (UTxO era) -> UTxO era
UTxO era -> UTxO era -> UTxO era
(UTxO era -> UTxO era -> UTxO era)
-> (NonEmpty (UTxO era) -> UTxO era)
-> (forall b. Integral b => b -> UTxO era -> UTxO era)
-> Semigroup (UTxO era)
forall b. Integral b => b -> UTxO era -> UTxO era
forall era. NonEmpty (UTxO era) -> UTxO era
forall era. UTxO era -> UTxO era -> UTxO era
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall era b. Integral b => b -> UTxO era -> UTxO era
$c<> :: forall era. UTxO era -> UTxO era -> UTxO era
<> :: UTxO era -> UTxO era -> UTxO era
$csconcat :: forall era. NonEmpty (UTxO era) -> UTxO era
sconcat :: NonEmpty (UTxO era) -> UTxO era
$cstimes :: forall era b. Integral b => b -> UTxO era -> UTxO era
stimes :: forall b. Integral b => b -> UTxO era -> UTxO era
Semigroup, Semigroup (UTxO era)
UTxO era
Semigroup (UTxO era) =>
UTxO era
-> (UTxO era -> UTxO era -> UTxO era)
-> ([UTxO era] -> UTxO era)
-> Monoid (UTxO era)
[UTxO era] -> UTxO era
UTxO era -> UTxO era -> UTxO era
forall era. Semigroup (UTxO era)
forall era. UTxO era
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall era. [UTxO era] -> UTxO era
forall era. UTxO era -> UTxO era -> UTxO era
$cmempty :: forall era. UTxO era
mempty :: UTxO era
$cmappend :: forall era. UTxO era -> UTxO era -> UTxO era
mappend :: UTxO era -> UTxO era -> UTxO era
$cmconcat :: forall era. [UTxO era] -> UTxO era
mconcat :: [UTxO era] -> UTxO era
Monoid)

instance GHC.IsList (UTxO era) where
  type Item (UTxO era) = (TxIn, TxOut CtxUTxO era)
  fromList :: [Item (UTxO era)] -> UTxO era
fromList = Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall era. Map TxIn (TxOut CtxUTxO era) -> UTxO era
UTxO (Map TxIn (TxOut CtxUTxO era) -> UTxO era)
-> ([(TxIn, TxOut CtxUTxO era)] -> Map TxIn (TxOut CtxUTxO era))
-> [(TxIn, TxOut CtxUTxO era)]
-> UTxO era
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(TxIn, TxOut CtxUTxO era)] -> Map TxIn (TxOut CtxUTxO era)
[Item (Map TxIn (TxOut CtxUTxO era))]
-> Map TxIn (TxOut CtxUTxO era)
forall l. IsList l => [Item l] -> l
GHC.fromList
  toList :: UTxO era -> [Item (UTxO era)]
toList = Map TxIn (TxOut CtxUTxO era) -> [(TxIn, TxOut CtxUTxO era)]
Map TxIn (TxOut CtxUTxO era)
-> [Item (Map TxIn (TxOut CtxUTxO era))]
forall l. IsList l => l -> [Item l]
GHC.toList (Map TxIn (TxOut CtxUTxO era) -> [(TxIn, TxOut CtxUTxO era)])
-> (UTxO era -> Map TxIn (TxOut CtxUTxO era))
-> UTxO era
-> [(TxIn, TxOut CtxUTxO era)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTxO era -> Map TxIn (TxOut CtxUTxO era)
forall era. UTxO era -> Map TxIn (TxOut CtxUTxO era)
unUTxO

instance IsCardanoEra era => ToJSON (UTxO era) where
  toJSON :: UTxO era -> Value
toJSON (UTxO Map TxIn (TxOut CtxUTxO era)
m) = Map TxIn (TxOut CtxUTxO era) -> Value
forall a. ToJSON a => a -> Value
toJSON Map TxIn (TxOut CtxUTxO era)
m
  toEncoding :: UTxO era -> Encoding
toEncoding (UTxO Map TxIn (TxOut CtxUTxO era)
m) = Map TxIn (TxOut CtxUTxO era) -> Encoding
forall a. ToJSON a => a -> Encoding
toEncoding Map TxIn (TxOut CtxUTxO era)
m

instance IsShelleyBasedEra era => FromJSON (UTxO era) where
  parseJSON :: Value -> Parser (UTxO era)
parseJSON = String
-> (Object -> Parser (UTxO era)) -> Value -> Parser (UTxO era)
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Aeson.withObject String
"UTxO" ((Object -> Parser (UTxO era)) -> Value -> Parser (UTxO era))
-> (Object -> Parser (UTxO era)) -> Value -> Parser (UTxO era)
forall a b. (a -> b) -> a -> b
$ \Object
hm -> do
    let l :: [Item (HashMap Text Value)]
l = HashMap Text Value -> [Item (HashMap Text Value)]
forall l. IsList l => l -> [Item l]
GHC.toList (HashMap Text Value -> [Item (HashMap Text Value)])
-> HashMap Text Value -> [Item (HashMap Text Value)]
forall a b. (a -> b) -> a -> b
$ Object -> HashMap Text Value
forall v. KeyMap v -> HashMap Text v
KeyMap.toHashMapText Object
hm
    [(TxIn, TxOut CtxUTxO era)]
res <- ((Text, Value) -> Parser (TxIn, TxOut CtxUTxO era))
-> [(Text, Value)] -> Parser [(TxIn, TxOut CtxUTxO era)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (Text, Value) -> Parser (TxIn, TxOut CtxUTxO era)
toTxIn [(Text, Value)]
[Item (HashMap Text Value)]
l
    UTxO era -> Parser (UTxO era)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (UTxO era -> Parser (UTxO era))
-> (Map TxIn (TxOut CtxUTxO era) -> UTxO era)
-> Map TxIn (TxOut CtxUTxO era)
-> Parser (UTxO era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall era. Map TxIn (TxOut CtxUTxO era) -> UTxO era
UTxO (Map TxIn (TxOut CtxUTxO era) -> Parser (UTxO era))
-> Map TxIn (TxOut CtxUTxO era) -> Parser (UTxO era)
forall a b. (a -> b) -> a -> b
$ [(TxIn, TxOut CtxUTxO era)] -> Map TxIn (TxOut CtxUTxO era)
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(TxIn, TxOut CtxUTxO era)]
res
   where
    toTxIn :: (Text, Aeson.Value) -> Parser (TxIn, TxOut CtxUTxO era)
    toTxIn :: (Text, Value) -> Parser (TxIn, TxOut CtxUTxO era)
toTxIn (Text
txinText, Value
txOutVal) = do
      (,)
        (TxIn -> TxOut CtxUTxO era -> (TxIn, TxOut CtxUTxO era))
-> Parser TxIn
-> Parser (TxOut CtxUTxO era -> (TxIn, TxOut CtxUTxO era))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser TxIn
forall a. FromJSON a => Value -> Parser a
parseJSON (Text -> Value
Aeson.String Text
txinText)
        Parser (TxOut CtxUTxO era -> (TxIn, TxOut CtxUTxO era))
-> Parser (TxOut CtxUTxO era) -> Parser (TxIn, TxOut CtxUTxO era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Value -> Parser (TxOut CtxUTxO era)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
txOutVal

type instance Element (UTxO era) = TxOut CtxUTxO era

instance MonoFunctor (UTxO era) where
  omap :: (Element (UTxO era) -> Element (UTxO era)) -> UTxO era -> UTxO era
omap Element (UTxO era) -> Element (UTxO era)
f (UTxO Map TxIn (TxOut CtxUTxO era)
utxos) = Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall era. Map TxIn (TxOut CtxUTxO era) -> UTxO era
UTxO (Map TxIn (TxOut CtxUTxO era) -> UTxO era)
-> Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall a b. (a -> b) -> a -> b
$ Element (UTxO era) -> Element (UTxO era)
TxOut CtxUTxO era -> TxOut CtxUTxO era
f (TxOut CtxUTxO era -> TxOut CtxUTxO era)
-> Map TxIn (TxOut CtxUTxO era) -> Map TxIn (TxOut CtxUTxO era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map TxIn (TxOut CtxUTxO era)
utxos

deriving newtype instance MonoFoldable (UTxO era)

instance MonoTraversable (UTxO era) where
  otraverse :: forall (f :: * -> *).
Applicative f =>
(Element (UTxO era) -> f (Element (UTxO era)))
-> UTxO era -> f (UTxO era)
otraverse = (Element (UTxO era) -> f (Element (UTxO era)))
-> UTxO era -> f (UTxO era)
forall mono (f :: * -> *).
(MonoTraversable mono, Applicative f) =>
(Element mono -> f (Element mono)) -> mono -> f mono
forall (f :: * -> *).
Applicative f =>
(Element (UTxO era) -> f (Element (UTxO era)))
-> UTxO era -> f (UTxO era)
omapM
  omapM :: forall (f :: * -> *).
Applicative f =>
(Element (UTxO era) -> f (Element (UTxO era)))
-> UTxO era -> f (UTxO era)
omapM Element (UTxO era) -> m (Element (UTxO era))
f (UTxO Map TxIn (TxOut CtxUTxO era)
utxos) = Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall era. Map TxIn (TxOut CtxUTxO era) -> UTxO era
UTxO (Map TxIn (TxOut CtxUTxO era) -> UTxO era)
-> m (Map TxIn (TxOut CtxUTxO era)) -> m (UTxO era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Element (Map TxIn (TxOut CtxUTxO era))
 -> m (Element (Map TxIn (TxOut CtxUTxO era))))
-> Map TxIn (TxOut CtxUTxO era) -> m (Map TxIn (TxOut CtxUTxO era))
forall mono (f :: * -> *).
(MonoTraversable mono, Applicative f) =>
(Element mono -> f (Element mono)) -> mono -> f mono
forall (m :: * -> *).
Applicative m =>
(Element (Map TxIn (TxOut CtxUTxO era))
 -> m (Element (Map TxIn (TxOut CtxUTxO era))))
-> Map TxIn (TxOut CtxUTxO era) -> m (Map TxIn (TxOut CtxUTxO era))
omapM Element (Map TxIn (TxOut CtxUTxO era))
-> m (Element (Map TxIn (TxOut CtxUTxO era)))
Element (UTxO era) -> m (Element (UTxO era))
f Map TxIn (TxOut CtxUTxO era)
utxos

{--------------------------------------------------------------------
  Operators
--------------------------------------------------------------------}

-- | Infix version of `difference`.
(\\) :: UTxO era -> UTxO era -> UTxO era
UTxO era
a \\ :: forall era. UTxO era -> UTxO era -> UTxO era
\\ UTxO era
b = UTxO era -> UTxO era -> UTxO era
forall era. UTxO era -> UTxO era -> UTxO era
difference UTxO era
a UTxO era
b

{--------------------------------------------------------------------
  Query
--------------------------------------------------------------------}

-- | Find a 'TxOut' for a given 'TxIn'.
lookup :: TxIn -> UTxO era -> Maybe (TxOut CtxUTxO era)
lookup :: forall era. TxIn -> UTxO era -> Maybe (TxOut CtxUTxO era)
lookup TxIn
k = TxIn -> Map TxIn (TxOut CtxUTxO era) -> Maybe (TxOut CtxUTxO era)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup TxIn
k (Map TxIn (TxOut CtxUTxO era) -> Maybe (TxOut CtxUTxO era))
-> (UTxO era -> Map TxIn (TxOut CtxUTxO era))
-> UTxO era
-> Maybe (TxOut CtxUTxO era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTxO era -> Map TxIn (TxOut CtxUTxO era)
forall era. UTxO era -> Map TxIn (TxOut CtxUTxO era)
unUTxO

-- | Synonym for `lookup`.
resolveTxIn :: TxIn -> UTxO era -> Maybe (TxOut CtxUTxO era)
resolveTxIn :: forall era. TxIn -> UTxO era -> Maybe (TxOut CtxUTxO era)
resolveTxIn = TxIn -> UTxO era -> Maybe (TxOut CtxUTxO era)
forall era. TxIn -> UTxO era -> Maybe (TxOut CtxUTxO era)
Cardano.Api.UTxO.lookup

{--------------------------------------------------------------------
  Construction
--------------------------------------------------------------------}

-- | Create an empty `UTxO`.
empty :: UTxO era
empty :: forall era. UTxO era
empty = Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall era. Map TxIn (TxOut CtxUTxO era) -> UTxO era
UTxO Map TxIn (TxOut CtxUTxO era)
forall k a. Map k a
Map.empty

-- | Create a `UTxO` from a single unspent transaction output.
singleton :: TxIn -> TxOut CtxUTxO era -> UTxO era
singleton :: forall era. TxIn -> TxOut CtxUTxO era -> UTxO era
singleton TxIn
i TxOut CtxUTxO era
o = Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall era. Map TxIn (TxOut CtxUTxO era) -> UTxO era
UTxO (Map TxIn (TxOut CtxUTxO era) -> UTxO era)
-> Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall a b. (a -> b) -> a -> b
$ TxIn -> TxOut CtxUTxO era -> Map TxIn (TxOut CtxUTxO era)
forall k a. k -> a -> Map k a
Map.singleton TxIn
i TxOut CtxUTxO era
o

{--------------------------------------------------------------------
  Insertion
--------------------------------------------------------------------}

-- | Insert a new `TxIn` and `TxOut` into the `UTxO`. If the `TxIn` is
-- already present in the `UTxO`, the associated `TxOut` is replaced with
-- the supplied `TxOut`.
insert :: TxIn -> TxOut CtxUTxO era -> UTxO era -> UTxO era
insert :: forall era. TxIn -> TxOut CtxUTxO era -> UTxO era -> UTxO era
insert TxIn
k TxOut CtxUTxO era
v = Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall era. Map TxIn (TxOut CtxUTxO era) -> UTxO era
UTxO (Map TxIn (TxOut CtxUTxO era) -> UTxO era)
-> (UTxO era -> Map TxIn (TxOut CtxUTxO era))
-> UTxO era
-> UTxO era
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxIn
-> TxOut CtxUTxO era
-> Map TxIn (TxOut CtxUTxO era)
-> Map TxIn (TxOut CtxUTxO era)
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert TxIn
k TxOut CtxUTxO era
v (Map TxIn (TxOut CtxUTxO era) -> Map TxIn (TxOut CtxUTxO era))
-> (UTxO era -> Map TxIn (TxOut CtxUTxO era))
-> UTxO era
-> Map TxIn (TxOut CtxUTxO era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTxO era -> Map TxIn (TxOut CtxUTxO era)
forall era. UTxO era -> Map TxIn (TxOut CtxUTxO era)
toMap

{--------------------------------------------------------------------
  Delete/Update
--------------------------------------------------------------------}

-- | Delete a `TxIn` and `TxOut` from the `UTxO` if it exists. When the `TxIn` is not
-- a member of the `UTxO`, the original `UTxO` is returned.
delete :: TxIn -> UTxO era -> UTxO era
delete :: forall era. TxIn -> UTxO era -> UTxO era
delete TxIn
k = Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall era. Map TxIn (TxOut CtxUTxO era) -> UTxO era
UTxO (Map TxIn (TxOut CtxUTxO era) -> UTxO era)
-> (UTxO era -> Map TxIn (TxOut CtxUTxO era))
-> UTxO era
-> UTxO era
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxIn
-> Map TxIn (TxOut CtxUTxO era) -> Map TxIn (TxOut CtxUTxO era)
forall k a. Ord k => k -> Map k a -> Map k a
Map.delete TxIn
k (Map TxIn (TxOut CtxUTxO era) -> Map TxIn (TxOut CtxUTxO era))
-> (UTxO era -> Map TxIn (TxOut CtxUTxO era))
-> UTxO era
-> Map TxIn (TxOut CtxUTxO era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTxO era -> Map TxIn (TxOut CtxUTxO era)
forall era. UTxO era -> Map TxIn (TxOut CtxUTxO era)
toMap

-- | Update a `TxOut` corresponding to a specific `TxIn` with the result of the
-- provided function. When the `TxIn` is not a member of the `UTxO`, the
-- original `UTxO` is returned.
adjust :: (TxOut CtxUTxO era -> TxOut CtxUTxO era) -> TxIn -> UTxO era -> UTxO era
adjust :: forall era.
(TxOut CtxUTxO era -> TxOut CtxUTxO era)
-> TxIn -> UTxO era -> UTxO era
adjust TxOut CtxUTxO era -> TxOut CtxUTxO era
f TxIn
k = Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall era. Map TxIn (TxOut CtxUTxO era) -> UTxO era
UTxO (Map TxIn (TxOut CtxUTxO era) -> UTxO era)
-> (UTxO era -> Map TxIn (TxOut CtxUTxO era))
-> UTxO era
-> UTxO era
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TxOut CtxUTxO era -> TxOut CtxUTxO era)
-> TxIn
-> Map TxIn (TxOut CtxUTxO era)
-> Map TxIn (TxOut CtxUTxO era)
forall k a. Ord k => (a -> a) -> k -> Map k a -> Map k a
Map.adjust TxOut CtxUTxO era -> TxOut CtxUTxO era
f TxIn
k (Map TxIn (TxOut CtxUTxO era) -> Map TxIn (TxOut CtxUTxO era))
-> (UTxO era -> Map TxIn (TxOut CtxUTxO era))
-> UTxO era
-> Map TxIn (TxOut CtxUTxO era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTxO era -> Map TxIn (TxOut CtxUTxO era)
forall era. UTxO era -> Map TxIn (TxOut CtxUTxO era)
toMap

{--------------------------------------------------------------------
  Union
--------------------------------------------------------------------}

-- | Left-biased union of two `UTxO`.
union :: UTxO era -> UTxO era -> UTxO era
union :: forall era. UTxO era -> UTxO era -> UTxO era
union UTxO era
a UTxO era
b = Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall era. Map TxIn (TxOut CtxUTxO era) -> UTxO era
UTxO (Map TxIn (TxOut CtxUTxO era) -> UTxO era)
-> Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall a b. (a -> b) -> a -> b
$ Map TxIn (TxOut CtxUTxO era)
-> Map TxIn (TxOut CtxUTxO era) -> Map TxIn (TxOut CtxUTxO era)
forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union (UTxO era -> Map TxIn (TxOut CtxUTxO era)
forall era. UTxO era -> Map TxIn (TxOut CtxUTxO era)
toMap UTxO era
a) (UTxO era -> Map TxIn (TxOut CtxUTxO era)
forall era. UTxO era -> Map TxIn (TxOut CtxUTxO era)
toMap UTxO era
b)

-- | The union of a list of `UTxO`.
unions :: [UTxO era] -> UTxO era
unions :: forall era. [UTxO era] -> UTxO era
unions = Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall era. Map TxIn (TxOut CtxUTxO era) -> UTxO era
UTxO (Map TxIn (TxOut CtxUTxO era) -> UTxO era)
-> ([UTxO era] -> Map TxIn (TxOut CtxUTxO era))
-> [UTxO era]
-> UTxO era
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Map TxIn (TxOut CtxUTxO era)] -> Map TxIn (TxOut CtxUTxO era)
forall (f :: * -> *) k a.
(Foldable f, Ord k) =>
f (Map k a) -> Map k a
Map.unions ([Map TxIn (TxOut CtxUTxO era)] -> Map TxIn (TxOut CtxUTxO era))
-> ([UTxO era] -> [Map TxIn (TxOut CtxUTxO era)])
-> [UTxO era]
-> Map TxIn (TxOut CtxUTxO era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UTxO era -> Map TxIn (TxOut CtxUTxO era))
-> [UTxO era] -> [Map TxIn (TxOut CtxUTxO era)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap UTxO era -> Map TxIn (TxOut CtxUTxO era)
forall era. UTxO era -> Map TxIn (TxOut CtxUTxO era)
toMap

{--------------------------------------------------------------------
  Difference
--------------------------------------------------------------------}

-- | Difference of two `UTxO`. Returns elements of the first `UTxO` not existing
-- in the second `UTxO`.
difference :: UTxO era -> UTxO era -> UTxO era
difference :: forall era. UTxO era -> UTxO era -> UTxO era
difference UTxO era
a UTxO era
b = Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall era. Map TxIn (TxOut CtxUTxO era) -> UTxO era
UTxO (Map TxIn (TxOut CtxUTxO era) -> UTxO era)
-> Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall a b. (a -> b) -> a -> b
$ Map TxIn (TxOut CtxUTxO era)
-> Map TxIn (TxOut CtxUTxO era) -> Map TxIn (TxOut CtxUTxO era)
forall k a b. Ord k => Map k a -> Map k b -> Map k a
Map.difference (UTxO era -> Map TxIn (TxOut CtxUTxO era)
forall era. UTxO era -> Map TxIn (TxOut CtxUTxO era)
toMap UTxO era
a) (UTxO era -> Map TxIn (TxOut CtxUTxO era)
forall era. UTxO era -> Map TxIn (TxOut CtxUTxO era)
toMap UTxO era
b)

{--------------------------------------------------------------------
  Intersection
--------------------------------------------------------------------}

intersection :: UTxO era -> UTxO era -> UTxO era
intersection :: forall era. UTxO era -> UTxO era -> UTxO era
intersection UTxO era
a UTxO era
b = Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall era. Map TxIn (TxOut CtxUTxO era) -> UTxO era
UTxO (Map TxIn (TxOut CtxUTxO era) -> UTxO era)
-> Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall a b. (a -> b) -> a -> b
$ Map TxIn (TxOut CtxUTxO era)
-> Map TxIn (TxOut CtxUTxO era) -> Map TxIn (TxOut CtxUTxO era)
forall k a b. Ord k => Map k a -> Map k b -> Map k a
Map.intersection (UTxO era -> Map TxIn (TxOut CtxUTxO era)
forall era. UTxO era -> Map TxIn (TxOut CtxUTxO era)
toMap UTxO era
a) (UTxO era -> Map TxIn (TxOut CtxUTxO era)
forall era. UTxO era -> Map TxIn (TxOut CtxUTxO era)
toMap UTxO era
b)

{--------------------------------------------------------------------
  Map
--------------------------------------------------------------------}

-- | Map a function over all `TxOut` in the `UTxO`.
map :: (TxOut CtxUTxO era -> TxOut CtxUTxO era) -> UTxO era -> UTxO era
map :: forall era.
(TxOut CtxUTxO era -> TxOut CtxUTxO era) -> UTxO era -> UTxO era
map TxOut CtxUTxO era -> TxOut CtxUTxO era
f = Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall era. Map TxIn (TxOut CtxUTxO era) -> UTxO era
UTxO (Map TxIn (TxOut CtxUTxO era) -> UTxO era)
-> (UTxO era -> Map TxIn (TxOut CtxUTxO era))
-> UTxO era
-> UTxO era
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TxOut CtxUTxO era -> TxOut CtxUTxO era)
-> Map TxIn (TxOut CtxUTxO era) -> Map TxIn (TxOut CtxUTxO era)
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map TxOut CtxUTxO era -> TxOut CtxUTxO era
f (Map TxIn (TxOut CtxUTxO era) -> Map TxIn (TxOut CtxUTxO era))
-> (UTxO era -> Map TxIn (TxOut CtxUTxO era))
-> UTxO era
-> Map TxIn (TxOut CtxUTxO era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTxO era -> Map TxIn (TxOut CtxUTxO era)
forall era. UTxO era -> Map TxIn (TxOut CtxUTxO era)
toMap

-- | Map a function over all `TxIn`/`TxOut` in the `UTxO`.
mapWithKey :: (TxIn -> TxOut CtxUTxO era -> TxOut CtxUTxO era) -> UTxO era -> UTxO era
mapWithKey :: forall era.
(TxIn -> TxOut CtxUTxO era -> TxOut CtxUTxO era)
-> UTxO era -> UTxO era
mapWithKey TxIn -> TxOut CtxUTxO era -> TxOut CtxUTxO era
f = Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall era. Map TxIn (TxOut CtxUTxO era) -> UTxO era
UTxO (Map TxIn (TxOut CtxUTxO era) -> UTxO era)
-> (UTxO era -> Map TxIn (TxOut CtxUTxO era))
-> UTxO era
-> UTxO era
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TxIn -> TxOut CtxUTxO era -> TxOut CtxUTxO era)
-> Map TxIn (TxOut CtxUTxO era) -> Map TxIn (TxOut CtxUTxO era)
forall k a b. (k -> a -> b) -> Map k a -> Map k b
Map.mapWithKey TxIn -> TxOut CtxUTxO era -> TxOut CtxUTxO era
f (Map TxIn (TxOut CtxUTxO era) -> Map TxIn (TxOut CtxUTxO era))
-> (UTxO era -> Map TxIn (TxOut CtxUTxO era))
-> UTxO era
-> Map TxIn (TxOut CtxUTxO era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTxO era -> Map TxIn (TxOut CtxUTxO era)
forall era. UTxO era -> Map TxIn (TxOut CtxUTxO era)
toMap

-- | Map a function over the `TxIn` keys in the `UTxO`.
mapKeys :: (TxIn -> TxIn) -> UTxO era -> UTxO era
mapKeys :: forall era. (TxIn -> TxIn) -> UTxO era -> UTxO era
mapKeys TxIn -> TxIn
f = Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall era. Map TxIn (TxOut CtxUTxO era) -> UTxO era
UTxO (Map TxIn (TxOut CtxUTxO era) -> UTxO era)
-> (UTxO era -> Map TxIn (TxOut CtxUTxO era))
-> UTxO era
-> UTxO era
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TxIn -> TxIn)
-> Map TxIn (TxOut CtxUTxO era) -> Map TxIn (TxOut CtxUTxO era)
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys TxIn -> TxIn
f (Map TxIn (TxOut CtxUTxO era) -> Map TxIn (TxOut CtxUTxO era))
-> (UTxO era -> Map TxIn (TxOut CtxUTxO era))
-> UTxO era
-> Map TxIn (TxOut CtxUTxO era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTxO era -> Map TxIn (TxOut CtxUTxO era)
forall era. UTxO era -> Map TxIn (TxOut CtxUTxO era)
toMap

{--------------------------------------------------------------------
   Filter
--------------------------------------------------------------------}

-- | Filter all `TxOut` that satisfy the predicate.
filter :: (TxOut CtxUTxO era -> Bool) -> UTxO era -> UTxO era
filter :: forall era. (TxOut CtxUTxO era -> Bool) -> UTxO era -> UTxO era
filter TxOut CtxUTxO era -> Bool
fn = Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall era. Map TxIn (TxOut CtxUTxO era) -> UTxO era
UTxO (Map TxIn (TxOut CtxUTxO era) -> UTxO era)
-> (UTxO era -> Map TxIn (TxOut CtxUTxO era))
-> UTxO era
-> UTxO era
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TxOut CtxUTxO era -> Bool)
-> Map TxIn (TxOut CtxUTxO era) -> Map TxIn (TxOut CtxUTxO era)
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter TxOut CtxUTxO era -> Bool
fn (Map TxIn (TxOut CtxUTxO era) -> Map TxIn (TxOut CtxUTxO era))
-> (UTxO era -> Map TxIn (TxOut CtxUTxO era))
-> UTxO era
-> Map TxIn (TxOut CtxUTxO era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTxO era -> Map TxIn (TxOut CtxUTxO era)
forall era. UTxO era -> Map TxIn (TxOut CtxUTxO era)
toMap

-- | Filter all UTxO to only include 'out's satisfying given predicate.
filterWithKey :: (TxIn -> TxOut CtxUTxO era -> Bool) -> UTxO era -> UTxO era
filterWithKey :: forall era.
(TxIn -> TxOut CtxUTxO era -> Bool) -> UTxO era -> UTxO era
filterWithKey TxIn -> TxOut CtxUTxO era -> Bool
fn = Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall era. Map TxIn (TxOut CtxUTxO era) -> UTxO era
UTxO (Map TxIn (TxOut CtxUTxO era) -> UTxO era)
-> (UTxO era -> Map TxIn (TxOut CtxUTxO era))
-> UTxO era
-> UTxO era
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TxIn -> TxOut CtxUTxO era -> Bool)
-> Map TxIn (TxOut CtxUTxO era) -> Map TxIn (TxOut CtxUTxO era)
forall k a. (k -> a -> Bool) -> Map k a -> Map k a
Map.filterWithKey TxIn -> TxOut CtxUTxO era -> Bool
fn (Map TxIn (TxOut CtxUTxO era) -> Map TxIn (TxOut CtxUTxO era))
-> (UTxO era -> Map TxIn (TxOut CtxUTxO era))
-> UTxO era
-> Map TxIn (TxOut CtxUTxO era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTxO era -> Map TxIn (TxOut CtxUTxO era)
forall era. UTxO era -> Map TxIn (TxOut CtxUTxO era)
toMap

{--------------------------------------------------------------------
   Fold
--------------------------------------------------------------------}

-- | Fold the `TxOut`s to a monoid and combine the results.
foldMap :: Monoid m => (TxOut CtxUTxO era -> m) -> UTxO era -> m
foldMap :: forall m era. Monoid m => (TxOut CtxUTxO era -> m) -> UTxO era -> m
foldMap TxOut CtxUTxO era -> m
fn = (TxOut CtxUTxO era -> m) -> Map TxIn (TxOut CtxUTxO era) -> m
forall m a. Monoid m => (a -> m) -> Map TxIn a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
Prelude.foldMap TxOut CtxUTxO era -> m
fn (Map TxIn (TxOut CtxUTxO era) -> m)
-> (UTxO era -> Map TxIn (TxOut CtxUTxO era)) -> UTxO era -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTxO era -> Map TxIn (TxOut CtxUTxO era)
forall era. UTxO era -> Map TxIn (TxOut CtxUTxO era)
toMap

{--------------------------------------------------------------------
   Find
--------------------------------------------------------------------}

-- | Find the first `TxIn`/`TxOut` pair in `UTxO` using the predicate.
find :: (TxOut CtxUTxO era -> Bool) -> UTxO era -> Maybe (TxIn, TxOut CtxUTxO era)
find :: forall era.
(TxOut CtxUTxO era -> Bool)
-> UTxO era -> Maybe (TxIn, TxOut CtxUTxO era)
find TxOut CtxUTxO era -> Bool
f = (TxIn -> TxOut CtxUTxO era -> Bool)
-> UTxO era -> Maybe (TxIn, TxOut CtxUTxO era)
forall era.
(TxIn -> TxOut CtxUTxO era -> Bool)
-> UTxO era -> Maybe (TxIn, TxOut CtxUTxO era)
findWithKey ((TxOut CtxUTxO era -> Bool) -> TxIn -> TxOut CtxUTxO era -> Bool
forall a b. a -> b -> a
const TxOut CtxUTxO era -> Bool
f)

-- | Find the first `TxIn`/`TxOut` pair in `UTxO` using the predicate.
findWithKey :: (TxIn -> TxOut CtxUTxO era -> Bool) -> UTxO era -> Maybe (TxIn, TxOut CtxUTxO era)
findWithKey :: forall era.
(TxIn -> TxOut CtxUTxO era -> Bool)
-> UTxO era -> Maybe (TxIn, TxOut CtxUTxO era)
findWithKey TxIn -> TxOut CtxUTxO era -> Bool
f = ((TxIn, TxOut CtxUTxO era) -> Bool)
-> [(TxIn, TxOut CtxUTxO era)] -> Maybe (TxIn, TxOut CtxUTxO era)
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
Data.List.find ((TxIn -> TxOut CtxUTxO era -> Bool)
-> (TxIn, TxOut CtxUTxO era) -> Bool
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry TxIn -> TxOut CtxUTxO era -> Bool
f) ([(TxIn, TxOut CtxUTxO era)] -> Maybe (TxIn, TxOut CtxUTxO era))
-> (UTxO era -> [(TxIn, TxOut CtxUTxO era)])
-> UTxO era
-> Maybe (TxIn, TxOut CtxUTxO era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTxO era -> [(TxIn, TxOut CtxUTxO era)]
forall era. UTxO era -> [(TxIn, TxOut CtxUTxO era)]
toList

{--------------------------------------------------------------------
   Conversion
--------------------------------------------------------------------}

-- | Get the `UTxO`'s `TxIn` `Set`.
inputSet :: UTxO era -> Set TxIn
inputSet :: forall era. UTxO era -> Set TxIn
inputSet = Map TxIn (TxOut CtxUTxO era) -> Set TxIn
forall k a. Map k a -> Set k
Map.keysSet (Map TxIn (TxOut CtxUTxO era) -> Set TxIn)
-> (UTxO era -> Map TxIn (TxOut CtxUTxO era))
-> UTxO era
-> Set TxIn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTxO era -> Map TxIn (TxOut CtxUTxO era)
forall era. UTxO era -> Map TxIn (TxOut CtxUTxO era)
unUTxO

-- | Get the `UTxO`'s `TxOut` `Set`.
txOutputs :: UTxO era -> [TxOut CtxUTxO era]
txOutputs :: forall era. UTxO era -> [TxOut CtxUTxO era]
txOutputs = Map TxIn (TxOut CtxUTxO era) -> [TxOut CtxUTxO era]
forall k a. Map k a -> [a]
Map.elems (Map TxIn (TxOut CtxUTxO era) -> [TxOut CtxUTxO era])
-> (UTxO era -> Map TxIn (TxOut CtxUTxO era))
-> UTxO era
-> [TxOut CtxUTxO era]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTxO era -> Map TxIn (TxOut CtxUTxO era)
forall era. UTxO era -> Map TxIn (TxOut CtxUTxO era)
unUTxO

{--------------------------------------------------------------------
   Lists
--------------------------------------------------------------------}

-- | Convert to a `List` of `TxIn`/`TxOut` pairs.
fromList :: [(TxIn, TxOut CtxUTxO era)] -> UTxO era
fromList :: forall era. [(TxIn, TxOut CtxUTxO era)] -> UTxO era
fromList = Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall era. Map TxIn (TxOut CtxUTxO era) -> UTxO era
UTxO (Map TxIn (TxOut CtxUTxO era) -> UTxO era)
-> ([(TxIn, TxOut CtxUTxO era)] -> Map TxIn (TxOut CtxUTxO era))
-> [(TxIn, TxOut CtxUTxO era)]
-> UTxO era
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(TxIn, TxOut CtxUTxO era)] -> Map TxIn (TxOut CtxUTxO era)
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList

-- | Convert from a `List` of `TxIn`/`TxOut` pairs.
toList :: UTxO era -> [(TxIn, TxOut CtxUTxO era)]
toList :: forall era. UTxO era -> [(TxIn, TxOut CtxUTxO era)]
toList (UTxO Map TxIn (TxOut CtxUTxO era)
xs) = Map TxIn (TxOut CtxUTxO era) -> [(TxIn, TxOut CtxUTxO era)]
forall k a. Map k a -> [(k, a)]
Map.toList Map TxIn (TxOut CtxUTxO era)
xs

{--------------------------------------------------------------------
   Maps
--------------------------------------------------------------------}

-- | Convert to a `Map` of `TxIn`/`TxOut`.
toMap :: UTxO era -> Map TxIn (TxOut CtxUTxO era)
toMap :: forall era. UTxO era -> Map TxIn (TxOut CtxUTxO era)
toMap = UTxO era -> Map TxIn (TxOut CtxUTxO era)
forall era. UTxO era -> Map TxIn (TxOut CtxUTxO era)
unUTxO

-- | Convert from a `Map` of `TxIn`/`TxOut`.
fromMap :: Map TxIn (TxOut CtxUTxO era) -> UTxO era
fromMap :: forall era. Map TxIn (TxOut CtxUTxO era) -> UTxO era
fromMap = Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall era. Map TxIn (TxOut CtxUTxO era) -> UTxO era
UTxO

{--------------------------------------------------------------------
   Shelley
--------------------------------------------------------------------}

-- | Convert from a `cardano-api` `UTxO` to a `cardano-ledger` UTxO.
toShelleyUTxO :: ShelleyBasedEra era -> UTxO era -> Ledger.UTxO (ShelleyLedgerEra era)
toShelleyUTxO :: forall era.
ShelleyBasedEra era -> UTxO era -> UTxO (ShelleyLedgerEra era)
toShelleyUTxO ShelleyBasedEra era
sbe =
  Map TxIn (TxOut (ShelleyLedgerEra era))
-> UTxO (ShelleyLedgerEra era)
forall era. Map TxIn (TxOut era) -> UTxO era
Ledger.UTxO (Map TxIn (TxOut (ShelleyLedgerEra era))
 -> UTxO (ShelleyLedgerEra era))
-> (UTxO era -> Map TxIn (TxOut (ShelleyLedgerEra era)))
-> UTxO era
-> UTxO (ShelleyLedgerEra era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TxIn
 -> TxOut CtxUTxO era -> Map TxIn (TxOut (ShelleyLedgerEra era)))
-> Map TxIn (TxOut CtxUTxO era)
-> Map TxIn (TxOut (ShelleyLedgerEra era))
forall m k a. Monoid m => (k -> a -> m) -> Map k a -> m
Map.foldMapWithKey TxIn
-> TxOut CtxUTxO era -> Map TxIn (TxOut (ShelleyLedgerEra era))
f (Map TxIn (TxOut CtxUTxO era)
 -> Map TxIn (TxOut (ShelleyLedgerEra era)))
-> (UTxO era -> Map TxIn (TxOut CtxUTxO era))
-> UTxO era
-> Map TxIn (TxOut (ShelleyLedgerEra era))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTxO era -> Map TxIn (TxOut CtxUTxO era)
forall era. UTxO era -> Map TxIn (TxOut CtxUTxO era)
unUTxO
 where
  f :: TxIn
-> TxOut CtxUTxO era -> Map TxIn (TxOut (ShelleyLedgerEra era))
f TxIn
i TxOut CtxUTxO era
o =
    TxIn
-> TxOut (ShelleyLedgerEra era)
-> Map TxIn (TxOut (ShelleyLedgerEra era))
forall k a. k -> a -> Map k a
Map.singleton (TxIn -> TxIn
toShelleyTxIn TxIn
i) (ShelleyBasedEra era
-> TxOut CtxUTxO era -> TxOut (ShelleyLedgerEra era)
forall era ledgerera.
(HasCallStack, ShelleyLedgerEra era ~ ledgerera) =>
ShelleyBasedEra era -> TxOut CtxUTxO era -> TxOut ledgerera
toShelleyTxOut ShelleyBasedEra era
sbe TxOut CtxUTxO era
o)

-- | Convert from a `cardano-ledger` `UTxO` to a `cardano-api` UTxO.
fromShelleyUTxO :: ShelleyBasedEra era -> Ledger.UTxO (ShelleyLedgerEra era) -> UTxO era
fromShelleyUTxO :: forall era.
ShelleyBasedEra era -> UTxO (ShelleyLedgerEra era) -> UTxO era
fromShelleyUTxO ShelleyBasedEra era
sbe =
  Map TxIn (TxOut CtxUTxO era) -> UTxO era
forall era. Map TxIn (TxOut CtxUTxO era) -> UTxO era
UTxO (Map TxIn (TxOut CtxUTxO era) -> UTxO era)
-> (UTxO (ShelleyLedgerEra era) -> Map TxIn (TxOut CtxUTxO era))
-> UTxO (ShelleyLedgerEra era)
-> UTxO era
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TxIn
 -> TxOut (ShelleyLedgerEra era) -> Map TxIn (TxOut CtxUTxO era))
-> Map TxIn (TxOut (ShelleyLedgerEra era))
-> Map TxIn (TxOut CtxUTxO era)
forall m k a. Monoid m => (k -> a -> m) -> Map k a -> m
Map.foldMapWithKey TxIn
-> TxOut (ShelleyLedgerEra era) -> Map TxIn (TxOut CtxUTxO era)
f (Map TxIn (TxOut (ShelleyLedgerEra era))
 -> Map TxIn (TxOut CtxUTxO era))
-> (UTxO (ShelleyLedgerEra era)
    -> Map TxIn (TxOut (ShelleyLedgerEra era)))
-> UTxO (ShelleyLedgerEra era)
-> Map TxIn (TxOut CtxUTxO era)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTxO (ShelleyLedgerEra era)
-> Map TxIn (TxOut (ShelleyLedgerEra era))
forall era. UTxO era -> Map TxIn (TxOut era)
Ledger.unUTxO
 where
  f :: TxIn
-> TxOut (ShelleyLedgerEra era) -> Map TxIn (TxOut CtxUTxO era)
f TxIn
i TxOut (ShelleyLedgerEra era)
o =
    TxIn -> TxOut CtxUTxO era -> Map TxIn (TxOut CtxUTxO era)
forall k a. k -> a -> Map k a
Map.singleton (TxIn -> TxIn
fromShelleyTxIn TxIn
i) (ShelleyBasedEra era
-> TxOut (ShelleyLedgerEra era) -> TxOut CtxUTxO era
forall era ctx.
ShelleyBasedEra era
-> TxOut (ShelleyLedgerEra era) -> TxOut ctx era
fromShelleyTxOut ShelleyBasedEra era
sbe TxOut (ShelleyLedgerEra era)
o)