module Cardano.CLI.Byron.Parsers
  ( ByronCommand(..)
  , NodeCmd(..)
  , backwardsCompatibilityCommands
  , parseByronCommands
  , parseHeavyDelThd
  , parseInstallerHash
  , parseMaxBlockSize
  , parseMaxHeaderSize
  , parseMaxTxSize
  , parseMaxProposalSize
  , parseMpcThd
  , parseScriptVersion
  , parseSlotDuration
  , parseSoftforkRule
  , parseSystemTag
  , parseTxFeePolicy
  , parseUpdateProposalThd
  , parseUpdateProposalTTL
  , parseUnlockStakeEpoch
  , parseUpdateVoteThd
  ) where

import           Cardano.Prelude (ConvertText (..))

import           Control.Monad (when)
import qualified Data.Attoparsec.ByteString.Char8 as Atto
import           Data.Attoparsec.Combinator ((<?>))
import qualified Data.ByteString.Char8 as BSC
import qualified Data.ByteString.Lazy.Char8 as C8
import qualified Data.Char as Char
import           Data.Foldable
import           Data.Text (Text)
import           Data.Time (UTCTime)
import           Data.Time.Clock.POSIX (posixSecondsToUTCTime)
import           Data.Word (Word16, Word64)
import           Formatting (build, sformat)
import           GHC.Natural (Natural)
import           GHC.Word (Word8)

import           Options.Applicative
import qualified Options.Applicative as Opt

import           Cardano.Binary (Annotated (..))

import           Cardano.Crypto (RequiresNetworkMagic (..))
import           Cardano.Crypto.Hashing (hashRaw)
import           Cardano.Crypto.ProtocolMagic (AProtocolMagic (..), ProtocolMagic,
                   ProtocolMagicId (..))

import           Cardano.Chain.Common (BlockCount (..), TxFeePolicy (..), TxSizeLinear (..),
                   decodeAddressBase58, rationalToLovelacePortion)
import qualified Cardano.Chain.Common as Byron
import           Cardano.Chain.Genesis (FakeAvvmOptions (..), TestnetBalanceOptions (..))
import           Cardano.Chain.Slotting (EpochNumber (..), SlotNumber (..))
import           Cardano.Chain.Update (ApplicationName (..), InstallerHash (..), NumSoftwareVersion,
                   ProtocolVersion (..), SoftforkRule (..), SoftwareVersion (..), SystemTag (..),
                   checkApplicationName, checkSystemTag)

import           Cardano.Api hiding (GenesisParameters, UpdateProposal)
import           Cardano.Api.Byron (Address (..), ByronProtocolParametersUpdate (..),
                   toByronLovelace)

import           Cardano.Api.Shelley (ReferenceScript (ReferenceScriptNone))
import           Cardano.CLI.Byron.Commands
import           Cardano.CLI.Byron.Genesis
import           Cardano.CLI.Byron.Key
import           Cardano.CLI.Byron.Tx
import           Cardano.CLI.Run (ClientCommand (ByronCommand))
import           Cardano.CLI.Shelley.Commands (ByronKeyFormat (..))
import           Cardano.CLI.Types

command' :: String -> String -> Parser a -> Mod CommandFields a
command' :: forall a. [Char] -> [Char] -> Parser a -> Mod CommandFields a
command' [Char]
c [Char]
descr Parser a
p =
    forall a. [Char] -> ParserInfo a -> Mod CommandFields a
command [Char]
c forall a b. (a -> b) -> a -> b
$ forall a. Parser a -> InfoMod a -> ParserInfo a
info (Parser a
p forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> forall a. Parser (a -> a)
helper)
              forall a b. (a -> b) -> a -> b
$ forall a. Monoid a => [a] -> a
mconcat [ forall a. [Char] -> InfoMod a
progDesc [Char]
descr ]

backwardsCompatibilityCommands :: Parser ClientCommand
backwardsCompatibilityCommands :: Parser ClientCommand
backwardsCompatibilityCommands =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum [Parser ClientCommand]
hiddenCmds
 where
  convertToByronCommand :: Mod CommandFields ByronCommand -> Parser ClientCommand
  convertToByronCommand :: Mod CommandFields ByronCommand -> Parser ClientCommand
convertToByronCommand Mod CommandFields ByronCommand
p = ByronCommand -> ClientCommand
ByronCommand forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Mod CommandFields a -> Parser a
Opt.subparser (Mod CommandFields ByronCommand
p forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. Mod f a
Opt.internal)

  hiddenCmds :: [Parser ClientCommand]
  hiddenCmds :: [Parser ClientCommand]
hiddenCmds = forall a b. (a -> b) -> [a] -> [b]
map Mod CommandFields ByronCommand -> Parser ClientCommand
convertToByronCommand [ Mod CommandFields ByronCommand
parseGenesisRelatedValues
                                         , Mod CommandFields ByronCommand
parseKeyRelatedValues
                                         , Mod CommandFields ByronCommand
parseTxRelatedValues
                                         , Mod CommandFields ByronCommand
parseLocalNodeQueryValues
                                         , Mod CommandFields ByronCommand
parseMiscellaneous
                                         ]

