{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE DisambiguateRecordFields #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}

-- | Transaction inputs
module Cardano.Api.Tx.Internal.TxIn
  ( -- * Transaction inputs
    TxIn (..)
  , parseTxIn
  , TxIx (..)
  , parseTxIx

    -- * Transaction Ids
  , TxId (..)
  , parseTxId

    -- * Data family instances
  , AsType (AsTxId)

    -- * Internal conversion functions
  , toByronTxId
  , toShelleyTxId
  , fromShelleyTxId
  , toByronTxIn
  , fromByronTxIn
  , toShelleyTxIn
  , fromShelleyTxIn
  , renderTxIn
  )
where

import Cardano.Api.HasTypeProxy
import Cardano.Api.Parser.Text qualified as P
import Cardano.Api.Pretty
import Cardano.Api.Serialise.Json
import Cardano.Api.Serialise.Raw
import Cardano.Api.Serialise.SerialiseUsing

import Cardano.Chain.UTxO qualified as Byron
import Cardano.Crypto.Hash.Class qualified as Crypto
import Cardano.Crypto.Hashing qualified as Byron
import Cardano.Ledger.BaseTypes qualified as Ledger
import Cardano.Ledger.Hashes qualified as Hashes
import Cardano.Ledger.Shelley.TxBody qualified as Shelley
import Cardano.Ledger.TxIn qualified as Ledger

import Data.Aeson (withText)
import Data.Aeson qualified as Aeson
import Data.Aeson.Types (ToJSONKey (..), toJSONKeyText)
import Data.Text (Text)

-- ----------------------------------------------------------------------------
-- Transaction Ids
--

newtype TxId = TxId (Crypto.Hash Hashes.HASH Shelley.EraIndependentTxBody)
  -- We use the Shelley representation and convert to/from the Byron one
  deriving stock (TxId -> TxId -> Bool
(TxId -> TxId -> Bool) -> (TxId -> TxId -> Bool) -> Eq TxId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TxId -> TxId -> Bool
== :: TxId -> TxId -> Bool
$c/= :: TxId -> TxId -> Bool
/= :: TxId -> TxId -> Bool
Eq, Eq TxId
Eq TxId =>
(TxId -> TxId -> Ordering)
-> (TxId -> TxId -> Bool)
-> (TxId -> TxId -> Bool)
-> (TxId -> TxId -> Bool)
-> (TxId -> TxId -> Bool)
-> (TxId -> TxId -> TxId)
-> (TxId -> TxId -> TxId)
-> Ord TxId
TxId -> TxId -> Bool
TxId -> TxId -> Ordering
TxId -> TxId -> TxId
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TxId -> TxId -> Ordering
compare :: TxId -> TxId -> Ordering
$c< :: TxId -> TxId -> Bool
< :: TxId -> TxId -> Bool
$c<= :: TxId -> TxId -> Bool
<= :: TxId -> TxId -> Bool
$c> :: TxId -> TxId -> Bool
> :: TxId -> TxId -> Bool
$c>= :: TxId -> TxId -> Bool
>= :: TxId -> TxId -> Bool
$cmax :: TxId -> TxId -> TxId
max :: TxId -> TxId -> TxId
$cmin :: TxId -> TxId -> TxId
min :: TxId -> TxId -> TxId
Ord)
  deriving (Int -> TxId -> ShowS
[TxId] -> ShowS
TxId -> [Char]
(Int -> TxId -> ShowS)
-> (TxId -> [Char]) -> ([TxId] -> ShowS) -> Show TxId
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TxId -> ShowS
showsPrec :: Int -> TxId -> ShowS
$cshow :: TxId -> [Char]
show :: TxId -> [Char]
$cshowList :: [TxId] -> ShowS
showList :: [TxId] -> ShowS
Show, (forall ann. TxId -> Doc ann)
-> (forall ann. [TxId] -> Doc ann) -> Pretty TxId
forall ann. [TxId] -> Doc ann
forall ann. TxId -> Doc ann
forall a.
(forall ann. a -> Doc ann)
-> (forall ann. [a] -> Doc ann) -> Pretty a
$cpretty :: forall ann. TxId -> Doc ann
pretty :: forall ann. TxId -> Doc ann
$cprettyList :: forall ann. [TxId] -> Doc ann
prettyList :: forall ann. [TxId] -> Doc ann
Pretty) via UsingRawBytesHex TxId
  deriving ([TxId] -> Value
[TxId] -> Encoding
TxId -> Bool
TxId -> Value
TxId -> Encoding
(TxId -> Value)
-> (TxId -> Encoding)
-> ([TxId] -> Value)
-> ([TxId] -> Encoding)
-> (TxId -> Bool)
-> ToJSON TxId
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: TxId -> Value
toJSON :: TxId -> Value
$ctoEncoding :: TxId -> Encoding
toEncoding :: TxId -> Encoding
$ctoJSONList :: [TxId] -> Value
toJSONList :: [TxId] -> Value
$ctoEncodingList :: [TxId] -> Encoding
toEncodingList :: [TxId] -> Encoding
$comitField :: TxId -> Bool
omitField :: TxId -> Bool
ToJSON, Maybe TxId
Value -> Parser [TxId]
Value -> Parser TxId
(Value -> Parser TxId)
-> (Value -> Parser [TxId]) -> Maybe TxId -> FromJSON TxId
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser TxId
parseJSON :: Value -> Parser TxId
$cparseJSONList :: Value -> Parser [TxId]
parseJSONList :: Value -> Parser [TxId]
$comittedField :: Maybe TxId
omittedField :: Maybe TxId
FromJSON) via UsingRawBytesHex TxId
  deriving (ToJSONKeyFunction [TxId]
ToJSONKeyFunction TxId
ToJSONKeyFunction TxId
-> ToJSONKeyFunction [TxId] -> ToJSONKey TxId
forall a.
ToJSONKeyFunction a -> ToJSONKeyFunction [a] -> ToJSONKey a
$ctoJSONKey :: ToJSONKeyFunction TxId
toJSONKey :: ToJSONKeyFunction TxId
$ctoJSONKeyList :: ToJSONKeyFunction [TxId]
toJSONKeyList :: ToJSONKeyFunction [TxId]
ToJSONKey, FromJSONKeyFunction [TxId]
FromJSONKeyFunction TxId
FromJSONKeyFunction TxId
-> FromJSONKeyFunction [TxId] -> FromJSONKey TxId
forall a.
FromJSONKeyFunction a -> FromJSONKeyFunction [a] -> FromJSONKey a
$cfromJSONKey :: FromJSONKeyFunction TxId
fromJSONKey :: FromJSONKeyFunction TxId
$cfromJSONKeyList :: FromJSONKeyFunction [TxId]
fromJSONKeyList :: FromJSONKeyFunction [TxId]
FromJSONKey) via UsingRawBytesHex TxId

instance HasTypeProxy TxId where
  data AsType TxId = AsTxId
  proxyToAsType :: Proxy TxId -> AsType TxId
proxyToAsType Proxy TxId
_ = AsType TxId
AsTxId

instance SerialiseAsRawBytes TxId where
  serialiseToRawBytes :: TxId -> ByteString
serialiseToRawBytes (TxId Hash HASH EraIndependentTxBody
h) = Hash HASH EraIndependentTxBody -> ByteString
forall h a. Hash h a -> ByteString
Crypto.hashToBytes Hash HASH EraIndependentTxBody
h
  deserialiseFromRawBytes :: AsType TxId -> ByteString -> Either SerialiseAsRawBytesError TxId
deserialiseFromRawBytes AsType TxId
R:AsTypeTxId
AsTxId ByteString
bs = case ByteString -> Maybe (Hash HASH EraIndependentTxBody)
forall h a. HashAlgorithm h => ByteString -> Maybe (Hash h a)
Crypto.hashFromBytes ByteString
bs of
    Just Hash HASH EraIndependentTxBody
a -> TxId -> Either SerialiseAsRawBytesError TxId
forall a b. b -> Either a b
Right (Hash HASH EraIndependentTxBody -> TxId
TxId Hash HASH EraIndependentTxBody
a)
    Maybe (Hash HASH EraIndependentTxBody)
Nothing -> SerialiseAsRawBytesError -> Either SerialiseAsRawBytesError TxId
forall a b. a -> Either a b
Left (SerialiseAsRawBytesError -> Either SerialiseAsRawBytesError TxId)
-> SerialiseAsRawBytesError -> Either SerialiseAsRawBytesError TxId
forall a b. (a -> b) -> a -> b
$ [Char] -> SerialiseAsRawBytesError
SerialiseAsRawBytesError [Char]
"Unable to deserialise TxId"

parseTxId :: P.Parser TxId
parseTxId :: Parser TxId
parseTxId = Parser TxId
forall a. SerialiseAsRawBytes a => Parser a
parseRawBytesHex

toByronTxId :: TxId -> Byron.TxId
toByronTxId :: TxId -> TxId
toByronTxId (TxId Hash HASH EraIndependentTxBody
h) =
  ByteString -> TxId
forall a. ByteString -> Hash a
Byron.unsafeHashFromBytes (Hash HASH EraIndependentTxBody -> ByteString
forall h a. Hash h a -> ByteString
Crypto.hashToBytes Hash HASH EraIndependentTxBody
h)

toShelleyTxId :: TxId -> Ledger.TxId
toShelleyTxId :: TxId -> TxId
toShelleyTxId (TxId Hash HASH EraIndependentTxBody
h) =
  SafeHash EraIndependentTxBody -> TxId
Ledger.TxId (Hash HASH EraIndependentTxBody -> SafeHash EraIndependentTxBody
forall i. Hash HASH i -> SafeHash i
Hashes.unsafeMakeSafeHash (Hash HASH EraIndependentTxBody -> Hash HASH EraIndependentTxBody
forall h a b. Hash h a -> Hash h b
Crypto.castHash Hash HASH EraIndependentTxBody
h))

fromShelleyTxId :: Ledger.TxId -> TxId
fromShelleyTxId :: TxId -> TxId
fromShelleyTxId (Ledger.TxId SafeHash EraIndependentTxBody
h) =
  Hash HASH EraIndependentTxBody -> TxId
TxId (Hash HASH EraIndependentTxBody -> Hash HASH EraIndependentTxBody
forall h a b. Hash h a -> Hash h b
Crypto.castHash (SafeHash EraIndependentTxBody -> Hash HASH EraIndependentTxBody
forall i. SafeHash i -> Hash HASH i
Hashes.extractHash SafeHash EraIndependentTxBody
h))

-- ----------------------------------------------------------------------------
-- Transaction inputs
--

data TxIn = TxIn TxId TxIx
  deriving (TxIn -> TxIn -> Bool
(TxIn -> TxIn -> Bool) -> (TxIn -> TxIn -> Bool) -> Eq TxIn
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TxIn -> TxIn -> Bool
== :: TxIn -> TxIn -> Bool
$c/= :: TxIn -> TxIn -> Bool
/= :: TxIn -> TxIn -> Bool
Eq, Eq TxIn
Eq TxIn =>
(TxIn -> TxIn -> Ordering)
-> (TxIn -> TxIn -> Bool)
-> (TxIn -> TxIn -> Bool)
-> (TxIn -> TxIn -> Bool)
-> (TxIn -> TxIn -> Bool)
-> (TxIn -> TxIn -> TxIn)
-> (TxIn -> TxIn -> TxIn)
-> Ord TxIn
TxIn -> TxIn -> Bool
TxIn -> TxIn -> Ordering
TxIn -> TxIn -> TxIn
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TxIn -> TxIn -> Ordering
compare :: TxIn -> TxIn -> Ordering
$c< :: TxIn -> TxIn -> Bool
< :: TxIn -> TxIn -> Bool
$c<= :: TxIn -> TxIn -> Bool
<= :: TxIn -> TxIn -> Bool
$c> :: TxIn -> TxIn -> Bool
> :: TxIn -> TxIn -> Bool
$c>= :: TxIn -> TxIn -> Bool
>= :: TxIn -> TxIn -> Bool
$cmax :: TxIn -> TxIn -> TxIn
max :: TxIn -> TxIn -> TxIn
$cmin :: TxIn -> TxIn -> TxIn
min :: TxIn -> TxIn -> TxIn
Ord, Int -> TxIn -> ShowS
[TxIn] -> ShowS
TxIn -> [Char]
(Int -> TxIn -> ShowS)
-> (TxIn -> [Char]) -> ([TxIn] -> ShowS) -> Show TxIn
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TxIn -> ShowS
showsPrec :: Int -> TxIn -> ShowS
$cshow :: TxIn -> [Char]
show :: TxIn -> [Char]
$cshowList :: [TxIn] -> ShowS
showList :: [TxIn] -> ShowS
Show)

instance ToJSON TxIn where
  toJSON :: TxIn -> Value
toJSON TxIn
txIn = Text -> Value
Aeson.String (Text -> Value) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ TxIn -> Text
renderTxIn TxIn
txIn

instance ToJSONKey TxIn where
  toJSONKey :: ToJSONKeyFunction TxIn
toJSONKey = (TxIn -> Text) -> ToJSONKeyFunction TxIn
forall a. (a -> Text) -> ToJSONKeyFunction a
toJSONKeyText TxIn -> Text
renderTxIn

instance FromJSON TxIn where
  parseJSON :: Value -> Parser TxIn
parseJSON = [Char] -> (Text -> Parser TxIn) -> Value -> Parser TxIn
forall a. [Char] -> (Text -> Parser a) -> Value -> Parser a
withText [Char]
"TxIn" ((Text -> Parser TxIn) -> Value -> Parser TxIn)
-> (Text -> Parser TxIn) -> Value -> Parser TxIn
forall a b. (a -> b) -> a -> b
$ Parser TxIn -> Text -> Parser TxIn
forall (m :: * -> *) a. MonadFail m => Parser a -> Text -> m a
P.runParserFail Parser TxIn
parseTxIn

instance FromJSONKey TxIn where
  fromJSONKey :: FromJSONKeyFunction TxIn
fromJSONKey = (Text -> Parser TxIn) -> FromJSONKeyFunction TxIn
forall a. (Text -> Parser a) -> FromJSONKeyFunction a
Aeson.FromJSONKeyTextParser ((Text -> Parser TxIn) -> FromJSONKeyFunction TxIn)
-> (Text -> Parser TxIn) -> FromJSONKeyFunction TxIn
forall a b. (a -> b) -> a -> b
$ Parser TxIn -> Text -> Parser TxIn
forall (m :: * -> *) a. MonadFail m => Parser a -> Text -> m a
P.runParserFail Parser TxIn
parseTxIn

instance Pretty TxIn where
  pretty :: forall ann. TxIn -> Doc ann
pretty (TxIn TxId
txId TxIx
txIx) = TxId -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. TxId -> Doc ann
pretty TxId
txId Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
"#" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> TxIx -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. TxIx -> Doc ann
pretty TxIx
txIx

parseTxIn :: P.Parser TxIn
parseTxIn :: Parser TxIn
parseTxIn = TxId -> TxIx -> TxIn
TxIn (TxId -> TxIx -> TxIn)
-> Parser TxId -> ParsecT Text () Identity (TxIx -> TxIn)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TxId
parseTxId ParsecT Text () Identity (TxIx -> TxIn)
-> ParsecT Text () Identity TxIx -> Parser TxIn
forall a b.
ParsecT Text () Identity (a -> b)
-> ParsecT Text () Identity a -> ParsecT Text () Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Char -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
P.char Char
'#' ParsecT Text () Identity Char
-> ParsecT Text () Identity TxIx -> ParsecT Text () Identity TxIx
forall a b.
ParsecT Text () Identity a
-> ParsecT Text () Identity b -> ParsecT Text () Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Text () Identity TxIx
parseTxIx)

