Update to Node 8.8

cabal.project

@@ -10,8 +10,8 @@ repository cardano-haskell-packages
     d4a35cd3121aa00d18544bb0ac01c3e1691d618f462c46129271bccf39f7e8ee
 
 index-state:
-  , hackage.haskell.org 2023-11-20T23:52:53Z
-  , cardano-haskell-packages 2023-12-06T19:40:56Z
+  , hackage.haskell.org 2024-02-06T15:14:59Z
+  , cardano-haskell-packages 2024-02-07T07:51:35Z
 
 packages:
   cardano-db
@@ -79,8 +79,8 @@ allow-newer:
 source-repository-package
   type: git
   location: https://github.com/IntersectMBO/cardano-node
-  tag: 34d89af65439db92293b88967c299c20692abc1c
-  --sha256: sha256-pVUWfzVnM4RvpFlJNH2ZmWPZzmkGT1Ty8B1p7NFh69M=
+  tag: 4bb2048db77d623ee6e3678618c2d8b6c4676333
+  --sha256: sha256-pWXI8dyqKQ3HncbBtd54wdHi3Pj7J5y+nybqpzMXOj4=
   subdir:
     cardano-git-rev
     cardano-node

cardano-chain-gen/cardano-chain-gen.cabal

@@ -212,4 +212,4 @@ test-suite cardano-chain-gen
                       , persistent-postgresql
                       , postgresql-simple
                       , QuickCheck
-                      , quickcheck-state-machine
+                      , quickcheck-state-machine:no-vendored-treediff

cardano-db-sync/src/Cardano/DbSync/Api/Ledger.hs

@@ -11,6 +11,7 @@ import qualified Cardano.Db as DB
 import Cardano.DbSync.Api
 import Cardano.DbSync.Api.Types
 import Cardano.DbSync.Era.Shelley.Generic.Tx.Babbage (fromTxOut)
+import Cardano.DbSync.Era.Shelley.Generic.Tx.Types (DBPlutusScript)
 import qualified Cardano.DbSync.Era.Shelley.Generic.Util as Generic
 import qualified Cardano.DbSync.Era.Shelley.Insert as Insert
 import Cardano.DbSync.Era.Shelley.Insert.Grouped
@@ -105,6 +106,7 @@ storeUTxO ::
   , BabbageEraTxOut era
   , MonadIO m
   , MonadBaseControl IO m
+  , DBPlutusScript era
   ) =>
   SyncEnv ->
   TxCache ->
@@ -131,6 +133,7 @@ storePage ::
   , Cardano.Ledger.Core.Value era ~ MaryValue StandardCrypto
   , Script era ~ AlonzoScript era
   , TxOut era ~ BabbageTxOut era
+  , DBPlutusScript era
   , BabbageEraTxOut era
   , MonadIO m
   , MonadBaseControl IO m
@@ -158,6 +161,7 @@ prepareTxOut ::
   , BabbageEraTxOut era
   , MonadIO m
   , MonadBaseControl IO m
+  , DBPlutusScript era
   ) =>
   SyncEnv ->
   TxCache ->

cardano-db-sync/src/Cardano/DbSync/Config/Conway.hs

@@ -36,7 +36,7 @@ readConwayGenesisConfig ::
 readConwayGenesisConfig SyncNodeConfig {..} =
   case dncConwayGenesisFile of
     Just file -> readConwayGenesisConfig' file dncConwayGenesisHash
-    Nothing -> pure (ConwayGenesis def def def)
+    Nothing -> pure (ConwayGenesis def def def mempty mempty)
   where
     readConwayGenesisConfig' file hash =
       firstExceptT (SNErrConwayConfig (unGenesisFile file) . renderConwayGenesisError) $

cardano-db-sync/src/Cardano/DbSync/Era/Shelley/Generic/Metadata.hs

@@ -20,8 +20,8 @@ module Cardano.DbSync.Era.Shelley.Generic.Metadata (
 ) where
 
 import qualified Cardano.Ledger.Allegra.TxAuxData as Allegra
+import Cardano.Ledger.Alonzo.Scripts (AlonzoEraScript)
 import qualified Cardano.Ledger.Alonzo.TxAuxData as Alonzo
-import Cardano.Ledger.Era (Era)
 import qualified Cardano.Ledger.Shelley.TxAuxData as Shelley
 import Cardano.Prelude
 import qualified Data.Aeson as Aeson
