{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE UndecidableSuperClasses #-}
{-# LANGUAGE ViewPatterns #-}
{-# OPTIONS_GHC -Wno-orphans #-}

module Cardano.Ledger.Allegra.TxAuxData (
  AllegraTxAuxData (AllegraTxAuxData, MkAlegraTxAuxData),
  AllegraTxAuxDataRaw (..),
  metadataAllegraTxAuxDataL,
  AllegraEraTxAuxData (..),
  nativeScriptsAllegraTxAuxDataL,
) where

import Cardano.Ledger.Allegra.Era (AllegraEra)
import Cardano.Ledger.Allegra.Scripts (AllegraEraScript)
import Cardano.Ledger.BaseTypes (KeyValuePairs (..), ToKeyValuePairs (..))
import Cardano.Ledger.Binary (
  Annotator,
  DecCBOR (..),
  EncCBOR (..),
  ToCBOR,
  peekTokenType,
 )
import Cardano.Ledger.Binary.Coders
import Cardano.Ledger.MemoBytes (
  EqRaw,
  Mem,
  MemoBytes,
  MemoHashIndex,
  Memoized (RawType),
  getMemoRawType,
  getMemoSafeHash,
  lensMemoRawType,
  mkMemoizedEra,
 )
import Cardano.Ledger.Shelley.Core
import Cardano.Ledger.Shelley.TxAuxData (Metadatum)
import Codec.CBOR.Decoding (
  TokenType (
    TypeListLen,
    TypeListLen64,
    TypeListLenIndef,
    TypeMapLen,
    TypeMapLen64,
    TypeMapLenIndef
  ),
 )
import Control.DeepSeq (NFData, deepseq)
import Data.Aeson (FromJSON (..), ToJSON (..), (.:), (.:?), (.=))
import qualified Data.Aeson as Aeson
import qualified Data.Foldable as F
import Data.Map.Strict (Map)
import Data.Sequence.Strict (StrictSeq)
import qualified Data.Sequence.Strict as StrictSeq
import Data.Typeable (Typeable)
import Data.Word (Word64)
import GHC.Generics (Generic)
import Lens.Micro (Lens')
import NoThunks.Class (NoThunks)

-- =======================================

-- | Raw, un-memoised metadata type
data AllegraTxAuxDataRaw era = AllegraTxAuxDataRaw
  { forall era. AllegraTxAuxDataRaw era -> Map Word64 Metadatum
atadrMetadata :: !(Map Word64 Metadatum)
  -- ^ Structured transaction metadata
  , forall era. AllegraTxAuxDataRaw era -> StrictSeq (NativeScript era)
atadrNativeScripts :: !(StrictSeq (NativeScript era))
  -- ^ Pre-images of script hashes found within the TxBody, but which are not
  -- required as witnesses. Examples include:
  -- - Token policy IDs appearing in transaction outputs
  -- - Pool account address registrations
  }
  deriving ((forall x.
 AllegraTxAuxDataRaw era -> Rep (AllegraTxAuxDataRaw era) x)
-> (forall x.
    Rep (AllegraTxAuxDataRaw era) x -> AllegraTxAuxDataRaw era)
-> Generic (AllegraTxAuxDataRaw era)
forall x.
Rep (AllegraTxAuxDataRaw era) x -> AllegraTxAuxDataRaw era
forall x.
AllegraTxAuxDataRaw era -> Rep (AllegraTxAuxDataRaw era) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall era x.
Rep (AllegraTxAuxDataRaw era) x -> AllegraTxAuxDataRaw era
forall era x.
AllegraTxAuxDataRaw era -> Rep (AllegraTxAuxDataRaw era) x
$cfrom :: forall era x.
AllegraTxAuxDataRaw era -> Rep (AllegraTxAuxDataRaw era) x
from :: forall x.
AllegraTxAuxDataRaw era -> Rep (AllegraTxAuxDataRaw era) x
$cto :: forall era x.
Rep (AllegraTxAuxDataRaw era) x -> AllegraTxAuxDataRaw era
to :: forall x.
Rep (AllegraTxAuxDataRaw era) x -> AllegraTxAuxDataRaw era
Generic)

deriving instance Eq (NativeScript era) => Eq (AllegraTxAuxDataRaw era)

class EraTxAuxData era => AllegraEraTxAuxData era where
  nativeScriptsTxAuxDataL :: Lens' (TxAuxData era) (StrictSeq (NativeScript era))

instance EraTxAuxData AllegraEra where
  type TxAuxData AllegraEra = AllegraTxAuxData AllegraEra

  mkBasicTxAuxData :: TxAuxData AllegraEra
mkBasicTxAuxData = Map Word64 Metadatum
-> StrictSeq (NativeScript AllegraEra)
-> AllegraTxAuxData AllegraEra
forall era.
(Era era, EncCBOR (NativeScript era)) =>
Map Word64 Metadatum
-> StrictSeq (NativeScript era) -> AllegraTxAuxData era
AllegraTxAuxData Map Word64 Metadatum
forall a. Monoid a => a
mempty StrictSeq (NativeScript AllegraEra)
StrictSeq (Timelock AllegraEra)
forall a. Monoid a => a
mempty

  metadataTxAuxDataL :: Lens' (TxAuxData AllegraEra) (Map Word64 Metadatum)
metadataTxAuxDataL = (Map Word64 Metadatum -> f (Map Word64 Metadatum))
-> TxAuxData AllegraEra -> f (TxAuxData AllegraEra)
(Map Word64 Metadatum -> f (Map Word64 Metadatum))
-> AllegraTxAuxData AllegraEra -> f (AllegraTxAuxData AllegraEra)
forall era.
(Era era, EncCBOR (NativeScript era)) =>
Lens' (AllegraTxAuxData era) (Map Word64 Metadatum)
Lens' (AllegraTxAuxData AllegraEra) (Map Word64 Metadatum)
metadataAllegraTxAuxDataL

  validateTxAuxData :: StAnnTxCache AllegraEra -> ProtVer -> TxAuxData AllegraEra -> Bool
validateTxAuxData StAnnTxCache AllegraEra
_ ProtVer
_ (AllegraTxAuxData Map Word64 Metadatum
_ StrictSeq (NativeScript AllegraEra)
as) = StrictSeq (NativeScript AllegraEra)
StrictSeq (Timelock AllegraEra)
as StrictSeq (Timelock AllegraEra) -> Bool -> Bool
forall a b. NFData a => a -> b -> b
`deepseq` Bool
True

metadataAllegraTxAuxDataL ::
  forall era.
  ( Era era
  , EncCBOR (NativeScript era)
  ) =>
  Lens' (AllegraTxAuxData era) (Map Word64 Metadatum)
metadataAllegraTxAuxDataL :: forall era.
(Era era, EncCBOR (NativeScript era)) =>
Lens' (AllegraTxAuxData era) (Map Word64 Metadatum)
metadataAllegraTxAuxDataL =
  forall era t a b.
(Era era, EncCBOR (RawType t), Memoized t) =>
(RawType t -> a) -> (RawType t -> b -> RawType t) -> Lens t t a b
lensMemoRawType @era RawType (AllegraTxAuxData era) -> Map Word64 Metadatum
AllegraTxAuxDataRaw era -> Map Word64 Metadatum
forall era. AllegraTxAuxDataRaw era -> Map Word64 Metadatum
atadrMetadata ((RawType (AllegraTxAuxData era)
  -> Map Word64 Metadatum -> RawType (AllegraTxAuxData era))
 -> Lens
      (AllegraTxAuxData era)
      (AllegraTxAuxData era)
      (Map Word64 Metadatum)
      (Map Word64 Metadatum))
-> (RawType (AllegraTxAuxData era)
    -> Map Word64 Metadatum -> RawType (AllegraTxAuxData era))
-> Lens
     (AllegraTxAuxData era)
     (AllegraTxAuxData era)
     (Map Word64 Metadatum)
     (Map Word64 Metadatum)
forall a b. (a -> b) -> a -> b
$
    \RawType (AllegraTxAuxData era)
txAuxDataRaw Map Word64 Metadatum
md -> RawType (AllegraTxAuxData era)
txAuxDataRaw {atadrMetadata = md}

instance AllegraEraTxAuxData AllegraEra where
  nativeScriptsTxAuxDataL :: Lens' (TxAuxData AllegraEra) (StrictSeq (NativeScript AllegraEra))
nativeScriptsTxAuxDataL = (StrictSeq (NativeScript AllegraEra)
 -> f (StrictSeq (NativeScript AllegraEra)))
-> TxAuxData AllegraEra -> f (TxAuxData AllegraEra)
(StrictSeq (NativeScript AllegraEra)
 -> f (StrictSeq (NativeScript AllegraEra)))
-> AllegraTxAuxData AllegraEra -> f (AllegraTxAuxData AllegraEra)
forall era.
(Era era, EncCBOR (NativeScript era)) =>
Lens' (AllegraTxAuxData era) (StrictSeq (NativeScript era))
Lens'
  (AllegraTxAuxData AllegraEra) (StrictSeq (NativeScript AllegraEra))
nativeScriptsAllegraTxAuxDataL

nativeScriptsAllegraTxAuxDataL ::
  forall era.
  (Era era, EncCBOR (NativeScript era)) =>
  Lens' (AllegraTxAuxData era) (StrictSeq (NativeScript era))
nativeScriptsAllegraTxAuxDataL :: forall era.
(Era era, EncCBOR (NativeScript era)) =>
Lens' (AllegraTxAuxData era) (StrictSeq (NativeScript era))
nativeScriptsAllegraTxAuxDataL =
  forall era t a b.
(Era era, EncCBOR (RawType t), Memoized t) =>
(RawType t -> a) -> (RawType t -> b -> RawType t) -> Lens t t a b
lensMemoRawType @era RawType (AllegraTxAuxData era) -> StrictSeq (NativeScript era)
AllegraTxAuxDataRaw era -> StrictSeq (NativeScript era)
forall era. AllegraTxAuxDataRaw era -> StrictSeq (NativeScript era)
atadrNativeScripts ((RawType (AllegraTxAuxData era)
  -> StrictSeq (NativeScript era) -> RawType (AllegraTxAuxData era))
 -> Lens
      (AllegraTxAuxData era)
      (AllegraTxAuxData era)
      (StrictSeq (NativeScript era))
      (StrictSeq (NativeScript era)))
-> (RawType (AllegraTxAuxData era)
    -> StrictSeq (NativeScript era) -> RawType (AllegraTxAuxData era))
-> Lens
     (AllegraTxAuxData era)
     (AllegraTxAuxData era)
     (StrictSeq (NativeScript era))
     (StrictSeq (NativeScript era))
forall a b. (a -> b) -> a -> b
$
    \RawType (AllegraTxAuxData era)
txAuxDataRaw StrictSeq (NativeScript era)
ts -> RawType (AllegraTxAuxData era)
txAuxDataRaw {atadrNativeScripts = ts}

deriving instance Show (NativeScript era) => Show (AllegraTxAuxDataRaw era)

deriving instance (Era era, NoThunks (NativeScript era)) => NoThunks (AllegraTxAuxDataRaw era)

instance NFData (NativeScript era) => NFData (AllegraTxAuxDataRaw era)

newtype AllegraTxAuxData era = MkAlegraTxAuxData (MemoBytes (AllegraTxAuxDataRaw era))
  deriving ((forall x. AllegraTxAuxData era -> Rep (AllegraTxAuxData era) x)
-> (forall x. Rep (AllegraTxAuxData era) x -> AllegraTxAuxData era)
-> Generic (AllegraTxAuxData era)
forall x. Rep (AllegraTxAuxData era) x -> AllegraTxAuxData era
forall x. AllegraTxAuxData era -> Rep (AllegraTxAuxData era) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall era x. Rep (AllegraTxAuxData era) x -> AllegraTxAuxData era
forall era x. AllegraTxAuxData era -> Rep (AllegraTxAuxData era) x
$cfrom :: forall era x. AllegraTxAuxData era -> Rep (AllegraTxAuxData era) x
from :: forall x. AllegraTxAuxData era -> Rep (AllegraTxAuxData era) x
$cto :: forall era x. Rep (AllegraTxAuxData era) x -> AllegraTxAuxData era
to :: forall x. Rep (AllegraTxAuxData era) x -> AllegraTxAuxData era
Generic)
  deriving newtype (Typeable (AllegraTxAuxData era)
Typeable (AllegraTxAuxData era) =>
(AllegraTxAuxData era -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy (AllegraTxAuxData era) -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size)
    -> Proxy [AllegraTxAuxData era] -> Size)
-> ToCBOR (AllegraTxAuxData era)
AllegraTxAuxData era -> Encoding
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [AllegraTxAuxData era] -> Size
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (AllegraTxAuxData era) -> Size
forall era. Typeable era => Typeable (AllegraTxAuxData era)
forall era. Typeable era => AllegraTxAuxData era -> Encoding
forall a.
Typeable a =>
(a -> Encoding)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy a -> Size)
-> ((forall t. ToCBOR t => Proxy t -> Size) -> Proxy [a] -> Size)
-> ToCBOR a
forall era.
Typeable era =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [AllegraTxAuxData era] -> Size
forall era.
Typeable era =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (AllegraTxAuxData era) -> Size
$ctoCBOR :: forall era. Typeable era => AllegraTxAuxData era -> Encoding
toCBOR :: AllegraTxAuxData era -> Encoding
$cencodedSizeExpr :: forall era.
Typeable era =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (AllegraTxAuxData era) -> Size
encodedSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy (AllegraTxAuxData era) -> Size
$cencodedListSizeExpr :: forall era.
Typeable era =>
(forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [AllegraTxAuxData era] -> Size
encodedListSizeExpr :: (forall t. ToCBOR t => Proxy t -> Size)
-> Proxy [AllegraTxAuxData era] -> Size
ToCBOR, AllegraTxAuxData era -> Int
AllegraTxAuxData era -> ByteString
(AllegraTxAuxData era -> ByteString)
-> (AllegraTxAuxData era -> Int)
-> (forall i. Proxy i -> AllegraTxAuxData era -> SafeHash i)
-> SafeToHash (AllegraTxAuxData era)
forall i. Proxy i -> AllegraTxAuxData era -> SafeHash i
forall era. AllegraTxAuxData era -> Int
forall era. AllegraTxAuxData era -> ByteString
forall t.
(t -> ByteString)
-> (t -> Int)
-> (forall i. Proxy i -> t -> SafeHash i)
-> SafeToHash t
forall era i. Proxy i -> AllegraTxAuxData era -> SafeHash i
$coriginalBytes :: forall era. AllegraTxAuxData era -> ByteString
originalBytes :: AllegraTxAuxData era -> ByteString
$coriginalBytesSize :: forall era. AllegraTxAuxData era -> Int
originalBytesSize :: AllegraTxAuxData era -> Int
$cmakeHashWithExplicitProxys :: forall era i. Proxy i -> AllegraTxAuxData era -> SafeHash i
makeHashWithExplicitProxys :: forall i. Proxy i -> AllegraTxAuxData era -> SafeHash i
SafeToHash)

deriving instance Eq (NativeScript era) => Eq (AllegraTxAuxData era)

instance Memoized (AllegraTxAuxData era) where
  type RawType (AllegraTxAuxData era) = AllegraTxAuxDataRaw era

deriving via
  (Mem (AllegraTxAuxDataRaw era))
  instance
    AllegraEraScript era => DecCBOR (Annotator (AllegraTxAuxData era))

type instance MemoHashIndex (AllegraTxAuxDataRaw era) = EraIndependentTxAuxData

instance HashAnnotated (AllegraTxAuxData era) EraIndependentTxAuxData where
  hashAnnotated :: AllegraTxAuxData era -> SafeHash EraIndependentTxAuxData
hashAnnotated = AllegraTxAuxData era -> SafeHash EraIndependentTxAuxData
AllegraTxAuxData era
-> SafeHash (MemoHashIndex (RawType (AllegraTxAuxData era)))
forall t. Memoized t => t -> SafeHash (MemoHashIndex (RawType t))
getMemoSafeHash

deriving newtype instance Show (NativeScript era) => Show (AllegraTxAuxData era)

deriving newtype instance (Era era, NoThunks (NativeScript era)) => NoThunks (AllegraTxAuxData era)

deriving newtype instance NFData (NativeScript era) => NFData (AllegraTxAuxData era)

instance Eq (NativeScript era) => EqRaw (AllegraTxAuxData era)

pattern AllegraTxAuxData ::
  forall era.
  ( Era era
  , EncCBOR (NativeScript era)
  ) =>
  Map Word64 Metadatum ->
  StrictSeq (NativeScript era) ->
  AllegraTxAuxData era
pattern $mAllegraTxAuxData :: forall {r} {era}.
(Era era, EncCBOR (NativeScript era)) =>
AllegraTxAuxData era
-> (Map Word64 Metadatum -> StrictSeq (NativeScript era) -> r)
-> ((# #) -> r)
-> r
$bAllegraTxAuxData :: forall era.
(Era era, EncCBOR (NativeScript era)) =>
Map Word64 Metadatum
-> StrictSeq (NativeScript era) -> AllegraTxAuxData era
AllegraTxAuxData blob sp <- (getMemoRawType -> AllegraTxAuxDataRaw blob sp)
  where
    AllegraTxAuxData Map Word64 Metadatum
blob StrictSeq (NativeScript era)
sp = forall era t.
(Era era, EncCBOR (RawType t), Memoized t) =>
RawType t -> t
mkMemoizedEra @era (RawType (AllegraTxAuxData era) -> AllegraTxAuxData era)
-> RawType (AllegraTxAuxData era) -> AllegraTxAuxData era
forall a b. (a -> b) -> a -> b
$ Map Word64 Metadatum
-> StrictSeq (NativeScript era) -> AllegraTxAuxDataRaw era
forall era.
Map Word64 Metadatum
-> StrictSeq (NativeScript era) -> AllegraTxAuxDataRaw era
AllegraTxAuxDataRaw Map Word64 Metadatum
blob StrictSeq (NativeScript era)
sp

{-# COMPLETE AllegraTxAuxData #-}

--------------------------------------------------------------------------------
-- Serialisation
--------------------------------------------------------------------------------

instance (Era era, EncCBOR (NativeScript era)) => EncCBOR (AllegraTxAuxDataRaw era) where
  encCBOR :: AllegraTxAuxDataRaw era -> Encoding
encCBOR (AllegraTxAuxDataRaw Map Word64 Metadatum
blob StrictSeq (NativeScript era)
sp) =
    Encode (Closed Dense) (AllegraTxAuxDataRaw era) -> Encoding
forall (w :: Wrapped) t. Encode w t -> Encoding
encode ((Map Word64 Metadatum
 -> StrictSeq (NativeScript era) -> AllegraTxAuxDataRaw era)
-> Encode
     (Closed Dense)
     (Map Word64 Metadatum
      -> StrictSeq (NativeScript era) -> AllegraTxAuxDataRaw era)
forall t. t -> Encode (Closed Dense) t
Rec Map Word64 Metadatum
-> StrictSeq (NativeScript era) -> AllegraTxAuxDataRaw era
forall era.
Map Word64 Metadatum
-> StrictSeq (NativeScript era) -> AllegraTxAuxDataRaw era
AllegraTxAuxDataRaw Encode
  (Closed Dense)
  (Map Word64 Metadatum
   -> StrictSeq (NativeScript era) -> AllegraTxAuxDataRaw era)
-> Encode (Closed Dense) (Map Word64 Metadatum)
-> Encode
     (Closed Dense)
     (StrictSeq (NativeScript era) -> AllegraTxAuxDataRaw era)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> Map Word64 Metadatum
-> Encode (Closed Dense) (Map Word64 Metadatum)
forall t. EncCBOR t => t -> Encode (Closed Dense) t
To Map Word64 Metadatum
blob Encode
  (Closed Dense)
  (StrictSeq (NativeScript era) -> AllegraTxAuxDataRaw era)
-> Encode (Closed Dense) (StrictSeq (NativeScript era))
-> Encode (Closed Dense) (AllegraTxAuxDataRaw era)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode (Closed r) a -> Encode w t
!> StrictSeq (NativeScript era)
-> Encode (Closed Dense) (StrictSeq (NativeScript era))
forall t. EncCBOR t => t -> Encode (Closed Dense) t
To StrictSeq (NativeScript era)
sp)

-- | Encodes memoized bytes created upon construction.
instance Era era => EncCBOR (AllegraTxAuxData era)

instance
  (Era era, Typeable (NativeScript era), DecCBOR (Annotator (NativeScript era))) =>
  DecCBOR (Annotator (AllegraTxAuxDataRaw era))
  where
  decCBOR :: forall s. Decoder s (Annotator (AllegraTxAuxDataRaw era))
decCBOR =
    Decoder s TokenType
forall s. Decoder s TokenType
peekTokenType Decoder s TokenType
-> (TokenType -> Decoder s (Annotator (AllegraTxAuxDataRaw era)))
-> Decoder s (Annotator (AllegraTxAuxDataRaw era))
forall a b. Decoder s a -> (a -> Decoder s b) -> Decoder s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
      TokenType
TypeMapLen -> Decoder s (Annotator (AllegraTxAuxDataRaw era))
forall s. Decoder s (Annotator (AllegraTxAuxDataRaw era))
decodeFromMap
      TokenType
TypeMapLen64 -> Decoder s (Annotator (AllegraTxAuxDataRaw era))
forall s. Decoder s (Annotator (AllegraTxAuxDataRaw era))
decodeFromMap
      TokenType
TypeMapLenIndef -> Decoder s (Annotator (AllegraTxAuxDataRaw era))
forall s. Decoder s (Annotator (AllegraTxAuxDataRaw era))
decodeFromMap
      TokenType
TypeListLen -> Decoder s (Annotator (AllegraTxAuxDataRaw era))
forall s. Decoder s (Annotator (AllegraTxAuxDataRaw era))
decodeFromList
      TokenType
TypeListLen64 -> Decoder s (Annotator (AllegraTxAuxDataRaw era))
forall s. Decoder s (Annotator (AllegraTxAuxDataRaw era))
decodeFromList
      TokenType
TypeListLenIndef -> Decoder s (Annotator (AllegraTxAuxDataRaw era))
forall s. Decoder s (Annotator (AllegraTxAuxDataRaw era))
decodeFromList
      TokenType
_ -> String -> Decoder s (Annotator (AllegraTxAuxDataRaw era))
forall a. String -> Decoder s a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Failed to decode AuxiliaryDataRaw"
    where
      decodeFromMap :: Decoder s (Annotator (AllegraTxAuxDataRaw era))
decodeFromMap =
        Decode (ZonkAny 1) (Annotator (AllegraTxAuxDataRaw era))
-> Decoder s (Annotator (AllegraTxAuxDataRaw era))
forall t (w :: Wrapped) s. Typeable t => Decode w t -> Decoder s t
decode
          ( Decode
  (ZonkAny 1)
  (Map Word64 Metadatum
   -> StrictSeq (NativeScript era) -> AllegraTxAuxDataRaw era)
-> Decode
     (ZonkAny 1)
     (Annotator
        (Map Word64 Metadatum
         -> StrictSeq (NativeScript era) -> AllegraTxAuxDataRaw era))
forall t1 (w :: Wrapped).
Typeable t1 =>
Decode w t1 -> Decode w (Annotator t1)
Ann ((Map Word64 Metadatum
 -> StrictSeq (NativeScript era) -> AllegraTxAuxDataRaw era)
-> Decode
     (ZonkAny 1)
     (Map Word64 Metadatum
      -> StrictSeq (NativeScript era) -> AllegraTxAuxDataRaw era)
forall t (w :: Wrapped). t -> Decode w t
Emit Map Word64 Metadatum
-> StrictSeq (NativeScript era) -> AllegraTxAuxDataRaw era
forall era.
Map Word64 Metadatum
-> StrictSeq (NativeScript era) -> AllegraTxAuxDataRaw era
AllegraTxAuxDataRaw)
              Decode
  (ZonkAny 1)
  (Annotator
     (Map Word64 Metadatum
      -> StrictSeq (NativeScript era) -> AllegraTxAuxDataRaw era))
-> Decode (Closed (ZonkAny 3)) (Annotator (Map Word64 Metadatum))
-> Decode
     (ZonkAny 1)
     (Annotator
        (StrictSeq (NativeScript era) -> AllegraTxAuxDataRaw era))
forall a t (w1 :: Wrapped) (d :: Density).
(Typeable a, Typeable t) =>
Decode w1 (Annotator (a -> t))
-> Decode (Closed d) (Annotator a) -> Decode w1 (Annotator t)
<*! Decode (Closed (ZonkAny 3)) (Map Word64 Metadatum)
-> Decode (Closed (ZonkAny 3)) (Annotator (Map Word64 Metadatum))
forall t1 (w :: Wrapped).
Typeable t1 =>
Decode w t1 -> Decode w (Annotator t1)
Ann Decode (Closed (ZonkAny 3)) (Map Word64 Metadatum)
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
              Decode
  (ZonkAny 1)
  (Annotator
     (StrictSeq (NativeScript era) -> AllegraTxAuxDataRaw era))
-> Decode
     (Closed (ZonkAny 2)) (Annotator (StrictSeq (NativeScript era)))
-> Decode (ZonkAny 1) (Annotator (AllegraTxAuxDataRaw era))
forall a t (w1 :: Wrapped) (d :: Density).
(Typeable a, Typeable t) =>
Decode w1 (Annotator (a -> t))
-> Decode (Closed d) (Annotator a) -> Decode w1 (Annotator t)
<*! Decode (Closed (ZonkAny 2)) (StrictSeq (NativeScript era))
-> Decode
     (Closed (ZonkAny 2)) (Annotator (StrictSeq (NativeScript era)))
forall t1 (w :: Wrapped).
Typeable t1 =>
Decode w t1 -> Decode w (Annotator t1)
Ann (StrictSeq (NativeScript era)
-> Decode (Closed (ZonkAny 2)) (StrictSeq (NativeScript era))
forall t (w :: Wrapped). t -> Decode w t
Emit StrictSeq (NativeScript era)
forall a. StrictSeq a
StrictSeq.empty)
          )
      decodeFromList :: Decoder s (Annotator (AllegraTxAuxDataRaw era))
decodeFromList =
        Decode (Closed Dense) (Annotator (AllegraTxAuxDataRaw era))
-> Decoder s (Annotator (AllegraTxAuxDataRaw era))
forall t (w :: Wrapped) s. Typeable t => Decode w t -> Decoder s t
decode
          ( Decode
  (Closed Dense)
  (Map Word64 Metadatum
   -> StrictSeq (NativeScript era) -> AllegraTxAuxDataRaw era)
-> Decode
     (Closed Dense)
     (Annotator
        (Map Word64 Metadatum
         -> StrictSeq (NativeScript era) -> AllegraTxAuxDataRaw era))
forall t1 (w :: Wrapped).
Typeable t1 =>
Decode w t1 -> Decode w (Annotator t1)
Ann ((Map Word64 Metadatum
 -> StrictSeq (NativeScript era) -> AllegraTxAuxDataRaw era)
-> Decode
     (Closed Dense)
     (Map Word64 Metadatum
      -> StrictSeq (NativeScript era) -> AllegraTxAuxDataRaw era)
forall t. t -> Decode (Closed Dense) t
RecD Map Word64 Metadatum
-> StrictSeq (NativeScript era) -> AllegraTxAuxDataRaw era
forall era.
Map Word64 Metadatum
-> StrictSeq (NativeScript era) -> AllegraTxAuxDataRaw era
AllegraTxAuxDataRaw)
              Decode
  (Closed Dense)
  (Annotator
     (Map Word64 Metadatum
      -> StrictSeq (NativeScript era) -> AllegraTxAuxDataRaw era))
-> Decode (Closed (ZonkAny 0)) (Annotator (Map Word64 Metadatum))
-> Decode
     (Closed Dense)
     (Annotator
        (StrictSeq (NativeScript era) -> AllegraTxAuxDataRaw era))
forall a t (w1 :: Wrapped) (d :: Density).
(Typeable a, Typeable t) =>
Decode w1 (Annotator (a -> t))
-> Decode (Closed d) (Annotator a) -> Decode w1 (Annotator t)
<*! Decode (Closed (ZonkAny 0)) (Map Word64 Metadatum)
-> Decode (Closed (ZonkAny 0)) (Annotator (Map Word64 Metadatum))
forall t1 (w :: Wrapped).
Typeable t1 =>
Decode w t1 -> Decode w (Annotator t1)
Ann Decode (Closed (ZonkAny 0)) (Map Word64 Metadatum)
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
              Decode
  (Closed Dense)
  (Annotator
     (StrictSeq (NativeScript era) -> AllegraTxAuxDataRaw era))
-> Decode (Closed Dense) (Annotator (StrictSeq (NativeScript era)))
-> Decode (Closed Dense) (Annotator (AllegraTxAuxDataRaw era))
forall a t (w1 :: Wrapped) (d :: Density).
(Typeable a, Typeable t) =>
Decode w1 (Annotator (a -> t))
-> Decode (Closed d) (Annotator a) -> Decode w1 (Annotator t)
<*! (forall s. Decoder s (Annotator (StrictSeq (NativeScript era))))
-> Decode (Closed Dense) (Annotator (StrictSeq (NativeScript era)))
forall t. (forall s. Decoder s t) -> Decode (Closed Dense) t
D (StrictSeq (Annotator (NativeScript era))
-> Annotator (StrictSeq (NativeScript era))
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a.
Monad m =>
StrictSeq (m a) -> m (StrictSeq a)
sequence (StrictSeq (Annotator (NativeScript era))
 -> Annotator (StrictSeq (NativeScript era)))
-> Decoder s (StrictSeq (Annotator (NativeScript era)))
-> Decoder s (Annotator (StrictSeq (NativeScript era)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Decoder s (StrictSeq (Annotator (NativeScript era)))
forall s. Decoder s (StrictSeq (Annotator (NativeScript era)))
forall a s. DecCBOR a => Decoder s a
decCBOR)
          )

instance
  (Era era, EncCBOR (NativeScript era), ToJSON (NativeScript era)) =>
  ToKeyValuePairs (AllegraTxAuxData era)
  where
  toKeyValuePairs :: forall e kv. KeyValue e kv => AllegraTxAuxData era -> [kv]
toKeyValuePairs (AllegraTxAuxData Map Word64 Metadatum
metadata StrictSeq (NativeScript era)
nativeScripts) =
    [ Key
"metadata" Key -> Map Word64 Metadatum -> kv
forall v. ToJSON v => Key -> v -> kv
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Map Word64 Metadatum
metadata
    , Key
"nativeScripts" Key -> [NativeScript era] -> kv
forall v. ToJSON v => Key -> v -> kv
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= StrictSeq (NativeScript era) -> [NativeScript era]
forall a. StrictSeq a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
F.toList StrictSeq (NativeScript era)
nativeScripts
    ]

deriving via
  KeyValuePairs (AllegraTxAuxData era)
  instance
    (Era era, EncCBOR (NativeScript era), ToJSON (NativeScript era)) => ToJSON (AllegraTxAuxData era)

instance
  (Era era, EncCBOR (NativeScript era), FromJSON (NativeScript era)) =>
  FromJSON (AllegraTxAuxData era)
  where
  parseJSON :: Value -> Parser (AllegraTxAuxData era)
parseJSON = String
-> (Object -> Parser (AllegraTxAuxData era))
-> Value
-> Parser (AllegraTxAuxData era)
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Aeson.withObject String
"AllegraTxAuxData" ((Object -> Parser (AllegraTxAuxData era))
 -> Value -> Parser (AllegraTxAuxData era))
-> (Object -> Parser (AllegraTxAuxData era))
-> Value
-> Parser (AllegraTxAuxData era)
forall a b. (a -> b) -> a -> b
$ \Object
o ->
    Map Word64 Metadatum
-> StrictSeq (NativeScript era) -> AllegraTxAuxData era
forall era.
(Era era, EncCBOR (NativeScript era)) =>
Map Word64 Metadatum
-> StrictSeq (NativeScript era) -> AllegraTxAuxData era
AllegraTxAuxData
      (Map Word64 Metadatum
 -> StrictSeq (NativeScript era) -> AllegraTxAuxData era)
-> Parser (Map Word64 Metadatum)
-> Parser (StrictSeq (NativeScript era) -> AllegraTxAuxData era)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (Map Word64 Metadatum)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"metadata"
      Parser (StrictSeq (NativeScript era) -> AllegraTxAuxData era)
-> Parser (StrictSeq (NativeScript era))
-> Parser (AllegraTxAuxData era)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (StrictSeq (NativeScript era)
-> ([NativeScript era] -> StrictSeq (NativeScript era))
-> Maybe [NativeScript era]
-> StrictSeq (NativeScript era)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe StrictSeq (NativeScript era)
forall a. Monoid a => a
mempty [NativeScript era] -> StrictSeq (NativeScript era)
forall a. [a] -> StrictSeq a
StrictSeq.fromList (Maybe [NativeScript era] -> StrictSeq (NativeScript era))
-> Parser (Maybe [NativeScript era])
-> Parser (StrictSeq (NativeScript era))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (Maybe [NativeScript era])
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"nativeScripts")