{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE ViewPatterns #-}
{-# OPTIONS_GHC -Wno-orphans #-}
{-# OPTIONS_HADDOCK not-home #-}

module Cardano.Ledger.Shelley.Tx (
  -- * Transaction
  ShelleyTx (..),
  bodyShelleyTxL,
  witsShelleyTxL,
  auxDataShelleyTxL,
  mkBasicShelleyTx,
  shelleyMinFeeTx,
  shelleyEqTxRaw,
  sizeShelleyTxF,
) where

import Cardano.Ledger.Binary (
  Annotator (..),
  DecCBOR (decCBOR),
  EncCBOR (encCBOR),
  Encoding,
  ToCBOR,
  decodeNullStrictMaybe,
  encodeListLen,
  encodeNullStrictMaybe,
  serialize,
 )
import Cardano.Ledger.Binary.Coders
import qualified Cardano.Ledger.Binary.Plain as Plain
import Cardano.Ledger.Coin (Coin)
import Cardano.Ledger.Core
import Cardano.Ledger.MemoBytes (
  EqRaw (..),
 )
import Cardano.Ledger.Shelley.Era (ShelleyEra)
import Cardano.Ledger.Shelley.Scripts (validateMultiSig)
import Cardano.Ledger.Shelley.TxAuxData ()
import Cardano.Ledger.Shelley.TxBody ()
import Cardano.Ledger.Shelley.TxWits ()
import Cardano.Ledger.Val ((<+>), (<×>))
import Control.DeepSeq (NFData)
import qualified Data.ByteString.Lazy as LBS
import Data.Functor.Classes (Eq1 (liftEq))
import Data.Maybe.Strict (
  StrictMaybe (..),
  strictMaybeToMaybe,
 )
import GHC.Generics (Generic)
import Lens.Micro (Lens', SimpleGetter, lens, to, (^.))
import NoThunks.Class (NoThunks (..))

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

data ShelleyTx era = ShelleyTx
  { forall era. ShelleyTx era -> TxBody era
stBody :: !(TxBody era)
  , forall era. ShelleyTx era -> TxWits era
stWits :: !(TxWits era)
  , forall era. ShelleyTx era -> StrictMaybe (TxAuxData era)
stAuxData :: !(StrictMaybe (TxAuxData era))
  }
  deriving ((forall x. ShelleyTx era -> Rep (ShelleyTx era) x)
-> (forall x. Rep (ShelleyTx era) x -> ShelleyTx era)
-> Generic (ShelleyTx era)
forall x. Rep (ShelleyTx era) x -> ShelleyTx era
forall x. ShelleyTx era -> Rep (ShelleyTx era) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall era x. Rep (ShelleyTx era) x -> ShelleyTx era
forall era x. ShelleyTx era -> Rep (ShelleyTx era) x
$cfrom :: forall era x. ShelleyTx era -> Rep (ShelleyTx era) x
from :: forall x. ShelleyTx era -> Rep (ShelleyTx era) x
$cto :: forall era x. Rep (ShelleyTx era) x -> ShelleyTx era
to :: forall x. Rep (ShelleyTx era) x -> ShelleyTx era
Generic)

instance
  ( NFData (TxBody era)
  , NFData (TxWits era)
  , NFData (TxAuxData era)
  ) =>
  NFData (ShelleyTx era)

deriving instance
  ( Era era
  , Eq (TxBody era)
  , Eq (TxWits era)
  , Eq (TxAuxData era)
  ) =>
  Eq (ShelleyTx era)

deriving instance
  ( Era era
  , Show (TxBody era)
  , Show (TxWits era)
  , Show (TxAuxData era)
  ) =>
  Show (ShelleyTx era)

instance
  ( Era era
  , NoThunks (TxAuxData era)
  , NoThunks (TxBody era)
  , NoThunks (TxWits era)
  ) =>
  NoThunks (ShelleyTx era)

-- | `TxBody` setter and getter for `ShelleyTx`.
bodyShelleyTxL :: Lens' (ShelleyTx era) (TxBody era)
bodyShelleyTxL :: forall era (f :: * -> *).
Functor f =>
(TxBody era -> f (TxBody era))
-> ShelleyTx era -> f (ShelleyTx era)
bodyShelleyTxL =
  (ShelleyTx era -> TxBody era)
-> (ShelleyTx era -> TxBody era -> ShelleyTx era)
-> forall {f :: * -> *}.
   Functor f =>
   (TxBody era -> f (TxBody era))
   -> ShelleyTx era -> f (ShelleyTx era)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens ShelleyTx era -> TxBody era
forall era. ShelleyTx era -> TxBody era
stBody ((ShelleyTx era -> TxBody era -> ShelleyTx era)
 -> forall {f :: * -> *}.
    Functor f =>
    (TxBody era -> f (TxBody era))
    -> ShelleyTx era -> f (ShelleyTx era))
-> (ShelleyTx era -> TxBody era -> ShelleyTx era)
-> forall {f :: * -> *}.
   Functor f =>
   (TxBody era -> f (TxBody era))
   -> ShelleyTx era -> f (ShelleyTx era)
forall a b. (a -> b) -> a -> b
$ \ShelleyTx era
tx TxBody era
txBody -> ShelleyTx era
tx {stBody = txBody}
{-# INLINEABLE bodyShelleyTxL #-}

-- | `TxWits` setter and getter for `ShelleyTx`.
witsShelleyTxL :: Lens' (ShelleyTx era) (TxWits era)
witsShelleyTxL :: forall era (f :: * -> *).
Functor f =>
(TxWits era -> f (TxWits era))
-> ShelleyTx era -> f (ShelleyTx era)
witsShelleyTxL =
  (ShelleyTx era -> TxWits era)
-> (ShelleyTx era -> TxWits era -> ShelleyTx era)
-> forall {f :: * -> *}.
   Functor f =>
   (TxWits era -> f (TxWits era))
   -> ShelleyTx era -> f (ShelleyTx era)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens ShelleyTx era -> TxWits era
forall era. ShelleyTx era -> TxWits era
stWits ((ShelleyTx era -> TxWits era -> ShelleyTx era)
 -> forall {f :: * -> *}.
    Functor f =>
    (TxWits era -> f (TxWits era))
    -> ShelleyTx era -> f (ShelleyTx era))
-> (ShelleyTx era -> TxWits era -> ShelleyTx era)
-> forall {f :: * -> *}.
   Functor f =>
   (TxWits era -> f (TxWits era))
   -> ShelleyTx era -> f (ShelleyTx era)
forall a b. (a -> b) -> a -> b
$ \ShelleyTx era
tx TxWits era
txWits -> ShelleyTx era
tx {stWits = txWits}
{-# INLINEABLE witsShelleyTxL #-}

-- | `TxAuxData` setter and getter for `ShelleyTx`.
auxDataShelleyTxL :: Lens' (ShelleyTx era) (StrictMaybe (TxAuxData era))
auxDataShelleyTxL :: forall era (f :: * -> *).
Functor f =>
(StrictMaybe (TxAuxData era) -> f (StrictMaybe (TxAuxData era)))
-> ShelleyTx era -> f (ShelleyTx era)
auxDataShelleyTxL =
  (ShelleyTx era -> StrictMaybe (TxAuxData era))
-> (ShelleyTx era -> StrictMaybe (TxAuxData era) -> ShelleyTx era)
-> forall {f :: * -> *}.
   Functor f =>
   (StrictMaybe (TxAuxData era) -> f (StrictMaybe (TxAuxData era)))
   -> ShelleyTx era -> f (ShelleyTx era)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens ShelleyTx era -> StrictMaybe (TxAuxData era)
forall era. ShelleyTx era -> StrictMaybe (TxAuxData era)
stAuxData ((ShelleyTx era -> StrictMaybe (TxAuxData era) -> ShelleyTx era)
 -> forall {f :: * -> *}.
    Functor f =>
    (StrictMaybe (TxAuxData era) -> f (StrictMaybe (TxAuxData era)))
    -> ShelleyTx era -> f (ShelleyTx era))
-> (ShelleyTx era -> StrictMaybe (TxAuxData era) -> ShelleyTx era)
-> forall {f :: * -> *}.
   Functor f =>
   (StrictMaybe (TxAuxData era) -> f (StrictMaybe (TxAuxData era)))
   -> ShelleyTx era -> f (ShelleyTx era)
forall a b. (a -> b) -> a -> b
$ \ShelleyTx era
tx StrictMaybe (TxAuxData era)
txAuxData -> ShelleyTx era
tx {stAuxData = txAuxData}
{-# INLINEABLE auxDataShelleyTxL #-}

mkBasicShelleyTx :: EraTx era => TxBody era -> ShelleyTx era
mkBasicShelleyTx :: forall era. EraTx era => TxBody era -> ShelleyTx era
mkBasicShelleyTx TxBody era
txBody =
  ShelleyTx
    { stBody :: TxBody era
stBody = TxBody era
txBody
    , stWits :: TxWits era
stWits = TxWits era
forall era. EraTxWits era => TxWits era
mkBasicTxWits
    , stAuxData :: StrictMaybe (TxAuxData era)
stAuxData = StrictMaybe (TxAuxData era)
forall a. StrictMaybe a
SNothing
    }

toCBORForSizeComputation ::
  ( EncCBOR (TxBody era)
  , EncCBOR (TxWits era)
  , EncCBOR (TxAuxData era)
  ) =>
  ShelleyTx era ->
  Encoding
toCBORForSizeComputation :: forall era.
(EncCBOR (TxBody era), EncCBOR (TxWits era),
 EncCBOR (TxAuxData era)) =>
ShelleyTx era -> Encoding
toCBORForSizeComputation ShelleyTx {TxBody era
stBody :: forall era. ShelleyTx era -> TxBody era
stBody :: TxBody era
stBody, TxWits era
stWits :: forall era. ShelleyTx era -> TxWits era
stWits :: TxWits era
stWits, StrictMaybe (TxAuxData era)
stAuxData :: forall era. ShelleyTx era -> StrictMaybe (TxAuxData era)
stAuxData :: StrictMaybe (TxAuxData era)
stAuxData} =
  Word -> Encoding
encodeListLen Word
3
    Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> TxBody era -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR TxBody era
stBody
    Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> TxWits era -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR TxWits era
stWits
    Encoding -> Encoding -> Encoding
forall a. Semigroup a => a -> a -> a
<> (TxAuxData era -> Encoding)
-> StrictMaybe (TxAuxData era) -> Encoding
forall a. (a -> Encoding) -> StrictMaybe a -> Encoding
encodeNullStrictMaybe TxAuxData era -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR StrictMaybe (TxAuxData era)
stAuxData

-- | txsize computes the length of the serialised bytes (for estimations)
sizeShelleyTxF :: forall era. EraTx era => SimpleGetter (ShelleyTx era) Integer
sizeShelleyTxF :: forall era. EraTx era => SimpleGetter (ShelleyTx era) Integer
sizeShelleyTxF =
  (ShelleyTx era -> Integer) -> SimpleGetter (ShelleyTx era) Integer
forall s a. (s -> a) -> SimpleGetter s a
to ((ShelleyTx era -> Integer)
 -> SimpleGetter (ShelleyTx era) Integer)
-> (ShelleyTx era -> Integer)
-> SimpleGetter (ShelleyTx era) Integer
forall a b. (a -> b) -> a -> b
$
    Int64 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral
      (Int64 -> Integer)
-> (ShelleyTx era -> Int64) -> ShelleyTx era -> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Int64
LBS.length
      (ByteString -> Int64)
-> (ShelleyTx era -> ByteString) -> ShelleyTx era -> Int64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Version -> Encoding -> ByteString
forall a. EncCBOR a => Version -> a -> ByteString
serialize (forall era. Era era => Version
eraProtVerLow @era)
      (Encoding -> ByteString)
-> (ShelleyTx era -> Encoding) -> ShelleyTx era -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShelleyTx era -> Encoding
forall era.
(EncCBOR (TxBody era), EncCBOR (TxWits era),
 EncCBOR (TxAuxData era)) =>
ShelleyTx era -> Encoding
toCBORForSizeComputation
{-# INLINEABLE sizeShelleyTxF #-}

instance
  ( EraTxBody era
  , EraTxWits era
  , EraTxAuxData era
  ) =>
  DecCBOR (Annotator (ShelleyTx era))
  where
  decCBOR :: forall s. Decoder s (Annotator (ShelleyTx era))
decCBOR =
    Decode ('Closed 'Dense) (Annotator (ShelleyTx era))
-> Decoder s (Annotator (ShelleyTx era))
forall t (w :: Wrapped) s. Typeable t => Decode w t -> Decoder s t
decode (Decode ('Closed 'Dense) (Annotator (ShelleyTx era))
 -> Decoder s (Annotator (ShelleyTx era)))
-> Decode ('Closed 'Dense) (Annotator (ShelleyTx era))
-> Decoder s (Annotator (ShelleyTx era))
forall a b. (a -> b) -> a -> b
$
      Decode
  ('Closed 'Dense)
  (TxBody era
   -> TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx era)
-> Decode
     ('Closed 'Dense)
     (Annotator
        (TxBody era
         -> TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx era))
forall t1 (w :: Wrapped).
Typeable t1 =>
Decode w t1 -> Decode w (Annotator t1)
Ann ((TxBody era
 -> TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx era)
-> Decode
     ('Closed 'Dense)
     (TxBody era
      -> TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx era)
forall t. t -> Decode ('Closed 'Dense) t
RecD TxBody era
-> TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx era
forall era.
TxBody era
-> TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx era
ShelleyTx)
        Decode
  ('Closed 'Dense)
  (Annotator
     (TxBody era
      -> TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx era))
-> Decode ('Closed Any) (Annotator (TxBody era))
-> Decode
     ('Closed 'Dense)
     (Annotator
        (TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx 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 Any) (Annotator (TxBody era))
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
        Decode
  ('Closed 'Dense)
  (Annotator
     (TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx era))
-> Decode ('Closed Any) (Annotator (TxWits era))
-> Decode
     ('Closed 'Dense)
     (Annotator (StrictMaybe (TxAuxData era) -> ShelleyTx 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 Any) (Annotator (TxWits era))
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
        Decode
  ('Closed 'Dense)
  (Annotator (StrictMaybe (TxAuxData era) -> ShelleyTx era))
-> Decode
     ('Closed 'Dense) (Annotator (StrictMaybe (TxAuxData era)))
-> Decode ('Closed 'Dense) (Annotator (ShelleyTx 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 (StrictMaybe (TxAuxData era))))
-> Decode
     ('Closed 'Dense) (Annotator (StrictMaybe (TxAuxData era)))
forall t. (forall s. Decoder s t) -> Decode ('Closed 'Dense) t
D (StrictMaybe (Annotator (TxAuxData era))
-> Annotator (StrictMaybe (TxAuxData era))
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a.
Monad m =>
StrictMaybe (m a) -> m (StrictMaybe a)
sequence (StrictMaybe (Annotator (TxAuxData era))
 -> Annotator (StrictMaybe (TxAuxData era)))
-> Decoder s (StrictMaybe (Annotator (TxAuxData era)))
-> Decoder s (Annotator (StrictMaybe (TxAuxData era)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Decoder s (Annotator (TxAuxData era))
-> Decoder s (StrictMaybe (Annotator (TxAuxData era)))
forall s a. Decoder s a -> Decoder s (StrictMaybe a)
decodeNullStrictMaybe Decoder s (Annotator (TxAuxData era))
forall s. Decoder s (Annotator (TxAuxData era))
forall a s. DecCBOR a => Decoder s a
decCBOR)

instance EraTx ShelleyEra where
  type Tx ShelleyEra = ShelleyTx ShelleyEra

  mkBasicTx :: TxBody ShelleyEra -> Tx ShelleyEra
mkBasicTx = TxBody ShelleyEra -> Tx ShelleyEra
TxBody ShelleyEra -> ShelleyTx ShelleyEra
forall era. EraTx era => TxBody era -> ShelleyTx era
mkBasicShelleyTx

  bodyTxL :: Lens' (Tx ShelleyEra) (TxBody ShelleyEra)
bodyTxL = (TxBody ShelleyEra -> f (TxBody ShelleyEra))
-> Tx ShelleyEra -> f (Tx ShelleyEra)
(TxBody ShelleyEra -> f (TxBody ShelleyEra))
-> ShelleyTx ShelleyEra -> f (ShelleyTx ShelleyEra)
forall era (f :: * -> *).
Functor f =>
(TxBody era -> f (TxBody era))
-> ShelleyTx era -> f (ShelleyTx era)
bodyShelleyTxL
  {-# INLINE bodyTxL #-}

  witsTxL :: Lens' (Tx ShelleyEra) (TxWits ShelleyEra)
witsTxL = (TxWits ShelleyEra -> f (TxWits ShelleyEra))
-> Tx ShelleyEra -> f (Tx ShelleyEra)
(TxWits ShelleyEra -> f (TxWits ShelleyEra))
-> ShelleyTx ShelleyEra -> f (ShelleyTx ShelleyEra)
forall era (f :: * -> *).
Functor f =>
(TxWits era -> f (TxWits era))
-> ShelleyTx era -> f (ShelleyTx era)
witsShelleyTxL
  {-# INLINE witsTxL #-}

  auxDataTxL :: Lens' (Tx ShelleyEra) (StrictMaybe (TxAuxData ShelleyEra))
auxDataTxL = (StrictMaybe (TxAuxData ShelleyEra)
 -> f (StrictMaybe (TxAuxData ShelleyEra)))
-> Tx ShelleyEra -> f (Tx ShelleyEra)
(StrictMaybe (TxAuxData ShelleyEra)
 -> f (StrictMaybe (TxAuxData ShelleyEra)))
-> ShelleyTx ShelleyEra -> f (ShelleyTx ShelleyEra)
forall era (f :: * -> *).
Functor f =>
(StrictMaybe (TxAuxData era) -> f (StrictMaybe (TxAuxData era)))
-> ShelleyTx era -> f (ShelleyTx era)
auxDataShelleyTxL
  {-# INLINE auxDataTxL #-}

  sizeTxF :: SimpleGetter (Tx ShelleyEra) Integer
sizeTxF = (Integer -> Const r Integer)
-> Tx ShelleyEra -> Const r (Tx ShelleyEra)
Getting r (ShelleyTx ShelleyEra) Integer
forall era. EraTx era => SimpleGetter (ShelleyTx era) Integer
SimpleGetter (ShelleyTx ShelleyEra) Integer
sizeShelleyTxF
  {-# INLINE sizeTxF #-}

  validateNativeScript :: Tx ShelleyEra -> NativeScript ShelleyEra -> Bool
validateNativeScript = Tx ShelleyEra -> NativeScript ShelleyEra -> Bool
forall era.
(ShelleyEraScript era, EraTx era,
 NativeScript era ~ MultiSig era) =>
Tx era -> NativeScript era -> Bool
validateMultiSig
  {-# INLINE validateNativeScript #-}

  getMinFeeTx :: PParams ShelleyEra -> Tx ShelleyEra -> Int -> Coin
getMinFeeTx PParams ShelleyEra
pp Tx ShelleyEra
tx Int
_ = PParams ShelleyEra -> Tx ShelleyEra -> Coin
forall era. EraTx era => PParams era -> Tx era -> Coin
shelleyMinFeeTx PParams ShelleyEra
pp Tx ShelleyEra
tx

instance (Tx era ~ ShelleyTx era, EraTx era) => EqRaw (ShelleyTx era) where
  eqRaw :: ShelleyTx era -> ShelleyTx era -> Bool
eqRaw = Tx era -> Tx era -> Bool
ShelleyTx era -> ShelleyTx era -> Bool
forall era. EraTx era => Tx era -> Tx era -> Bool
shelleyEqTxRaw

shelleyEqTxRaw :: EraTx era => Tx era -> Tx era -> Bool
shelleyEqTxRaw :: forall era. EraTx era => Tx era -> Tx era -> Bool
shelleyEqTxRaw Tx era
tx1 Tx era
tx2 =
  TxBody era -> TxBody era -> Bool
forall a. EqRaw a => a -> a -> Bool
eqRaw (Tx era
tx1 Tx era -> Getting (TxBody era) (Tx era) (TxBody era) -> TxBody era
forall s a. s -> Getting a s a -> a
^. Getting (TxBody era) (Tx era) (TxBody era)
forall era. EraTx era => Lens' (Tx era) (TxBody era)
Lens' (Tx era) (TxBody era)
bodyTxL) (Tx era
tx2 Tx era -> Getting (TxBody era) (Tx era) (TxBody era) -> TxBody era
forall s a. s -> Getting a s a -> a
^. Getting (TxBody era) (Tx era) (TxBody era)
forall era. EraTx era => Lens' (Tx era) (TxBody era)
Lens' (Tx era) (TxBody era)
bodyTxL)
    Bool -> Bool -> Bool
&& TxWits era -> TxWits era -> Bool
forall a. EqRaw a => a -> a -> Bool
eqRaw (Tx era
tx1 Tx era -> Getting (TxWits era) (Tx era) (TxWits era) -> TxWits era
forall s a. s -> Getting a s a -> a
^. Getting (TxWits era) (Tx era) (TxWits era)
forall era. EraTx era => Lens' (Tx era) (TxWits era)
Lens' (Tx era) (TxWits era)
witsTxL) (Tx era
tx2 Tx era -> Getting (TxWits era) (Tx era) (TxWits era) -> TxWits era
forall s a. s -> Getting a s a -> a
^. Getting (TxWits era) (Tx era) (TxWits era)
forall era. EraTx era => Lens' (Tx era) (TxWits era)
Lens' (Tx era) (TxWits era)
witsTxL)
    Bool -> Bool -> Bool
&& (TxAuxData era -> TxAuxData era -> Bool)
-> Maybe (TxAuxData era) -> Maybe (TxAuxData era) -> Bool
forall a b. (a -> b -> Bool) -> Maybe a -> Maybe b -> Bool
forall (f :: * -> *) a b.
Eq1 f =>
(a -> b -> Bool) -> f a -> f b -> Bool
liftEq -- TODO: Implement Eq1 instance for StrictMaybe
      TxAuxData era -> TxAuxData era -> Bool
forall a. EqRaw a => a -> a -> Bool
eqRaw
      (StrictMaybe (TxAuxData era) -> Maybe (TxAuxData era)
forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe (Tx era
tx1 Tx era
-> Getting
     (StrictMaybe (TxAuxData era))
     (Tx era)
     (StrictMaybe (TxAuxData era))
-> StrictMaybe (TxAuxData era)
forall s a. s -> Getting a s a -> a
^. Getting
  (StrictMaybe (TxAuxData era))
  (Tx era)
  (StrictMaybe (TxAuxData era))
forall era.
EraTx era =>
Lens' (Tx era) (StrictMaybe (TxAuxData era))
Lens' (Tx era) (StrictMaybe (TxAuxData era))
auxDataTxL))
      (StrictMaybe (TxAuxData era) -> Maybe (TxAuxData era)
forall a. StrictMaybe a -> Maybe a
strictMaybeToMaybe (Tx era
tx2 Tx era
-> Getting
     (StrictMaybe (TxAuxData era))
     (Tx era)
     (StrictMaybe (TxAuxData era))
-> StrictMaybe (TxAuxData era)
forall s a. s -> Getting a s a -> a
^. Getting
  (StrictMaybe (TxAuxData era))
  (Tx era)
  (StrictMaybe (TxAuxData era))
forall era.
EraTx era =>
Lens' (Tx era) (StrictMaybe (TxAuxData era))
Lens' (Tx era) (StrictMaybe (TxAuxData era))
auxDataTxL))

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

instance
  (Era era, EncCBOR (TxWits era), EncCBOR (TxBody era), EncCBOR (TxAuxData era)) =>
  EncCBOR (ShelleyTx era)
  where
  encCBOR :: ShelleyTx era -> Encoding
encCBOR ShelleyTx {StrictMaybe (TxAuxData era)
TxWits era
TxBody era
stBody :: forall era. ShelleyTx era -> TxBody era
stWits :: forall era. ShelleyTx era -> TxWits era
stAuxData :: forall era. ShelleyTx era -> StrictMaybe (TxAuxData era)
stBody :: TxBody era
stWits :: TxWits era
stAuxData :: StrictMaybe (TxAuxData era)
..} =
    Encode ('Closed 'Dense) (ShelleyTx era) -> Encoding
forall (w :: Wrapped) t. Encode w t -> Encoding
encode (Encode ('Closed 'Dense) (ShelleyTx era) -> Encoding)
-> Encode ('Closed 'Dense) (ShelleyTx era) -> Encoding
forall a b. (a -> b) -> a -> b
$
      (TxBody era
 -> TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx era)
-> Encode
     ('Closed 'Dense)
     (TxBody era
      -> TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx era)
forall t. t -> Encode ('Closed 'Dense) t
Rec TxBody era
-> TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx era
forall era.
TxBody era
-> TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx era
ShelleyTx
        Encode
  ('Closed 'Dense)
  (TxBody era
   -> TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx era)
-> Encode ('Closed 'Dense) (TxBody era)
-> Encode
     ('Closed 'Dense)
     (TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx era)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode ('Closed r) a -> Encode w t
!> TxBody era -> Encode ('Closed 'Dense) (TxBody era)
forall t. EncCBOR t => t -> Encode ('Closed 'Dense) t
To TxBody era
stBody
        Encode
  ('Closed 'Dense)
  (TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx era)
-> Encode ('Closed 'Dense) (TxWits era)
-> Encode
     ('Closed 'Dense) (StrictMaybe (TxAuxData era) -> ShelleyTx era)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode ('Closed r) a -> Encode w t
!> TxWits era -> Encode ('Closed 'Dense) (TxWits era)
forall t. EncCBOR t => t -> Encode ('Closed 'Dense) t
To TxWits era
stWits
        Encode
  ('Closed 'Dense) (StrictMaybe (TxAuxData era) -> ShelleyTx era)
-> Encode ('Closed 'Dense) (StrictMaybe (TxAuxData era))
-> Encode ('Closed 'Dense) (ShelleyTx era)
forall (w :: Wrapped) a t (r :: Density).
Encode w (a -> t) -> Encode ('Closed r) a -> Encode w t
!> (StrictMaybe (TxAuxData era) -> Encoding)
-> StrictMaybe (TxAuxData era)
-> Encode ('Closed 'Dense) (StrictMaybe (TxAuxData era))
forall t. (t -> Encoding) -> t -> Encode ('Closed 'Dense) t
E ((TxAuxData era -> Encoding)
-> StrictMaybe (TxAuxData era) -> Encoding
forall a. (a -> Encoding) -> StrictMaybe a -> Encoding
encodeNullStrictMaybe TxAuxData era -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR) StrictMaybe (TxAuxData era)
stAuxData

instance
  ( Era era
  , DecCBOR (TxBody era)
  , DecCBOR (TxWits era)
  , DecCBOR (TxAuxData era)
  ) =>
  DecCBOR (ShelleyTx era)
  where
  decCBOR :: forall s. Decoder s (ShelleyTx era)
decCBOR =
    Decode ('Closed 'Dense) (ShelleyTx era)
-> Decoder s (ShelleyTx era)
forall t (w :: Wrapped) s. Typeable t => Decode w t -> Decoder s t
decode (Decode ('Closed 'Dense) (ShelleyTx era)
 -> Decoder s (ShelleyTx era))
-> Decode ('Closed 'Dense) (ShelleyTx era)
-> Decoder s (ShelleyTx era)
forall a b. (a -> b) -> a -> b
$
      (TxBody era
 -> TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx era)
-> Decode
     ('Closed 'Dense)
     (TxBody era
      -> TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx era)
forall t. t -> Decode ('Closed 'Dense) t
RecD TxBody era
-> TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx era
forall era.
TxBody era
-> TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx era
ShelleyTx
        Decode
  ('Closed 'Dense)
  (TxBody era
   -> TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx era)
-> Decode ('Closed Any) (TxBody era)
-> Decode
     ('Closed 'Dense)
     (TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx era)
forall a (w1 :: Wrapped) t (w :: Density).
Typeable a =>
Decode w1 (a -> t) -> Decode ('Closed w) a -> Decode w1 t
<! Decode ('Closed Any) (TxBody era)
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
        Decode
  ('Closed 'Dense)
  (TxWits era -> StrictMaybe (TxAuxData era) -> ShelleyTx era)
-> Decode ('Closed Any) (TxWits era)
-> Decode
     ('Closed 'Dense) (StrictMaybe (TxAuxData era) -> ShelleyTx era)
forall a (w1 :: Wrapped) t (w :: Density).
Typeable a =>
Decode w1 (a -> t) -> Decode ('Closed w) a -> Decode w1 t
<! Decode ('Closed Any) (TxWits era)
forall t (w :: Wrapped). DecCBOR t => Decode w t
From
        Decode
  ('Closed 'Dense) (StrictMaybe (TxAuxData era) -> ShelleyTx era)
-> Decode ('Closed 'Dense) (StrictMaybe (TxAuxData era))
-> Decode ('Closed 'Dense) (ShelleyTx era)
forall a (w1 :: Wrapped) t (w :: Density).
Typeable a =>
Decode w1 (a -> t) -> Decode ('Closed w) a -> Decode w1 t
<! (forall s. Decoder s (StrictMaybe (TxAuxData era)))
-> Decode ('Closed 'Dense) (StrictMaybe (TxAuxData era))
forall t. (forall s. Decoder s t) -> Decode ('Closed 'Dense) t
D (Decoder s (TxAuxData era)
-> Decoder s (StrictMaybe (TxAuxData era))
forall s a. Decoder s a -> Decoder s (StrictMaybe a)
decodeNullStrictMaybe Decoder s (TxAuxData era)
forall s. Decoder s (TxAuxData era)
forall a s. DecCBOR a => Decoder s a
decCBOR)

instance
  (Era era, EncCBOR (TxWits era), EncCBOR (TxBody era), EncCBOR (TxAuxData era)) =>
  ToCBOR (ShelleyTx era)
  where
  toCBOR :: ShelleyTx era -> Encoding
toCBOR = forall era t. (Era era, EncCBOR t) => t -> Encoding
toEraCBOR @era

-- | Minimum fee calculation
shelleyMinFeeTx :: EraTx era => PParams era -> Tx era -> Coin
shelleyMinFeeTx :: forall era. EraTx era => PParams era -> Tx era -> Coin
shelleyMinFeeTx PParams era
pp Tx era
tx =
  (Tx era
tx Tx era -> Getting Integer (Tx era) Integer -> Integer
forall s a. s -> Getting a s a -> a
^. Getting Integer (Tx era) Integer
forall era. EraTx era => SimpleGetter (Tx era) Integer
SimpleGetter (Tx era) Integer
sizeTxF Integer -> Coin -> Coin
forall i. Integral i => i -> Coin -> Coin
forall t i. (Val t, Integral i) => i -> t -> t
<×> PParams era
pp PParams era -> Getting Coin (PParams era) Coin -> Coin
forall s a. s -> Getting a s a -> a
^. Getting Coin (PParams era) Coin
forall era. EraPParams era => Lens' (PParams era) Coin
Lens' (PParams era) Coin
ppMinFeeAL) Coin -> Coin -> Coin
forall t. Val t => t -> t -> t
<+> PParams era
pp PParams era -> Getting Coin (PParams era) Coin -> Coin
forall s a. s -> Getting a s a -> a
^. Getting Coin (PParams era) Coin
forall era. EraPParams era => Lens' (PParams era) Coin
Lens' (PParams era) Coin
ppMinFeeBL