renderTxIn :: TxIn -> Text
renderTxIn :: TxIn -> Text
renderTxIn = Doc AnsiStyle -> Text
docToText (Doc AnsiStyle -> Text) -> (TxIn -> Doc AnsiStyle) -> TxIn -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TxIn -> Doc AnsiStyle
forall a ann. Pretty a => a -> Doc ann
forall ann. TxIn -> Doc ann
pretty

newtype TxIx = TxIx Word
  deriving stock (TxIx -> TxIx -> Bool
(TxIx -> TxIx -> Bool) -> (TxIx -> TxIx -> Bool) -> Eq TxIx
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TxIx -> TxIx -> Bool
== :: TxIx -> TxIx -> Bool
$c/= :: TxIx -> TxIx -> Bool
/= :: TxIx -> TxIx -> Bool
Eq, Eq TxIx
Eq TxIx =>
(TxIx -> TxIx -> Ordering)
-> (TxIx -> TxIx -> Bool)
-> (TxIx -> TxIx -> Bool)
-> (TxIx -> TxIx -> Bool)
-> (TxIx -> TxIx -> Bool)
-> (TxIx -> TxIx -> TxIx)
-> (TxIx -> TxIx -> TxIx)
-> Ord TxIx
TxIx -> TxIx -> Bool
TxIx -> TxIx -> Ordering
TxIx -> TxIx -> TxIx
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TxIx -> TxIx -> Ordering
compare :: TxIx -> TxIx -> Ordering
$c< :: TxIx -> TxIx -> Bool
< :: TxIx -> TxIx -> Bool
$c<= :: TxIx -> TxIx -> Bool
<= :: TxIx -> TxIx -> Bool
$c> :: TxIx -> TxIx -> Bool
> :: TxIx -> TxIx -> Bool
$c>= :: TxIx -> TxIx -> Bool
>= :: TxIx -> TxIx -> Bool
$cmax :: TxIx -> TxIx -> TxIx
max :: TxIx -> TxIx -> TxIx
$cmin :: TxIx -> TxIx -> TxIx
min :: TxIx -> TxIx -> TxIx
Ord, Int -> TxIx -> ShowS
[TxIx] -> ShowS
TxIx -> [Char]
(Int -> TxIx -> ShowS)
-> (TxIx -> [Char]) -> ([TxIx] -> ShowS) -> Show TxIx
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TxIx -> ShowS
showsPrec :: Int -> TxIx -> ShowS
$cshow :: TxIx -> [Char]
show :: TxIx -> [Char]
$cshowList :: [TxIx] -> ShowS
showList :: [TxIx] -> ShowS
Show)
  deriving newtype Int -> TxIx
