{-# OPTIONS_GHC -Wno-orphans #-}

-- | This module exposes the minting constructs used in a
-- 'Cooked.Skeleton.TxSkel' and their associated utilities.
module Cooked.Skeleton.Mint
  ( TxSkelMints,
    Mint (..),
    mintRedeemerL,
    mintTokensL,
    mint,
    burn,
    txSkelMintsValueG,
    txSkelMintsListI,
    mintVersionedScriptL,
    txSkelMintsAssetClassAmountL,
    txSkelMintsFromList,
    txSkelMintsValue,
  )
where

import Cooked.Skeleton.Redeemer as X
import Data.Bifunctor
import Data.List.NonEmpty qualified as NEList
import Data.Map (Map)
import Data.Map qualified as Map
import Data.Map.NonEmpty (NEMap)
import Data.Map.NonEmpty qualified as NEMap
import Data.Maybe
import Optics.Core
import Optics.TH
import Plutus.Script.Utils.Scripts qualified as Script
import PlutusLedgerApi.V1.Value qualified as Api
import PlutusTx.AssocMap qualified as PMap
import Test.QuickCheck (NonZero (..))

-- * Describing single mint entries

-- | A description of a new entry to be added in a 'TxSkelMints'. The users
-- should be using lists of those (using 'txSkelMintsFromList') instead of
-- building a 'TxSkelMints' directly.
data Mint where
  Mint ::
    (Script.ToVersioned Script.MintingPolicy a) =>
    { ()
mintMintingPolicy :: a,
      Mint -> TxSkelRedeemer
mintRedeemer :: TxSkelRedeemer,
      Mint -> [(TokenName, Integer)]
mintTokens :: [(Api.TokenName, Integer)]
    } ->
    Mint

-- * Extra builders for single mint entries

-- | Builds some 'Mint' when a single type of token is minted for a given MP
mint :: (Script.ToVersioned Script.MintingPolicy a) => a -> TxSkelRedeemer -> Api.TokenName -> Integer -> Mint
mint :: forall a.
ToVersioned MintingPolicy a =>
a -> TxSkelRedeemer -> TokenName -> Integer -> Mint
mint a
mp TxSkelRedeemer
red TokenName
tn Integer
n = a -> TxSkelRedeemer -> [(TokenName, Integer)] -> Mint
forall a.
ToVersioned MintingPolicy a =>
a -> TxSkelRedeemer -> [(TokenName, Integer)] -> Mint
Mint a
mp TxSkelRedeemer
red [(TokenName
tn, Integer
n)]

-- | Similar to 'mint' but deducing the tokens instead
burn :: (Script.ToVersioned Script.MintingPolicy a) => a -> TxSkelRedeemer -> Api.TokenName -> Integer -> Mint
burn :: forall a.
ToVersioned MintingPolicy a =>
a -> TxSkelRedeemer -> TokenName -> Integer -> Mint
burn a
mp TxSkelRedeemer
red TokenName
tn Integer
n = a -> TxSkelRedeemer -> TokenName -> Integer -> Mint
forall a.
ToVersioned MintingPolicy a =>
a -> TxSkelRedeemer -> TokenName -> Integer -> Mint
mint a
mp TxSkelRedeemer
red TokenName
tn (-Integer
n)

-- * Optics to manipulate elements of 'Mint'

-- | A lens to set or get the redeemer of a 'Mint'
makeLensesFor [("mintRedeemer", "mintRedeemerL")] ''Mint

-- | A lens to set or get the token list of a 'Mint'
makeLensesFor [("mintTokens", "mintTokensL")] ''Mint

-- | A lens to set or get the versioned script of a 'Mint'
mintVersionedScriptL :: Lens' Mint (Script.Versioned Script.Script)
mintVersionedScriptL :: Lens' Mint (Versioned Script)
mintVersionedScriptL =
  (Mint -> Versioned Script)
-> (Mint -> Versioned Script -> Mint)
-> Lens' Mint (Versioned Script)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
    (\(Mint a
mp TxSkelRedeemer
_ [(TokenName, Integer)]
_) -> MintingPolicy -> Script
forall a. ToScript a => a -> Script
Script.toScript (MintingPolicy -> Script)
-> Versioned MintingPolicy -> Versioned Script
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s a. ToVersioned s a => a -> Versioned s
Script.toVersioned @Script.MintingPolicy a
mp)
    (\Mint
m Versioned Script
mp -> Mint
m {mintMintingPolicy = mp})

-- * Describing full minted values with associated redeemers

-- | A description of what a transaction mints. For every policy, there can only
-- be one 'TxSkelRedeemer', and if there is, there must be some token names, each
-- with a non-zero amount of tokens.
--
-- You'll probably not construct this by hand, but use 'txSkelMintsFromList'.
type TxSkelMints =
  Map
    (Script.Versioned Script.MintingPolicy)
    (TxSkelRedeemer, NEMap Api.TokenName (NonZero Integer))

-- * Optics to manipulate components of 'TxSkelMints' bind it to 'Mint'

-- | Sets or gets the amount of tokens minted for a certain asset class,
-- represented by a token name and a versioned minting policy. This removes the
-- appropriate entries (the token entry, and possible the mp entry if it would
-- leave it empty) when setting the amount to 0. This function is very similar
-- to 'Cooked.Skeleton.Value.valueAssetClassAmountL' but it also involves the
-- 'TxSkelRedeemer' associated with the minting policy.
--
-- This Lens is quite involved and is the main way to build 'TxSkelMints'
-- iteratively from a list of 'Mint' (see 'txSkelMintsListI'). If you're looking
-- for simpler optics working in a 'TxSkelMints', consider using @ix mp % _1@
-- for instance to modify an existing redeemer, or @ix mp % _2 % ix tk@ to
-- modify a token amount. Another option is to use the optics working on 'Mint'
-- and combining them with 'txSkelMintsListI'.
txSkelMintsAssetClassAmountL :: (Script.ToVersioned Script.MintingPolicy mp) => mp -> Api.TokenName -> Lens' TxSkelMints (Maybe TxSkelRedeemer, Integer)
txSkelMintsAssetClassAmountL :: forall mp.
ToVersioned MintingPolicy mp =>
mp
-> TokenName -> Lens' TxSkelMints (Maybe TxSkelRedeemer, Integer)
txSkelMintsAssetClassAmountL (forall s a. ToVersioned s a => a -> Versioned s
Script.toVersioned @Script.MintingPolicy -> Versioned MintingPolicy
mp) TokenName
tk =
  (TxSkelMints -> (Maybe TxSkelRedeemer, Integer))
-> (TxSkelMints -> (Maybe TxSkelRedeemer, Integer) -> TxSkelMints)
-> Lens' TxSkelMints (Maybe TxSkelRedeemer, Integer)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
    -- We return (Nothing, 0) when the mp is not in the map, (Just red, 0) when
    -- the mp is present but not the token, and (Just red, n) otherwise.
    ((Maybe TxSkelRedeemer, Integer)
-> ((TxSkelRedeemer, NEMap TokenName (NonZero Integer))
    -> (Maybe TxSkelRedeemer, Integer))
-> Maybe (TxSkelRedeemer, NEMap TokenName (NonZero Integer))
-> (Maybe TxSkelRedeemer, Integer)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Maybe TxSkelRedeemer
forall a. Maybe a
Nothing, Integer
0) ((TxSkelRedeemer -> Maybe TxSkelRedeemer)
-> (NEMap TokenName (NonZero Integer) -> Integer)
-> (TxSkelRedeemer, NEMap TokenName (NonZero Integer))
-> (Maybe TxSkelRedeemer, Integer)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap TxSkelRedeemer -> Maybe TxSkelRedeemer
forall a. a -> Maybe a
Just (Integer
-> (NonZero Integer -> Integer)
-> Maybe (NonZero Integer)
-> Integer
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Integer
0 NonZero Integer -> Integer
forall a. NonZero a -> a
getNonZero (Maybe (NonZero Integer) -> Integer)
-> (NEMap TokenName (NonZero Integer) -> Maybe (NonZero Integer))
-> NEMap TokenName (NonZero Integer)
-> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TokenName
-> NEMap TokenName (NonZero Integer) -> Maybe (NonZero Integer)
forall k a. Ord k => k -> NEMap k a -> Maybe a
NEMap.lookup TokenName
tk)) (Maybe (TxSkelRedeemer, NEMap TokenName (NonZero Integer))
 -> (Maybe TxSkelRedeemer, Integer))
-> (TxSkelMints
    -> Maybe (TxSkelRedeemer, NEMap TokenName (NonZero Integer)))
-> TxSkelMints
-> (Maybe TxSkelRedeemer, Integer)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Versioned MintingPolicy
-> TxSkelMints
-> Maybe (TxSkelRedeemer, NEMap TokenName (NonZero Integer))
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Versioned MintingPolicy
mp)
    ( \TxSkelMints
mints (Maybe TxSkelRedeemer
newRed, Integer
i) -> case Versioned MintingPolicy
-> TxSkelMints
-> Maybe (TxSkelRedeemer, NEMap TokenName (NonZero Integer))
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Versioned MintingPolicy
mp TxSkelMints
mints of
        -- No previous mp entry and nothing to add
        Maybe (TxSkelRedeemer, NEMap TokenName (NonZero Integer))
Nothing | Integer
i Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
0 -> TxSkelMints
mints
        -- No previous mp entry and something to add but no redeemer to attach
        Maybe (TxSkelRedeemer, NEMap TokenName (NonZero Integer))
Nothing | Maybe TxSkelRedeemer
Nothing <- Maybe TxSkelRedeemer
newRed -> TxSkelMints
mints
        -- No previous mp entry, something to add and a redeemer to attach
        Maybe (TxSkelRedeemer, NEMap TokenName (NonZero Integer))
Nothing | Just TxSkelRedeemer
newRed' <- Maybe TxSkelRedeemer
newRed -> Versioned MintingPolicy
-> (TxSkelRedeemer, NEMap TokenName (NonZero Integer))
-> TxSkelMints
-> TxSkelMints
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert Versioned MintingPolicy
mp (TxSkelRedeemer
newRed', TokenName -> NonZero Integer -> NEMap TokenName (NonZero Integer)
forall k a. k -> a -> NEMap k a
NEMap.singleton TokenName
tk (Integer -> NonZero Integer
forall a. a -> NonZero a
NonZero Integer
i)) TxSkelMints
mints
        -- A previous mp and tk entry, which needs to be removed and the whole
        -- mp entry as well because it only containes this tk.
        Just (Map TokenName (NonZero Integer)
-> Maybe (NEMap TokenName (NonZero Integer))
forall k a. Map k a -> Maybe (NEMap k a)
NEMap.nonEmptyMap (Map TokenName (NonZero Integer)
 -> Maybe (NEMap TokenName (NonZero Integer)))
-> ((TxSkelRedeemer, NEMap TokenName (NonZero Integer))
    -> Map TokenName (NonZero Integer))
-> (TxSkelRedeemer, NEMap TokenName (NonZero Integer))
-> Maybe (NEMap TokenName (NonZero Integer))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TokenName
-> NEMap TokenName (NonZero Integer)
-> Map TokenName (NonZero Integer)
forall k a. Ord k => k -> NEMap k a -> Map k a
NEMap.delete TokenName
tk (NEMap TokenName (NonZero Integer)
 -> Map TokenName (NonZero Integer))
-> ((TxSkelRedeemer, NEMap TokenName (NonZero Integer))
    -> NEMap TokenName (NonZero Integer))
-> (TxSkelRedeemer, NEMap TokenName (NonZero Integer))
-> Map TokenName (NonZero Integer)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TxSkelRedeemer, NEMap TokenName (NonZero Integer))
-> NEMap TokenName (NonZero Integer)
forall a b. (a, b) -> b
snd -> Maybe (NEMap TokenName (NonZero Integer))
Nothing) | Integer
i Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
0 -> Versioned MintingPolicy -> TxSkelMints -> TxSkelMints
forall k a. Ord k => k -> Map k a -> Map k a
Map.delete Versioned MintingPolicy
mp TxSkelMints
mints
        -- A prevous mp and tk entry, which needs to be removed, but the whole
        -- mp entry has other tokens and thus is kept with the new redeemer if
        -- it exists. If it does not, the previous one is kept.
        Just (TxSkelRedeemer
prevRed, Map TokenName (NonZero Integer)
-> Maybe (NEMap TokenName (NonZero Integer))
forall k a. Map k a -> Maybe (NEMap k a)
NEMap.nonEmptyMap (Map TokenName (NonZero Integer)
 -> Maybe (NEMap TokenName (NonZero Integer)))
-> (NEMap TokenName (NonZero Integer)
    -> Map TokenName (NonZero Integer))
-> NEMap TokenName (NonZero Integer)
-> Maybe (NEMap TokenName (NonZero Integer))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TokenName
-> NEMap TokenName (NonZero Integer)
-> Map TokenName (NonZero Integer)
forall k a. Ord k => k -> NEMap k a -> Map k a
NEMap.delete TokenName
tk -> Just NEMap TokenName (NonZero Integer)
tokenMap) | Integer
i Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
0 -> Versioned MintingPolicy
-> (TxSkelRedeemer, NEMap TokenName (NonZero Integer))
-> TxSkelMints
-> TxSkelMints
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert Versioned MintingPolicy
mp (TxSkelRedeemer -> Maybe TxSkelRedeemer -> TxSkelRedeemer
forall a. a -> Maybe a -> a
fromMaybe TxSkelRedeemer
prevRed Maybe TxSkelRedeemer
newRed, NEMap TokenName (NonZero Integer)
tokenMap) TxSkelMints
mints
        -- A previous mp entry, in which we insert the new tk, regardless if
        -- it's already there or not, with the new redeemer.
        Just (TxSkelRedeemer
prevRed, NEMap TokenName (NonZero Integer)
tokenMap) -> Versioned MintingPolicy
-> (TxSkelRedeemer, NEMap TokenName (NonZero Integer))
-> TxSkelMints
-> TxSkelMints
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert Versioned MintingPolicy
mp (TxSkelRedeemer -> Maybe TxSkelRedeemer -> TxSkelRedeemer
forall a. a -> Maybe a -> a
fromMaybe TxSkelRedeemer
prevRed Maybe TxSkelRedeemer
newRed, TokenName
-> NonZero Integer
-> NEMap TokenName (NonZero Integer)
-> NEMap TokenName (NonZero Integer)
forall k a. Ord k => k -> a -> NEMap k a -> NEMap k a
NEMap.insert TokenName
tk (Integer -> NonZero Integer
forall a. a -> NonZero a
NonZero Integer
i) NEMap TokenName (NonZero Integer)
tokenMap) TxSkelMints
mints
    )

