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

-- | The Byron-era 'HasAnalysis' instance. db-analyser's analyses are per-era,
-- so the Cardano instance dispatches to this one. There is no Byron-only
-- db-analyser, hence no 'HasProtocolInfo' instance.
module Cardano.Tools.DBAnalyser.Block.Byron () where

import qualified Cardano.Chain.Block as Chain
import qualified Cardano.Chain.UTxO as Chain
import Cardano.Ledger.Binary (unAnnotated)
import Cardano.Tools.DBAnalyser.HasAnalysis
import Data.ByteString (ByteString)
import qualified Data.ByteString.Lazy as BL
import Ouroboros.Consensus.Byron.Ledger (ByronBlock)
import qualified Ouroboros.Consensus.Byron.Ledger as Byron
import TextBuilder (decimal)

instance HasAnalysis ByronBlock where
  countTxOutputs :: ByronBlock -> Int
countTxOutputs = (ABoundaryBlock ByteString -> Int)
-> (ABlock ByteString -> Int) -> ByronBlock -> Int
forall a.
(ABoundaryBlock ByteString -> a)
-> (ABlock ByteString -> a) -> ByronBlock -> a
aBlockOrBoundary (Int -> ABoundaryBlock ByteString -> Int
forall a b. a -> b -> a
const Int
0) ABlock ByteString -> Int
countTxOutputsByron
  blockTxSizes :: ByronBlock -> [SizeInBytes]
blockTxSizes = (ABoundaryBlock ByteString -> [SizeInBytes])
-> (ABlock ByteString -> [SizeInBytes])
-> ByronBlock
-> [SizeInBytes]
forall a.
(ABoundaryBlock ByteString -> a)
-> (ABlock ByteString -> a) -> ByronBlock -> a
aBlockOrBoundary ([SizeInBytes] -> ABoundaryBlock ByteString -> [SizeInBytes]
forall a b. a -> b -> a
const []) ABlock ByteString -> [SizeInBytes]
blockTxSizesByron
  knownEBBs :: forall (proxy :: * -> *).
proxy ByronBlock
-> Map (HeaderHash ByronBlock) (ChainHash ByronBlock)
knownEBBs = Map ByronHash (ChainHash ByronBlock)
-> proxy ByronBlock -> Map ByronHash (ChainHash ByronBlock)
forall a b. a -> b -> a
const Map (HeaderHash ByronBlock) (ChainHash ByronBlock)
Map ByronHash (ChainHash ByronBlock)
Byron.knownEBBs
  emitTraces :: WithLedgerState ByronBlock -> [String]
emitTraces WithLedgerState ByronBlock
_ = []
  blockStats :: ByronBlock -> [TextBuilder]
blockStats ByronBlock
blk =
    [ Int -> TextBuilder
forall a. Integral a => a -> TextBuilder
decimal (Int -> TextBuilder) -> Int -> TextBuilder
forall a b. (a -> b) -> a -> b
$ [SizeInBytes] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([SizeInBytes] -> Int) -> [SizeInBytes] -> Int
forall a b. (a -> b) -> a -> b
$ ByronBlock -> [SizeInBytes]
forall blk. HasAnalysis blk => blk -> [SizeInBytes]
blockTxSizes ByronBlock
blk
    , SizeInBytes -> TextBuilder
forall a. Integral a => a -> TextBuilder
decimal (SizeInBytes -> TextBuilder) -> SizeInBytes -> TextBuilder
forall a b. (a -> b) -> a -> b
$ [SizeInBytes] -> SizeInBytes
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([SizeInBytes] -> SizeInBytes) -> [SizeInBytes] -> SizeInBytes
forall a b. (a -> b) -> a -> b
$ ByronBlock -> [SizeInBytes]
forall blk. HasAnalysis blk => blk -> [SizeInBytes]
blockTxSizes ByronBlock
blk
    ]

  -- For the time being we do not support any block application
  -- metrics for the Byron era only.
  blockApplicationMetrics :: [(TextBuilder, WithLedgerState ByronBlock -> IO TextBuilder)]
blockApplicationMetrics = []

-- | Equivalent of 'either' for 'ABlockOrBoundary'.
aBlockOrBoundary ::
  (Chain.ABoundaryBlock ByteString -> a) ->
  (Chain.ABlock ByteString -> a) ->
  ByronBlock ->
  a