@@ -48,7 +48,7 @@ fromAllegraMetadata :: Allegra.AllegraTxAuxData StandardAllegra -> Map Word64 Tx
 fromAllegraMetadata (Allegra.AllegraTxAuxData mdMap _scripts) =
   Map.map fromMetadatum mdMap
 
-fromAlonzoMetadata :: Era era => Alonzo.AlonzoTxAuxData era -> Map Word64 TxMetadataValue
+fromAlonzoMetadata :: AlonzoEraScript era => Alonzo.AlonzoTxAuxData era -> Map Word64 TxMetadataValue
 fromAlonzoMetadata aux =
   Map.map fromMetadatum $ Alonzo.atadMetadata aux
 

cardano-db-sync/src/Cardano/DbSync/Era/Shelley/Generic/ParamProposal.hs

@@ -15,11 +15,10 @@ import Cardano.DbSync.Era.Shelley.Generic.Util (unKeyHashRaw)
 import Cardano.DbSync.Era.Shelley.Generic.Witness (Witness (..))
 import Cardano.Ledger.Alonzo.Core
 import qualified Cardano.Ledger.Alonzo.Scripts as Alonzo
-import Cardano.Ledger.BaseTypes (UnitInterval, strictMaybeToMaybe)
+import Cardano.Ledger.BaseTypes (EpochInterval, UnitInterval, strictMaybeToMaybe)
 import qualified Cardano.Ledger.BaseTypes as Ledger
 import Cardano.Ledger.Coin (Coin, unCoin)
 import Cardano.Ledger.Conway.Core
-import Cardano.Ledger.Conway.PParams
 import Cardano.Ledger.Crypto
 import qualified Cardano.Ledger.Keys as Ledger
 import Cardano.Ledger.Plutus.Language (Language)
@@ -35,12 +34,12 @@ data ParamProposal = ParamProposal
   , pppKey :: !(Maybe ByteString)
   , pppMinFeeA :: !(Maybe Natural)
   , pppMinFeeB :: !(Maybe Natural)
-  , pppMaxBlockSize :: !(Maybe Natural)
-  , pppMaxTxSize :: !(Maybe Natural)
-  , pppMaxBhSize :: !(Maybe Natural)
+  , pppMaxBlockSize :: !(Maybe Word32)
+  , pppMaxTxSize :: !(Maybe Word32)
+  , pppMaxBhSize :: !(Maybe Word16)
   , pppKeyDeposit :: !(Maybe Coin)
   , pppPoolDeposit :: !(Maybe Coin)
-  , pppMaxEpoch :: !(Maybe EpochNo)
+  , pppMaxEpoch :: !(Maybe EpochInterval)
   , pppOptimalPoolCount :: !(Maybe Natural)
   , pppInfluence :: !(Maybe Rational)
   , pppMonetaryExpandRate :: !(Maybe UnitInterval)
@@ -66,11 +65,11 @@ data ParamProposal = ParamProposal
     pppPoolVotingThresholds :: !(Maybe PoolVotingThresholds)
   , pppDRepVotingThresholds :: !(Maybe DRepVotingThresholds)
   , pppCommitteeMinSize :: !(Maybe Natural)
-  , pppCommitteeMaxTermLength :: !(Maybe Word64)
-  , pppGovActionLifetime :: !(Maybe EpochNo)
+  , pppCommitteeMaxTermLength :: !(Maybe EpochInterval)
+  , pppGovActionLifetime :: !(Maybe EpochInterval)
   , pppGovActionDeposit :: !(Maybe Natural)
   , pppDRepDeposit :: !(Maybe Natural)
-  , pppDRepActivity :: !(Maybe EpochNo)
+  , pppDRepActivity :: !(Maybe EpochInterval)
   }
 
 convertParamProposal :: EraCrypto era ~ StandardCrypto => Witness era -> Shelley.Update era -> [ParamProposal]
@@ -135,7 +134,7 @@ convertConwayParamProposal pmap =
       pppPoolVotingThresholds = strictMaybeToMaybe (pmap ^. ppuPoolVotingThresholdsL)
     , pppDRepVotingThresholds = strictMaybeToMaybe (pmap ^. ppuDRepVotingThresholdsL)
     , pppCommitteeMinSize = strictMaybeToMaybe (pmap ^. ppuCommitteeMinSizeL)