-- | The value described by a 'TxSkelMints'
txSkelMintsValueG :: Getter TxSkelMints Api.Value
txSkelMintsValueG :: Getter TxSkelMints Value
txSkelMintsValueG = (TxSkelMints -> Value) -> Getter TxSkelMints Value
forall s a. (s -> a) -> Getter s a
to TxSkelMints -> Value
txSkelMintsValue

-- | Seeing a 'TxSkelMints' as a list of 'Mint'
txSkelMintsListI :: Iso' TxSkelMints [Mint]
txSkelMintsListI :: Iso' TxSkelMints [Mint]
txSkelMintsListI =
  (TxSkelMints -> [Mint])
-> ([Mint] -> TxSkelMints) -> Iso' TxSkelMints [Mint]
forall s a b t. (s -> a) -> (b -> t) -> Iso s t a b
iso
    (((Versioned MintingPolicy,
  (TxSkelRedeemer, NEMap TokenName (NonZero Integer)))
 -> Mint)
-> [(Versioned MintingPolicy,
     (TxSkelRedeemer, NEMap TokenName (NonZero Integer)))]
-> [Mint]
forall a b. (a -> b) -> [a] -> [b]
map (\(Versioned MintingPolicy
p, (TxSkelRedeemer
r, NEMap TokenName (NonZero Integer)
m)) -> Versioned MintingPolicy
-> TxSkelRedeemer -> [(TokenName, Integer)] -> Mint
forall a.
ToVersioned MintingPolicy a =>
a -> TxSkelRedeemer -> [(TokenName, Integer)] -> Mint
Mint Versioned MintingPolicy
p TxSkelRedeemer
r ([(TokenName, Integer)] -> Mint) -> [(TokenName, Integer)] -> Mint
forall a b. (a -> b) -> a -> b
$ (NonZero Integer -> Integer)
-> (TokenName, NonZero Integer) -> (TokenName, Integer)
forall b c a. (b -> c) -> (a, b) -> (a, c)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second NonZero Integer -> Integer
forall a. NonZero a -> a
getNonZero ((TokenName, NonZero Integer) -> (TokenName, Integer))
-> [(TokenName, NonZero Integer)] -> [(TokenName, Integer)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty (TokenName, NonZero Integer)
-> [(TokenName, NonZero Integer)]
forall a. NonEmpty a -> [a]
NEList.toList (NEMap TokenName (NonZero Integer)
-> NonEmpty (TokenName, NonZero Integer)
forall k a. NEMap k a -> NonEmpty (k, a)
NEMap.toList NEMap TokenName (NonZero Integer)
m)) ([(Versioned MintingPolicy,
   (TxSkelRedeemer, NEMap TokenName (NonZero Integer)))]
 -> [Mint])
-> (TxSkelMints
    -> [(Versioned MintingPolicy,
         (TxSkelRedeemer, NEMap TokenName (NonZero Integer)))])
-> TxSkelMints
-> [Mint]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxSkelMints
-> [(Versioned MintingPolicy,
     (TxSkelRedeemer, NEMap TokenName (NonZero Integer)))]
forall k a. Map k a -> [(k, a)]
Map.toList)
    ( (TxSkelMints -> Mint -> TxSkelMints)
-> TxSkelMints -> [Mint] -> TxSkelMints
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl
        ( \TxSkelMints
mints (Mint a
mp TxSkelRedeemer
red [(TokenName, Integer)]
tks) ->
            (TxSkelMints -> (TokenName, Integer) -> TxSkelMints)
-> TxSkelMints -> [(TokenName, Integer)] -> TxSkelMints
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl
              (\TxSkelMints
mints' (TokenName
tk, Integer
n) -> TxSkelMints
mints' TxSkelMints -> (TxSkelMints -> TxSkelMints) -> TxSkelMints
forall a b. a -> (a -> b) -> b
& a -> TokenName -> Lens' TxSkelMints (Maybe TxSkelRedeemer, Integer)
forall mp.
ToVersioned MintingPolicy mp =>
mp
-> TokenName -> Lens' TxSkelMints (Maybe TxSkelRedeemer, Integer)
txSkelMintsAssetClassAmountL a
mp TokenName
tk Lens' TxSkelMints (Maybe TxSkelRedeemer, Integer)
-> ((Maybe TxSkelRedeemer, Integer)
    -> (Maybe TxSkelRedeemer, Integer))
-> TxSkelMints
-> TxSkelMints
forall k (is :: IxList) s t a b.
Is k A_Setter =>
Optic k is s t a b -> (a -> b) -> s -> t
%~ (\(Maybe TxSkelRedeemer
_, Integer
n') -> (TxSkelRedeemer -> Maybe TxSkelRedeemer
forall a. a -> Maybe a
Just TxSkelRedeemer
red, Integer
n Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Integer
n')))
              TxSkelMints
mints
              [(TokenName, Integer)]
tks
        )
        TxSkelMints
forall a. Monoid a => a
mempty
    )

-- * Additional instances an useful helpers

-- | Combining 'TxSkelMints' in a sensible way. In particular, this means that
--
-- > Map.fromList [(pol, (red, NEMap.fromList [(tName, 1)]))]
--
-- and
--
-- > Map.fromList [(pol, (red', NEMap.fromList [(tName, -1)]))]
--
-- will combine to become the empty 'TxSkelMints'
--
-- In every case, if you add mints with a different redeemer for the same
-- policy, the redeemer used in the right argument takes precedence.
instance {-# OVERLAPPING #-} Semigroup TxSkelMints where
  TxSkelMints
a <> :: TxSkelMints -> TxSkelMints -> TxSkelMints
<> TxSkelMints
b = Iso' TxSkelMints [Mint] -> [Mint] -> TxSkelMints
forall k (is :: IxList) t b.
Is k A_Review =>
Optic' k is t b -> b -> t
review Iso' TxSkelMints [Mint]
txSkelMintsListI ([Mint] -> TxSkelMints) -> [Mint] -> TxSkelMints
forall a b. (a -> b) -> a -> b
$ Iso' TxSkelMints [Mint] -> TxSkelMints -> [Mint]
forall k (is :: IxList) s a.
Is k A_Getter =>
Optic' k is s a -> s -> a
view Iso' TxSkelMints [Mint]
txSkelMintsListI TxSkelMints
a [Mint] -> [Mint] -> [Mint]
forall a. [a] -> [a] -> [a]
++ Iso' TxSkelMints [Mint] -> TxSkelMints -> [Mint]
forall k (is :: IxList) s a.
Is k A_Getter =>
Optic' k is s a -> s -> a
view Iso' TxSkelMints [Mint]
txSkelMintsListI TxSkelMints
b

instance {-# OVERLAPPING #-} Monoid TxSkelMints where
  mempty :: TxSkelMints
mempty = TxSkelMints
forall k a. Map k a
Map.empty

-- | This builds a 'TxSkelMints' from a list of 'Mint', which should be the main
-- way of declaring minted values in a 'Cooked.Skeleton.TxSkel'.
txSkelMintsFromList :: [Mint] -> TxSkelMints
txSkelMintsFromList :: [Mint] -> TxSkelMints
txSkelMintsFromList = Iso' TxSkelMints [Mint] -> [Mint] -> TxSkelMints
forall k (is :: IxList) t b.
Is k A_Review =>
Optic' k is t b -> b -> t
review Iso' TxSkelMints [Mint]
txSkelMintsListI

-- | This retrieves the 'Api.Value' from a 'TxSkelMints'
txSkelMintsValue :: TxSkelMints -> Api.Value
txSkelMintsValue :: TxSkelMints -> Value
txSkelMintsValue =
  Map CurrencySymbol (Map TokenName Integer) -> Value
Api.Value
    (Map CurrencySymbol (Map TokenName Integer) -> Value)
-> (TxSkelMints -> Map CurrencySymbol (Map TokenName Integer))
-> TxSkelMints
-> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(CurrencySymbol, Map TokenName Integer)]
-> Map CurrencySymbol (Map TokenName Integer)
forall k v. [(k, v)] -> Map k v
PMap.unsafeFromList
    ([(CurrencySymbol, Map TokenName Integer)]
 -> Map CurrencySymbol (Map TokenName Integer))
-> (TxSkelMints -> [(CurrencySymbol, Map TokenName Integer)])
-> TxSkelMints
-> Map CurrencySymbol (Map TokenName Integer)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Versioned MintingPolicy,
  (TxSkelRedeemer, NEMap TokenName (NonZero Integer)))
 -> (CurrencySymbol, Map TokenName Integer))
-> [(Versioned MintingPolicy,
     (TxSkelRedeemer, NEMap TokenName (NonZero Integer)))]
-> [(CurrencySymbol, Map TokenName Integer)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
      ( (Versioned MintingPolicy -> CurrencySymbol)
-> ((TxSkelRedeemer, NEMap TokenName (NonZero Integer))
    -> Map TokenName Integer)
-> (Versioned MintingPolicy,
    (TxSkelRedeemer, NEMap TokenName (NonZero Integer)))
-> (CurrencySymbol, Map TokenName Integer)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap
          Versioned MintingPolicy -> CurrencySymbol
forall script.
ToMintingPolicyHash script =>
script -> CurrencySymbol
Script.toCurrencySymbol
          ( [(TokenName, Integer)] -> Map TokenName Integer
forall k v. [(k, v)] -> Map k v
PMap.unsafeFromList
              ([(TokenName, Integer)] -> Map TokenName Integer)
-> ((TxSkelRedeemer, NEMap TokenName (NonZero Integer))
    -> [(TokenName, Integer)])
-> (TxSkelRedeemer, NEMap TokenName (NonZero Integer))
-> Map TokenName Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((TokenName, NonZero Integer) -> (TokenName, Integer))
-> [(TokenName, NonZero Integer)] -> [(TokenName, Integer)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((NonZero Integer -> Integer)
-> (TokenName, NonZero Integer) -> (TokenName, Integer)
forall b c a. (b -> c) -> (a, b) -> (a, c)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second NonZero Integer -> Integer
forall a. NonZero a -> a
getNonZero)
              ([(TokenName, NonZero Integer)] -> [(TokenName, Integer)])
-> ((TxSkelRedeemer, NEMap TokenName (NonZero Integer))
    -> [(TokenName, NonZero Integer)])
-> (TxSkelRedeemer, NEMap TokenName (NonZero Integer))
-> [(TokenName, Integer)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty (TokenName, NonZero Integer)
-> [(TokenName, NonZero Integer)]
forall a. NonEmpty a -> [a]
NEList.toList
              (NonEmpty (TokenName, NonZero Integer)
 -> [(TokenName, NonZero Integer)])
-> ((TxSkelRedeemer, NEMap TokenName (NonZero Integer))
    -> NonEmpty (TokenName, NonZero Integer))
-> (TxSkelRedeemer, NEMap TokenName (NonZero Integer))
-> [(TokenName, NonZero Integer)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NEMap TokenName (NonZero Integer)
-> NonEmpty (TokenName, NonZero Integer)
forall k a. NEMap k a -> NonEmpty (k, a)
NEMap.toList
              (NEMap TokenName (NonZero Integer)
 -> NonEmpty (TokenName, NonZero Integer))
-> ((TxSkelRedeemer, NEMap TokenName (NonZero Integer))
    -> NEMap TokenName (NonZero Integer))
-> (TxSkelRedeemer, NEMap TokenName (NonZero Integer))
-> NonEmpty (TokenName, NonZero Integer)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TxSkelRedeemer, NEMap TokenName (NonZero Integer))
-> NEMap TokenName (NonZero Integer)
forall a b. (a, b) -> b
snd
          )
      )
    ([(Versioned MintingPolicy,
   (TxSkelRedeemer, NEMap TokenName (NonZero Integer)))]
 -> [(CurrencySymbol, Map TokenName Integer)])
-> (TxSkelMints
    -> [(Versioned MintingPolicy,
         (TxSkelRedeemer, NEMap TokenName (NonZero Integer)))])
-> TxSkelMints
-> [(CurrencySymbol, Map TokenName Integer)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxSkelMints
-> [(Versioned MintingPolicy,
     (TxSkelRedeemer, NEMap TokenName (NonZero Integer)))]
forall k a. Map k a -> [(k, a)]
Map.toList