-- Implemented with asum so all commands don't get hidden when trying to hide
-- the 'pNodeCmdBackwardCompatible' parser.
parseByronCommands :: Parser ByronCommand
parseByronCommands :: Parser ByronCommand
parseByronCommands = forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
  [ [Char] -> ParserInfo ByronCommand -> Parser ByronCommand
subParser [Char]
"key" (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info (forall a. Mod CommandFields a -> Parser a
Opt.subparser Mod CommandFields ByronCommand
parseKeyRelatedValues)
      forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Byron key utility commands")
  , [Char] -> ParserInfo ByronCommand -> Parser ByronCommand
subParser [Char]
"transaction" (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info (forall a. Mod CommandFields a -> Parser a
Opt.subparser Mod CommandFields ByronCommand
parseTxRelatedValues)
      forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Byron transaction commands")
  , [Char] -> ParserInfo ByronCommand -> Parser ByronCommand
subParser [Char]
"query" (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info (forall a. Mod CommandFields a -> Parser a
Opt.subparser Mod CommandFields ByronCommand
parseLocalNodeQueryValues)
      forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Byron node query commands.")
  , [Char] -> ParserInfo ByronCommand -> Parser ByronCommand
subParser [Char]
"genesis" (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info (forall a. Mod CommandFields a -> Parser a
Opt.subparser Mod CommandFields ByronCommand
parseGenesisRelatedValues)
      forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Byron genesis block commands")
  , [Char] -> ParserInfo ByronCommand -> Parser ByronCommand
subParser [Char]
"governance" (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info (NodeCmd -> ByronCommand
NodeCmd forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Mod CommandFields a -> Parser a
Opt.subparser Mod CommandFields NodeCmd
pNodeCmd)
      forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Byron governance commands")
  , [Char] -> ParserInfo ByronCommand -> Parser ByronCommand
subParser [Char]
"miscellaneous" (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info (forall a. Mod CommandFields a -> Parser a
Opt.subparser Mod CommandFields ByronCommand
parseMiscellaneous)
      forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Byron miscellaneous commands")
  , NodeCmd -> ByronCommand
NodeCmd forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser NodeCmd
pNodeCmdBackwardCompatible
  ]
 where
   subParser :: String -> ParserInfo ByronCommand -> Parser ByronCommand
   subParser :: [Char] -> ParserInfo ByronCommand -> Parser ByronCommand
subParser [Char]
name ParserInfo ByronCommand
pInfo = forall a. Mod CommandFields a -> Parser a
Opt.subparser forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> ParserInfo a -> Mod CommandFields a
Opt.command [Char]
name ParserInfo ByronCommand
pInfo forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
name

pNodeCmdBackwardCompatible :: Parser NodeCmd
pNodeCmdBackwardCompatible :: Parser NodeCmd
pNodeCmdBackwardCompatible = forall a. Mod CommandFields a -> Parser a
Opt.subparser forall a b. (a -> b) -> a -> b
$ Mod CommandFields NodeCmd
pNodeCmd forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. Mod f a
Opt.internal

parseCBORObject :: Parser CBORObject
parseCBORObject :: Parser CBORObject
parseCBORObject = forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
  [ EpochSlots -> CBORObject
CBORBlockByron forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option forall a. Read a => ReadM a
auto
      (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"byron-block"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help
          (   [Char]
"The CBOR file is a byron era block."
          forall a. Semigroup a => a -> a -> a
<>  [Char]
" Enter the number of slots in an epoch. The default value is 21600")
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
"INT"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasValue f => a -> Mod f a
value (Word64 -> EpochSlots
EpochSlots Word64
21600)
      )

  , forall a. a -> Mod FlagFields a -> Parser a
flag' CBORObject
CBORDelegationCertificateByron forall a b. (a -> b) -> a -> b
$
        forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"byron-delegation-certificate"
     forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"The CBOR file is a byron era delegation certificate"

  , forall a. a -> Mod FlagFields a -> Parser a
flag' CBORObject
CBORTxByron forall a b. (a -> b) -> a -> b
$
        forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"byron-tx"
     forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"The CBOR file is a byron era tx"

  , forall a. a -> Mod FlagFields a -> Parser a
flag' CBORObject
CBORUpdateProposalByron forall a b. (a -> b) -> a -> b
$
        forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"byron-update-proposal"
     forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"The CBOR file is a byron era update proposal"
  , forall a. a -> Mod FlagFields a -> Parser a
flag' CBORObject
CBORVoteByron forall a b. (a -> b) -> a -> b
$
        forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"byron-vote"
     forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"The CBOR file is a byron era vote"
  ]

-- | Values required to create genesis.
parseGenesisParameters :: Parser GenesisParameters
parseGenesisParameters :: Parser GenesisParameters
parseGenesisParameters =
  UTCTime
-> [Char]
-> BlockCount
-> ProtocolMagic
-> TestnetBalanceOptions
-> FakeAvvmOptions
-> LovelacePortion
-> Maybe Integer
-> GenesisParameters
GenesisParameters
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> [Char] -> Parser UTCTime
parseUTCTime
          [Char]
"start-time"
          [Char]
"Start time of the new cluster to be enshrined in the new genesis."
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> [Char] -> Parser [Char]
parseFilePath
          [Char]
"protocol-parameters-file"
          [Char]
"JSON file with protocol parameters."
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser BlockCount
parseK
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ProtocolMagic
parseProtocolMagic
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TestnetBalanceOptions
parseTestnetBalanceOptions
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser FakeAvvmOptions
parseFakeAvvmOptions
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Rational -> LovelacePortion
rationalToLovelacePortion forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
         [Char] -> [Char] -> Double -> Parser Rational
parseFractionWithDefault
          [Char]
"avvm-balance-factor"
          [Char]
"AVVM balances will be multiplied by this factor (defaults to 1)."
          Double
1)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional
        ( forall a. Integral a => [Char] -> [Char] -> Parser a
parseIntegral
            [Char]
"secret-seed"
            [Char]
"Optionally specify the seed of generation."
        )

parseGenesisRelatedValues :: Mod CommandFields ByronCommand
parseGenesisRelatedValues :: Mod CommandFields ByronCommand
parseGenesisRelatedValues =
  forall a. Monoid a => [a] -> a
mconcat
    [ forall a. [Char] -> [Char] -> Parser a -> Mod CommandFields a
command' [Char]
"genesis" [Char]
"Create genesis."
      forall a b. (a -> b) -> a -> b
$ NewDirectory -> GenesisParameters -> ByronCommand
Genesis
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> [Char] -> Parser NewDirectory
parseNewDirectory
              [Char]
"genesis-output-dir"
              [Char]
"Non-existent directory where genesis JSON file and secrets shall be placed."
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser GenesisParameters
parseGenesisParameters
    , forall a. [Char] -> [Char] -> Parser a -> Mod CommandFields a
command' [Char]
"print-genesis-hash" [Char]
"Compute hash of a genesis file."
        forall a b. (a -> b) -> a -> b
$ GenesisFile -> ByronCommand
PrintGenesisHash
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> Parser GenesisFile
parseGenesisFile [Char]
"genesis-json"
    ]

-- | Values required to create keys and perform
-- transformation on keys.
parseKeyRelatedValues :: Mod CommandFields ByronCommand
parseKeyRelatedValues :: Mod CommandFields ByronCommand
parseKeyRelatedValues =
    forall a. Monoid a => [a] -> a
mconcat
        [ forall a. [Char] -> [Char] -> Parser a -> Mod CommandFields a
command' [Char]
"keygen" [Char]
"Generate a signing key."
            forall a b. (a -> b) -> a -> b
$ NewSigningKeyFile -> ByronCommand
Keygen
                forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> Parser NewSigningKeyFile
parseNewSigningKeyFile [Char]
"secret"
        , forall a. [Char] -> [Char] -> Parser a -> Mod CommandFields a
command'
            [Char]
"to-verification"
            [Char]
"Extract a verification key in its base64 form."
            forall a b. (a -> b) -> a -> b
$ ByronKeyFormat
-> SigningKeyFile -> NewVerificationKeyFile -> ByronCommand
ToVerification
                forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ByronKeyFormat
parseByronKeyFormat
                forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> [Char] -> Parser SigningKeyFile
parseSigningKeyFile
                      [Char]
"secret"
                      [Char]
"Signing key file to extract the verification part from."
                forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> Parser NewVerificationKeyFile
parseNewVerificationKeyFile [Char]
"to"
        , forall a. [Char] -> [Char] -> Parser a -> Mod CommandFields a
command'
            [Char]
"signing-key-public"
            [Char]
"Pretty-print a signing key's verification key (not a secret)."
            forall a b. (a -> b) -> a -> b
$ ByronKeyFormat -> SigningKeyFile -> ByronCommand
PrettySigningKeyPublic
                forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ByronKeyFormat
parseByronKeyFormat
                forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> [Char] -> Parser SigningKeyFile
parseSigningKeyFile
                      [Char]
"secret"
                      [Char]
"Signing key to pretty-print."
        , forall a. [Char] -> [Char] -> Parser a -> Mod CommandFields a
command'
            [Char]
"signing-key-address"
            [Char]
"Print address of a signing key."
            forall a b. (a -> b) -> a -> b
$ ByronKeyFormat -> NetworkId -> SigningKeyFile -> ByronCommand
PrintSigningKeyAddress
                forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ByronKeyFormat
parseByronKeyFormat
                forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser NetworkId
pNetworkId
                forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> [Char] -> Parser SigningKeyFile
parseSigningKeyFile
                      [Char]
"secret"
                      [Char]
"Signing key, whose address is to be printed."
        , forall a. [Char] -> [Char] -> Parser a -> Mod CommandFields a
command'
            [Char]
"migrate-delegate-key-from"
            [Char]
"Migrate a delegate key from an older version."
            forall a b. (a -> b) -> a -> b
$ SigningKeyFile -> NewSigningKeyFile -> ByronCommand
MigrateDelegateKeyFrom
                forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> [Char] -> Parser SigningKeyFile
parseSigningKeyFile [Char]
"from" [Char]
"Legacy signing key file to migrate."
                forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> Parser NewSigningKeyFile
parseNewSigningKeyFile [Char]
"to"
        ]

parseLocalNodeQueryValues :: Mod CommandFields ByronCommand
parseLocalNodeQueryValues :: Mod CommandFields ByronCommand
parseLocalNodeQueryValues =
    forall a. Monoid a => [a] -> a
mconcat
        [ forall a. [Char] -> [Char] -> Parser a -> Mod CommandFields a
command' [Char]
"get-tip" [Char]
"Get the tip of your local node's blockchain"
            forall a b. (a -> b) -> a -> b
$ NetworkId -> ByronCommand
GetLocalNodeTip
                forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser NetworkId
pNetworkId
        ]

parseMiscellaneous :: Mod CommandFields ByronCommand
parseMiscellaneous :: Mod CommandFields ByronCommand
parseMiscellaneous = forall a. Monoid a => [a] -> a
mconcat
  [ forall a. [Char] -> [Char] -> Parser a -> Mod CommandFields a
command'
      [Char]
"validate-cbor"
      [Char]
"Validate a CBOR blockchain object."
      forall a b. (a -> b) -> a -> b
$ CBORObject -> [Char] -> ByronCommand
ValidateCBOR
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser CBORObject
parseCBORObject
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> [Char] -> Parser [Char]
parseFilePath [Char]
"filepath" [Char]
"Filepath of CBOR file."
  , forall a. [Char] -> [Char] -> Parser a -> Mod CommandFields a
command'
      [Char]
"pretty-print-cbor"
      [Char]
"Pretty print a CBOR file."
      forall a b. (a -> b) -> a -> b
$ [Char] -> ByronCommand
PrettyPrintCBOR
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> [Char] -> Parser [Char]
parseFilePath [Char]
"filepath" [Char]
"Filepath of CBOR file."
  ]



parseTestnetBalanceOptions :: Parser TestnetBalanceOptions
parseTestnetBalanceOptions :: Parser TestnetBalanceOptions
parseTestnetBalanceOptions =
  Word -> Word -> Lovelace -> Rational -> TestnetBalanceOptions
TestnetBalanceOptions
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Integral a => [Char] -> [Char] -> Parser a
parseIntegral
          [Char]
"n-poor-addresses"
          [Char]
"Number of poor nodes (with small balance)."
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. Integral a => [Char] -> [Char] -> Parser a
parseIntegral
          [Char]
"n-delegate-addresses"
          [Char]
"Number of delegate nodes (with huge balance)."
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> [Char] -> Parser Lovelace
parseLovelace
          [Char]
"total-balance"
          [Char]
"Total balance owned by these nodes."
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> [Char] -> Parser Rational
parseFraction
          [Char]
"delegate-share"
          [Char]
"Portion of stake owned by all delegates together."

parseTxIn :: Parser TxIn
parseTxIn :: Parser TxIn
parseTxIn =
  forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option
  (forall a. Parser a -> ReadM a
readerFromAttoParser Parser TxIn
parseTxInAtto)
  forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"txin"
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
"(TXID,INDEX)"
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Transaction input is a pair of an UTxO TxId and a zero-based output index."

parseTxInAtto :: Atto.Parser TxIn
parseTxInAtto :: Parser TxIn
parseTxInAtto =
  TxId -> TxIx -> TxIn
TxIn forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Char -> Parser Char
Atto.char Char
'(' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser ByteString TxId
parseTxIdAtto forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Char -> Parser Char
Atto.char Char
',')
       forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Parser ByteString TxIx
parseTxIxAtto forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Char -> Parser Char
Atto.char Char
')')


parseTxIdAtto :: Atto.Parser TxId
parseTxIdAtto :: Parser ByteString TxId
parseTxIdAtto = (forall i a. Parser i a -> [Char] -> Parser i a
<?> [Char]
"Transaction ID (hexadecimal)") forall a b. (a -> b) -> a -> b
$ do
  ByteString
bstr <- (Char -> Bool) -> Parser ByteString
Atto.takeWhile1 Char -> Bool
Char.isHexDigit
  case forall a.
SerialiseAsRawBytes a =>
AsType a -> ByteString -> Either RawBytesHexError a
deserialiseFromRawBytesHex AsType TxId
AsTxId ByteString
bstr of
    Right TxId
addr -> forall (m :: * -> *) a. Monad m => a -> m a
return TxId
addr
    Left RawBytesHexError
e -> forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail forall a b. (a -> b) -> a -> b
$ [Char]
"Incorrect transaction id format: " forall a. [a] -> [a] -> [a]
++ forall e. Error e => e -> [Char]
displayError RawBytesHexError
e

parseTxIxAtto :: Atto.Parser TxIx
parseTxIxAtto :: Parser ByteString TxIx
parseTxIxAtto = forall a. Enum a => Int -> a
toEnum forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Integral a => Parser a
Atto.decimal

parseTxOut :: Parser (TxOut CtxTx ByronEra)
parseTxOut :: Parser (TxOut CtxTx ByronEra)
parseTxOut =
  forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option
    ( (\(Text
addr, Word64
lovelace) -> forall ctx era.
AddressInEra era
-> TxOutValue era
-> TxOutDatum ctx era
-> ReferenceScript era
-> TxOut ctx era
TxOut (Text -> AddressInEra ByronEra
pAddressInEra Text
addr)
                                  (Word64 -> TxOutValue ByronEra
pLovelaceTxOut Word64
lovelace)
                                  forall ctx era. TxOutDatum ctx era
TxOutDatumNone
                                  forall era. ReferenceScript era
ReferenceScriptNone)
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Read a => ReadM a
auto
    )
    forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"txout"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
"'(\"ADDR\", LOVELACE)'"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Specify a transaction output, as a pair of an address and lovelace."
 where
  pAddressInEra :: Text -> AddressInEra ByronEra
  pAddressInEra :: Text -> AddressInEra ByronEra
pAddressInEra Text
t =
    case Text -> Either DecoderError Address
decodeAddressBase58 Text
t of
      Left DecoderError
err -> forall a. HasCallStack => [Char] -> a
error forall a b. (a -> b) -> a -> b
$ [Char]
"Bad Base58 address: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> [Char]
show DecoderError
err
      Right Address
byronAddress -> forall addrtype era.
AddressTypeInEra addrtype era
-> Address addrtype -> AddressInEra era
AddressInEra forall era. AddressTypeInEra ByronAddr era
ByronAddressInAnyEra forall a b. (a -> b) -> a -> b
$ Address -> Address ByronAddr
ByronAddress Address
byronAddress

  pLovelaceTxOut :: Word64 -> TxOutValue ByronEra
  pLovelaceTxOut :: Word64 -> TxOutValue ByronEra
pLovelaceTxOut Word64
l =
    if Word64
l forall a. Ord a => a -> a -> Bool
> (forall a. Bounded a => a
maxBound :: Word64)
    then forall a. HasCallStack => [Char] -> a
error forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show Word64
l forall a. Semigroup a => a -> a -> a
<> [Char]
" lovelace exceeds the Word64 upper bound"
    else forall era. OnlyAdaSupportedInEra era -> Lovelace -> TxOutValue era
TxOutAdaOnly OnlyAdaSupportedInEra ByronEra
AdaOnlyInByronEra forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Lovelace
Lovelace forall a b. (a -> b) -> a -> b
$ forall a. Integral a => a -> Integer
toInteger Word64
l

readerFromAttoParser :: Atto.Parser a -> Opt.ReadM a
readerFromAttoParser :: forall a. Parser a -> ReadM a
readerFromAttoParser Parser a
p =
  forall a. ([Char] -> Either [Char] a) -> ReadM a
Opt.eitherReader (forall a. Parser a -> ByteString -> Either [Char] a
Atto.parseOnly (Parser a
p forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall t. Chunk t => Parser t ()
Atto.endOfInput) forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> ByteString
BSC.pack)

parseTxRelatedValues :: Mod CommandFields ByronCommand
parseTxRelatedValues :: Mod CommandFields ByronCommand
parseTxRelatedValues =
  forall a. Monoid a => [a] -> a
mconcat
    [ forall a. [Char] -> [Char] -> Parser a -> Mod CommandFields a
command'
        [Char]
"submit-tx"
        [Char]
"Submit a raw, signed transaction, in its on-wire representation."
        forall a b. (a -> b) -> a -> b
$ NetworkId -> TxFile -> ByronCommand
SubmitTx
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser NetworkId
pNetworkId
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> Parser TxFile
parseTxFile [Char]
"tx"
    , forall a. [Char] -> [Char] -> Parser a -> Mod CommandFields a
command'
        [Char]
"issue-genesis-utxo-expenditure"
        [Char]
"Write a file with a signed transaction, spending genesis UTxO."
        forall a b. (a -> b) -> a -> b
$ GenesisFile
-> NetworkId
-> ByronKeyFormat
-> NewTxFile
-> SigningKeyFile
-> Address ByronAddr
-> [TxOut CtxTx ByronEra]
-> ByronCommand
SpendGenesisUTxO
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> Parser GenesisFile
parseGenesisFile [Char]
"genesis-json"
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser NetworkId
pNetworkId
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByronKeyFormat
parseByronKeyFormat
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> Parser NewTxFile
parseNewTxFile [Char]
"tx"
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> [Char] -> Parser SigningKeyFile
parseSigningKeyFile
                  [Char]
"wallet-key"
                  [Char]
"Key that has access to all mentioned genesis UTxO inputs."
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> [Char] -> Parser (Address ByronAddr)
parseAddress
                  [Char]
"rich-addr-from"
                  [Char]
"Tx source: genesis UTxO richman address (non-HD)."
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
some Parser (TxOut CtxTx ByronEra)
parseTxOut

    , forall a. [Char] -> [Char] -> Parser a -> Mod CommandFields a
command'
        [Char]
"issue-utxo-expenditure"
        [Char]
"Write a file with a signed transaction, spending normal UTxO."
        forall a b. (a -> b) -> a -> b
$ NetworkId
-> ByronKeyFormat
-> NewTxFile
-> SigningKeyFile
-> [TxIn]
-> [TxOut CtxTx ByronEra]
-> ByronCommand
SpendUTxO
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser NetworkId
pNetworkId
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByronKeyFormat
parseByronKeyFormat
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> Parser NewTxFile
parseNewTxFile [Char]
"tx"
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> [Char] -> Parser SigningKeyFile
parseSigningKeyFile
                  [Char]
"wallet-key"
                  [Char]
"Key that has access to all mentioned genesis UTxO inputs."
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
some Parser TxIn
parseTxIn
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
some Parser (TxOut CtxTx ByronEra)
parseTxOut

    , forall a. [Char] -> [Char] -> Parser a -> Mod CommandFields a
command'
        [Char]
"txid"
        [Char]
"Print the txid of a raw, signed transaction."
        forall a b. (a -> b) -> a -> b
$ TxFile -> ByronCommand
GetTxId
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> Parser TxFile
parseTxFile [Char]
"tx"
    ]

pNodeCmd :: Mod CommandFields NodeCmd
pNodeCmd :: Mod CommandFields NodeCmd
pNodeCmd =
    forall a. Monoid a => [a] -> a
mconcat
      [ forall a. [Char] -> ParserInfo a -> Mod CommandFields a
Opt.command [Char]
"create-update-proposal"
          (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser NodeCmd
parseByronUpdateProposal forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc  [Char]
"Create an update proposal.")

      , forall a. [Char] -> ParserInfo a -> Mod CommandFields a
Opt.command [Char]
"create-proposal-vote"
          (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser NodeCmd
parseByronVote forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Create an update proposal vote.")

      , forall a. [Char] -> ParserInfo a -> Mod CommandFields a
Opt.command [Char]
"submit-update-proposal"
          (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser NodeCmd
parseByronUpdateProposalSubmission forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Submit an update proposal.")

      , forall a. [Char] -> ParserInfo a -> Mod CommandFields a
Opt.command [Char]
"submit-proposal-vote"
          (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser NodeCmd
parseByronVoteSubmission forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Submit a proposal vote.")
      ]

parseByronUpdateProposal :: Parser NodeCmd
parseByronUpdateProposal :: Parser NodeCmd
parseByronUpdateProposal = do
  NetworkId
-> SigningKeyFile
-> ProtocolVersion
-> SoftwareVersion
-> SystemTag
-> InstallerHash
-> [Char]
-> ByronProtocolParametersUpdate
-> NodeCmd
UpdateProposal
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser NetworkId
pNetworkId
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> [Char] -> Parser SigningKeyFile
parseSigningKeyFile [Char]
"signing-key" [Char]
"Path to signing key."
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ProtocolVersion
parseProtocolVersion
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser SoftwareVersion
parseSoftwareVersion
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser SystemTag
parseSystemTag
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser InstallerHash
parseInstallerHash
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> [Char] -> Parser [Char]
parseFilePath [Char]
"filepath" [Char]
"Byron proposal output filepath."
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByronProtocolParametersUpdate
pByronProtocolParametersUpdate

parseByronVoteSubmission :: Parser NodeCmd
parseByronVoteSubmission :: Parser NodeCmd
parseByronVoteSubmission = do
  NetworkId -> [Char] -> NodeCmd
SubmitVote
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser NetworkId
pNetworkId
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> [Char] -> Parser [Char]
parseFilePath [Char]
"filepath" [Char]
"Filepath of Byron update proposal vote."


pByronProtocolParametersUpdate :: Parser ByronProtocolParametersUpdate
pByronProtocolParametersUpdate :: Parser ByronProtocolParametersUpdate
pByronProtocolParametersUpdate =
  Maybe Word16
-> Maybe Natural
-> Maybe Natural
-> Maybe Natural
-> Maybe Natural
-> Maybe Natural
-> Maybe LovelacePortion
-> Maybe LovelacePortion
-> Maybe LovelacePortion
-> Maybe LovelacePortion
-> Maybe SlotNumber
-> Maybe SoftforkRule
-> Maybe TxFeePolicy
-> Maybe EpochNumber
-> ByronProtocolParametersUpdate
ByronProtocolParametersUpdate
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Word16
parseScriptVersion
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Natural
parseSlotDuration
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Natural
parseMaxBlockSize
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Natural
parseMaxHeaderSize
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Natural
parseMaxTxSize
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Natural
parseMaxProposalSize
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser LovelacePortion
parseMpcThd
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser LovelacePortion
parseHeavyDelThd
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser LovelacePortion
parseUpdateVoteThd
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser LovelacePortion
parseUpdateProposalThd
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser SlotNumber
parseUpdateProposalTTL
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser SoftforkRule
parseSoftforkRule
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser TxFeePolicy
parseTxFeePolicy
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser EpochNumber
parseUnlockStakeEpoch

parseByronUpdateProposalSubmission :: Parser NodeCmd
parseByronUpdateProposalSubmission :: Parser NodeCmd
parseByronUpdateProposalSubmission =
  NetworkId -> [Char] -> NodeCmd
SubmitUpdateProposal
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser NetworkId
pNetworkId
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> [Char] -> Parser [Char]
parseFilePath [Char]
"filepath" [Char]
"Filepath of Byron update proposal."


parseByronVote :: Parser NodeCmd
parseByronVote :: Parser NodeCmd
parseByronVote =
  NetworkId -> SigningKeyFile -> [Char] -> Bool -> [Char] -> NodeCmd
CreateVote
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser NetworkId
pNetworkId
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ([Char] -> SigningKeyFile
SigningKeyFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> [Char] -> Parser [Char]
parseFilePath [Char]
"signing-key" [Char]
"Filepath of signing key.")
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> [Char] -> Parser [Char]
parseFilePath [Char]
"proposal-filepath" [Char]
"Filepath of Byron update proposal."
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Bool
parseVoteBool
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> [Char] -> Parser [Char]
parseFilePath [Char]
"output-filepath" [Char]
"Byron vote output filepath."

--------------------------------------------------------------------------------
-- CLI Parsers
--------------------------------------------------------------------------------

parseScriptVersion :: Parser Word16
parseScriptVersion :: Parser Word16
parseScriptVersion =
  forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option forall a. Read a => ReadM a
auto
    ( forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"script-version"
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
"WORD16"
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Proposed script version."
    )

parseSlotDuration :: Parser Natural
parseSlotDuration :: Parser Natural
parseSlotDuration =
  forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option forall a. Read a => ReadM a
auto
    ( forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"slot-duration"
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
"NATURAL"
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Proposed slot duration."
    )

parseSystemTag :: Parser SystemTag
parseSystemTag :: Parser SystemTag
parseSystemTag = forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option (forall a. ([Char] -> Either [Char] a) -> ReadM a
eitherReader [Char] -> Either [Char] SystemTag
checkSysTag)
                   ( forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"system-tag"
                   forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
"STRING"
                   forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Identify which system (linux, win64, etc) the update proposal is for."
                   )
 where
  checkSysTag :: String -> Either String SystemTag
  checkSysTag :: [Char] -> Either [Char] SystemTag
checkSysTag [Char]
name =
    let tag :: SystemTag
tag = Text -> SystemTag
SystemTag forall a b. (a -> b) -> a -> b
$ forall a b. ConvertText a b => a -> b
toS [Char]
name
    in case forall (m :: * -> *).
MonadError SystemTagError m =>
SystemTag -> m ()
checkSystemTag SystemTag
tag of
         Left SystemTagError
err -> forall a b. a -> Either a b
Left forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. ConvertText a b => a -> b
toS forall a b. (a -> b) -> a -> b
$ forall a. Format Text a -> a
sformat forall a r. Buildable a => Format r (a -> r)
build SystemTagError
err
         Right () -> forall a b. b -> Either a b
Right SystemTag
tag

parseInstallerHash :: Parser InstallerHash
parseInstallerHash :: Parser InstallerHash
parseInstallerHash =
  Hash Raw -> InstallerHash
InstallerHash forall b c a. (b -> c) -> (a -> b) -> a -> c
.  ByteString -> Hash Raw
hashRaw forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> ByteString
C8.pack
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s. IsString s => Mod OptionFields s -> Parser s
strOption ( forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"installer-hash"
                  forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
"HASH"
                  forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Software hash."
                  )

parseMaxBlockSize :: Parser Natural
parseMaxBlockSize :: Parser Natural
parseMaxBlockSize =
  forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option forall a. Read a => ReadM a
auto
    ( forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"max-block-size"
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
"NATURAL"
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Proposed max block size."
    )

parseMaxHeaderSize :: Parser Natural
parseMaxHeaderSize :: Parser Natural
parseMaxHeaderSize =
  forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option forall a. Read a => ReadM a
auto
    ( forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"max-header-size"
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
"NATURAL"
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Proposed max block header size."
    )

parseMaxTxSize :: Parser Natural
parseMaxTxSize :: Parser Natural
parseMaxTxSize =
  forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option forall a. Read a => ReadM a
auto
    ( forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"max-tx-size"
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
"NATURAL"
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Proposed max transaction size."
    )

parseMaxProposalSize :: Parser  Natural
parseMaxProposalSize :: Parser Natural
parseMaxProposalSize =
  forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option forall a. Read a => ReadM a
auto
    ( forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"max-proposal-size"
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
"NATURAL"
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Proposed max update proposal size."
    )

parseMpcThd :: Parser Byron.LovelacePortion
parseMpcThd :: Parser LovelacePortion
parseMpcThd =
  Rational -> LovelacePortion
rationalToLovelacePortion
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> [Char] -> Parser Rational
parseFraction [Char]
"max-mpc-thd" [Char]
"Proposed max mpc threshold."

parseProtocolVersion :: Parser ProtocolVersion
parseProtocolVersion :: Parser ProtocolVersion
parseProtocolVersion =
  Word16 -> Word16 -> Word8 -> ProtocolVersion
ProtocolVersion forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall a. Integral a => [Char] -> [Char] -> [Char] -> Parser a
parseWord [Char]
"protocol-version-major" [Char]
"Protocol version major." [Char]
"WORD16" :: Parser Word16)
                  forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall a. Integral a => [Char] -> [Char] -> [Char] -> Parser a
parseWord [Char]
"protocol-version-minor" [Char]
"Protocol version minor." [Char]
"WORD16" :: Parser Word16)
                  forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (forall a. Integral a => [Char] -> [Char] -> [Char] -> Parser a
parseWord [Char]
"protocol-version-alt" [Char]
"Protocol version alt." [Char]
"WORD8" :: Parser Word8)

parseHeavyDelThd :: Parser Byron.LovelacePortion
parseHeavyDelThd :: Parser LovelacePortion
parseHeavyDelThd =
  Rational -> LovelacePortion
rationalToLovelacePortion
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> [Char] -> Parser Rational
parseFraction [Char]
"heavy-del-thd" [Char]
"Proposed heavy delegation threshold."

parseUpdateVoteThd :: Parser Byron.LovelacePortion
parseUpdateVoteThd :: Parser LovelacePortion
parseUpdateVoteThd =
  Rational -> LovelacePortion
rationalToLovelacePortion
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> [Char] -> Parser Rational
parseFraction [Char]
"update-vote-thd" [Char]
"Propose update vote threshold."

parseUpdateProposalThd :: Parser Byron.LovelacePortion
parseUpdateProposalThd :: Parser LovelacePortion
parseUpdateProposalThd =
  Rational -> LovelacePortion
rationalToLovelacePortion
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> [Char] -> Parser Rational
parseFraction [Char]
"update-proposal-thd" [Char]
"Propose update proposal threshold."

parseUpdateProposalTTL :: Parser SlotNumber
parseUpdateProposalTTL :: Parser SlotNumber
parseUpdateProposalTTL =
  Word64 -> SlotNumber
SlotNumber
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option forall a. Read a => ReadM a
auto
          ( forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"time-to-live"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
"WORD64"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Proposed time for an update proposal to live."
          )

parseSoftforkRule :: Parser SoftforkRule
parseSoftforkRule :: Parser SoftforkRule
parseSoftforkRule =
  LovelacePortion
-> LovelacePortion -> LovelacePortion -> SoftforkRule
SoftforkRule
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Rational -> LovelacePortion
rationalToLovelacePortion forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> [Char] -> Parser Rational
parseFraction [Char]
"softfork-init-thd" [Char]
"Propose initial threshold (right after proposal is confirmed).")
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Rational -> LovelacePortion
rationalToLovelacePortion forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> [Char] -> Parser Rational
parseFraction [Char]
"softfork-min-thd" [Char]
"Propose minimum threshold (threshold can't be less than this).")
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Rational -> LovelacePortion
rationalToLovelacePortion forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> [Char] -> Parser Rational
parseFraction [Char]
"softfork-thd-dec" [Char]
"Propose threshold decrement (threshold will decrease by this amount after each epoch).")


parseSoftwareVersion :: Parser SoftwareVersion
parseSoftwareVersion :: Parser SoftwareVersion
parseSoftwareVersion =
  ApplicationName -> Word32 -> SoftwareVersion
SoftwareVersion forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ApplicationName
parseApplicationName forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Word32
parseNumSoftwareVersion

parseApplicationName :: Parser ApplicationName
parseApplicationName :: Parser ApplicationName
parseApplicationName = forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option (forall a. ([Char] -> Either [Char] a) -> ReadM a
eitherReader [Char] -> Either [Char] ApplicationName
checkAppNameLength)
       (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"application-name"
       forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
"STRING"
       forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"The name of the application."
       )
 where
  checkAppNameLength :: String -> Either String ApplicationName
  checkAppNameLength :: [Char] -> Either [Char] ApplicationName
checkAppNameLength [Char]
name =
    let appName :: ApplicationName
appName = Text -> ApplicationName
ApplicationName forall a b. (a -> b) -> a -> b
$ forall a b. ConvertText a b => a -> b
toS [Char]
name
    in case forall (m :: * -> *).
MonadError ApplicationNameError m =>
ApplicationName -> m ()
checkApplicationName ApplicationName
appName of
         Left ApplicationNameError
err -> forall a b. a -> Either a b
Left forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. ConvertText a b => a -> b
toS forall a b. (a -> b) -> a -> b
$ forall a. Format Text a -> a
sformat forall a r. Buildable a => Format r (a -> r)
build ApplicationNameError
err
         Right () -> forall a b. b -> Either a b
Right ApplicationName
appName

parseNumSoftwareVersion :: Parser NumSoftwareVersion
parseNumSoftwareVersion :: Parser Word32
parseNumSoftwareVersion =
  forall a. Integral a => [Char] -> [Char] -> [Char] -> Parser a
parseWord
    [Char]
"software-version-num"
    [Char]
"Numeric software version associated with application name."
    [Char]
"WORD32"

parseTxFeePolicy :: Parser TxFeePolicy
parseTxFeePolicy :: Parser TxFeePolicy
parseTxFeePolicy =
  TxSizeLinear -> TxFeePolicy
TxFeePolicyTxSizeLinear
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ( Lovelace -> Rational -> TxSizeLinear
TxSizeLinear forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> [Char] -> Parser Lovelace
parseLovelace [Char]
"tx-fee-a-constant" [Char]
"Propose the constant a for txfee = a + b*s where s is the size."
                       forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> [Char] -> Parser Rational
parseFraction [Char]
"tx-fee-b-constant" [Char]
"Propose the constant b for txfee = a + b*s where s is the size."
        )

parseVoteBool :: Parser Bool
parseVoteBool :: Parser Bool
parseVoteBool = forall a. a -> Mod FlagFields a -> Parser a
flag' Bool
True (forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"vote-yes" forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Vote yes with respect to an update proposal.")
            forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall a. a -> Mod FlagFields a -> Parser a
flag' Bool
False (forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"vote-no" forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Vote no with respect to an update proposal.")

parseUnlockStakeEpoch :: Parser EpochNumber
parseUnlockStakeEpoch :: Parser EpochNumber
parseUnlockStakeEpoch =
  Word64 -> EpochNumber
EpochNumber
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option forall a. Read a => ReadM a
auto
      ( forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"unlock-stake-epoch"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
"WORD64"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Proposed epoch to unlock all stake."
      )


parseWord :: Integral a => String -> String -> String -> Parser a
parseWord :: forall a. Integral a => [Char] -> [Char] -> [Char] -> Parser a
parseWord [Char]
optname [Char]
desc [Char]
metvar = forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option (forall a. Num a => Integer -> a
fromInteger forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Read a => ReadM a
auto)
  forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
optname forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
metvar forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
desc



parseAddress :: String -> String -> Parser (Address ByronAddr)
parseAddress :: [Char] -> [Char] -> Parser (Address ByronAddr)
parseAddress [Char]
opt [Char]
desc =
  forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option (Text -> Address ByronAddr
cliParseBase58Address forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s. IsString s => ReadM s
str)
    forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
opt forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
"ADDR" forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
desc

parseByronKeyFormat :: Parser ByronKeyFormat
parseByronKeyFormat :: Parser ByronKeyFormat
parseByronKeyFormat = forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
  [ forall a. a -> Mod FlagFields a -> Parser a
flag' ByronKeyFormat
LegacyByronKeyFormat forall a b. (a -> b) -> a -> b
$
        forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"byron-legacy-formats"
     forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Byron/cardano-sl formats and compatibility"

  , forall a. a -> Mod FlagFields a -> Parser a
flag' ByronKeyFormat
NonLegacyByronKeyFormat forall a b. (a -> b) -> a -> b
$
        forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"byron-formats"
     forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Byron era formats and compatibility"

    -- And hidden compatibility flag aliases that should be deprecated:
  , forall a. a -> Mod FlagFields a -> Parser a
flag' ByronKeyFormat
LegacyByronKeyFormat forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. Mod f a
hidden forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"byron-legacy"
  , forall a. a -> Mod FlagFields a -> Parser a
flag' ByronKeyFormat
NonLegacyByronKeyFormat forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. Mod f a
hidden forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"real-pbft"

  -- Default Byron key format
  , forall (f :: * -> *) a. Applicative f => a -> f a
pure ByronKeyFormat
NonLegacyByronKeyFormat
  ]


parseFakeAvvmOptions :: Parser FakeAvvmOptions
parseFakeAvvmOptions :: Parser FakeAvvmOptions
parseFakeAvvmOptions =
  Word -> Lovelace -> FakeAvvmOptions
FakeAvvmOptions
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Integral a => [Char] -> [Char] -> Parser a
parseIntegral [Char]
"avvm-entry-count" [Char]
"Number of AVVM addresses."
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> [Char] -> Parser Lovelace
parseLovelace [Char]
"avvm-entry-balance" [Char]
"AVVM address."

parseK :: Parser BlockCount
parseK :: Parser BlockCount
parseK =
  Word64 -> BlockCount
BlockCount
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Integral a => [Char] -> [Char] -> Parser a
parseIntegral [Char]
"k" [Char]
"The security parameter of the Ouroboros protocol."

parseNewDirectory :: String -> String -> Parser NewDirectory
parseNewDirectory :: [Char] -> [Char] -> Parser NewDirectory
parseNewDirectory [Char]
opt [Char]
desc = [Char] -> NewDirectory
NewDirectory forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> [Char] -> Parser [Char]
parseFilePath [Char]
opt [Char]
desc

parseFractionWithDefault
  :: String
  -> String
  -> Double
  -> Parser Rational
parseFractionWithDefault :: [Char] -> [Char] -> Double -> Parser Rational
parseFractionWithDefault [Char]
optname [Char]
desc Double
w =
  forall a. Real a => a -> Rational
toRational forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option ReadM Double
readDouble
    ( forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
optname
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
"DOUBLE"
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
desc
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasValue f => a -> Mod f a
value Double
w
    )

pNetworkId :: Parser NetworkId
pNetworkId :: Parser NetworkId
pNetworkId =
  Parser NetworkId
pMainnet' forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap NetworkMagic -> NetworkId
Testnet Parser NetworkMagic
pTestnetMagic
 where
   pMainnet' :: Parser NetworkId
   pMainnet' :: Parser NetworkId
pMainnet' =
    forall a. a -> Mod FlagFields a -> Parser a
Opt.flag' NetworkId
Mainnet
      (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"mainnet"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Use the mainnet magic id."
      )

pTestnetMagic :: Parser NetworkMagic
pTestnetMagic :: Parser NetworkMagic
pTestnetMagic =
  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word32 -> NetworkMagic
NetworkMagic forall a b. (a -> b) -> a -> b
$ forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option (forall a. (Bounded a, Integral a, Show a) => [Char] -> ReadM a
bounded [Char]
"TESTNET_MAGIC") forall a b. (a -> b) -> a -> b
$ forall a. Monoid a => [a] -> a
mconcat
    [ forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"testnet-magic"
    , forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"NATURAL"
    , forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Specify a testnet magic id."
    ]

parseNewSigningKeyFile :: String -> Parser NewSigningKeyFile
parseNewSigningKeyFile :: [Char] -> Parser NewSigningKeyFile
parseNewSigningKeyFile [Char]
opt =
  [Char] -> NewSigningKeyFile
NewSigningKeyFile
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> [Char] -> Parser [Char]
parseFilePath [Char]
opt [Char]
"Non-existent file to write the signing key to."

parseNewTxFile :: String -> Parser NewTxFile
parseNewTxFile :: [Char] -> Parser NewTxFile
parseNewTxFile [Char]
opt =
  [Char] -> NewTxFile
NewTxFile
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> [Char] -> Parser [Char]
parseFilePath [Char]
opt [Char]
"Non-existent file to write the signed transaction to."

parseNewVerificationKeyFile :: String -> Parser NewVerificationKeyFile
parseNewVerificationKeyFile :: [Char] -> Parser NewVerificationKeyFile
parseNewVerificationKeyFile [Char]
opt =
  [Char] -> NewVerificationKeyFile
NewVerificationKeyFile
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> [Char] -> Parser [Char]
parseFilePath [Char]
opt [Char]
"Non-existent file to write the verification key to."

parseProtocolMagicId :: String -> Parser ProtocolMagicId
parseProtocolMagicId :: [Char] -> Parser ProtocolMagicId
parseProtocolMagicId [Char]
arg =
  Word32 -> ProtocolMagicId
ProtocolMagicId
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Integral a => [Char] -> [Char] -> Parser a
parseIntegral [Char]
arg [Char]
"The magic number unique to any instance of Cardano."

parseProtocolMagic :: Parser ProtocolMagic
parseProtocolMagic :: Parser ProtocolMagic
parseProtocolMagic =
  forall a b c. (a -> b -> c) -> b -> a -> c
flip forall a.
Annotated ProtocolMagicId a
-> RequiresNetworkMagic -> AProtocolMagic a
AProtocolMagic RequiresNetworkMagic
RequiresMagic forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b c. (a -> b -> c) -> b -> a -> c
flip forall b a. b -> a -> Annotated b a
Annotated ()
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> Parser ProtocolMagicId
parseProtocolMagicId [Char]
"protocol-magic"

parseTxFile :: String -> Parser TxFile
parseTxFile :: [Char] -> Parser TxFile
parseTxFile [Char]
opt =
  [Char] -> TxFile
TxFile
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> [Char] -> Parser [Char]
parseFilePath [Char]
opt [Char]
"File containing the signed transaction."

parseUTCTime :: String -> String -> Parser UTCTime
parseUTCTime :: [Char] -> [Char] -> Parser UTCTime
parseUTCTime [Char]
optname [Char]
desc =
  forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option (POSIXTime -> UTCTime
posixSecondsToUTCTime forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Num a => Integer -> a
fromInteger forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Read a => ReadM a
auto)
    forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
optname forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
"POSIXSECONDS" forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
desc

cliParseBase58Address :: Text -> Address ByronAddr
cliParseBase58Address :: Text -> Address ByronAddr
cliParseBase58Address Text
t =
  case Text -> Either DecoderError Address
decodeAddressBase58 Text
t of
    Left DecoderError
err -> forall a. HasCallStack => [Char] -> a
error forall a b. (a -> b) -> a -> b
$ [Char]
"Bad Base58 address: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> [Char]
show DecoderError
err
    Right Address
byronAddress -> Address -> Address ByronAddr
ByronAddress Address
byronAddress

parseFraction :: String -> String -> Parser Rational
parseFraction :: [Char] -> [Char] -> Parser Rational
parseFraction [Char]
optname [Char]
desc =
  forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option (forall a. Real a => a -> Rational
toRational forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ReadM Double
readDouble) forall a b. (a -> b) -> a -> b
$
      forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
optname
   forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
"DOUBLE"
   forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
desc

parseIntegral :: Integral a => String -> String -> Parser a
parseIntegral :: forall a. Integral a => [Char] -> [Char] -> Parser a
parseIntegral [Char]
optname [Char]
desc = forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option (forall a. Num a => Integer -> a
fromInteger forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Read a => ReadM a
auto)
  forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
optname forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
"INT" forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
desc

parseLovelace :: String -> String -> Parser Byron.Lovelace
parseLovelace :: [Char] -> [Char] -> Parser Lovelace
parseLovelace [Char]
optname [Char]
desc =
  forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option (forall a. Parser a -> ReadM a
readerFromAttoParser Parser Lovelace
parseLovelaceAtto)
    (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
optname
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
"INT"
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
desc
    )
 where
  parseLovelaceAtto :: Atto.Parser Byron.Lovelace
  parseLovelaceAtto :: Parser Lovelace
parseLovelaceAtto = do
    Integer
i <- forall a. Integral a => Parser a
Atto.decimal
    if Integer
i forall a. Ord a => a -> a -> Bool
> forall a. Integral a => a -> Integer
toInteger (forall a. Bounded a => a
maxBound :: Word64)
    then forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show Integer
i forall a. Semigroup a => a -> a -> a
<> [Char]
" lovelace exceeds the Word64 upper bound"
    else case Lovelace -> Maybe Lovelace
toByronLovelace (Integer -> Lovelace
Lovelace Integer
i) of
           Just Lovelace
byronLovelace -> forall (m :: * -> *) a. Monad m => a -> m a
return Lovelace
byronLovelace
           Maybe Lovelace
Nothing -> forall a. HasCallStack => [Char] -> a
error forall a b. (a -> b) -> a -> b
$ [Char]
"Error converting lovelace: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> [Char]
show Integer
i

readDouble :: ReadM Double
readDouble :: ReadM Double
readDouble = do
  Double
f <- forall a. Read a => ReadM a
auto
  forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Double
f forall a. Ord a => a -> a -> Bool
< Double
0) forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> ReadM a
readerError [Char]
"fraction must be >= 0"
  forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Double
f forall a. Ord a => a -> a -> Bool
> Double
1) forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> ReadM a
readerError [Char]
"fraction must be <= 1"
  forall (m :: * -> *) a. Monad m => a -> m a
return Double
f

parseSigningKeyFile :: String -> String -> Parser SigningKeyFile
parseSigningKeyFile :: [Char] -> [Char] -> Parser SigningKeyFile
parseSigningKeyFile [Char]
opt [Char]
desc = [Char] -> SigningKeyFile
SigningKeyFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> [Char] -> Parser [Char]
parseFilePath [Char]
opt [Char]
desc


parseGenesisFile :: String -> Parser GenesisFile
parseGenesisFile :: [Char] -> Parser GenesisFile
parseGenesisFile [Char]
opt =
  [Char] -> GenesisFile
GenesisFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> [Char] -> Parser [Char]
parseFilePath [Char]
opt [Char]
"Genesis JSON file."