TxIx -> Int
TxIx -> [TxIx]
TxIx -> TxIx
TxIx -> TxIx -> [TxIx]
TxIx -> TxIx -> TxIx -> [TxIx]
(TxIx -> TxIx)
-> (TxIx -> TxIx)
-> (Int -> TxIx)
-> (TxIx -> Int)
-> (TxIx -> [TxIx])
-> (TxIx -> TxIx -> [TxIx])
-> (TxIx -> TxIx -> [TxIx])
-> (TxIx -> TxIx -> TxIx -> [TxIx])
-> Enum TxIx
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: TxIx -> TxIx
succ :: TxIx -> TxIx
$cpred :: TxIx -> TxIx
pred :: TxIx -> TxIx
$ctoEnum :: Int -> TxIx
toEnum :: Int -> TxIx
$cfromEnum :: TxIx -> Int
fromEnum :: TxIx -> Int
$cenumFrom :: TxIx -> [TxIx]
enumFrom :: TxIx -> [TxIx]
$cenumFromThen :: TxIx -> TxIx -> [TxIx]
enumFromThen :: TxIx -> TxIx -> [TxIx]
$cenumFromTo :: TxIx -> TxIx -> [TxIx]
enumFromTo :: TxIx -> TxIx -> [TxIx]
$cenumFromThenTo :: TxIx -> TxIx -> TxIx -> [TxIx]
enumFromThenTo :: TxIx -> TxIx -> TxIx -> [TxIx]
Enum
  deriving newtype ([TxIx] -> Value
[TxIx] -> Encoding
TxIx -> Bool
TxIx -> Value
TxIx -> Encoding
(TxIx -> Value)
-> (TxIx -> Encoding)
-> ([TxIx] -> Value)
-> ([TxIx] -> Encoding)
-> (TxIx -> Bool)
-> ToJSON TxIx
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: TxIx -> Value
toJSON :: TxIx -> Value
$ctoEncoding :: TxIx -> Encoding
toEncoding :: TxIx -> Encoding
$ctoJSONList :: [TxIx] -> Value
toJSONList :: [TxIx] -> Value
$ctoEncodingList :: [TxIx] -> Encoding
toEncodingList :: [TxIx] -> Encoding
$comitField :: TxIx -> Bool
omitField :: TxIx -> Bool
ToJSON, Maybe TxIx
Value -> Parser [TxIx]
Value -> Parser TxIx
(Value -> Parser TxIx)
-> (Value -> Parser [TxIx]) -> Maybe TxIx -> FromJSON TxIx
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser TxIx
parseJSON :: Value -> Parser TxIx
$cparseJSONList :: Value -> Parser [TxIx]
parseJSONList :: Value -> Parser [TxIx]
$comittedField :: Maybe TxIx
omittedField :: Maybe TxIx
FromJSON)