-    , pppCommitteeMaxTermLength = unEpochNo <$> strictMaybeToMaybe (pmap ^. ppuCommitteeMaxTermLengthL)
+    , pppCommitteeMaxTermLength = strictMaybeToMaybe (pmap ^. ppuCommitteeMaxTermLengthL)
     , pppGovActionLifetime = strictMaybeToMaybe (pmap ^. ppuGovActionLifetimeL)
     , pppGovActionDeposit = fromIntegral . unCoin <$> strictMaybeToMaybe (pmap ^. ppuGovActionDepositL)
     , pppDRepDeposit = fromIntegral . unCoin <$> strictMaybeToMaybe (pmap ^. ppuDRepDepositL)

cardano-db-sync/src/Cardano/DbSync/Era/Shelley/Generic/ProtoParams.hs

@@ -11,15 +11,13 @@ module Cardano.DbSync.Era.Shelley.Generic.ProtoParams (
 import Cardano.DbSync.Types
 import Cardano.Ledger.Alonzo.Core
 import qualified Cardano.Ledger.Alonzo.Scripts as Alonzo
-import Cardano.Ledger.BaseTypes (UnitInterval)
+import Cardano.Ledger.BaseTypes (EpochInterval, UnitInterval)
 import qualified Cardano.Ledger.BaseTypes as Ledger
 import Cardano.Ledger.Coin (Coin (..))
 import Cardano.Ledger.Conway.Core
-import Cardano.Ledger.Conway.PParams hiding (params)
 import Cardano.Ledger.Plutus.Language (Language)
 import qualified Cardano.Ledger.Shelley.LedgerState as Shelley
 import Cardano.Prelude
-import Cardano.Slotting.Slot (EpochNo (..))
 import Lens.Micro ((^.))
 import Ouroboros.Consensus.Cardano (Nonce (..))
 import Ouroboros.Consensus.Cardano.Block hiding (CardanoBlock)
@@ -30,12 +28,12 @@ import qualified Ouroboros.Consensus.Shelley.Ledger.Ledger as Consensus
 data ProtoParams = ProtoParams
   { ppMinfeeA :: !Natural
   , ppMinfeeB :: !Natural
-  , ppMaxBBSize :: !Natural
-  , ppMaxTxSize :: !Natural
-  , ppMaxBHSize :: !Natural
+  , ppMaxBBSize :: !Word32
+  , ppMaxTxSize :: !Word32
+  , ppMaxBHSize :: !Word16
   , ppKeyDeposit :: !Coin
   , ppPoolDeposit :: !Coin
-  , ppMaxEpoch :: !EpochNo
+  , ppMaxEpoch :: !EpochInterval
   , ppOptialPoolCount :: !Natural
   , ppInfluence :: !Rational
   , ppMonetaryExpandRate :: !UnitInterval
@@ -61,11 +59,11 @@ data ProtoParams = ProtoParams
     ppPoolVotingThresholds :: !(Maybe PoolVotingThresholds)
   , ppDRepVotingThresholds :: !(Maybe DRepVotingThresholds)
   , ppCommitteeMinSize :: !(Maybe Natural)
-  , ppCommitteeMaxTermLength :: !(Maybe Word64)
-  , ppGovActionLifetime :: !(Maybe EpochNo)
+  , ppCommitteeMaxTermLength :: !(Maybe EpochInterval)
+  , ppGovActionLifetime :: !(Maybe EpochInterval)
   , ppGovActionDeposit :: !(Maybe Natural)
   , ppDRepDeposit :: !(Maybe Natural)
-  , ppDRepActivity :: !(Maybe EpochNo)
+  , ppDRepActivity :: !(Maybe EpochInterval)
   }
 
 epochProtoParams :: ExtLedgerState CardanoBlock -> Maybe ProtoParams
@@ -121,7 +119,7 @@ fromConwayParams params =
     , ppPoolVotingThresholds = Just $ params ^. ppPoolVotingThresholdsL
     , ppDRepVotingThresholds = Just $ params ^. ppDRepVotingThresholdsL
     , ppCommitteeMinSize = Just $ params ^. ppCommitteeMinSizeL
-    , ppCommitteeMaxTermLength = Just . unEpochNo $ params ^. ppCommitteeMaxTermLengthL
+    , ppCommitteeMaxTermLength = Just $ params ^. ppCommitteeMaxTermLengthL
     , ppGovActionLifetime = Just $ params ^. ppGovActionLifetimeL
     , ppGovActionDeposit = Just . fromIntegral . unCoin $ params ^. ppGovActionDepositL
     , ppDRepDeposit = Just . fromIntegral . unCoin $ params ^. ppDRepDepositL

cardano-db-sync/src/Cardano/DbSync/Era/Shelley/Generic/Tx/Alonzo.hs

@@ -2,6 +2,7 @@
 {-# LANGUAGE DataKinds #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE GADTs #-}
+{-# LANGUAGE LambdaCase #-}
 {-# LANGUAGE RankNTypes #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE TypeApplications #-}
@@ -36,7 +37,7 @@ import Cardano.DbSync.Era.Shelley.Generic.Util
 import Cardano.DbSync.Era.Shelley.Generic.Witness
 import Cardano.DbSync.Types (DataHash)
 import qualified Cardano.Ledger.Address as Ledger
-import Cardano.Ledger.Alonzo.Scripts (ExUnits (..), txscriptfee, unBinaryPlutus)
+import Cardano.Ledger.Alonzo.Scripts (AsIndex (..), ExUnits (..), PlutusPurpose (..), txscriptfee, unPlutusBinary)
 import qualified Cardano.Ledger.Alonzo.Scripts as Alonzo
 import qualified Cardano.Ledger.Alonzo.Tx as Alonzo
 import Cardano.Ledger.Alonzo.TxAuxData (AlonzoTxAuxData (..), getAlonzoTxAuxDataScripts)
@@ -46,21 +47,29 @@ import qualified Cardano.Ledger.Alonzo.TxWits as Alonzo
 import Cardano.Ledger.BaseTypes
 import Cardano.Ledger.Coin (Coin (..))
 import qualified Cardano.Ledger.Core as Core
-import qualified Cardano.Ledger.Era as Ledger
+
+-- import qualified Cardano.Ledger.Era as Ledger
 import qualified Cardano.Ledger.Keys as Ledger
 import Cardano.Ledger.Mary.Value (MaryValue (..), MultiAsset (..), policyID)
-import Cardano.Ledger.Plutus.Language (Plutus (..))
-import qualified Cardano.Ledger.Plutus.Language as Alonzo
+
+-- import Cardano.Ledger.Plutus.Language (Plutus (..))
+-- import qualified Cardano.Ledger.Plutus.Language as Alonzo
 import qualified Cardano.Ledger.SafeHash as Ledger
 import Cardano.Ledger.Shelley.Scripts (ScriptHash)
-import qualified Cardano.Ledger.Shelley.Tx as ShelleyTx
+
+-- import qualified Cardano.Ledger.Shelley.Tx as ShelleyTx
 import qualified Cardano.Ledger.Shelley.TxBody as Shelley
 import Cardano.Ledger.Shelley.TxCert as Shelley
 import Cardano.Prelude
 import qualified Data.Aeson as Aeson
 import qualified Data.ByteString.Lazy.Char8 as LBS
+
 import qualified Data.ByteString.Short as SBS
+
+import Cardano.Ledger.Conway.Scripts (ConwayPlutusPurpose (..))
+import qualified Cardano.Ledger.TxIn as Ledger
 import qualified Data.Map.Strict as Map
+import qualified Data.Maybe.Strict as Strict
 import qualified Data.Set as Set
 import Lens.Micro
 import Ouroboros.Consensus.Cardano.Block (EraCrypto, StandardAlonzo, StandardCrypto)
@@ -149,6 +158,7 @@ getScripts ::
   , Core.Script era ~ Alonzo.AlonzoScript era
   , Core.TxAuxData era ~ AlonzoTxAuxData era
   , Core.EraTx era
+  , DBPlutusScript era
   ) =>
   Core.Tx era ->
   [TxScript]
@@ -174,7 +184,7 @@ resolveRedeemers ::
   ( EraCrypto era ~ StandardCrypto
   , Alonzo.AlonzoEraTxWits era
   , Core.EraTx era
-  , Alonzo.MaryEraTxBody era
+  , DBScriptPurpose era
   ) =>
   Bool ->
   Maybe Alonzo.Prices ->
@@ -204,15 +214,15 @@ resolveRedeemers ioExtraPlutus mprices tx toCert =
         toList $
           toCert <$> (txBody ^. Core.certsTxBodyL)
 
-    txInsMissingRedeemer :: Map (ShelleyTx.TxIn StandardCrypto) TxIn
+    txInsMissingRedeemer :: Map (Ledger.TxIn StandardCrypto) TxIn
     txInsMissingRedeemer = Map.fromList $ fmap (\inp -> (inp, fromTxIn inp)) $ toList $ txBody ^. Core.inputsTxBodyL
 
     initRedeemersMaps :: RedeemerMaps
     initRedeemersMaps = RedeemerMaps withdrawalsNoRedeemers txCertsNoRedeemers txInsMissingRedeemer
 
     mkRdmrAndUpdateRec ::
       (RedeemerMaps, [(Word64, TxRedeemer)]) ->
-      [(Word64, (Alonzo.RdmrPtr, (Alonzo.Data era, ExUnits)))] ->
+      [(Word64, (Alonzo.PlutusPurpose AsIndex era, (Alonzo.Data era, ExUnits)))] ->
       (RedeemerMaps, [(Word64, TxRedeemer)])
     mkRdmrAndUpdateRec (rdmrMaps, rdmrsAcc) [] = (rdmrMaps, reverse rdmrsAcc)
     mkRdmrAndUpdateRec (rdmrMaps, rdmrsAcc) ((rdmrIx, rdmr) : rest) =
@@ -221,33 +231,46 @@ resolveRedeemers ioExtraPlutus mprices tx toCert =
 
     handleRedeemer ::
       Word64 ->
-      (Alonzo.RdmrPtr, (Alonzo.Data era, ExUnits)) ->
+      (PlutusPurpose AsIndex era, (Alonzo.Data era, ExUnits)) ->
       RedeemerMaps ->
       (TxRedeemer, RedeemerMaps)
-    handleRedeemer rdmrIx (ptr@(Alonzo.RdmrPtr tag index), (dt, exUnits)) rdmrMps =
+    handleRedeemer rdmrIx (ptr, (dt, exUnits)) rdmrMps =
       (txRdmr, rdmrMps')
       where
-        (rdmrMps', mScript) = case strictMaybeToMaybe (Alonzo.rdptrInv txBody ptr) of
-          Just (Alonzo.Minting policyId) -> (rdmrMps, Just $ Right $ unScriptHash $ policyID policyId)
-          Just (Alonzo.Spending txIn) -> handleTxInPtr rdmrIx txIn rdmrMps
-          Just (Alonzo.Rewarding rwdAcnt) -> handleRewardPtr rdmrIx rwdAcnt rdmrMps
-          Just prp@(Alonzo.Certifying dcert) -> case strictMaybeToMaybe (Alonzo.rdptr txBody prp) of
-            Just ptr' | ptr == ptr' -> handleCertPtr rdmrIx (toCert dcert) rdmrMps
-            _ -> (rdmrMps, Nothing)
+        (rdmrMps', mScript) = case mkPurpose $ Alonzo.redeemerPointerInverse txBody ptr of
+          Just (Left (Alonzo.AlonzoMinting policyId, _)) -> (rdmrMps, Just $ Right $ unScriptHash $ policyID (Alonzo.unAsItem policyId))
+          Just (Left (Alonzo.AlonzoSpending txIn, _)) -> handleTxInPtr rdmrIx (Alonzo.unAsItem txIn) rdmrMps
+          Just (Left (Alonzo.AlonzoRewarding rwdAcnt, _)) -> handleRewardPtr rdmrIx (Alonzo.unAsItem rwdAcnt) rdmrMps
+          Just (Left (Alonzo.AlonzoCertifying dcert, Just ptr')) ->
+            if ptr == ptr'
+              then handleCertPtr rdmrIx (toCert $ Alonzo.unAsItem dcert) rdmrMps
+              else (rdmrMps, Nothing)
+          Just (Left (Alonzo.AlonzoCertifying _, Nothing)) -> (rdmrMps, Nothing)
+          Just (Right (ConwayMinting policyId)) -> (rdmrMps, Just $ Right $ unScriptHash $ policyID (Alonzo.unAsItem policyId))
+          Just (Right (ConwaySpending txIn)) -> handleTxInPtr rdmrIx (Alonzo.unAsItem txIn) rdmrMps
+          Just (Right (ConwayRewarding rwdAcnt)) -> handleRewardPtr rdmrIx (Alonzo.unAsItem rwdAcnt) rdmrMps
+          Just (Right (ConwayCertifying dcert)) -> handleCertPtr rdmrIx (toCert $ Alonzo.unAsItem dcert) rdmrMps
+          Just (Right (ConwayVoting _)) -> (rdmrMps, Nothing)
+          Just (Right (ConwayProposing _)) -> (rdmrMps, Nothing)
           Nothing -> (rdmrMps, Nothing)
 
+        (tag, idx) = getPurpose ptr
         txRdmr =
           TxRedeemer
             { txRedeemerMem = fromIntegral $ exUnitsMem exUnits
             , txRedeemerSteps = fromIntegral $ exUnitsSteps exUnits
             , txRedeemerFee = (`txscriptfee` exUnits) <$> mprices
             , txRedeemerPurpose = tag
-            , txRedeemerIndex = index
+            , txRedeemerIndex = fromIntegral idx
             , txRedeemerScriptHash = mScript
             , txRedeemerData = mkTxData (Alonzo.hashData dt, dt)
             }
 
-handleTxInPtr :: Word64 -> ShelleyTx.TxIn StandardCrypto -> RedeemerMaps -> (RedeemerMaps, Maybe (Either TxIn ByteString))
+        mkPurpose = \case
+          Strict.SNothing -> Nothing
+          Strict.SJust a -> toAlonzoPurpose txBody a
+
+handleTxInPtr :: Word64 -> Ledger.TxIn StandardCrypto -> RedeemerMaps -> (RedeemerMaps, Maybe (Either TxIn ByteString))
 handleTxInPtr rdmrIx txIn mps = case Map.lookup txIn (rmInps mps) of
   Nothing -> (mps, Nothing)
   Just gtxIn ->
@@ -271,11 +294,11 @@ handleCertPtr rdmrIx dcert mps =
 data RedeemerMaps = RedeemerMaps
   { rmWdrl :: Map (Shelley.RewardAcnt StandardCrypto) TxWithdrawal
   , rmCerts :: [(Cert, TxCertificate)]
-  , rmInps :: Map (ShelleyTx.TxIn StandardCrypto) TxIn
+  , rmInps :: Map (Ledger.TxIn StandardCrypto) TxIn
   }
 
 mkTxScript ::
-  (Ledger.Era era) =>
+  DBPlutusScript era =>
   (ScriptHash StandardCrypto, Alonzo.AlonzoScript era) ->
   TxScript
 mkTxScript (hsh, script) =
@@ -291,9 +314,7 @@ mkTxScript (hsh, script) =
     getScriptType =
       case script of
         Alonzo.TimelockScript {} -> Timelock
-        Alonzo.PlutusScript (Plutus Alonzo.PlutusV1 _s) -> PlutusV1
-        Alonzo.PlutusScript (Plutus Alonzo.PlutusV2 _s) -> PlutusV2
-        Alonzo.PlutusScript (Plutus Alonzo.PlutusV3 _s) -> PlutusV3
+        Alonzo.PlutusScript ps -> getPlutusScriptType ps
 
     timelockJsonScript :: Maybe ByteString
     timelockJsonScript =
@@ -313,6 +334,7 @@ getPlutusSizes ::
   ( Core.EraTx era
   , Core.TxWits era ~ Alonzo.AlonzoTxWits era
   , Core.Script era ~ Alonzo.AlonzoScript era
+  , AlonzoEraScript era
   ) =>
   Core.Tx era ->
   [Word64]
@@ -322,11 +344,12 @@ getPlutusSizes tx =
       tx ^. (Core.witsTxL . Alonzo.scriptAlonzoTxWitsL)
 
 -- | Returns Nothing for non-plutus scripts.
-getPlutusScriptSize :: Alonzo.AlonzoScript era -> Maybe Word64
+getPlutusScriptSize :: AlonzoEraScript era => Alonzo.AlonzoScript era -> Maybe Word64
 getPlutusScriptSize script =
   case script of
     Alonzo.TimelockScript {} -> Nothing
-    Alonzo.PlutusScript (Plutus _lang sbs) -> Just $ fromIntegral (SBS.length $ unBinaryPlutus sbs)
+    Alonzo.PlutusScript ps ->
+      Just $ fromIntegral $ SBS.length $ unPlutusBinary $ Alonzo.plutusScriptBinary ps
 
 txDataWitness ::
   (Core.TxWits era ~ Alonzo.AlonzoTxWits era, Core.EraTx era, EraCrypto era ~ StandardCrypto) =>