aBlockOrBoundary :: forall a.
(ABoundaryBlock ByteString -> a)
-> (ABlock ByteString -> a) -> ByronBlock -> a
aBlockOrBoundary ABoundaryBlock ByteString -> a
fromBoundary ABlock ByteString -> a
fromRegular ByronBlock
blk = case ByronBlock
blk of
  Byron.ByronBlock (Chain.ABOBBoundary ABoundaryBlock ByteString
boundaryBlock) SlotNo
_ ByronHash
_ ->
    ABoundaryBlock ByteString -> a
fromBoundary ABoundaryBlock ByteString
boundaryBlock
  Byron.ByronBlock (Chain.ABOBBlock ABlock ByteString
regularBlk) SlotNo
_ ByronHash
_ ->
    ABlock ByteString -> a
fromRegular ABlock ByteString
regularBlk

countTxOutputsByron :: Chain.ABlock ByteString -> Int
countTxOutputsByron :: ABlock ByteString -> Int
countTxOutputsByron Chain.ABlock{ABody ByteString
blockBody :: ABody ByteString
blockBody :: forall a. ABlock a -> ABody a
Chain.blockBody} = ATxPayload ByteString -> Int
forall a. ATxPayload a -> Int
countTxPayload ATxPayload ByteString
bodyTxPayload
 where
  Chain.ABody{ATxPayload ByteString
bodyTxPayload :: ATxPayload ByteString
bodyTxPayload :: forall a. ABody a -> ATxPayload a
Chain.bodyTxPayload} = ABody ByteString
blockBody

  countTxPayload :: Chain.ATxPayload a -> Int
  countTxPayload :: forall a. ATxPayload a -> Int
countTxPayload =
    [Int] -> Int
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum
      ([Int] -> Int) -> (ATxPayload a -> [Int]) -> ATxPayload a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ATxAux a -> Int) -> [ATxAux a] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map (Tx -> Int
countTx (Tx -> Int) -> (ATxAux a -> Tx) -> ATxAux a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Annotated Tx a -> Tx
forall b a. Annotated b a -> b
unAnnotated (Annotated Tx a -> Tx)
-> (ATxAux a -> Annotated Tx a) -> ATxAux a -> Tx
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ATxAux a -> Annotated Tx a
forall a. ATxAux a -> Annotated Tx a
Chain.aTaTx)
      ([ATxAux a] -> [Int])
-> (ATxPayload a -> [ATxAux a]) -> ATxPayload a -> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ATxPayload a -> [ATxAux a]
forall a. ATxPayload a -> [ATxAux a]
Chain.aUnTxPayload

  countTx :: Chain.Tx -> Int
  countTx :: Tx -> Int
countTx = NonEmpty TxOut -> Int
forall a. NonEmpty a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (NonEmpty TxOut -> Int) -> (Tx -> NonEmpty TxOut) -> Tx -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Tx -> NonEmpty TxOut
Chain.txOutputs

blockTxSizesByron :: Chain.ABlock ByteString -> [SizeInBytes]
blockTxSizesByron :: ABlock ByteString -> [SizeInBytes]
blockTxSizesByron ABlock ByteString
block =
  (ATxAux ByteString -> SizeInBytes)
-> [ATxAux ByteString] -> [SizeInBytes]
forall a b. (a -> b) -> [a] -> [b]
map (Int64 -> SizeInBytes
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int64 -> SizeInBytes)
-> (ATxAux ByteString -> Int64) -> ATxAux ByteString -> SizeInBytes
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Int64
BL.length (ByteString -> Int64)
-> (ATxAux ByteString -> ByteString) -> ATxAux ByteString -> Int64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
BL.fromStrict (ByteString -> ByteString)
-> (ATxAux ByteString -> ByteString)
-> ATxAux ByteString
-> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ATxAux ByteString -> ByteString
forall a. ATxAux a -> a
Chain.aTaAnnotation) [ATxAux ByteString]
blockTxAuxs
 where
  Chain.ABlock{ABody ByteString
blockBody :: forall a. ABlock a -> ABody a
blockBody :: ABody ByteString
Chain.blockBody} = ABlock ByteString
block
  Chain.ABody{ATxPayload ByteString
bodyTxPayload :: forall a. ABody a -> ATxPayload a
bodyTxPayload :: ATxPayload ByteString
Chain.bodyTxPayload} = ABody ByteString
blockBody
  Chain.ATxPayload{aUnTxPayload :: forall a. ATxPayload a -> [ATxAux a]
Chain.aUnTxPayload = [ATxAux ByteString]
blockTxAuxs} = ATxPayload ByteString
bodyTxPayload