instance Pretty TxIx where
  pretty :: forall ann. TxIx -> Doc ann
pretty (TxIx Word
ix') = Word -> Doc ann
forall ann. Word -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Word
ix'

parseTxIx :: P.Parser TxIx
parseTxIx :: ParsecT Text () Identity TxIx
parseTxIx = Word -> TxIx
TxIx (Word -> TxIx) -> (Integer -> Word) -> Integer -> TxIx
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> TxIx)
-> ParsecT Text () Identity Integer
-> ParsecT Text () Identity TxIx
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Text () Identity Integer
P.parseDecimal

fromByronTxIn :: Byron.TxIn -> TxIn
fromByronTxIn :: TxIn -> TxIn
fromByronTxIn (Byron.TxInUtxo TxId
txId Word16
index) =
  let shortBs :: ShortByteString
shortBs = TxId -> ShortByteString
forall algo a. AbstractHash algo a -> ShortByteString
Byron.abstractHashToShort TxId
txId
      mApiHash :: Maybe (Hash HASH EraIndependentTxBody)
mApiHash = ShortByteString -> Maybe (Hash HASH EraIndependentTxBody)
forall h a. HashAlgorithm h => ShortByteString -> Maybe (Hash h a)
Crypto.hashFromBytesShort ShortByteString
shortBs
   in case Maybe (Hash HASH EraIndependentTxBody)
