{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE TypeFamilies #-}
{-# OPTIONS_GHC -Wno-orphans #-}

module Cardano.Ledger.Mary.Scripts (
  module Cardano.Ledger.Allegra.Scripts,
)
where

import Cardano.Ledger.Allegra.Scripts
import Cardano.Ledger.Core
import Cardano.Ledger.Crypto (Crypto, StandardCrypto)
import Cardano.Ledger.Mary.Era (MaryEra)
import Cardano.Ledger.Shelley.Scripts (
  ShelleyEraScript (..),
  nativeMultiSigTag,
 )

-- | Since Timelock scripts are a strictly backwards compatible extension of
-- MultiSig scripts, we can use the same 'scriptPrefixTag' tag here as we did
-- for the ValidateScript instance in MultiSig
instance Crypto c => EraScript (MaryEra c) where
  type Script (MaryEra c) = Timelock (MaryEra c)
  type NativeScript (MaryEra c) = Timelock (MaryEra c)

  upgradeScript :: EraScript (PreviousEra (MaryEra c)) =>
Script (PreviousEra (MaryEra c)) -> Script (MaryEra c)
upgradeScript = forall era1 era2.
(Era era1, Era era2, EraCrypto era1 ~ EraCrypto era2) =>
Timelock era1 -> Timelock era2
translateTimelock

  scriptPrefixTag :: Script (MaryEra c) -> ByteString
scriptPrefixTag Script (MaryEra c)
_script = ByteString
nativeMultiSigTag -- "\x00"

  getNativeScript :: Script (MaryEra c) -> Maybe (NativeScript (MaryEra c))
getNativeScript = forall a. a -> Maybe a
Just

  fromNativeScript :: NativeScript (MaryEra c) -> Script (MaryEra c)
fromNativeScript = forall a. a -> a
id

instance Crypto c => ShelleyEraScript (MaryEra c) where
  {-# SPECIALIZE instance ShelleyEraScript (MaryEra StandardCrypto) #-}

  mkRequireSignature :: KeyHash 'Witness (EraCrypto (MaryEra c))
-> NativeScript (MaryEra c)
mkRequireSignature = forall era.
Era era =>
KeyHash 'Witness (EraCrypto era) -> Timelock era
mkRequireSignatureTimelock
  getRequireSignature :: NativeScript (MaryEra c)
-> Maybe (KeyHash 'Witness (EraCrypto (MaryEra c)))
getRequireSignature = forall era.
Era era =>
Timelock era -> Maybe (KeyHash 'Witness (EraCrypto era))
getRequireSignatureTimelock

  mkRequireAllOf :: StrictSeq (NativeScript (MaryEra c)) -> NativeScript (MaryEra c)
mkRequireAllOf = forall era. Era era => StrictSeq (Timelock era) -> Timelock era
mkRequireAllOfTimelock
  getRequireAllOf :: NativeScript (MaryEra c)
-> Maybe (StrictSeq (NativeScript (MaryEra c)))
getRequireAllOf = forall era.
Era era =>
Timelock era -> Maybe (StrictSeq (Timelock era))
getRequireAllOfTimelock

  mkRequireAnyOf :: StrictSeq (NativeScript (MaryEra c)) -> NativeScript (MaryEra c)
mkRequireAnyOf = forall era. Era era => StrictSeq (Timelock era) -> Timelock era
mkRequireAnyOfTimelock
  getRequireAnyOf :: NativeScript (MaryEra c)
-> Maybe (StrictSeq (NativeScript (MaryEra c)))
getRequireAnyOf = forall era.
Era era =>
Timelock era -> Maybe (StrictSeq (Timelock era))
getRequireAnyOfTimelock

  mkRequireMOf :: Int
-> StrictSeq (NativeScript (MaryEra c)) -> NativeScript (MaryEra c)
mkRequireMOf = forall era.
Era era =>
Int -> StrictSeq (Timelock era) -> Timelock era
mkRequireMOfTimelock
  getRequireMOf :: NativeScript (MaryEra c)
-> Maybe (Int, StrictSeq (NativeScript (MaryEra c)))
getRequireMOf = forall era.
Era era =>
Timelock era -> Maybe (Int, StrictSeq (Timelock era))
getRequireMOfTimelock

instance Crypto c => AllegraEraScript (MaryEra c) where
  {-# SPECIALIZE instance AllegraEraScript (MaryEra StandardCrypto) #-}

  mkTimeStart :: SlotNo -> NativeScript (MaryEra c)
mkTimeStart = forall era. Era era => SlotNo -> Timelock era
mkTimeStartTimelock
  getTimeStart :: NativeScript (MaryEra c) -> Maybe SlotNo
getTimeStart = forall era. Era era => Timelock era -> Maybe SlotNo
getTimeStartTimelock

  mkTimeExpire :: SlotNo -> NativeScript (MaryEra c)
mkTimeExpire = forall era. Era era => SlotNo -> Timelock era
mkTimeExpireTimelock
  getTimeExpire :: NativeScript (MaryEra c) -> Maybe SlotNo
getTimeExpire = forall era. Era era => Timelock era -> Maybe SlotNo
getTimeExpireTimelock