mApiHash of
        Just Hash HASH EraIndependentTxBody
apiHash -> TxId -> TxIx -> TxIn
TxIn (Hash HASH EraIndependentTxBody -> TxId
TxId Hash HASH EraIndependentTxBody
apiHash) (Word -> TxIx
TxIx (Word -> TxIx) -> (Integer -> Word) -> Integer -> TxIx
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> TxIx) -> Integer -> TxIx
forall a b. (a -> b) -> a -> b
$ Word16 -> Integer
forall a. Integral a => a -> Integer
toInteger Word16
index)
        Maybe (Hash HASH EraIndependentTxBody)
Nothing -> [Char] -> TxIn
forall a. HasCallStack => [Char] -> a
error ([Char] -> TxIn) -> [Char] -> TxIn
forall a b. (a -> b) -> a -> b
$ [Char]
"Error converting Byron era TxId: " [Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> TxId -> [Char]
forall a. Show a => a -> [Char]
show TxId
txId

toByronTxIn :: TxIn -> Byron.TxIn
toByronTxIn :: TxIn -> TxIn
toByronTxIn (TxIn TxId
txid (TxIx Word
txix)) =
  TxId -> Word16 -> TxIn
Byron.TxInUtxo (TxId -> TxId
toByronTxId TxId
txid) (Word -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
txix)

-- | This function may overflow on the transaction index. Call sites must ensure
-- that all uses of this function are appropriately guarded.
toShelleyTxIn :: TxIn -> Ledger.TxIn
toShelleyTxIn :: TxIn -> TxIn
toShelleyTxIn (TxIn TxId
txid (TxIx Word
txix)) =
  TxId -> TxIx -> TxIn
Ledger.TxIn (TxId -> TxId
toShelleyTxId TxId
txid) (Word16 -> TxIx
Ledger.TxIx (Word16 -> TxIx) -> Word16 -> TxIx
forall a b. (a -> b) -> a -> b
$ Word -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
txix)

fromShelleyTxIn :: Ledger.TxIn -> TxIn
fromShelleyTxIn :: TxIn -> TxIn
fromShelleyTxIn (Ledger.TxIn TxId
txid (Ledger.TxIx Word16
txix)) =
  TxId -> TxIx -> TxIn
TxIn (TxId -> TxId
fromShelleyTxId TxId
txid) (Word -> TxIx
TxIx (Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
txix))