{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}

module Cardano.CLI.Shelley.Parsers
  ( -- * CLI command parser
    parseShelleyCommands

    -- * CLI command and flag types
  , module Cardano.CLI.Shelley.Commands

    -- * Field parser and renderers
  , parseTxIn
  ) where

import           Cardano.Prelude (ConvertText (..))

import qualified Data.Aeson as Aeson
import qualified Data.Attoparsec.ByteString.Char8 as Atto
import           Data.Bifunctor
import           Data.ByteString (ByteString)
import qualified Data.ByteString.Base16 as B16
import qualified Data.ByteString.Char8 as BSC
import           Data.Foldable
import           Data.Functor (($>))
import qualified Data.IP as IP
import           Data.List.NonEmpty (NonEmpty)
import qualified Data.List.NonEmpty as NE
import           Data.Maybe (fromMaybe)
import           Data.Ratio ((%))
import qualified Data.Set as Set
import           Data.Text (Text)
import qualified Data.Text as Text
import qualified Data.Text.Encoding as Text
import           Data.Time.Clock (UTCTime)
import           Data.Time.Format (defaultTimeLocale, parseTimeOrError)
import           Data.Word (Word64)
import           GHC.Natural (Natural)
import           Network.Socket (PortNumber)
import           Options.Applicative hiding (help, str)
import qualified Options.Applicative as Opt
import qualified Options.Applicative.Help as H
import           Prettyprinter (line, pretty)
import qualified Text.Parsec as Parsec
import           Text.Parsec ((<?>))
import qualified Text.Parsec.Error as Parsec
import qualified Text.Parsec.Language as Parsec
import qualified Text.Parsec.String as Parsec
import qualified Text.Parsec.Token as Parsec
import           Text.Read (readEither, readMaybe)

import qualified Cardano.Ledger.BaseTypes as Shelley
import qualified Cardano.Ledger.Shelley.TxBody as Shelley

import           Cardano.Api
import           Cardano.Api.Shelley

import           Cardano.Chain.Common (BlockCount (BlockCount))
import           Cardano.CLI.Shelley.Commands
import           Cardano.CLI.Shelley.Key (PaymentVerifier (..), StakeVerifier (..),
                   VerificationKeyOrFile (..), VerificationKeyOrHashOrFile (..),
                   VerificationKeyTextOrFile (..))
import           Cardano.CLI.Types

{- HLINT ignore "Use <$>" -}

--
-- Shelley CLI command parsers
--

parseShelleyCommands :: Parser ShelleyCommand
parseShelleyCommands :: Parser ShelleyCommand
parseShelleyCommands =
  forall a. Mod CommandFields a -> Parser a
Opt.hsubparser forall a b. (a -> b) -> a -> b
$
    forall a. Monoid a => [a] -> a
mconcat
      [ forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"Era based commands"
      , forall a. [Char] -> Mod CommandFields a
Opt.commandGroup [Char]
"Era based commands"
      , forall a. [Char] -> ParserInfo a -> Mod CommandFields a
Opt.command [Char]
"address"
          (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info (AddressCmd -> ShelleyCommand
AddressCmd forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser AddressCmd
pAddressCmd) forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Payment address commands")
      , forall a. [Char] -> ParserInfo a -> Mod CommandFields a
Opt.command [Char]
"stake-address"
          (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info (StakeAddressCmd -> ShelleyCommand
StakeAddressCmd forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser StakeAddressCmd
pStakeAddressCmd) forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Stake address commands")
      , forall a. [Char] -> ParserInfo a -> Mod CommandFields a
Opt.command [Char]
"key"
          (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info (KeyCmd -> ShelleyCommand
KeyCmd forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser KeyCmd
pKeyCmd) forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Key utility commands")
      , forall a. [Char] -> ParserInfo a -> Mod CommandFields a
Opt.command [Char]
"transaction"
          (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info (TransactionCmd -> ShelleyCommand
TransactionCmd forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TransactionCmd
pTransaction) forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Transaction commands")
      , forall a. [Char] -> ParserInfo a -> Mod CommandFields a
Opt.command [Char]
"node"
          (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info (NodeCmd -> ShelleyCommand
NodeCmd forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser NodeCmd
pNodeCmd) forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Node operation commands")
      , forall a. [Char] -> ParserInfo a -> Mod CommandFields a
Opt.command [Char]
"stake-pool"
          (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info (PoolCmd -> ShelleyCommand
PoolCmd forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser PoolCmd
pPoolCmd) forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Stake pool commands")
      , forall a. [Char] -> ParserInfo a -> Mod CommandFields a
Opt.command [Char]
"query"
          (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info (QueryCmd -> ShelleyCommand
QueryCmd forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser QueryCmd
pQueryCmd) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [Char] -> InfoMod a
Opt.progDesc forall a b. (a -> b) -> a -> b
$
             forall a. Monoid a => [a] -> a
mconcat
               [ [Char]
"Node query commands. Will query the local node whose Unix domain socket "
               , [Char]
"is obtained from the CARDANO_NODE_SOCKET_PATH environment variable."
               ]
            )
      , forall a. [Char] -> ParserInfo a -> Mod CommandFields a
Opt.command [Char]
"genesis"
          (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info (GenesisCmd -> ShelleyCommand
GenesisCmd forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser GenesisCmd
pGenesisCmd) forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Genesis block commands")
      , forall a. [Char] -> ParserInfo a -> Mod CommandFields a
Opt.command [Char]
"governance"
          (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info (GovernanceCmd -> ShelleyCommand
GovernanceCmd forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser GovernanceCmd
pGovernanceCmd) forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Governance commands")
      , forall a. [Char] -> ParserInfo a -> Mod CommandFields a
Opt.command [Char]
"text-view"
          (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info (TextViewCmd -> ShelleyCommand
TextViewCmd forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TextViewCmd
pTextViewCmd) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [Char] -> InfoMod a
Opt.progDesc forall a b. (a -> b) -> a -> b
$
             forall a. Monoid a => [a] -> a
mconcat
               [ [Char]
"Commands for dealing with Shelley TextView files. "
               , [Char]
"Transactions, addresses etc are stored on disk as TextView files."
               ]
            )

      ]

pTextViewCmd :: Parser TextViewCmd
pTextViewCmd :: Parser TextViewCmd
pTextViewCmd =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"decode-cbor"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info ([Char] -> Maybe OutputFile -> TextViewCmd
TextViewInfo forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser [Char]
pCBORInFile forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Maybe OutputFile)
pMaybeOutputFile)
          forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Print a TextView file as decoded CBOR."
          )
    ]

pCBORInFile :: Parser FilePath
pCBORInFile :: Parser [Char]
pCBORInFile =
  forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
    (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"in-file"
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"CBOR input file."
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
    )
  forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
  forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
    (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"file"
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. Mod f a
Opt.internal
    )

pAddressCmd :: Parser AddressCmd
pAddressCmd :: Parser AddressCmd
pAddressCmd =
   forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
     [ forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"key-gen"
         (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser AddressCmd
pAddressKeyGen forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Create an address key pair.")
     , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"key-hash"
         (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser AddressCmd
pAddressKeyHash forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Print the hash of an address key.")
     , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"build"
         (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser AddressCmd
pAddressBuild forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Build a Shelley payment address, with optional delegation to a stake address.")
     , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"info"
         (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser AddressCmd
pAddressInfo forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Print information about an address.")
     ]
  where
    pAddressKeyGen :: Parser AddressCmd
    pAddressKeyGen :: Parser AddressCmd
pAddressKeyGen = AddressKeyType
-> VerificationKeyFile -> SigningKeyFile -> AddressCmd
AddressKeyGen forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser AddressKeyType
pAddressKeyType
                                   forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> FileDirection -> Parser VerificationKeyFile
pVerificationKeyFile FileDirection
Output
                                   forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> FileDirection -> Parser SigningKeyFile
pSigningKeyFile FileDirection
Output

    pAddressKeyHash :: Parser AddressCmd
    pAddressKeyHash :: Parser AddressCmd
pAddressKeyHash =
      VerificationKeyTextOrFile -> Maybe OutputFile -> AddressCmd
AddressKeyHash
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser VerificationKeyTextOrFile
pPaymentVerificationKeyTextOrFile
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Maybe OutputFile)
pMaybeOutputFile

    pAddressBuild :: Parser AddressCmd
    pAddressBuild :: Parser AddressCmd
pAddressBuild = PaymentVerifier
-> Maybe StakeVerifier
-> NetworkId
-> Maybe OutputFile
-> AddressCmd
AddressBuild
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser PaymentVerifier
pPaymentVerifier
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
Opt.optional Parser StakeVerifier
pStakeVerifier
      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 (Maybe OutputFile)
pMaybeOutputFile

    pAddressInfo :: Parser AddressCmd
    pAddressInfo :: Parser AddressCmd
pAddressInfo = Text -> Maybe OutputFile -> AddressCmd
AddressInfo forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text
pAddress forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Maybe OutputFile)
pMaybeOutputFile

pPaymentVerifier :: Parser PaymentVerifier
pPaymentVerifier :: Parser PaymentVerifier
pPaymentVerifier =
        VerificationKeyTextOrFile -> PaymentVerifier
PaymentVerifierKey forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser VerificationKeyTextOrFile
pPaymentVerificationKeyTextOrFile
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ScriptFile -> PaymentVerifier
PaymentVerifierScriptFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
          [Char] -> Maybe [Char] -> [Char] -> Parser ScriptFile
pScriptFor [Char]
"payment-script-file" forall a. Maybe a
Nothing
                     [Char]
"Filepath of the payment script."

pStakeVerifier :: Parser StakeVerifier
pStakeVerifier :: Parser StakeVerifier
pStakeVerifier =
        VerificationKeyOrFile StakeKey -> StakeVerifier
StakeVerifierKey forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (VerificationKeyOrFile StakeKey)
pStakeVerificationKeyOrFile
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ScriptFile -> StakeVerifier
StakeVerifierScriptFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
          [Char] -> Maybe [Char] -> [Char] -> Parser ScriptFile
pScriptFor [Char]
"stake-script-file" forall a. Maybe a
Nothing
                     [Char]
"Filepath of the staking script."
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StakeAddress -> StakeVerifier
StakeVerifierAddress forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser StakeAddress
pStakeAddress

pPaymentVerificationKeyTextOrFile :: Parser VerificationKeyTextOrFile
pPaymentVerificationKeyTextOrFile :: Parser VerificationKeyTextOrFile
pPaymentVerificationKeyTextOrFile =
        Text -> VerificationKeyTextOrFile
VktofVerificationKeyText forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Text
pPaymentVerificationKeyText
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> VerificationKeyFile -> VerificationKeyTextOrFile
VktofVerificationKeyFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser VerificationKeyFile
pPaymentVerificationKeyFile

pPaymentVerificationKeyText :: Parser Text
pPaymentVerificationKeyText :: Parser Text
pPaymentVerificationKeyText =
  [Char] -> Text
Text.pack forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
      (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"payment-verification-key"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"STRING"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Payment verification key (Bech32-encoded)"
      )

pPaymentVerificationKeyFile :: Parser VerificationKeyFile
pPaymentVerificationKeyFile :: Parser VerificationKeyFile
pPaymentVerificationKeyFile =
  [Char] -> VerificationKeyFile
VerificationKeyFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    ( forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
        (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"payment-verification-key-file"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Filepath of the payment verification key."
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
        )
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
        (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"verification-key-file"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. Mod f a
Opt.internal
        )
    )

pScript :: Parser ScriptFile
pScript :: Parser ScriptFile
pScript = [Char] -> Maybe [Char] -> [Char] -> Parser ScriptFile
pScriptFor [Char]
"script-file" forall a. Maybe a
Nothing [Char]
"Filepath of the script."

pScriptFor :: String -> Maybe String -> String -> Parser ScriptFile
pScriptFor :: [Char] -> Maybe [Char] -> [Char] -> Parser ScriptFile
pScriptFor [Char]
name Maybe [Char]
Nothing [Char]
help =
  [Char] -> ScriptFile
ScriptFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
    (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
name
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
help
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
    )

pScriptFor [Char]
name (Just [Char]
deprecated) [Char]
help =
      [Char] -> Maybe [Char] -> [Char] -> Parser ScriptFile
pScriptFor [Char]
name forall a. Maybe a
Nothing [Char]
help
  forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> ScriptFile
ScriptFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
        (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
deprecated
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. Mod f a
Opt.internal
        )

pReferenceTxIn :: String -> String -> Parser TxIn
pReferenceTxIn :: [Char] -> [Char] -> Parser TxIn
pReferenceTxIn [Char]
prefix [Char]
scriptType =
  forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option (forall a. Parser a -> ReadM a
readerFromParsecParser Parser TxIn
parseTxIn) 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]
prefix forall a. [a] -> [a] -> [a]
++ [Char]
"tx-in-reference")
    , forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"TX-IN"
    , forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help forall a b. (a -> b) -> a -> b
$ forall a. Monoid a => [a] -> a
mconcat
      [ [Char]
"TxId#TxIx - Specify a reference input. The reference input must have"
      , [Char]
" a " forall a. Semigroup a => a -> a -> a
<> [Char]
scriptType forall a. Semigroup a => a -> a -> a
<> [Char]
" reference script attached."
      ]
    ]

pReadOnlyReferenceTxIn :: Parser TxIn
pReadOnlyReferenceTxIn :: Parser TxIn
pReadOnlyReferenceTxIn =
  forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option (forall a. Parser a -> ReadM a
readerFromParsecParser Parser TxIn
parseTxIn) 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]
"read-only-tx-in-reference"
    , forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"TX-IN"
    , forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help forall a b. (a -> b) -> a -> b
$ forall a. Monoid a => [a] -> a
mconcat
      [ [Char]
"Specify a read only reference input. This reference input is not witnessing anything "
      , [Char]
"it is simply provided in the plutus script context."
      ]
    ]


pScriptWitnessFiles :: forall witctx.
                       WitCtx witctx
                    -> BalanceTxExecUnits -- ^ Use the @execution-units@ flag.
                    -> String -- ^ Script flag prefix
                    -> Maybe String
                    -> String
                    -> Parser (ScriptWitnessFiles witctx)
pScriptWitnessFiles :: forall witctx.
WitCtx witctx
-> BalanceTxExecUnits
-> [Char]
-> Maybe [Char]
-> [Char]
-> Parser (ScriptWitnessFiles witctx)
pScriptWitnessFiles WitCtx witctx
witctx BalanceTxExecUnits
autoBalanceExecUnits [Char]
scriptFlagPrefix Maybe [Char]
scriptFlagPrefixDeprecated [Char]
help =
    ScriptFile
-> Maybe
     (ScriptDatumOrFile witctx, ScriptRedeemerOrFile, ExecutionUnits)
-> ScriptWitnessFiles witctx
toScriptWitnessFiles
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> Maybe [Char] -> [Char] -> Parser ScriptFile
pScriptFor ([Char]
scriptFlagPrefix forall a. [a] -> [a] -> [a]
++ [Char]
"-script-file")
                     ((forall a. [a] -> [a] -> [a]
++ [Char]
"-script-file") forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe [Char]
scriptFlagPrefixDeprecated)
                     ([Char]
"The file containing the script to witness " forall a. [a] -> [a] -> [a]
++ [Char]
help)
      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 (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall witctx.
[Char] -> WitCtx witctx -> Parser (ScriptDatumOrFile witctx)
pScriptDatumOrFile [Char]
scriptFlagPrefix WitCtx witctx
witctx
                         forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> Parser ScriptRedeemerOrFile
pScriptRedeemerOrFile [Char]
scriptFlagPrefix
                         forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (case BalanceTxExecUnits
autoBalanceExecUnits of
                               BalanceTxExecUnits
AutoBalance -> forall (f :: * -> *) a. Applicative f => a -> f a
pure (Natural -> Natural -> ExecutionUnits
ExecutionUnits Natural
0 Natural
0)
                               BalanceTxExecUnits
ManualBalance -> [Char] -> Parser ExecutionUnits
pExecutionUnits [Char]
scriptFlagPrefix)
                   )
  where
    toScriptWitnessFiles :: ScriptFile
                         -> Maybe (ScriptDatumOrFile witctx,
                                   ScriptRedeemerOrFile,
                                   ExecutionUnits)
                         -> ScriptWitnessFiles witctx
    toScriptWitnessFiles :: ScriptFile
-> Maybe
     (ScriptDatumOrFile witctx, ScriptRedeemerOrFile, ExecutionUnits)
-> ScriptWitnessFiles witctx
toScriptWitnessFiles ScriptFile
sf Maybe
  (ScriptDatumOrFile witctx, ScriptRedeemerOrFile, ExecutionUnits)
Nothing        = forall witctx. ScriptFile -> ScriptWitnessFiles witctx
SimpleScriptWitnessFile  ScriptFile
sf
    toScriptWitnessFiles ScriptFile
sf (Just (ScriptDatumOrFile witctx
d,ScriptRedeemerOrFile
r, ExecutionUnits
e)) = forall witctx.
ScriptFile
-> ScriptDatumOrFile witctx
-> ScriptRedeemerOrFile
-> ExecutionUnits
-> ScriptWitnessFiles witctx
PlutusScriptWitnessFiles ScriptFile
sf ScriptDatumOrFile witctx
d ScriptRedeemerOrFile
r ExecutionUnits
e


pExecutionUnits :: String -> Parser ExecutionUnits
pExecutionUnits :: [Char] -> Parser ExecutionUnits
pExecutionUnits [Char]
scriptFlagPrefix =
  forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Natural -> Natural -> ExecutionUnits
ExecutionUnits 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
Opt.auto
      (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long ([Char]
scriptFlagPrefix forall a. [a] -> [a] -> [a]
++ [Char]
"-execution-units")
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"(INT, INT)"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"The time and space units needed by the script."
      )

pScriptRedeemerOrFile :: String -> Parser ScriptDataOrFile
pScriptRedeemerOrFile :: [Char] -> Parser ScriptRedeemerOrFile
pScriptRedeemerOrFile [Char]
scriptFlagPrefix =
  [Char] -> [Char] -> [Char] -> Parser ScriptRedeemerOrFile
pScriptDataOrFile ([Char]
scriptFlagPrefix forall a. [a] -> [a] -> [a]
++ [Char]
"-redeemer")
    [Char]
"The script redeemer, in JSON syntax."
    [Char]
"The script redeemer, in the given JSON file."


pScriptDatumOrFile :: String -> WitCtx witctx -> Parser (ScriptDatumOrFile witctx)
pScriptDatumOrFile :: forall witctx.
[Char] -> WitCtx witctx -> Parser (ScriptDatumOrFile witctx)
pScriptDatumOrFile [Char]
scriptFlagPrefix WitCtx witctx
witctx =
  case WitCtx witctx
witctx of
    WitCtx witctx
WitCtxTxIn  -> (ScriptRedeemerOrFile -> ScriptDatumOrFile WitCtxTxIn
ScriptDatumOrFileForTxIn forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                     [Char] -> [Char] -> [Char] -> Parser ScriptRedeemerOrFile
pScriptDataOrFile
                       ([Char]
scriptFlagPrefix forall a. [a] -> [a] -> [a]
++ [Char]
"-datum")
                       [Char]
"The script datum, in JSON syntax."
                       [Char]
"The script datum, in the given JSON file.") forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
                    Parser (ScriptDatumOrFile WitCtxTxIn)
pInlineDatumPresent
    WitCtx witctx
WitCtxMint  -> forall (f :: * -> *) a. Applicative f => a -> f a
pure ScriptDatumOrFile WitCtxMint
NoScriptDatumOrFileForMint
    WitCtx witctx
WitCtxStake -> forall (f :: * -> *) a. Applicative f => a -> f a
pure ScriptDatumOrFile WitCtxStake
NoScriptDatumOrFileForStake
 where
  pInlineDatumPresent :: Parser (ScriptDatumOrFile WitCtxTxIn)
  pInlineDatumPresent :: Parser (ScriptDatumOrFile WitCtxTxIn)
pInlineDatumPresent  =
    forall a. a -> Mod FlagFields a -> Parser a
flag' ScriptDatumOrFile WitCtxTxIn
InlineDatumPresentAtTxIn
      (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long ([Char]
scriptFlagPrefix forall a. [a] -> [a] -> [a]
++ [Char]
"-inline-datum-present")
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Inline datum present at transaction input."
      )

pScriptDataOrFile :: String -> String -> String -> Parser ScriptDataOrFile
pScriptDataOrFile :: [Char] -> [Char] -> [Char] -> Parser ScriptRedeemerOrFile
pScriptDataOrFile [Char]
dataFlagPrefix [Char]
helpTextForValue [Char]
helpTextForFile =
      Parser ScriptRedeemerOrFile
pScriptDataCborFile
  forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser ScriptRedeemerOrFile
pScriptDataFile
  forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser ScriptRedeemerOrFile
pScriptDataValue
  where
    pScriptDataCborFile :: Parser ScriptRedeemerOrFile
pScriptDataCborFile = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Char] -> ScriptRedeemerOrFile
ScriptDataCborFile forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption 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]
dataFlagPrefix forall a. [a] -> [a] -> [a]
++ [Char]
"-cbor-file")
      , forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"CBOR FILE"
      , forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help forall a b. (a -> b) -> a -> b
$ forall a. Monoid a => [a] -> a
mconcat
        [ [Char]
helpTextForFile
        , [Char]
" The file must follow the special JSON schema for script data."
        ]
      ]

    pScriptDataFile :: Parser ScriptRedeemerOrFile
pScriptDataFile = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Char] -> ScriptRedeemerOrFile
ScriptDataJsonFile forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption 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]
dataFlagPrefix forall a. [a] -> [a] -> [a]
++ [Char]
"-file")
      , forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"JSON FILE"
      , forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help forall a b. (a -> b) -> a -> b
$ forall a. Monoid a => [a] -> a
mconcat
        [ [Char]
helpTextForFile forall a. [a] -> [a] -> [a]
++ [Char]
" The file must follow the special "
        , [Char]
"JSON schema for script data."
        ]
      ]

    pScriptDataValue :: Parser ScriptRedeemerOrFile
pScriptDataValue = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap HashableScriptData -> ScriptRedeemerOrFile
ScriptDataValue forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option ReadM HashableScriptData
readerScriptData 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]
dataFlagPrefix forall a. [a] -> [a] -> [a]
++ [Char]
"-value")
      , forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"JSON VALUE"
      , forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help forall a b. (a -> b) -> a -> b
$ forall a. Monoid a => [a] -> a
mconcat
        [ [Char]
helpTextForValue
        , [Char]
" There is no schema: (almost) any JSON value is supported, including "
        , [Char]
"top-level strings and numbers."
        ]
      ]

    readerScriptData :: ReadM HashableScriptData
    readerScriptData :: ReadM HashableScriptData
readerScriptData = do
      ByteString
v <- forall s. IsString s => ReadM s
Opt.str
      case forall a. FromJSON a => ByteString -> Either [Char] a
Aeson.eitherDecode ByteString
v of
        Left [Char]
e -> forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail forall a b. (a -> b) -> a -> b
$ [Char]
"readerScriptData: " forall a. Semigroup a => a -> a -> a
<> [Char]
e
        Right Value
sDataValue ->
          case ScriptDataJsonSchema
-> Value -> Either ScriptDataJsonBytesError HashableScriptData
scriptDataJsonToHashable ScriptDataJsonSchema
ScriptDataJsonNoSchema Value
sDataValue of
            Left ScriptDataJsonBytesError
err -> forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail (forall e. Error e => e -> [Char]
displayError ScriptDataJsonBytesError
err)
            Right HashableScriptData
sd -> forall (m :: * -> *) a. Monad m => a -> m a
return HashableScriptData
sd

pStakeAddressCmd :: Parser StakeAddressCmd
pStakeAddressCmd :: Parser StakeAddressCmd
pStakeAddressCmd =
    forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
      [ forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"key-gen"
          (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser StakeAddressCmd
pStakeAddressKeyGen forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Create a stake address key pair")
      , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"build"
          (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser StakeAddressCmd
pStakeAddressBuild forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Build a stake address")
      , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"key-hash"
          (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser StakeAddressCmd
pStakeAddressKeyHash forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Print the hash of a stake address key.")
      , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"registration-certificate"
          (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser StakeAddressCmd
pStakeAddressRegistrationCert forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Create a stake address registration certificate")
      , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"deregistration-certificate"
          (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser StakeAddressCmd
pStakeAddressDeregistrationCert forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Create a stake address deregistration certificate")
      , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"delegation-certificate"
          (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser StakeAddressCmd
pStakeAddressDelegationCert forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Create a stake address delegation certificate")
      ]
  where
    pStakeAddressKeyGen :: Parser StakeAddressCmd
    pStakeAddressKeyGen :: Parser StakeAddressCmd
pStakeAddressKeyGen = VerificationKeyFile -> SigningKeyFile -> StakeAddressCmd
StakeAddressKeyGen
                            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FileDirection -> Parser VerificationKeyFile
pVerificationKeyFile FileDirection
Output
                            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> FileDirection -> Parser SigningKeyFile
pSigningKeyFile FileDirection
Output

    pStakeAddressKeyHash :: Parser StakeAddressCmd
    pStakeAddressKeyHash :: Parser StakeAddressCmd
pStakeAddressKeyHash = VerificationKeyOrFile StakeKey
-> Maybe OutputFile -> StakeAddressCmd
StakeAddressKeyHash forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (VerificationKeyOrFile StakeKey)
pStakeVerificationKeyOrFile forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Maybe OutputFile)
pMaybeOutputFile

    pStakeAddressBuild :: Parser StakeAddressCmd
    pStakeAddressBuild :: Parser StakeAddressCmd
pStakeAddressBuild = StakeVerifier -> NetworkId -> Maybe OutputFile -> StakeAddressCmd
StakeAddressBuild forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser StakeVerifier
pStakeVerifier
                                           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 (Maybe OutputFile)
pMaybeOutputFile

    pStakeAddressRegistrationCert :: Parser StakeAddressCmd
    pStakeAddressRegistrationCert :: Parser StakeAddressCmd
pStakeAddressRegistrationCert = StakeVerifier -> OutputFile -> StakeAddressCmd
StakeRegistrationCert
                                      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser StakeVerifier
pStakeVerifier
                                      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser OutputFile
pOutputFile

    pStakeAddressDeregistrationCert :: Parser StakeAddressCmd
    pStakeAddressDeregistrationCert :: Parser StakeAddressCmd
pStakeAddressDeregistrationCert = StakeVerifier -> OutputFile -> StakeAddressCmd
StakeCredentialDeRegistrationCert
                                        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser StakeVerifier
pStakeVerifier
                                        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser OutputFile
pOutputFile

    pStakeAddressDelegationCert :: Parser StakeAddressCmd
    pStakeAddressDelegationCert :: Parser StakeAddressCmd
pStakeAddressDelegationCert = StakeVerifier
-> VerificationKeyOrHashOrFile StakePoolKey
-> OutputFile
-> StakeAddressCmd
StakeCredentialDelegationCert
                                    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser StakeVerifier
pStakeVerifier
                                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (VerificationKeyOrHashOrFile StakePoolKey)
pStakePoolVerificationKeyOrHashOrFile
                                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser OutputFile
pOutputFile

pKeyCmd :: Parser KeyCmd
pKeyCmd :: Parser KeyCmd
pKeyCmd =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"verification-key" forall a b. (a -> b) -> a -> b
$
        forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser KeyCmd
pKeyGetVerificationKey forall a b. (a -> b) -> a -> b
$
          forall a. [Char] -> InfoMod a
Opt.progDesc forall a b. (a -> b) -> a -> b
$ [Char]
"Get a verification key from a signing key. This "
                      forall a. [a] -> [a] -> [a]
++ [Char]
" supports all key types."
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"non-extended-key" forall a b. (a -> b) -> a -> b
$
        forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser KeyCmd
pKeyNonExtendedKey forall a b. (a -> b) -> a -> b
$
          forall a. [Char] -> InfoMod a
Opt.progDesc forall a b. (a -> b) -> a -> b
$ [Char]
"Get a non-extended verification key from an "
                      forall a. [a] -> [a] -> [a]
++ [Char]
"extended verification key. This supports all "
                      forall a. [a] -> [a] -> [a]
++ [Char]
"extended key types."
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"convert-byron-key" forall a b. (a -> b) -> a -> b
$
        forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser KeyCmd
pKeyConvertByronKey forall a b. (a -> b) -> a -> b
$
          forall a. [Char] -> InfoMod a
Opt.progDesc forall a b. (a -> b) -> a -> b
$ [Char]
"Convert a Byron payment, genesis or genesis "
                      forall a. [a] -> [a] -> [a]
++ [Char]
"delegate key (signing or verification) to a "
                      forall a. [a] -> [a] -> [a]
++ [Char]
"corresponding Shelley-format key."
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"convert-byron-genesis-vkey" forall a b. (a -> b) -> a -> b
$
        forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser KeyCmd
pKeyConvertByronGenesisVKey forall a b. (a -> b) -> a -> b
$
          forall a. [Char] -> InfoMod a
Opt.progDesc forall a b. (a -> b) -> a -> b
$ [Char]
"Convert a Base64-encoded Byron genesis "
                      forall a. [a] -> [a] -> [a]
++ [Char]
"verification key to a Shelley genesis "
                      forall a. [a] -> [a] -> [a]
++ [Char]
"verification key"
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"convert-itn-key" forall a b. (a -> b) -> a -> b
$
        forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser KeyCmd
pKeyConvertITNKey forall a b. (a -> b) -> a -> b
$
          forall a. [Char] -> InfoMod a
Opt.progDesc forall a b. (a -> b) -> a -> b
$ [Char]
"Convert an Incentivized Testnet (ITN) non-extended "
                      forall a. [a] -> [a] -> [a]
++ [Char]
"(Ed25519) signing or verification key to a "
                      forall a. [a] -> [a] -> [a]
++ [Char]
"corresponding Shelley stake key"
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"convert-itn-extended-key" forall a b. (a -> b) -> a -> b
$
        forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser KeyCmd
pKeyConvertITNExtendedKey forall a b. (a -> b) -> a -> b
$
          forall a. [Char] -> InfoMod a
Opt.progDesc forall a b. (a -> b) -> a -> b
$ [Char]
"Convert an Incentivized Testnet (ITN) extended "
                      forall a. [a] -> [a] -> [a]
++ [Char]
"(Ed25519Extended) signing key to a corresponding "
                      forall a. [a] -> [a] -> [a]
++ [Char]
"Shelley stake signing key"
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"convert-itn-bip32-key" forall a b. (a -> b) -> a -> b
$
        forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser KeyCmd
pKeyConvertITNBip32Key forall a b. (a -> b) -> a -> b
$
          forall a. [Char] -> InfoMod a
Opt.progDesc forall a b. (a -> b) -> a -> b
$ [Char]
"Convert an Incentivized Testnet (ITN) BIP32 "
                      forall a. [a] -> [a] -> [a]
++ [Char]
"(Ed25519Bip32) signing key to a corresponding "
                      forall a. [a] -> [a] -> [a]
++ [Char]
"Shelley stake signing key"
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"convert-cardano-address-key" forall a b. (a -> b) -> a -> b
$
        forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser KeyCmd
pKeyConvertCardanoAddressSigningKey forall a b. (a -> b) -> a -> b
$
          forall a. [Char] -> InfoMod a
Opt.progDesc forall a b. (a -> b) -> a -> b
$ [Char]
"Convert a cardano-address extended signing key "
                      forall a. [a] -> [a] -> [a]
++ [Char]
"to a corresponding Shelley-format key."
    ]
  where
    pKeyGetVerificationKey :: Parser KeyCmd
    pKeyGetVerificationKey :: Parser KeyCmd
pKeyGetVerificationKey =
      SigningKeyFile -> VerificationKeyFile -> KeyCmd
KeyGetVerificationKey
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FileDirection -> Parser SigningKeyFile
pSigningKeyFile      FileDirection
Input
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> FileDirection -> Parser VerificationKeyFile
pVerificationKeyFile FileDirection
Output

    pKeyNonExtendedKey :: Parser KeyCmd
    pKeyNonExtendedKey :: Parser KeyCmd
pKeyNonExtendedKey =
      VerificationKeyFile -> VerificationKeyFile -> KeyCmd
KeyNonExtendedKey
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FileDirection -> Parser VerificationKeyFile
pExtendedVerificationKeyFile FileDirection
Input
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> FileDirection -> Parser VerificationKeyFile
pVerificationKeyFile FileDirection
Output

    pKeyConvertByronKey :: Parser KeyCmd
    pKeyConvertByronKey :: Parser KeyCmd
pKeyConvertByronKey =
      Maybe Text -> ByronKeyType -> SomeKeyFile -> OutputFile -> KeyCmd
KeyConvertByronKey
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser Text
pPassword
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ByronKeyType
pByronKeyType
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser SomeKeyFile
pByronKeyFile
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser OutputFile
pOutputFile

    pPassword :: Parser Text
    pPassword :: Parser Text
pPassword = forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
                  (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"password"
                  forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"TEXT"
                  forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Password for signing key (if applicable)."
                  )

    pByronKeyType :: Parser ByronKeyType
    pByronKeyType :: Parser ByronKeyType
pByronKeyType =
          forall a. a -> Mod FlagFields a -> Parser a
Opt.flag' (ByronKeyFormat -> ByronKeyType
ByronPaymentKey ByronKeyFormat
NonLegacyByronKeyFormat)
            (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"byron-payment-key-type"
            forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Use a Byron-era payment key."
            )
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall a. a -> Mod FlagFields a -> Parser a
Opt.flag' (ByronKeyFormat -> ByronKeyType
ByronPaymentKey ByronKeyFormat
LegacyByronKeyFormat)
            (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"legacy-byron-payment-key-type"
            forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Use a Byron-era payment key, in legacy SL format."
            )
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall a. a -> Mod FlagFields a -> Parser a
Opt.flag' (ByronKeyFormat -> ByronKeyType
ByronGenesisKey ByronKeyFormat
NonLegacyByronKeyFormat)
            (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"byron-genesis-key-type"
            forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Use a Byron-era genesis key."
            )
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall a. a -> Mod FlagFields a -> Parser a
Opt.flag' (ByronKeyFormat -> ByronKeyType
ByronGenesisKey ByronKeyFormat
LegacyByronKeyFormat)
            (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"legacy-byron-genesis-key-type"
            forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Use a Byron-era genesis key, in legacy SL format."
            )
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall a. a -> Mod FlagFields a -> Parser a
Opt.flag' (ByronKeyFormat -> ByronKeyType
ByronDelegateKey ByronKeyFormat
NonLegacyByronKeyFormat)
            (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"byron-genesis-delegate-key-type"
            forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Use a Byron-era genesis delegate key."
            )
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall a. a -> Mod FlagFields a -> Parser a
Opt.flag' (ByronKeyFormat -> ByronKeyType
ByronDelegateKey ByronKeyFormat
LegacyByronKeyFormat)
            (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"legacy-byron-genesis-delegate-key-type"
            forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Use a Byron-era genesis delegate key, in legacy SL format."
            )

    pByronKeyFile :: Parser SomeKeyFile
    pByronKeyFile :: Parser SomeKeyFile
pByronKeyFile =
          (SigningKeyFile -> SomeKeyFile
ASigningKeyFile      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser SigningKeyFile
pByronSigningKeyFile)
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (VerificationKeyFile -> SomeKeyFile
AVerificationKeyFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser VerificationKeyFile
pByronVerificationKeyFile)

    pByronSigningKeyFile :: Parser SigningKeyFile
    pByronSigningKeyFile :: Parser SigningKeyFile
pByronSigningKeyFile =
      [Char] -> SigningKeyFile
SigningKeyFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
        forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
          (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"byron-signing-key-file"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Input filepath of the Byron-format signing key."
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
          )

    pByronVerificationKeyFile :: Parser VerificationKeyFile
    pByronVerificationKeyFile :: Parser VerificationKeyFile
pByronVerificationKeyFile =
      [Char] -> VerificationKeyFile
VerificationKeyFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
        forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
          (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"byron-verification-key-file"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Input filepath of the Byron-format verification key."
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
          )

    pKeyConvertByronGenesisVKey :: Parser KeyCmd
    pKeyConvertByronGenesisVKey :: Parser KeyCmd
pKeyConvertByronGenesisVKey =
      VerificationKeyBase64 -> OutputFile -> KeyCmd
KeyConvertByronGenesisVKey
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser VerificationKeyBase64
pByronGenesisVKeyBase64
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser OutputFile
pOutputFile

    pByronGenesisVKeyBase64 :: Parser VerificationKeyBase64
    pByronGenesisVKeyBase64 :: Parser VerificationKeyBase64
pByronGenesisVKeyBase64 =
      [Char] -> VerificationKeyBase64
VerificationKeyBase64 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
        forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
          (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"byron-genesis-verification-key"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"BASE64"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Base64 string for the Byron genesis verification key."
          )

    pKeyConvertITNKey :: Parser KeyCmd
    pKeyConvertITNKey :: Parser KeyCmd
pKeyConvertITNKey =
      SomeKeyFile -> OutputFile -> KeyCmd
KeyConvertITNStakeKey
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser SomeKeyFile
pITNKeyFIle
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser OutputFile
pOutputFile

    pKeyConvertITNExtendedKey :: Parser KeyCmd
    pKeyConvertITNExtendedKey :: Parser KeyCmd
pKeyConvertITNExtendedKey =
      SomeKeyFile -> OutputFile -> KeyCmd
KeyConvertITNExtendedToStakeKey
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser SomeKeyFile
pITNSigningKeyFile
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser OutputFile
pOutputFile

    pKeyConvertITNBip32Key :: Parser KeyCmd
    pKeyConvertITNBip32Key :: Parser KeyCmd
pKeyConvertITNBip32Key =
      SomeKeyFile -> OutputFile -> KeyCmd
KeyConvertITNBip32ToStakeKey
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser SomeKeyFile
pITNSigningKeyFile
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser OutputFile
pOutputFile

    pITNKeyFIle :: Parser SomeKeyFile
    pITNKeyFIle :: Parser SomeKeyFile
pITNKeyFIle = Parser SomeKeyFile
pITNSigningKeyFile
              forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser SomeKeyFile
pITNVerificationKeyFile

    pITNSigningKeyFile :: Parser SomeKeyFile
    pITNSigningKeyFile :: Parser SomeKeyFile
pITNSigningKeyFile =
      SigningKeyFile -> SomeKeyFile
ASigningKeyFile forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> SigningKeyFile
SigningKeyFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
        forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
          (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"itn-signing-key-file"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Filepath of the ITN signing key."
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
          )

    pITNVerificationKeyFile :: Parser SomeKeyFile
    pITNVerificationKeyFile :: Parser SomeKeyFile
pITNVerificationKeyFile =
      VerificationKeyFile -> SomeKeyFile
AVerificationKeyFile forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> VerificationKeyFile
VerificationKeyFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
        forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
          (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"itn-verification-key-file"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Filepath of the ITN verification key."
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
          )

    pKeyConvertCardanoAddressSigningKey :: Parser KeyCmd
    pKeyConvertCardanoAddressSigningKey :: Parser KeyCmd
pKeyConvertCardanoAddressSigningKey =
      CardanoAddressKeyType -> SigningKeyFile -> OutputFile -> KeyCmd
KeyConvertCardanoAddressSigningKey
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser CardanoAddressKeyType
pCardanoAddressKeyType
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> FileDirection -> Parser SigningKeyFile
pSigningKeyFile FileDirection
Input
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser OutputFile
pOutputFile

    pCardanoAddressKeyType :: Parser CardanoAddressKeyType
    pCardanoAddressKeyType :: Parser CardanoAddressKeyType
pCardanoAddressKeyType =
          forall a. a -> Mod FlagFields a -> Parser a
Opt.flag' CardanoAddressKeyType
CardanoAddressShelleyPaymentKey
            (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"shelley-payment-key"
            forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Use a Shelley-era extended payment key."
            )
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall a. a -> Mod FlagFields a -> Parser a
Opt.flag' CardanoAddressKeyType
CardanoAddressShelleyStakeKey
            (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"shelley-stake-key"
            forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Use a Shelley-era extended stake key."
            )
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall a. a -> Mod FlagFields a -> Parser a
Opt.flag' CardanoAddressKeyType
CardanoAddressIcarusPaymentKey
            (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"icarus-payment-key"
            forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Use a Byron-era extended payment key formatted in the Icarus style."
            )
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall a. a -> Mod FlagFields a -> Parser a
Opt.flag' CardanoAddressKeyType
CardanoAddressByronPaymentKey
            (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"byron-payment-key"
            forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Use a Byron-era extended payment key formatted in the deprecated Byron style."
            )

pTransaction :: Parser TransactionCmd
pTransaction :: Parser TransactionCmd
pTransaction =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"build-raw"
        forall a b. (a -> b) -> a -> b
$ forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser TransactionCmd
pTransactionBuildRaw forall a b. (a -> b) -> a -> b
$ forall a. Maybe Doc -> InfoMod a
Opt.progDescDoc forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Monoid a => [a] -> a
mconcat
          [ forall a ann. Pretty a => a -> Doc ann
pretty @String [Char]
"Build a transaction (low-level, inconvenient)"
          , forall ann. Doc ann
line
          , forall ann. Doc ann
line
          , Doc -> Doc
H.yellow forall a b. (a -> b) -> a -> b
$ forall a. Monoid a => [a] -> a
mconcat
            [ Doc
"Please note the order of some cmd options is crucial. If used incorrectly may produce "
            , Doc
"undesired tx body. See nested [] notation above for details."
            ]
          ]
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"build"
        forall a b. (a -> b) -> a -> b
$ forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser TransactionCmd
pTransactionBuild forall a b. (a -> b) -> a -> b
$ forall a. Maybe Doc -> InfoMod a
Opt.progDescDoc forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Monoid a => [a] -> a
mconcat
          [ forall a ann. Pretty a => a -> Doc ann
pretty @String [Char]
"Build a balanced transaction (automatically calculates fees)"
          , forall ann. Doc ann
line
          , forall ann. Doc ann
line
          , Doc -> Doc
H.yellow forall a b. (a -> b) -> a -> b
$ forall a. Monoid a => [a] -> a
mconcat
            [ Doc
"Please note "
            , Doc -> Doc
H.underline Doc
"the order"
            , Doc
" of some cmd options is crucial. If used incorrectly may produce "
            , Doc
"undesired tx body. See nested [] notation above for details."
            ]
          ]
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"sign"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser TransactionCmd
pTransactionSign forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Sign a transaction")
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"witness"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser TransactionCmd
pTransactionCreateWitness forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Create a transaction witness")
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"assemble"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser TransactionCmd
pTransactionAssembleTxBodyWit
          forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Assemble a tx body and witness(es) to form a transaction")
    , Parser TransactionCmd
pSignWitnessBackwardCompatible
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"submit"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser TransactionCmd
pTransactionSubmit forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [Char] -> InfoMod a
Opt.progDesc forall a b. (a -> b) -> a -> b
$
           forall a. Monoid a => [a] -> a
mconcat
             [ [Char]
"Submit a transaction to the local node whose Unix domain socket "
             , [Char]
"is obtained from the CARDANO_NODE_SOCKET_PATH environment variable."
             ]
          )
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"policyid"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser TransactionCmd
pTransactionPolicyId forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Calculate the PolicyId from the monetary policy script.")
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"calculate-min-fee"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser TransactionCmd
pTransactionCalculateMinFee forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Calculate the minimum fee for a transaction.")
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"calculate-min-required-utxo"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser TransactionCmd
pTransactionCalculateMinReqUTxO forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Calculate the minimum required UTxO for a transaction output.")
    , Parser TransactionCmd
pCalculateMinRequiredUtxoBackwardCompatible
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"hash-script-data"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser TransactionCmd
pTxHashScriptData forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Calculate the hash of script data.")
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"txid"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser TransactionCmd
pTransactionId forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Print a transaction identifier.")
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"view" forall a b. (a -> b) -> a -> b
$
        forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser TransactionCmd
pTransactionView forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Print a transaction."
    ]
 where
  -- Backwards compatible parsers
  calcMinValueInfo :: ParserInfo TransactionCmd
  calcMinValueInfo :: ParserInfo TransactionCmd
calcMinValueInfo =
    forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser TransactionCmd
pTransactionCalculateMinReqUTxO
      forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"DEPRECATED: Use 'calculate-min-required-utxo' instead."

  pCalculateMinRequiredUtxoBackwardCompatible :: Parser TransactionCmd
  pCalculateMinRequiredUtxoBackwardCompatible :: Parser TransactionCmd
pCalculateMinRequiredUtxoBackwardCompatible =
    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]
"calculate-min-value" ParserInfo TransactionCmd
calcMinValueInfo forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. Mod f a
Opt.internal

  assembleInfo :: ParserInfo TransactionCmd
  assembleInfo :: ParserInfo TransactionCmd
assembleInfo =
    forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser TransactionCmd
pTransactionAssembleTxBodyWit
      forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Assemble a tx body and witness(es) to form a transaction"

  pSignWitnessBackwardCompatible :: Parser TransactionCmd
  pSignWitnessBackwardCompatible :: Parser TransactionCmd
pSignWitnessBackwardCompatible =
    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]
"sign-witness" ParserInfo TransactionCmd
assembleInfo forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. Mod f a
Opt.internal

  pScriptValidity :: Parser ScriptValidity
  pScriptValidity :: Parser ScriptValidity
pScriptValidity = forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ forall a. a -> Mod FlagFields a -> Parser a
Opt.flag' ScriptValidity
ScriptValid 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]
"script-valid"
      , forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Assertion that the script is valid. (default)"
      ]
    , forall a. a -> Mod FlagFields a -> Parser a
Opt.flag' ScriptValidity
ScriptInvalid 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]
"script-invalid"
      , forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help forall a b. (a -> b) -> a -> b
$ forall a. Monoid a => [a] -> a
mconcat
        [ [Char]
"Assertion that the script is invalid.  "
        , [Char]
"If a transaction is submitted with such a script, "
        , [Char]
"the script will fail and the collateral will be taken."
        ]
      ]
    ]

  pTransactionBuild :: Parser TransactionCmd
  pTransactionBuild :: Parser TransactionCmd
pTransactionBuild =
    AnyCardanoEra
-> AnyConsensusModeParams
-> NetworkId
-> Maybe ScriptValidity
-> Maybe Word
-> [(TxIn, Maybe (ScriptWitnessFiles WitCtxTxIn))]
-> [TxIn]
-> [RequiredSigner]
-> [TxIn]
-> Maybe TxOutAnyEra
-> Maybe Lovelace
-> [TxOutAnyEra]
-> TxOutChangeAddress
-> Maybe (Value, [ScriptWitnessFiles WitCtxMint])
-> Maybe SlotNo
-> Maybe SlotNo
-> [(CertificateFile, Maybe (ScriptWitnessFiles WitCtxStake))]
-> [(StakeAddress, Lovelace,
     Maybe (ScriptWitnessFiles WitCtxStake))]
-> TxMetadataJsonSchema
-> [ScriptFile]
-> [MetadataFile]
-> Maybe ProtocolParamsSourceSpec
-> Maybe UpdateProposalFile
-> TxBuildOutputOptions
-> TransactionCmd
TxBuild forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser AnyCardanoEra
pCardanoEra
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser AnyConsensusModeParams
pConsensusModeParams
            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
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser ScriptValidity
pScriptValidity
            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 Word
pWitnessOverride
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
some (BalanceTxExecUnits
-> Parser (TxIn, Maybe (ScriptWitnessFiles WitCtxTxIn))
pTxIn BalanceTxExecUnits
AutoBalance)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser TxIn
pReadOnlyReferenceTxIn
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser RequiredSigner
pRequiredSigner
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser TxIn
pTxInCollateral
            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 TxOutAnyEra
pReturnCollateral
            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 Lovelace
pTotalCollateral
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser TxOutAnyEra
pTxOut
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TxOutChangeAddress
pChangeAddress
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (BalanceTxExecUnits
-> Parser (Value, [ScriptWitnessFiles WitCtxMint])
pMintMultiAsset BalanceTxExecUnits
AutoBalance)
            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 SlotNo
pInvalidBefore
            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 SlotNo
pInvalidHereafter
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (BalanceTxExecUnits
-> Parser (CertificateFile, Maybe (ScriptWitnessFiles WitCtxStake))
pCertificateFile BalanceTxExecUnits
AutoBalance)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (BalanceTxExecUnits
-> Parser
     (StakeAddress, Lovelace, Maybe (ScriptWitnessFiles WitCtxStake))
pWithdrawal BalanceTxExecUnits
AutoBalance)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TxMetadataJsonSchema
pTxMetadataJsonSchema
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many ([Char] -> Maybe [Char] -> [Char] -> Parser ScriptFile
pScriptFor
                        [Char]
"auxiliary-script-file"
                        forall a. Maybe a
Nothing
                        [Char]
"Filepath of auxiliary script(s)")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser MetadataFile
pMetadataFile
            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 ProtocolParamsSourceSpec
pProtocolParamsSourceSpec
            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 UpdateProposalFile
pUpdateProposalFile
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (TxBodyFile -> TxBuildOutputOptions
OutputTxBodyOnly forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FileDirection -> Parser TxBodyFile
pTxBodyFile FileDirection
Output forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser TxBuildOutputOptions
pCalculatePlutusScriptCost)

  pChangeAddress :: Parser TxOutChangeAddress
  pChangeAddress :: Parser TxOutChangeAddress
pChangeAddress =
    AddressAny -> TxOutChangeAddress
TxOutChangeAddress 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. Parser a -> ReadM a
readerFromParsecParser Parser AddressAny
parseAddressAny)
        (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"change-address"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"ADDRESS"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Address where ADA in excess of the tx fee will go to."
        )

  pTransactionBuildRaw :: Parser TransactionCmd
  pTransactionBuildRaw :: Parser TransactionCmd
pTransactionBuildRaw =
    AnyCardanoEra
-> Maybe ScriptValidity
-> [(TxIn, Maybe (ScriptWitnessFiles WitCtxTxIn))]
-> [TxIn]
-> [TxIn]
-> Maybe TxOutAnyEra
-> Maybe Lovelace
-> [RequiredSigner]
-> [TxOutAnyEra]
-> Maybe (Value, [ScriptWitnessFiles WitCtxMint])
-> Maybe SlotNo
-> Maybe SlotNo
-> Maybe Lovelace
-> [(CertificateFile, Maybe (ScriptWitnessFiles WitCtxStake))]
-> [(StakeAddress, Lovelace,
     Maybe (ScriptWitnessFiles WitCtxStake))]
-> TxMetadataJsonSchema
-> [ScriptFile]
-> [MetadataFile]
-> Maybe ProtocolParamsSourceSpec
-> Maybe UpdateProposalFile
-> TxBodyFile
-> TransactionCmd
TxBuildRaw forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser AnyCardanoEra
pCardanoEra
               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 ScriptValidity
pScriptValidity
               forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
some (BalanceTxExecUnits
-> Parser (TxIn, Maybe (ScriptWitnessFiles WitCtxTxIn))
pTxIn BalanceTxExecUnits
ManualBalance)
               forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser TxIn
pReadOnlyReferenceTxIn
               forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser TxIn
pTxInCollateral
               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 TxOutAnyEra
pReturnCollateral
               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 Lovelace
pTotalCollateral
               forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser RequiredSigner
pRequiredSigner
               forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser TxOutAnyEra
pTxOut
               forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (BalanceTxExecUnits
-> Parser (Value, [ScriptWitnessFiles WitCtxMint])
pMintMultiAsset BalanceTxExecUnits
ManualBalance)
               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 SlotNo
pInvalidBefore
               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 SlotNo
pInvalidHereafter
               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 Lovelace
pTxFee
               forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (BalanceTxExecUnits
-> Parser (CertificateFile, Maybe (ScriptWitnessFiles WitCtxStake))
pCertificateFile BalanceTxExecUnits
ManualBalance )
               forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (BalanceTxExecUnits
-> Parser
     (StakeAddress, Lovelace, Maybe (ScriptWitnessFiles WitCtxStake))
pWithdrawal BalanceTxExecUnits
ManualBalance)
               forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TxMetadataJsonSchema
pTxMetadataJsonSchema
               forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many ([Char] -> Maybe [Char] -> [Char] -> Parser ScriptFile
pScriptFor
                           [Char]
"auxiliary-script-file"
                           forall a. Maybe a
Nothing
                           [Char]
"Filepath of auxiliary script(s)")
               forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser MetadataFile
pMetadataFile
               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 ProtocolParamsSourceSpec
pProtocolParamsSourceSpec
               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 UpdateProposalFile
pUpdateProposalFile
               forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> FileDirection -> Parser TxBodyFile
pTxBodyFile FileDirection
Output

  pTransactionSign  :: Parser TransactionCmd
  pTransactionSign :: Parser TransactionCmd
pTransactionSign = InputTxBodyOrTxFile
-> [WitnessSigningData]
-> Maybe NetworkId
-> TxFile
-> TransactionCmd
TxSign forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser InputTxBodyOrTxFile
pInputTxOrTxBodyFile
                            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser WitnessSigningData
pWitnessSigningData
                            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 NetworkId
pNetworkId
                            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> FileDirection -> Parser TxFile
pTxFile FileDirection
Output

  pTransactionCreateWitness :: Parser TransactionCmd
  pTransactionCreateWitness :: Parser TransactionCmd
pTransactionCreateWitness = TxBodyFile
-> WitnessSigningData
-> Maybe NetworkId
-> OutputFile
-> TransactionCmd
TxCreateWitness
                                forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FileDirection -> Parser TxBodyFile
pTxBodyFile FileDirection
Input
                                forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser WitnessSigningData
pWitnessSigningData
                                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 NetworkId
pNetworkId
                                forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser OutputFile
pOutputFile

  pTransactionAssembleTxBodyWit :: Parser TransactionCmd
  pTransactionAssembleTxBodyWit :: Parser TransactionCmd
pTransactionAssembleTxBodyWit = TxBodyFile -> [WitnessFile] -> OutputFile -> TransactionCmd
TxAssembleTxBodyWitness
                                    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FileDirection -> Parser TxBodyFile
pTxBodyFile FileDirection
Input
                                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser WitnessFile
pWitnessFile
                                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser OutputFile
pOutputFile

  pTransactionSubmit :: Parser TransactionCmd
  pTransactionSubmit :: Parser TransactionCmd
pTransactionSubmit = AnyConsensusModeParams -> NetworkId -> [Char] -> TransactionCmd
TxSubmit forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser AnyConsensusModeParams
pConsensusModeParams
                                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 [Char]
pTxSubmitFile

  pTransactionPolicyId :: Parser TransactionCmd
  pTransactionPolicyId :: Parser TransactionCmd
pTransactionPolicyId = ScriptFile -> TransactionCmd
TxMintedPolicyId forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ScriptFile
pScript

  pTransactionCalculateMinFee :: Parser TransactionCmd
  pTransactionCalculateMinFee :: Parser TransactionCmd
pTransactionCalculateMinFee =
    TxBodyFile
-> Maybe NetworkId
-> ProtocolParamsSourceSpec
-> TxInCount
-> TxOutCount
-> TxShelleyWitnessCount
-> TxByronWitnessCount
-> TransactionCmd
TxCalculateMinFee
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FileDirection -> Parser TxBodyFile
pTxBodyFile FileDirection
Input
      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 NetworkId
pNetworkId
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ProtocolParamsSourceSpec
pProtocolParamsSourceSpec
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TxInCount
pTxInCount
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TxOutCount
pTxOutCount
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TxShelleyWitnessCount
pTxShelleyWitnessCount
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TxByronWitnessCount
pTxByronWitnessCount

  pTransactionCalculateMinReqUTxO :: Parser TransactionCmd
  pTransactionCalculateMinReqUTxO :: Parser TransactionCmd
pTransactionCalculateMinReqUTxO = AnyCardanoEra
-> ProtocolParamsSourceSpec -> TxOutAnyEra -> TransactionCmd
TxCalculateMinRequiredUTxO
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser AnyCardanoEra
pCardanoEra
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ProtocolParamsSourceSpec
pProtocolParamsSourceSpec
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TxOutAnyEra
pTxOut

  pProtocolParamsSourceSpec :: Parser ProtocolParamsSourceSpec
  pProtocolParamsSourceSpec :: Parser ProtocolParamsSourceSpec
pProtocolParamsSourceSpec =
    GenesisFile -> ProtocolParamsSourceSpec
ParamsFromGenesis forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
      [Char] -> Parser GenesisFile
pGenesisFile
        [Char]
"[TESTING] The genesis file to take initial protocol parameters from.  For test clusters only, since the parameters are going to be obsolete for production clusters."
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    ProtocolParamsFile -> ProtocolParamsSourceSpec
ParamsFromFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ProtocolParamsFile
pProtocolParamsFile

  pTxHashScriptData :: Parser TransactionCmd
  pTxHashScriptData :: Parser TransactionCmd
pTxHashScriptData = ScriptRedeemerOrFile -> TransactionCmd
TxHashScriptData forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                        [Char] -> [Char] -> [Char] -> Parser ScriptRedeemerOrFile
pScriptDataOrFile
                          [Char]
"script-data"
                          [Char]
"The script data, in JSON syntax."
                          [Char]
"The script data, in the given JSON file."

  pTransactionId  :: Parser TransactionCmd
  pTransactionId :: Parser TransactionCmd
pTransactionId = InputTxBodyOrTxFile -> TransactionCmd
TxGetTxId forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser InputTxBodyOrTxFile
pInputTxOrTxBodyFile

  pTransactionView :: Parser TransactionCmd
  pTransactionView :: Parser TransactionCmd
pTransactionView = InputTxBodyOrTxFile -> TransactionCmd
TxView forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser InputTxBodyOrTxFile
pInputTxOrTxBodyFile

pNodeCmd :: Parser NodeCmd
pNodeCmd :: Parser NodeCmd
pNodeCmd =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"key-gen" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser NodeCmd
pKeyGenOperator forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [Char] -> InfoMod a
Opt.progDesc forall a b. (a -> b) -> a -> b
$ forall a. Monoid a => [a] -> a
mconcat
      [ [Char]
"Create a key pair for a node operator's offline "
      , [Char]
"key and a new certificate issue counter"
      ]
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"key-gen-KES" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser NodeCmd
pKeyGenKES forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [Char] -> InfoMod a
Opt.progDesc forall a b. (a -> b) -> a -> b
$ forall a. Monoid a => [a] -> a
mconcat
      [ [Char]
"Create a key pair for a node KES operational key"
      ]
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"key-gen-VRF" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser NodeCmd
pKeyGenVRF forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [Char] -> InfoMod a
Opt.progDesc forall a b. (a -> b) -> a -> b
$ forall a. Monoid a => [a] -> a
mconcat
      [ [Char]
"Create a key pair for a node VRF operational key"
      ]
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"key-hash-VRF"forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser NodeCmd
pKeyHashVRF forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [Char] -> InfoMod a
Opt.progDesc forall a b. (a -> b) -> a -> b
$ forall a. Monoid a => [a] -> a
mconcat
      [ [Char]
"Print hash of a node's operational VRF key."
      ]
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"new-counter" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser NodeCmd
pNewCounter forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [Char] -> InfoMod a
Opt.progDesc forall a b. (a -> b) -> a -> b
$ forall a. Monoid a => [a] -> a
mconcat
      [ [Char]
"Create a new certificate issue counter"
      ]
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"issue-op-cert" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser NodeCmd
pIssueOpCert forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [Char] -> InfoMod a
Opt.progDesc forall a b. (a -> b) -> a -> b
$ forall a. Monoid a => [a] -> a
mconcat
      [ [Char]
"Issue a node operational certificate"
      ]
    ]
  where
    pKeyGenOperator :: Parser NodeCmd
    pKeyGenOperator :: Parser NodeCmd
pKeyGenOperator =
      VerificationKeyFile
-> SigningKeyFile -> OpCertCounterFile -> NodeCmd
NodeKeyGenCold forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser VerificationKeyFile
pColdVerificationKeyFile
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser SigningKeyFile
pColdSigningKeyFile
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser OpCertCounterFile
pOperatorCertIssueCounterFile

    pKeyGenKES :: Parser NodeCmd
    pKeyGenKES :: Parser NodeCmd
pKeyGenKES =
      VerificationKeyFile -> SigningKeyFile -> NodeCmd
NodeKeyGenKES forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FileDirection -> Parser VerificationKeyFile
pVerificationKeyFile FileDirection
Output forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> FileDirection -> Parser SigningKeyFile
pSigningKeyFile FileDirection
Output

    pKeyGenVRF :: Parser NodeCmd
    pKeyGenVRF :: Parser NodeCmd
pKeyGenVRF =
      VerificationKeyFile -> SigningKeyFile -> NodeCmd
NodeKeyGenVRF forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FileDirection -> Parser VerificationKeyFile
pVerificationKeyFile FileDirection
Output forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> FileDirection -> Parser SigningKeyFile
pSigningKeyFile FileDirection
Output

    pKeyHashVRF :: Parser NodeCmd
    pKeyHashVRF :: Parser NodeCmd
pKeyHashVRF =
      VerificationKeyOrFile VrfKey -> Maybe OutputFile -> NodeCmd
NodeKeyHashVRF forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall keyrole.
SerialiseAsBech32 (VerificationKey keyrole) =>
AsType keyrole -> Parser (VerificationKeyOrFile keyrole)
pVerificationKeyOrFile AsType VrfKey
AsVrfKey forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Maybe OutputFile)
pMaybeOutputFile

    pNewCounter :: Parser NodeCmd
    pNewCounter :: Parser NodeCmd
pNewCounter =
      ColdVerificationKeyOrFile -> Word -> OpCertCounterFile -> NodeCmd
NodeNewCounter forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ColdVerificationKeyOrFile
pColdVerificationKeyOrFile
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Word
pCounterValue
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser OpCertCounterFile
pOperatorCertIssueCounterFile

    pCounterValue :: Parser Word
    pCounterValue :: Parser Word
pCounterValue =
        forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option forall a. Read a => ReadM a
Opt.auto
          (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"counter-value"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"INT"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"The next certificate issue counter value to use."
          )

    pIssueOpCert :: Parser NodeCmd
    pIssueOpCert :: Parser NodeCmd
pIssueOpCert =
      VerificationKeyOrFile KesKey
-> SigningKeyFile
-> OpCertCounterFile
-> KESPeriod
-> OutputFile
-> NodeCmd
NodeIssueOpCert forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (VerificationKeyOrFile KesKey)
pKesVerificationKeyOrFile
                      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser SigningKeyFile
pColdSigningKeyFile
                      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser OpCertCounterFile
pOperatorCertIssueCounterFile
                      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser KESPeriod
pKesPeriod
                      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser OutputFile
pOutputFile


pPoolCmd :: Parser PoolCmd
pPoolCmd :: Parser PoolCmd
pPoolCmd =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
      [ forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"registration-certificate"
          (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser PoolCmd
pStakePoolRegistrationCert forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Create a stake pool registration certificate")
      , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"deregistration-certificate"
          (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser PoolCmd
pStakePoolRetirementCert forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Create a stake pool deregistration certificate")
      , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"id"
          (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser PoolCmd
pId forall a b. (a -> b) -> a -> b
$
             forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Build pool id from the offline key")
      , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"metadata-hash"
          (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser PoolCmd
pPoolMetadataHashSubCmd forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Print the hash of pool metadata.")
      ]
  where
    pId :: Parser PoolCmd
    pId :: Parser PoolCmd
pId = VerificationKeyOrFile StakePoolKey -> OutputFormat -> PoolCmd
PoolGetId forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (VerificationKeyOrFile StakePoolKey)
pStakePoolVerificationKeyOrFile forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser OutputFormat
pOutputFormat

    pPoolMetadataHashSubCmd :: Parser PoolCmd
    pPoolMetadataHashSubCmd :: Parser PoolCmd
pPoolMetadataHashSubCmd = PoolMetadataFile -> Maybe OutputFile -> PoolCmd
PoolMetadataHash forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser PoolMetadataFile
pPoolMetadataFile forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Maybe OutputFile)
pMaybeOutputFile


pQueryCmd :: Parser QueryCmd
pQueryCmd :: Parser QueryCmd
pQueryCmd =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"protocol-parameters"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser QueryCmd
pQueryProtocolParameters forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Get the node's current protocol parameters")
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"tip"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser QueryCmd
pQueryTip forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Get the node's current tip (slot no, hash, block no)")
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"stake-pools"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser QueryCmd
pQueryStakePools forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Get the node's current set of stake pool ids")
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"stake-distribution"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser QueryCmd
pQueryStakeDistribution forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Get the node's current aggregated stake distribution")
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"stake-address-info"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser QueryCmd
pQueryStakeAddressInfo forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Get the current delegations and \
                                                        \reward accounts filtered by stake \
                                                        \address.")
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"utxo"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser QueryCmd
pQueryUTxO forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Get a portion of the current UTxO: \
                                            \by tx in, by address or the whole.")
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"ledger-state"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser QueryCmd
pQueryLedgerState forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Dump the current ledger state of the node (Ledger.NewEpochState -- advanced command)")
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"protocol-state"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser QueryCmd
pQueryProtocolState forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Dump the current protocol state of the node (Ledger.ChainDepState -- advanced command)")
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"stake-snapshot"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser QueryCmd
pQueryStakeSnapshot forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Obtain the three stake snapshots for a pool, plus the total active stake (advanced command)")
    , forall a. [Char] -> ParserInfo a -> Parser a
hiddenSubParser [Char]
"pool-params"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser QueryCmd
pQueryPoolState forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"DEPRECATED.  Use query pool-state instead.  Dump the pool parameters (Ledger.NewEpochState.esLState._delegationState._pState._pParams -- advanced command)")
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"leadership-schedule"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser QueryCmd
pLeadershipSchedule forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Get the slots the node is expected to mint a block in (advanced command)")
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"kes-period-info"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser QueryCmd
pKesPeriodInfo forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Get information about the current KES period and your node's operational certificate.")
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"pool-state"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser QueryCmd
pQueryPoolState forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Dump the pool state")
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"tx-mempool"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser QueryCmd
pQueryTxMempool forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Local Mempool info")
    ]
  where
    pQueryProtocolParameters :: Parser QueryCmd
    pQueryProtocolParameters :: Parser QueryCmd
pQueryProtocolParameters =
      AnyConsensusModeParams -> NetworkId -> Maybe OutputFile -> QueryCmd
QueryProtocolParameters'
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser AnyConsensusModeParams
pConsensusModeParams
        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 (Maybe OutputFile)
pMaybeOutputFile

    pQueryTip :: Parser QueryCmd
    pQueryTip :: Parser QueryCmd
pQueryTip = AnyConsensusModeParams -> NetworkId -> Maybe OutputFile -> QueryCmd
QueryTip
                  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser AnyConsensusModeParams
pConsensusModeParams
                  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 (Maybe OutputFile)
pMaybeOutputFile

    pQueryUTxO :: Parser QueryCmd
    pQueryUTxO :: Parser QueryCmd
pQueryUTxO =
      AnyConsensusModeParams
-> QueryUTxOFilter -> NetworkId -> Maybe OutputFile -> QueryCmd
QueryUTxO'
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser AnyConsensusModeParams
pConsensusModeParams
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser QueryUTxOFilter
pQueryUTxOFilter
        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 (Maybe OutputFile)
pMaybeOutputFile

    pQueryStakePools :: Parser QueryCmd
    pQueryStakePools :: Parser QueryCmd
pQueryStakePools =
      AnyConsensusModeParams -> NetworkId -> Maybe OutputFile -> QueryCmd
QueryStakePools'
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser AnyConsensusModeParams
pConsensusModeParams
        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 (Maybe OutputFile)
pMaybeOutputFile

    pQueryStakeDistribution :: Parser QueryCmd
    pQueryStakeDistribution :: Parser QueryCmd
pQueryStakeDistribution =
      AnyConsensusModeParams -> NetworkId -> Maybe OutputFile -> QueryCmd
QueryStakeDistribution'
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser AnyConsensusModeParams
pConsensusModeParams
        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 (Maybe OutputFile)
pMaybeOutputFile

    pQueryStakeAddressInfo :: Parser QueryCmd
    pQueryStakeAddressInfo :: Parser QueryCmd
pQueryStakeAddressInfo =
      AnyConsensusModeParams
-> StakeAddress -> NetworkId -> Maybe OutputFile -> QueryCmd
QueryStakeAddressInfo
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser AnyConsensusModeParams
pConsensusModeParams
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser StakeAddress
pFilterByStakeAddress
        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 (Maybe OutputFile)
pMaybeOutputFile

    pQueryLedgerState :: Parser QueryCmd
    pQueryLedgerState :: Parser QueryCmd
pQueryLedgerState = AnyConsensusModeParams -> NetworkId -> Maybe OutputFile -> QueryCmd
QueryDebugLedgerState'
                          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser AnyConsensusModeParams
pConsensusModeParams
                          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 (Maybe OutputFile)
pMaybeOutputFile

    pQueryProtocolState :: Parser QueryCmd
    pQueryProtocolState :: Parser QueryCmd
pQueryProtocolState = AnyConsensusModeParams -> NetworkId -> Maybe OutputFile -> QueryCmd
QueryProtocolState'
                            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser AnyConsensusModeParams
pConsensusModeParams
                            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 (Maybe OutputFile)
pMaybeOutputFile

    pAllStakePoolsOrOnly :: Parser (AllOrOnly [Hash StakePoolKey])
    pAllStakePoolsOrOnly :: Parser (AllOrOnly [Hash StakePoolKey])
pAllStakePoolsOrOnly = Parser (AllOrOnly [Hash StakePoolKey])
pAll forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (AllOrOnly [Hash StakePoolKey])
pOnly
      where pAll :: Parser (AllOrOnly [Hash StakePoolKey])
            pAll :: Parser (AllOrOnly [Hash StakePoolKey])
pAll = forall a. a -> Mod FlagFields a -> Parser a
Opt.flag' forall a. AllOrOnly a
All
              (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"all-stake-pools"
              forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Query for all stake pools"
              )
            pOnly :: Parser (AllOrOnly [Hash StakePoolKey])
            pOnly :: Parser (AllOrOnly [Hash StakePoolKey])
pOnly = forall a. a -> AllOrOnly a
Only forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser (Hash StakePoolKey)
pStakePoolVerificationKeyHash

    pQueryStakeSnapshot :: Parser QueryCmd
    pQueryStakeSnapshot :: Parser QueryCmd
pQueryStakeSnapshot = AnyConsensusModeParams
-> NetworkId
-> AllOrOnly [Hash StakePoolKey]
-> Maybe OutputFile
-> QueryCmd
QueryStakeSnapshot'
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser AnyConsensusModeParams
pConsensusModeParams
      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 (AllOrOnly [Hash StakePoolKey])
pAllStakePoolsOrOnly
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Maybe OutputFile)
pMaybeOutputFile

    pQueryPoolState :: Parser QueryCmd
    pQueryPoolState :: Parser QueryCmd
pQueryPoolState = AnyConsensusModeParams
-> NetworkId -> [Hash StakePoolKey] -> QueryCmd
QueryPoolState'
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser AnyConsensusModeParams
pConsensusModeParams
      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
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser (Hash StakePoolKey)
pStakePoolVerificationKeyHash

    pQueryTxMempool :: Parser QueryCmd
    pQueryTxMempool :: Parser QueryCmd
pQueryTxMempool = AnyConsensusModeParams
-> NetworkId -> TxMempoolQuery -> Maybe OutputFile -> QueryCmd
QueryTxMempool
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser AnyConsensusModeParams
pConsensusModeParams
      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 TxMempoolQuery
pTxMempoolQuery
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Maybe OutputFile)
pMaybeOutputFile
      where
        pTxMempoolQuery :: Parser TxMempoolQuery
        pTxMempoolQuery :: Parser TxMempoolQuery
pTxMempoolQuery = forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
          [ forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"info"
            (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info (forall (f :: * -> *) a. Applicative f => a -> f a
pure TxMempoolQuery
TxMempoolQueryInfo) forall a b. (a -> b) -> a -> b
$
              forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Ask the node about the current mempool's capacity and sizes")
          , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"next-tx"
            (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info (forall (f :: * -> *) a. Applicative f => a -> f a
pure TxMempoolQuery
TxMempoolQueryNextTx) forall a b. (a -> b) -> a -> b
$
              forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Requests the next transaction from the mempool's current list")
          , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"tx-exists"
            (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info (TxId -> TxMempoolQuery
TxMempoolQueryTxExists forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. ReadM a -> Mod ArgumentFields a -> Parser a
argument forall s. IsString s => ReadM s
Opt.str (forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
"TX_ID")) forall a b. (a -> b) -> a -> b
$
              forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Query if a particular transaction exists in the mempool")
          ]
    pLeadershipSchedule :: Parser QueryCmd
    pLeadershipSchedule :: Parser QueryCmd
pLeadershipSchedule = AnyConsensusModeParams
-> NetworkId
-> GenesisFile
-> VerificationKeyOrHashOrFile StakePoolKey
-> SigningKeyFile
-> EpochLeadershipSchedule
-> Maybe OutputFile
-> QueryCmd
QueryLeadershipSchedule
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser AnyConsensusModeParams
pConsensusModeParams
      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] -> Parser GenesisFile
pGenesisFile [Char]
"Shelley genesis filepath"
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (VerificationKeyOrHashOrFile StakePoolKey)
pStakePoolVerificationKeyOrHashOrFile
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser SigningKeyFile
pVrfSigningKeyFile
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser EpochLeadershipSchedule
pWhichLeadershipSchedule
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Maybe OutputFile)
pMaybeOutputFile

    pKesPeriodInfo :: Parser QueryCmd
    pKesPeriodInfo :: Parser QueryCmd
pKesPeriodInfo = AnyConsensusModeParams
-> NetworkId -> [Char] -> Maybe OutputFile -> QueryCmd
QueryKesPeriodInfo
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser AnyConsensusModeParams
pConsensusModeParams
      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 [Char]
pOperationalCertificateFile
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Maybe OutputFile)
pMaybeOutputFile

pGovernanceCmd :: Parser GovernanceCmd
pGovernanceCmd :: Parser GovernanceCmd
pGovernanceCmd =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"create-mir-certificate"
      forall a b. (a -> b) -> a -> b
$ forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info (Parser GovernanceCmd
pMIRPayStakeAddresses forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser GovernanceCmd
mirCertParsers)
      forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Create an MIR (Move Instantaneous Rewards) certificate"
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"create-genesis-key-delegation-certificate"
      forall a b. (a -> b) -> a -> b
$ forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser GovernanceCmd
pGovernanceGenesisKeyDelegationCertificate
      forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Create a genesis key delegation certificate"
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"create-update-proposal"
      forall a b. (a -> b) -> a -> b
$ forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser GovernanceCmd
pUpdateProposal
      forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Create an update proposal"
    ]
  where
    mirCertParsers :: Parser GovernanceCmd
    mirCertParsers :: Parser GovernanceCmd
mirCertParsers = forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
      [ forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"stake-addresses"
        forall a b. (a -> b) -> a -> b
$ forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser GovernanceCmd
pMIRPayStakeAddresses
        forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Create an MIR certificate to pay stake addresses"
      , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"transfer-to-treasury"
        forall a b. (a -> b) -> a -> b
$ forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser GovernanceCmd
pMIRTransferToTreasury
        forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Create an MIR certificate to transfer from the reserves pot to the treasury pot"
      , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"transfer-to-rewards"
        forall a b. (a -> b) -> a -> b
$ forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser GovernanceCmd
pMIRTransferToReserves
        forall a b. (a -> b) -> a -> b
$ forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Create an MIR certificate to transfer from the treasury pot to the reserves pot"
      ]

    pMIRPayStakeAddresses :: Parser GovernanceCmd
    pMIRPayStakeAddresses :: Parser GovernanceCmd
pMIRPayStakeAddresses = MIRPot
-> [StakeAddress] -> [Lovelace] -> OutputFile -> GovernanceCmd
GovernanceMIRPayStakeAddressesCertificate
                              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser MIRPot
pMIRPot
                              forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
some Parser StakeAddress
pStakeAddress
                              forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
some Parser Lovelace
pRewardAmt
                              forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser OutputFile
pOutputFile

    pMIRTransferToTreasury :: Parser GovernanceCmd
    pMIRTransferToTreasury :: Parser GovernanceCmd
pMIRTransferToTreasury = Lovelace -> OutputFile -> TransferDirection -> GovernanceCmd
GovernanceMIRTransfer
                               forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Lovelace
pTransferAmt
                               forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser OutputFile
pOutputFile
                               forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Applicative f => a -> f a
pure TransferDirection
TransferToTreasury

    pMIRTransferToReserves :: Parser GovernanceCmd
    pMIRTransferToReserves :: Parser GovernanceCmd
pMIRTransferToReserves = Lovelace -> OutputFile -> TransferDirection -> GovernanceCmd
GovernanceMIRTransfer
                               forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Lovelace
pTransferAmt
                               forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser OutputFile
pOutputFile
                               forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Applicative f => a -> f a
pure TransferDirection
TransferToReserves

    pGovernanceGenesisKeyDelegationCertificate :: Parser GovernanceCmd
    pGovernanceGenesisKeyDelegationCertificate :: Parser GovernanceCmd
pGovernanceGenesisKeyDelegationCertificate =
      VerificationKeyOrHashOrFile GenesisKey
-> VerificationKeyOrHashOrFile GenesisDelegateKey
-> VerificationKeyOrHashOrFile VrfKey
-> OutputFile
-> GovernanceCmd
GovernanceGenesisKeyDelegationCertificate
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (VerificationKeyOrHashOrFile GenesisKey)
pGenesisVerificationKeyOrHashOrFile
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (VerificationKeyOrHashOrFile GenesisDelegateKey)
pGenesisDelegateVerificationKeyOrHashOrFile
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (VerificationKeyOrHashOrFile VrfKey)
pVrfVerificationKeyOrHashOrFile
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser OutputFile
pOutputFile

    pMIRPot :: Parser Shelley.MIRPot
    pMIRPot :: Parser MIRPot
pMIRPot =
          forall a. a -> Mod FlagFields a -> Parser a
Opt.flag' MIRPot
Shelley.ReservesMIR
            (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"reserves"
            forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Use the reserves pot."
            )
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall a. a -> Mod FlagFields a -> Parser a
Opt.flag' MIRPot
Shelley.TreasuryMIR
            (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"treasury"
            forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Use the treasury pot."
            )

    pUpdateProposal :: Parser GovernanceCmd
    pUpdateProposal :: Parser GovernanceCmd
pUpdateProposal = OutputFile
-> EpochNo
-> [VerificationKeyFile]
-> ProtocolParametersUpdate
-> Maybe [Char]
-> GovernanceCmd
GovernanceUpdateProposal
                        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser OutputFile
pOutputFile
                        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser EpochNo
pEpochNoUpdateProp
                        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
some Parser VerificationKeyFile
pGenesisVerificationKeyFile
                        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ProtocolParametersUpdate
pProtocolParametersUpdate
                        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 [Char]
pCostModels

pTransferAmt :: Parser Lovelace
pTransferAmt :: Parser Lovelace
pTransferAmt =
    forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option (forall a. Parser a -> ReadM a
readerFromParsecParser Parser Lovelace
parseLovelace)
      (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"transfer"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"LOVELACE"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"The amount to transfer."
      )

pRewardAmt :: Parser Lovelace
pRewardAmt :: Parser Lovelace
pRewardAmt =
    forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option (forall a. Parser a -> ReadM a
readerFromParsecParser Parser Lovelace
parseLovelace)
      (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"reward"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"LOVELACE"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"The reward for the relevant reward account."
      )

pGenesisCmd :: Parser GenesisCmd
pGenesisCmd :: Parser GenesisCmd
pGenesisCmd =
  forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"key-gen-genesis"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser GenesisCmd
pGenesisKeyGen forall a b. (a -> b) -> a -> b
$
           forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Create a Shelley genesis key pair")
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"key-gen-delegate"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser GenesisCmd
pGenesisDelegateKeyGen forall a b. (a -> b) -> a -> b
$
           forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Create a Shelley genesis delegate key pair")
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"key-gen-utxo"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser GenesisCmd
pGenesisUTxOKeyGen forall a b. (a -> b) -> a -> b
$
           forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Create a Shelley genesis UTxO key pair")
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"key-hash"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser GenesisCmd
pGenesisKeyHash forall a b. (a -> b) -> a -> b
$
           forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Print the identifier (hash) of a public key")
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"get-ver-key"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser GenesisCmd
pGenesisVerKey forall a b. (a -> b) -> a -> b
$
           forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Derive the verification key from a signing key")
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"initial-addr"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser GenesisCmd
pGenesisAddr forall a b. (a -> b) -> a -> b
$
           forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Get the address for an initial UTxO based on the verification key")
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"initial-txin"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser GenesisCmd
pGenesisTxIn forall a b. (a -> b) -> a -> b
$
           forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Get the TxIn for an initial UTxO based on the verification key")
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"create-cardano"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser GenesisCmd
pGenesisCreateCardano forall a b. (a -> b) -> a -> b
$
           forall a. [Char] -> InfoMod a
Opt.progDesc ([Char]
"Create a Byron and Shelley genesis file from a genesis "
                      forall a. [a] -> [a] -> [a]
++ [Char]
"template and genesis/delegation/spending keys."))
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"create"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser GenesisCmd
pGenesisCreate forall a b. (a -> b) -> a -> b
$
           forall a. [Char] -> InfoMod a
Opt.progDesc ([Char]
"Create a Shelley genesis file from a genesis "
                      forall a. [a] -> [a] -> [a]
++ [Char]
"template and genesis/delegation/spending keys."))
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"create-staked"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser GenesisCmd
pGenesisCreateStaked forall a b. (a -> b) -> a -> b
$
           forall a. [Char] -> InfoMod a
Opt.progDesc ([Char]
"Create a staked Shelley genesis file from a genesis "
                      forall a. [a] -> [a] -> [a]
++ [Char]
"template and genesis/delegation/spending keys."))
    , forall a. [Char] -> ParserInfo a -> Parser a
subParser [Char]
"hash"
        (forall a. Parser a -> InfoMod a -> ParserInfo a
Opt.info Parser GenesisCmd
pGenesisHash forall a b. (a -> b) -> a -> b
$
           forall a. [Char] -> InfoMod a
Opt.progDesc [Char]
"Compute the hash of a genesis file")
    ]
  where
    pGenesisKeyGen :: Parser GenesisCmd
    pGenesisKeyGen :: Parser GenesisCmd
pGenesisKeyGen =
      VerificationKeyFile -> SigningKeyFile -> GenesisCmd
GenesisKeyGenGenesis forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FileDirection -> Parser VerificationKeyFile
pVerificationKeyFile FileDirection
Output forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> FileDirection -> Parser SigningKeyFile
pSigningKeyFile FileDirection
Output

    pGenesisDelegateKeyGen :: Parser GenesisCmd
    pGenesisDelegateKeyGen :: Parser GenesisCmd
pGenesisDelegateKeyGen =
      VerificationKeyFile
-> SigningKeyFile -> OpCertCounterFile -> GenesisCmd
GenesisKeyGenDelegate forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FileDirection -> Parser VerificationKeyFile
pVerificationKeyFile FileDirection
Output
                            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> FileDirection -> Parser SigningKeyFile
pSigningKeyFile FileDirection
Output
                            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser OpCertCounterFile
pOperatorCertIssueCounterFile

    pGenesisUTxOKeyGen :: Parser GenesisCmd
    pGenesisUTxOKeyGen :: Parser GenesisCmd
pGenesisUTxOKeyGen =
      VerificationKeyFile -> SigningKeyFile -> GenesisCmd
GenesisKeyGenUTxO forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FileDirection -> Parser VerificationKeyFile
pVerificationKeyFile FileDirection
Output forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> FileDirection -> Parser SigningKeyFile
pSigningKeyFile FileDirection
Output

    pGenesisKeyHash :: Parser GenesisCmd
    pGenesisKeyHash :: Parser GenesisCmd
pGenesisKeyHash =
      VerificationKeyFile -> GenesisCmd
GenesisCmdKeyHash forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FileDirection -> Parser VerificationKeyFile
pVerificationKeyFile FileDirection
Input

    pGenesisVerKey :: Parser GenesisCmd
    pGenesisVerKey :: Parser GenesisCmd
pGenesisVerKey =
      VerificationKeyFile -> SigningKeyFile -> GenesisCmd
GenesisVerKey forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FileDirection -> Parser VerificationKeyFile
pVerificationKeyFile FileDirection
Output forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> FileDirection -> Parser SigningKeyFile
pSigningKeyFile FileDirection
Output

    pGenesisAddr :: Parser GenesisCmd
    pGenesisAddr :: Parser GenesisCmd
pGenesisAddr =
      VerificationKeyFile -> NetworkId -> Maybe OutputFile -> GenesisCmd
GenesisAddr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FileDirection -> Parser VerificationKeyFile
pVerificationKeyFile FileDirection
Input 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 (Maybe OutputFile)
pMaybeOutputFile

    pGenesisTxIn :: Parser GenesisCmd
    pGenesisTxIn :: Parser GenesisCmd
pGenesisTxIn =
      VerificationKeyFile -> NetworkId -> Maybe OutputFile -> GenesisCmd
GenesisTxIn forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FileDirection -> Parser VerificationKeyFile
pVerificationKeyFile FileDirection
Input 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 (Maybe OutputFile)
pMaybeOutputFile

    pGenesisCreateCardano :: Parser GenesisCmd
    pGenesisCreateCardano :: Parser GenesisCmd
pGenesisCreateCardano =
      GenesisDir
-> Word
-> Word
-> Maybe SystemStart
-> Maybe Lovelace
-> BlockCount
-> Word
-> Rational
-> NetworkId
-> [Char]
-> [Char]
-> [Char]
-> [Char]
-> Maybe [Char]
-> GenesisCmd
GenesisCreateCardano forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser GenesisDir
pGenesisDir
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Word
pGenesisNumGenesisKeys
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Word
pGenesisNumUTxOKeys
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Maybe SystemStart)
pMaybeSystemStart
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Maybe Lovelace)
pInitialSupplyNonDelegated
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Word64 -> BlockCount
BlockCount forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Word64
pSecurityParam)
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Word
pSlotLength
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Rational
pSlotCoefficient
                    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 [Char]
parseFilePath
                          [Char]
"byron-template"
                          [Char]
"JSON file with genesis defaults for each byron."
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> [Char] -> Parser [Char]
parseFilePath
                          [Char]
"shelley-template"
                          [Char]
"JSON file with genesis defaults for each shelley."
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> [Char] -> Parser [Char]
parseFilePath
                          [Char]
"alonzo-template"
                          [Char]
"JSON file with genesis defaults for alonzo."
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> [Char] -> Parser [Char]
parseFilePath
                          [Char]
"conway-template"
                          [Char]
"JSON file with genesis defaults for conway."
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Maybe [Char])
pNodeConfigTemplate

    pGenesisCreate :: Parser GenesisCmd
    pGenesisCreate :: Parser GenesisCmd
pGenesisCreate =
      GenesisDir
-> Word
-> Word
-> Maybe SystemStart
-> Maybe Lovelace
-> NetworkId
-> GenesisCmd
GenesisCreate forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser GenesisDir
pGenesisDir
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Word
pGenesisNumGenesisKeys
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Word
pGenesisNumUTxOKeys
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Maybe SystemStart)
pMaybeSystemStart
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Maybe Lovelace)
pInitialSupplyNonDelegated
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser NetworkId
pNetworkId

    pGenesisCreateStaked :: Parser GenesisCmd
    pGenesisCreateStaked :: Parser GenesisCmd
pGenesisCreateStaked =
      GenesisDir
-> Word
-> Word
-> Word
-> Word
-> Maybe SystemStart
-> Maybe Lovelace
-> Lovelace
-> NetworkId
-> Word
-> Word
-> Word
-> Maybe [Char]
-> GenesisCmd
GenesisCreateStaked
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser GenesisDir
pGenesisDir
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Word
pGenesisNumGenesisKeys
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Word
pGenesisNumUTxOKeys
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Word
pGenesisNumPools
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Word
pGenesisNumStDelegs
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Maybe SystemStart)
pMaybeSystemStart
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Maybe Lovelace)
pInitialSupplyNonDelegated
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Lovelace
pInitialSupplyDelegated
        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 Word
pBulkPoolCredFiles
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Word
pBulkPoolsPerFile
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Word
pStuffedUtxoCount
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
Opt.optional Parser [Char]
pRelayJsonFp

    pGenesisHash :: Parser GenesisCmd
    pGenesisHash :: Parser GenesisCmd
pGenesisHash =
      GenesisFile -> GenesisCmd
GenesisHashFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> Parser GenesisFile
pGenesisFile [Char]
"The genesis file."

    pGenesisDir :: Parser GenesisDir
    pGenesisDir :: Parser GenesisDir
pGenesisDir =
      [Char] -> GenesisDir
GenesisDir forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
        forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
          (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"genesis-dir"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"DIR"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"The genesis directory containing the genesis template and required genesis/delegation/spending keys."
          )

    pMaybeSystemStart :: Parser (Maybe SystemStart)
    pMaybeSystemStart :: Parser (Maybe SystemStart)
pMaybeSystemStart =
      forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
Opt.optional forall a b. (a -> b) -> a -> b
$
        UTCTime -> SystemStart
SystemStart forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> UTCTime
convertTime forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
          forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
            (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"start-time"
            forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"UTC-TIME"
            forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"The genesis start time in YYYY-MM-DDThh:mm:ssZ format. If unspecified, will be the current time +30 seconds."
            )

    pGenesisNumGenesisKeys :: Parser Word
    pGenesisNumGenesisKeys :: Parser Word
pGenesisNumGenesisKeys =
        forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option forall a. Read a => ReadM a
Opt.auto
          (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"gen-genesis-keys"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"INT"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"The number of genesis keys to make [default is 3]."
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasValue f => a -> Mod f a
Opt.value Word
3
          )

    pNodeConfigTemplate :: Parser (Maybe FilePath)
    pNodeConfigTemplate :: Parser (Maybe [Char])
pNodeConfigTemplate = forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional forall a b. (a -> b) -> a -> b
$ [Char] -> [Char] -> Parser [Char]
parseFilePath [Char]
"node-config-template" [Char]
"the node config template"

    pGenesisNumUTxOKeys :: Parser Word
    pGenesisNumUTxOKeys :: Parser Word
pGenesisNumUTxOKeys =
        forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option forall a. Read a => ReadM a
Opt.auto
          (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"gen-utxo-keys"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"INT"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"The number of UTxO keys to make [default is 0]."
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasValue f => a -> Mod f a
Opt.value Word
0
          )

    pGenesisNumPools :: Parser Word
    pGenesisNumPools :: Parser Word
pGenesisNumPools =
        forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option forall a. Read a => ReadM a
Opt.auto
          (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"gen-pools"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"INT"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"The number of stake pool credential sets to make [default is 0]."
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasValue f => a -> Mod f a
Opt.value Word
0
          )

    pGenesisNumStDelegs :: Parser Word
    pGenesisNumStDelegs :: Parser Word
pGenesisNumStDelegs =
        forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option forall a. Read a => ReadM a
Opt.auto
          (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"gen-stake-delegs"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"INT"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"The number of stake delegator credential sets to make [default is 0]."
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasValue f => a -> Mod f a
Opt.value Word
0
          )

    pStuffedUtxoCount :: Parser Word
    pStuffedUtxoCount :: Parser Word
pStuffedUtxoCount =
        forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option forall a. Read a => ReadM a
Opt.auto
          (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"num-stuffed-utxo"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"INT"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"The number of fake UTxO entries to generate [default is 0]."
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasValue f => a -> Mod f a
Opt.value Word
0
          )

    pRelayJsonFp :: Parser FilePath
    pRelayJsonFp :: Parser [Char]
pRelayJsonFp =
      forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
        (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"relay-specification-file"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"JSON file specified the relays of each stake pool."
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
        )

    convertTime :: String -> UTCTime
    convertTime :: [Char] -> UTCTime
convertTime =
      forall t.
ParseTime t =>
Bool -> TimeLocale -> [Char] -> [Char] -> t
parseTimeOrError Bool
False TimeLocale
defaultTimeLocale [Char]
"%Y-%m-%dT%H:%M:%SZ"

    pInitialSupplyNonDelegated :: Parser (Maybe Lovelace)
    pInitialSupplyNonDelegated :: Parser (Maybe Lovelace)
pInitialSupplyNonDelegated =
      forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
Opt.optional forall a b. (a -> b) -> a -> b
$
      Integer -> Lovelace
Lovelace 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
Opt.auto
          (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"supply"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"LOVELACE"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"The initial coin supply in Lovelace which will be evenly distributed across initial, non-delegating stake holders."
          )

    pInitialSupplyDelegated :: Parser Lovelace
    pInitialSupplyDelegated :: Parser Lovelace
pInitialSupplyDelegated =
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Integer -> Lovelace
Lovelace forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a -> a
fromMaybe Integer
0) forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
Opt.optional forall a b. (a -> b) -> a -> b
$
        forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option forall a. Read a => ReadM a
Opt.auto
          (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"supply-delegated"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"LOVELACE"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"The initial coin supply in Lovelace which will be evenly distributed across initial, delegating stake holders."
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasValue f => a -> Mod f a
Opt.value Integer
0
          )

    pSecurityParam :: Parser Word64
    pSecurityParam :: Parser Word64
pSecurityParam =
        forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option forall a. Read a => ReadM a
Opt.auto
          (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"security-param"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"INT"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Security parameter for genesis file [default is 108]."
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasValue f => a -> Mod f a
Opt.value Word64
108
          )

    pSlotLength :: Parser Word
    pSlotLength :: Parser Word
pSlotLength =
        forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option forall a. Read a => ReadM a
Opt.auto
          (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"slot-length"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"INT"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"slot length (ms) parameter for genesis file [default is 1000]."
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasValue f => a -> Mod f a
Opt.value Word
1000
          )


    pSlotCoefficient :: Parser Rational
    pSlotCoefficient :: Parser Rational
pSlotCoefficient =
        forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option ReadM Rational
readRationalUnitInterval
          (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"slot-coefficient"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"RATIONAL"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Slot Coefficient for genesis file [default is .05]."
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasValue f => a -> Mod f a
Opt.value Rational
0.05
          )

    pBulkPoolCredFiles :: Parser Word
    pBulkPoolCredFiles :: Parser Word
pBulkPoolCredFiles =
        forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option forall a. Read a => ReadM a
Opt.auto
          (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"bulk-pool-cred-files"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"INT"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Generate bulk pool credential files [default is 0]."
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasValue f => a -> Mod f a
Opt.value Word
0
          )

    pBulkPoolsPerFile :: Parser Word
    pBulkPoolsPerFile :: Parser Word
pBulkPoolsPerFile =
        forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option forall a. Read a => ReadM a
Opt.auto
          (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"bulk-pools-per-file"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"INT"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Each bulk pool to contain this many pool credential sets [default is 0]."
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasValue f => a -> Mod f a
Opt.value Word
0
          )


--
-- Shelley CLI flag parsers
--

data FileDirection
  = Input
  | Output
  deriving (FileDirection -> FileDirection -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FileDirection -> FileDirection -> Bool
$c/= :: FileDirection -> FileDirection -> Bool
== :: FileDirection -> FileDirection -> Bool
$c== :: FileDirection -> FileDirection -> Bool
Eq, Int -> FileDirection -> [Char] -> [Char]
[FileDirection] -> [Char] -> [Char]
FileDirection -> [Char]
forall a.
(Int -> a -> [Char] -> [Char])
-> (a -> [Char]) -> ([a] -> [Char] -> [Char]) -> Show a
showList :: [FileDirection] -> [Char] -> [Char]
$cshowList :: [FileDirection] -> [Char] -> [Char]
show :: FileDirection -> [Char]
$cshow :: FileDirection -> [Char]
showsPrec :: Int -> FileDirection -> [Char] -> [Char]
$cshowsPrec :: Int -> FileDirection -> [Char] -> [Char]
Show)

pAddressKeyType :: Parser AddressKeyType
pAddressKeyType :: Parser AddressKeyType
pAddressKeyType =
    forall a. a -> Mod FlagFields a -> Parser a
Opt.flag' AddressKeyType
AddressKeyShelley
      (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"normal-key"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Use a normal Shelley-era key (default)."
      )
  forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    forall a. a -> Mod FlagFields a -> Parser a
Opt.flag' AddressKeyType
AddressKeyShelleyExtended
      (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"extended-key"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Use an extended ed25519 Shelley-era key."
      )
  forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    forall a. a -> Mod FlagFields a -> Parser a
Opt.flag' AddressKeyType
AddressKeyByron
      (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"byron-key"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Use a Byron-era key."
      )
  forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    forall (f :: * -> *) a. Applicative f => a -> f a
pure AddressKeyType
AddressKeyShelley


pProtocolParamsFile :: Parser ProtocolParamsFile
pProtocolParamsFile :: Parser ProtocolParamsFile
pProtocolParamsFile =
  [Char] -> ProtocolParamsFile
ProtocolParamsFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
      (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"protocol-params-file"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Filepath of the JSON-encoded protocol parameters file"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
      )

pCalculatePlutusScriptCost :: Parser TxBuildOutputOptions
pCalculatePlutusScriptCost :: Parser TxBuildOutputOptions
pCalculatePlutusScriptCost =
  [Char] -> TxBuildOutputOptions
OutputScriptCostOnly forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
   ( forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"calculate-plutus-script-cost" forall a. Semigroup a => a -> a -> a
<>
     forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE" forall a. Semigroup a => a -> a -> a
<>
     forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Output filepath of the script cost information." forall a. Semigroup a => a -> a -> a
<>
     forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
   )

pCertificateFile
  :: BalanceTxExecUnits
  -> Parser (CertificateFile, Maybe (ScriptWitnessFiles WitCtxStake))
pCertificateFile :: BalanceTxExecUnits
-> Parser (CertificateFile, Maybe (ScriptWitnessFiles WitCtxStake))
pCertificateFile BalanceTxExecUnits
balanceExecUnits =
  (,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ([Char] -> CertificateFile
CertificateFile
             forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (  forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
                      (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"certificate-file"
                      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"CERTIFICATEFILE"
                      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
helpText
                      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
                      )
                  forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
                     forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption (forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"certificate" forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. Mod f a
Opt.internal)
                  )
          )
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (BalanceTxExecUnits -> Parser (ScriptWitnessFiles WitCtxStake)
pCertifyingScriptOrReferenceScriptWit BalanceTxExecUnits
balanceExecUnits)
 where
  pCertifyingScriptOrReferenceScriptWit
    :: BalanceTxExecUnits -> Parser (ScriptWitnessFiles WitCtxStake)
  pCertifyingScriptOrReferenceScriptWit :: BalanceTxExecUnits -> Parser (ScriptWitnessFiles WitCtxStake)
pCertifyingScriptOrReferenceScriptWit BalanceTxExecUnits
bExecUnits =
    forall witctx.
WitCtx witctx
-> BalanceTxExecUnits
-> [Char]
-> Maybe [Char]
-> [Char]
-> Parser (ScriptWitnessFiles witctx)
pScriptWitnessFiles
     WitCtx WitCtxStake
WitCtxStake
     BalanceTxExecUnits
balanceExecUnits
     [Char]
"certificate" forall a. Maybe a
Nothing
     [Char]
"the use of the certificate." forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    [Char]
-> BalanceTxExecUnits -> Parser (ScriptWitnessFiles WitCtxStake)
pPlutusStakeReferenceScriptWitnessFiles [Char]
"certificate-" BalanceTxExecUnits
bExecUnits

  helpText :: [Char]
helpText = forall a. Monoid a => [a] -> a
mconcat
    [ [Char]
"Filepath of the certificate. This encompasses all "
    , [Char]
"types of certificates (stake pool certificates, "
    , [Char]
"stake key certificates etc). Optionally specify a script witness."
    ]

pPoolMetadataFile :: Parser PoolMetadataFile
pPoolMetadataFile :: Parser PoolMetadataFile
pPoolMetadataFile =
  [Char] -> PoolMetadataFile
PoolMetadataFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
      (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"pool-metadata-file"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Filepath of the pool metadata."
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
      )

pTxMetadataJsonSchema :: Parser TxMetadataJsonSchema
pTxMetadataJsonSchema :: Parser TxMetadataJsonSchema
pTxMetadataJsonSchema =
    (  forall a. a -> Mod FlagFields a -> Parser a
Opt.flag' ()
        (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"json-metadata-no-schema"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Use the \"no schema\" conversion from JSON to tx metadata."
        )
    forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> TxMetadataJsonSchema
TxMetadataJsonNoSchema
    )
  forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    (  forall a. a -> Mod FlagFields a -> Parser a
Opt.flag' ()
        (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"json-metadata-detailed-schema"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Use the \"detailed schema\" conversion from JSON to tx metadata."
        )
    forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> TxMetadataJsonSchema
TxMetadataJsonDetailedSchema
    )
  forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    -- Default to the no-schema conversion.
    forall (f :: * -> *) a. Applicative f => a -> f a
pure TxMetadataJsonSchema
TxMetadataJsonNoSchema

pMetadataFile :: Parser MetadataFile
pMetadataFile :: Parser MetadataFile
pMetadataFile =
      [Char] -> MetadataFile
MetadataFileJSON forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
        ( forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
            (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"metadata-json-file"
            forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
            forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Filepath of the metadata file, in JSON format."
            forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
            )
        forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
          forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
            (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"metadata-file" -- backward compat name
            forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. Mod f a
Opt.internal
            )
        )
  forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      [Char] -> MetadataFile
MetadataFileCBOR forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
        forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
          (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"metadata-cbor-file"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Filepath of the metadata, in raw CBOR format."
          forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
          )

pWithdrawal
  :: BalanceTxExecUnits
  -> Parser (StakeAddress,
            Lovelace,
            Maybe (ScriptWitnessFiles WitCtxStake))
pWithdrawal :: BalanceTxExecUnits
-> Parser
     (StakeAddress, Lovelace, Maybe (ScriptWitnessFiles WitCtxStake))
pWithdrawal BalanceTxExecUnits
balance =
    (\(StakeAddress
stakeAddr,Lovelace
lovelace) Maybe (ScriptWitnessFiles WitCtxStake)
maybeScriptFp -> (StakeAddress
stakeAddr, Lovelace
lovelace, Maybe (ScriptWitnessFiles WitCtxStake)
maybeScriptFp))
      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. Parser a -> ReadM a
readerFromParsecParser Parser (StakeAddress, Lovelace)
parseWithdrawal)
            (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"withdrawal"
            forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"WITHDRAWAL"
            forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
helpText
            )
      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 (ScriptWitnessFiles WitCtxStake)
pWithdrawalScriptOrReferenceScriptWit
 where
  pWithdrawalScriptOrReferenceScriptWit :: Parser (ScriptWitnessFiles WitCtxStake)
  pWithdrawalScriptOrReferenceScriptWit :: Parser (ScriptWitnessFiles WitCtxStake)
pWithdrawalScriptOrReferenceScriptWit =
   forall witctx.
WitCtx witctx
-> BalanceTxExecUnits
-> [Char]
-> Maybe [Char]
-> [Char]
-> Parser (ScriptWitnessFiles witctx)
pScriptWitnessFiles
     WitCtx WitCtxStake
WitCtxStake
     BalanceTxExecUnits
balance
     [Char]
"withdrawal" forall a. Maybe a
Nothing
     [Char]
"the withdrawal of rewards." forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
   [Char]
-> BalanceTxExecUnits -> Parser (ScriptWitnessFiles WitCtxStake)
pPlutusStakeReferenceScriptWitnessFiles [Char]
"withdrawal-" BalanceTxExecUnits
balance

  helpText :: [Char]
helpText = forall a. Monoid a => [a] -> a
mconcat
    [ [Char]
"The reward withdrawal as StakeAddress+Lovelace where "
    , [Char]
"StakeAddress is the Bech32-encoded stake address "
    , [Char]
"followed by the amount in Lovelace. Optionally specify "
    , [Char]
"a script witness."
    ]

  parseWithdrawal :: Parsec.Parser (StakeAddress, Lovelace)
  parseWithdrawal :: Parser (StakeAddress, Lovelace)
parseWithdrawal =
    (,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser StakeAddress
parseStakeAddress forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
Parsec.char Char
'+' forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Lovelace
parseLovelace

pPlutusStakeReferenceScriptWitnessFiles
  :: String
  -> BalanceTxExecUnits -- ^ Use the @execution-units@ flag.
  -> Parser (ScriptWitnessFiles WitCtxStake)
pPlutusStakeReferenceScriptWitnessFiles :: [Char]
-> BalanceTxExecUnits -> Parser (ScriptWitnessFiles WitCtxStake)
pPlutusStakeReferenceScriptWitnessFiles [Char]
prefix BalanceTxExecUnits
autoBalanceExecUnits =
  forall witctx.
TxIn
-> AnyScriptLanguage
-> ScriptDatumOrFile witctx
-> ScriptRedeemerOrFile
-> ExecutionUnits
-> Maybe PolicyId
-> ScriptWitnessFiles witctx
PlutusReferenceScriptWitnessFiles
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> [Char] -> Parser TxIn
pReferenceTxIn [Char]
prefix [Char]
"plutus"
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> Parser AnyScriptLanguage
pPlutusScriptLanguage [Char]
prefix
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Applicative f => a -> f a
pure ScriptDatumOrFile WitCtxStake
NoScriptDatumOrFileForStake
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> Parser ScriptRedeemerOrFile
pScriptRedeemerOrFile ([Char]
prefix forall a. [a] -> [a] -> [a]
++ [Char]
"reference-tx-in")
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (case BalanceTxExecUnits
autoBalanceExecUnits of
          BalanceTxExecUnits
AutoBalance -> forall (f :: * -> *) a. Applicative f => a -> f a
pure (Natural -> Natural -> ExecutionUnits
ExecutionUnits Natural
0 Natural
0)
          BalanceTxExecUnits
ManualBalance -> [Char] -> Parser ExecutionUnits
pExecutionUnits forall a b. (a -> b) -> a -> b
$ [Char]
prefix forall a. [a] -> [a] -> [a]
++ [Char]
"reference-tx-in")
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. Maybe a
Nothing

pPlutusScriptLanguage :: String -> Parser AnyScriptLanguage
pPlutusScriptLanguage :: [Char] -> Parser AnyScriptLanguage
pPlutusScriptLanguage [Char]
prefix =
  forall a. a -> Mod FlagFields a -> Parser a
Opt.flag' (forall lang. ScriptLanguage lang -> AnyScriptLanguage
AnyScriptLanguage forall a b. (a -> b) -> a -> b
$ forall lang. PlutusScriptVersion lang -> ScriptLanguage lang
PlutusScriptLanguage PlutusScriptVersion PlutusScriptV2
PlutusScriptV2)
    (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long ([Char]
prefix forall a. [a] -> [a] -> [a]
++ [Char]
"plutus-script-v2")
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Specify a plutus script v2 reference script."
    )

pUpdateProposalFile :: Parser UpdateProposalFile
pUpdateProposalFile :: Parser UpdateProposalFile
pUpdateProposalFile =
  [Char] -> UpdateProposalFile
UpdateProposalFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
  ( forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
     (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"update-proposal-file"
     forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
     forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Filepath of the update proposal."
     forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
     )
  forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
      (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"update-proposal"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. Mod f a
Opt.internal
      )
  )


pColdSigningKeyFile :: Parser SigningKeyFile
pColdSigningKeyFile :: Parser SigningKeyFile
pColdSigningKeyFile =
  [Char] -> SigningKeyFile
SigningKeyFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    ( forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
        (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"cold-signing-key-file"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Filepath of the cold signing key."
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
        )
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
      (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"signing-key-file"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. Mod f a
Opt.internal
      )
    )

pRequiredSigner :: Parser RequiredSigner
pRequiredSigner :: Parser RequiredSigner
pRequiredSigner =
      SigningKeyFile -> RequiredSigner
RequiredSignerSkeyFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser SigningKeyFile
sKeyFile
  forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Hash PaymentKey -> RequiredSigner
RequiredSignerHash forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Hash PaymentKey)
sPayKeyHash
 where
  sKeyFile :: Parser SigningKeyFile
  sKeyFile :: Parser SigningKeyFile
sKeyFile = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Char] -> SigningKeyFile
SigningKeyFile forall a b. (a -> b) -> a -> b
$ forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption 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]
"required-signer"
    , forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
    , forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help forall a b. (a -> b) -> a -> b
$ forall a. Monoid a => [a] -> a
mconcat
      [ [Char]
"Input filepath of the signing key (zero or more) whose "
      , [Char]
"signature is required."
      ]
    , forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
    ]
  sPayKeyHash :: Parser (Hash PaymentKey)
  sPayKeyHash :: Parser (Hash PaymentKey)
sPayKeyHash =
    forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option (forall a. Parser a -> ReadM a
readerFromParsecParser forall a b. (a -> b) -> a -> b
$ forall a.
SerialiseAsRawBytes (Hash a) =>
AsType (Hash a) -> Parser (Hash a)
parseHash (forall a. AsType a -> AsType (Hash a)
AsHash AsType PaymentKey
AsPaymentKey)) 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]
"required-signer-hash"
      , forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"HASH"
      , forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help forall a b. (a -> b) -> a -> b
$ forall a. Monoid a => [a] -> a
mconcat
        [ [Char]
"Hash of the verification key (zero or more) whose "
        , [Char]
"signature is required."
        ]
      ]

pVrfSigningKeyFile :: Parser SigningKeyFile
pVrfSigningKeyFile :: Parser SigningKeyFile
pVrfSigningKeyFile =
  [Char] -> SigningKeyFile
SigningKeyFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
      (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"vrf-signing-key-file"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Input filepath of the VRF signing key."
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
      )

pWhichLeadershipSchedule :: Parser EpochLeadershipSchedule
pWhichLeadershipSchedule :: Parser EpochLeadershipSchedule
pWhichLeadershipSchedule = Parser EpochLeadershipSchedule
pCurrent forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser EpochLeadershipSchedule
pNext
 where
   pCurrent :: Parser EpochLeadershipSchedule
   pCurrent :: Parser EpochLeadershipSchedule
pCurrent =
     forall a. a -> Mod FlagFields a -> Parser a
Opt.flag' EpochLeadershipSchedule
CurrentEpoch
       (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"current"
       forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Get the leadership schedule for the current epoch."
       )

   pNext :: Parser EpochLeadershipSchedule
   pNext :: Parser EpochLeadershipSchedule
pNext =
     forall a. a -> Mod FlagFields a -> Parser a
Opt.flag' EpochLeadershipSchedule
NextEpoch
       (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"next"
       forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Get the leadership schedule for the following epoch."
       )

pWitnessSigningData :: Parser WitnessSigningData
pWitnessSigningData :: Parser WitnessSigningData
pWitnessSigningData =
      SigningKeyFile -> Maybe (Address ByronAddr) -> WitnessSigningData
KeyWitnessSigningData
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
          ( [Char] -> SigningKeyFile
SigningKeyFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
              forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
                (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"signing-key-file"
                forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
                forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Input filepath of the signing key (one or more)."
                forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
                )
          )
        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 (Address ByronAddr)
pByronAddress

pSigningKeyFile :: FileDirection -> Parser SigningKeyFile
pSigningKeyFile :: FileDirection -> Parser SigningKeyFile
pSigningKeyFile FileDirection
fdir =
  [Char] -> SigningKeyFile
SigningKeyFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
      (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"signing-key-file"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help (forall a. Show a => a -> [Char]
show FileDirection
fdir forall a. [a] -> [a] -> [a]
++ [Char]
" filepath of the signing key.")
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
      )

pKesPeriod :: Parser KESPeriod
pKesPeriod :: Parser KESPeriod
pKesPeriod =
  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word -> KESPeriod
KESPeriod 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]
"KES_PERIOD") 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]
"kes-period"
    , forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"NATURAL"
    , forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"The start of the KES key validity period."
    ]

pEpochNo :: Parser EpochNo
pEpochNo :: Parser EpochNo
pEpochNo =
  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word64 -> EpochNo
EpochNo 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]
"EPOCH") 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]
"epoch"
    , forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"NATURAL"
    , forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"The epoch number."
    ]


pEpochNoUpdateProp :: Parser EpochNo
pEpochNoUpdateProp :: Parser EpochNo
pEpochNoUpdateProp =
  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word64 -> EpochNo
EpochNo 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]
"EPOCH") 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]
"epoch"
    , forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"EPOCH"
    , forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"The epoch number in which the update proposal is valid."
    ]

pGenesisFile :: String -> Parser GenesisFile
pGenesisFile :: [Char] -> Parser GenesisFile
pGenesisFile [Char]
desc =
  [Char] -> GenesisFile
GenesisFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
      (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"genesis"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
desc
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
      )

pOperatorCertIssueCounterFile :: Parser OpCertCounterFile
pOperatorCertIssueCounterFile :: Parser OpCertCounterFile
pOperatorCertIssueCounterFile =
  [Char] -> OpCertCounterFile
OpCertCounterFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    ( forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
        (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"operational-certificate-issue-counter-file"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"The file with the issue counter for the operational certificate."
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
        )
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
        (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"operational-certificate-issue-counter"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. Mod f a
Opt.internal
        )
    )

pOperationalCertificateFile :: Parser FilePath
pOperationalCertificateFile :: Parser [Char]
pOperationalCertificateFile =
  forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
    (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"op-cert-file"
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Filepath of the node's operational certificate."
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
    )

pOutputFormat :: Parser OutputFormat
pOutputFormat :: Parser OutputFormat
pOutputFormat =
  forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option ReadM OutputFormat
readOutputFormat
    (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"output-format"
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"STRING"
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Optional output format. Accepted output formats are \"hex\" \
                \and \"bech32\" (default is \"bech32\")."
    forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasValue f => a -> Mod f a
Opt.value OutputFormat
OutputFormatBech32
    )

pMaybeOutputFile :: Parser (Maybe OutputFile)
pMaybeOutputFile :: Parser (Maybe OutputFile)
pMaybeOutputFile =
  forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional forall a b. (a -> b) -> a -> b
$
    [Char] -> OutputFile
OutputFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
      forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
        (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"out-file"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Optional output file. Default is to write to stdout."
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
        )

pOutputFile :: Parser OutputFile
pOutputFile :: Parser OutputFile
pOutputFile =
  [Char] -> OutputFile
OutputFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
      (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"out-file"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"The output file."
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
      )

pColdVerificationKeyOrFile :: Parser ColdVerificationKeyOrFile
pColdVerificationKeyOrFile :: Parser ColdVerificationKeyOrFile
pColdVerificationKeyOrFile =
  VerificationKey StakePoolKey -> ColdVerificationKeyOrFile
ColdStakePoolVerificationKey forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (VerificationKey StakePoolKey)
pStakePoolVerificationKey
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> VerificationKey GenesisDelegateKey -> ColdVerificationKeyOrFile
ColdGenesisDelegateVerificationKey forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (VerificationKey GenesisDelegateKey)
pGenesisDelegateVerificationKey
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> VerificationKeyFile -> ColdVerificationKeyOrFile
ColdVerificationKeyFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser VerificationKeyFile
pColdVerificationKeyFile

pColdVerificationKeyFile :: Parser VerificationKeyFile
pColdVerificationKeyFile :: Parser VerificationKeyFile
pColdVerificationKeyFile =
  [Char] -> VerificationKeyFile
VerificationKeyFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    ( forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
        (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"cold-verification-key-file"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Filepath of the cold verification key."
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
        )
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
        (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"verification-key-file"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. Mod f a
Opt.internal
        )
    )

pVerificationKey
  :: forall keyrole. SerialiseAsBech32 (VerificationKey keyrole)
  => AsType keyrole
  -> Parser (VerificationKey keyrole)
pVerificationKey :: forall keyrole.
SerialiseAsBech32 (VerificationKey keyrole) =>
AsType keyrole -> Parser (VerificationKey keyrole)
pVerificationKey AsType keyrole
asType =
  forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option
    (forall keyrole.
SerialiseAsBech32 (VerificationKey keyrole) =>
AsType keyrole -> ReadM (VerificationKey keyrole)
readVerificationKey AsType keyrole
asType)
      (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"verification-key"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"STRING"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Verification key (Bech32 or hex-encoded)."
      )

pVerificationKeyOrFile
  :: SerialiseAsBech32 (VerificationKey keyrole)
  => AsType keyrole
  -> Parser (VerificationKeyOrFile keyrole)
pVerificationKeyOrFile :: forall keyrole.
SerialiseAsBech32 (VerificationKey keyrole) =>
AsType keyrole -> Parser (VerificationKeyOrFile keyrole)
pVerificationKeyOrFile AsType keyrole
asType =
  forall keyrole.
VerificationKey keyrole -> VerificationKeyOrFile keyrole
VerificationKeyValue forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall keyrole.
SerialiseAsBech32 (VerificationKey keyrole) =>
AsType keyrole -> Parser (VerificationKey keyrole)
pVerificationKey AsType keyrole
asType
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall keyrole.
VerificationKeyFile -> VerificationKeyOrFile keyrole
VerificationKeyFilePath forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FileDirection -> Parser VerificationKeyFile
pVerificationKeyFile FileDirection
Input

pVerificationKeyFile :: FileDirection -> Parser VerificationKeyFile
pVerificationKeyFile :: FileDirection -> Parser VerificationKeyFile
pVerificationKeyFile FileDirection
fdir =
  [Char] -> VerificationKeyFile
VerificationKeyFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
      (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"verification-key-file"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help (forall a. Show a => a -> [Char]
show FileDirection
fdir forall a. [a] -> [a] -> [a]
++ [Char]
" filepath of the verification key.")
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
      )

pExtendedVerificationKeyFile :: FileDirection -> Parser VerificationKeyFile
pExtendedVerificationKeyFile :: FileDirection -> Parser VerificationKeyFile
pExtendedVerificationKeyFile FileDirection
fdir =
  [Char] -> VerificationKeyFile
VerificationKeyFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
      (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"extended-verification-key-file"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help (forall a. Show a => a -> [Char]
show FileDirection
fdir forall a. [a] -> [a] -> [a]
++ [Char]
" filepath of the ed25519-bip32 verification key.")
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
      )

pGenesisVerificationKeyFile :: Parser VerificationKeyFile
pGenesisVerificationKeyFile :: Parser VerificationKeyFile
pGenesisVerificationKeyFile =
  [Char] -> VerificationKeyFile
VerificationKeyFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
      (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"genesis-verification-key-file"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Filepath of the genesis verification key."
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
      )

pGenesisVerificationKeyHash :: Parser (Hash GenesisKey)
pGenesisVerificationKeyHash :: Parser (Hash GenesisKey)
pGenesisVerificationKeyHash =
    forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option
      (forall a. ([Char] -> Either [Char] a) -> ReadM a
Opt.eitherReader [Char] -> Either [Char] (Hash GenesisKey)
deserialiseFromHex)
        (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"genesis-verification-key-hash"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"STRING"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Genesis verification key hash (hex-encoded)."
        )
  where
    deserialiseFromHex :: String -> Either String (Hash GenesisKey)
    deserialiseFromHex :: [Char] -> Either [Char] (Hash GenesisKey)
deserialiseFromHex =
      forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (\RawBytesHexError
e -> [Char]
"Invalid genesis verification key hash: " forall a. [a] -> [a] -> [a]
++ forall e. Error e => e -> [Char]
displayError RawBytesHexError
e)
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a.
SerialiseAsRawBytes a =>
AsType a -> ByteString -> Either RawBytesHexError a
deserialiseFromRawBytesHex (forall a. AsType a -> AsType (Hash a)
AsHash AsType GenesisKey
AsGenesisKey)
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> ByteString
BSC.pack

pGenesisVerificationKey :: Parser (VerificationKey GenesisKey)
pGenesisVerificationKey :: Parser (VerificationKey GenesisKey)
pGenesisVerificationKey =
    forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option
      (forall a. ([Char] -> Either [Char] a) -> ReadM a
Opt.eitherReader [Char] -> Either [Char] (VerificationKey GenesisKey)
deserialiseFromHex)
        (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"genesis-verification-key"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"STRING"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Genesis verification key (hex-encoded)."
        )
  where
    deserialiseFromHex :: String -> Either String (VerificationKey GenesisKey)
    deserialiseFromHex :: [Char] -> Either [Char] (VerificationKey GenesisKey)
deserialiseFromHex =
      forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (\RawBytesHexError
e -> [Char]
"Invalid genesis verification key: " forall a. [a] -> [a] -> [a]
++ forall e. Error e => e -> [Char]
displayError RawBytesHexError
e)
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a.
SerialiseAsRawBytes a =>
AsType a -> ByteString -> Either RawBytesHexError a
deserialiseFromRawBytesHex (forall a. AsType a -> AsType (VerificationKey a)
AsVerificationKey AsType GenesisKey
AsGenesisKey)
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> ByteString
BSC.pack

pGenesisVerificationKeyOrFile :: Parser (VerificationKeyOrFile GenesisKey)
pGenesisVerificationKeyOrFile :: Parser (VerificationKeyOrFile GenesisKey)
pGenesisVerificationKeyOrFile =
  forall keyrole.
VerificationKey keyrole -> VerificationKeyOrFile keyrole
VerificationKeyValue forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (VerificationKey GenesisKey)
pGenesisVerificationKey
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall keyrole.
VerificationKeyFile -> VerificationKeyOrFile keyrole
VerificationKeyFilePath forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser VerificationKeyFile
pGenesisVerificationKeyFile

pGenesisVerificationKeyOrHashOrFile :: Parser (VerificationKeyOrHashOrFile GenesisKey)
pGenesisVerificationKeyOrHashOrFile :: Parser (VerificationKeyOrHashOrFile GenesisKey)
pGenesisVerificationKeyOrHashOrFile =
  forall keyrole.
VerificationKeyOrFile keyrole
-> VerificationKeyOrHashOrFile keyrole
VerificationKeyOrFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (VerificationKeyOrFile GenesisKey)
pGenesisVerificationKeyOrFile
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall keyrole. Hash keyrole -> VerificationKeyOrHashOrFile keyrole
VerificationKeyHash forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Hash GenesisKey)
pGenesisVerificationKeyHash

pGenesisDelegateVerificationKeyFile :: Parser VerificationKeyFile
pGenesisDelegateVerificationKeyFile :: Parser VerificationKeyFile
pGenesisDelegateVerificationKeyFile =
  [Char] -> VerificationKeyFile
VerificationKeyFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
      (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"genesis-delegate-verification-key-file"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Filepath of the genesis delegate verification key."
      forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
      )

pGenesisDelegateVerificationKeyHash :: Parser (Hash GenesisDelegateKey)
pGenesisDelegateVerificationKeyHash :: Parser (Hash GenesisDelegateKey)
pGenesisDelegateVerificationKeyHash =
    forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option
      (forall a. ([Char] -> Either [Char] a) -> ReadM a
Opt.eitherReader [Char] -> Either [Char] (Hash GenesisDelegateKey)
deserialiseFromHex)
        (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"genesis-delegate-verification-key-hash"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"STRING"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Genesis delegate verification key hash (hex-encoded)."
        )
  where
    deserialiseFromHex :: String -> Either String (Hash GenesisDelegateKey)
    deserialiseFromHex :: [Char] -> Either [Char] (Hash GenesisDelegateKey)
deserialiseFromHex =
      forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first
        (\RawBytesHexError
e ->
          [Char]
"Invalid genesis delegate verification key hash: " forall a. [a] -> [a] -> [a]
++ forall e. Error e => e -> [Char]
displayError RawBytesHexError
e)
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a.
SerialiseAsRawBytes a =>
AsType a -> ByteString -> Either RawBytesHexError a
deserialiseFromRawBytesHex (forall a. AsType a -> AsType (Hash a)
AsHash AsType GenesisDelegateKey
AsGenesisDelegateKey)
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> ByteString
BSC.pack

pGenesisDelegateVerificationKey :: Parser (VerificationKey GenesisDelegateKey)
pGenesisDelegateVerificationKey :: Parser (VerificationKey GenesisDelegateKey)
pGenesisDelegateVerificationKey =
    forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option
      (forall a. ([Char] -> Either [Char] a) -> ReadM a
Opt.eitherReader [Char] -> Either [Char] (VerificationKey GenesisDelegateKey)
deserialiseFromHex)
        (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"genesis-delegate-verification-key"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"STRING"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Genesis delegate verification key (hex-encoded)."
        )
  where
    deserialiseFromHex
      :: String
      -> Either String (VerificationKey GenesisDelegateKey)
    deserialiseFromHex :: [Char] -> Either [Char] (VerificationKey GenesisDelegateKey)
deserialiseFromHex =
      forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first
        (\RawBytesHexError
e -> [Char]
"Invalid genesis delegate verification key: " forall a. [a] -> [a] -> [a]
++ forall e. Error e => e -> [Char]
displayError RawBytesHexError
e)
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a.
SerialiseAsRawBytes a =>
AsType a -> ByteString -> Either RawBytesHexError a
deserialiseFromRawBytesHex (forall a. AsType a -> AsType (VerificationKey a)
AsVerificationKey AsType GenesisDelegateKey
AsGenesisDelegateKey)
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> ByteString
BSC.pack

pGenesisDelegateVerificationKeyOrFile
  :: Parser (VerificationKeyOrFile GenesisDelegateKey)
pGenesisDelegateVerificationKeyOrFile :: Parser (VerificationKeyOrFile GenesisDelegateKey)
pGenesisDelegateVerificationKeyOrFile =
  forall keyrole.
VerificationKey keyrole -> VerificationKeyOrFile keyrole
VerificationKeyValue forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (VerificationKey GenesisDelegateKey)
pGenesisDelegateVerificationKey
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall keyrole.
VerificationKeyFile -> VerificationKeyOrFile keyrole
VerificationKeyFilePath forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser VerificationKeyFile
pGenesisDelegateVerificationKeyFile

pGenesisDelegateVerificationKeyOrHashOrFile
  :: Parser (VerificationKeyOrHashOrFile GenesisDelegateKey)
pGenesisDelegateVerificationKeyOrHashOrFile :: Parser (VerificationKeyOrHashOrFile GenesisDelegateKey)
pGenesisDelegateVerificationKeyOrHashOrFile =
  forall keyrole.
VerificationKeyOrFile keyrole
-> VerificationKeyOrHashOrFile keyrole
VerificationKeyOrFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (VerificationKeyOrFile GenesisDelegateKey)
pGenesisDelegateVerificationKeyOrFile
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall keyrole. Hash keyrole -> VerificationKeyOrHashOrFile keyrole
VerificationKeyHash forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Hash GenesisDelegateKey)
pGenesisDelegateVerificationKeyHash

pKesVerificationKeyOrFile :: Parser (VerificationKeyOrFile KesKey)
pKesVerificationKeyOrFile :: Parser (VerificationKeyOrFile KesKey)
pKesVerificationKeyOrFile =
  forall keyrole.
VerificationKey keyrole -> VerificationKeyOrFile keyrole
VerificationKeyValue forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (VerificationKey KesKey)
pKesVerificationKey
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall keyrole.
VerificationKeyFile -> VerificationKeyOrFile keyrole
VerificationKeyFilePath forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser VerificationKeyFile
pKesVerificationKeyFile

pKesVerificationKey :: Parser (VerificationKey KesKey)
pKesVerificationKey :: Parser (VerificationKey KesKey)
pKesVerificationKey =
    forall a. ReadM a -> Mod OptionFields a -> Parser a
Opt.option
      (forall a. ([Char] -> Either [Char] a) -> ReadM a
Opt.eitherReader [Char] -> Either [Char] (VerificationKey KesKey)
deserialiseVerKey)
        (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"kes-verification-key"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"STRING"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"A Bech32 or hex-encoded hot KES verification key."
        )
  where
    asType :: AsType (VerificationKey KesKey)
    asType :: AsType (VerificationKey KesKey)
asType = forall a. AsType a -> AsType (VerificationKey a)
AsVerificationKey AsType KesKey
AsKesKey

    deserialiseVerKey :: String -> Either String (VerificationKey KesKey)
    deserialiseVerKey :: [Char] -> Either [Char] (VerificationKey KesKey)
deserialiseVerKey [Char]
str =
      case forall a.
SerialiseAsBech32 a =>
AsType a -> Text -> Either Bech32DecodeError a
deserialiseFromBech32 AsType (VerificationKey KesKey)
asType ([Char] -> Text
Text.pack [Char]
str) of
        Right VerificationKey KesKey
res -> forall a b. b -> Either a b
Right VerificationKey KesKey
res

        -- The input was valid Bech32, but some other error occurred.
        Left err :: Bech32DecodeError
err@(Bech32UnexpectedPrefix Text
_ Set Text
_) -> forall a b. a -> Either a b
Left (forall e. Error e => e -> [Char]
displayError Bech32DecodeError
err)
        Left err :: Bech32DecodeError
err@(Bech32DataPartToBytesError Text
_) -> forall a b. a -> Either a b
Left (forall e. Error e => e -> [Char]
displayError Bech32DecodeError
err)
        Left err :: Bech32DecodeError
err@(Bech32DeserialiseFromBytesError ByteString
_) -> forall a b. a -> Either a b
Left (forall e. Error e => e -> [Char]
displayError Bech32DecodeError
err)
        Left err :: Bech32DecodeError
err@(Bech32WrongPrefix Text
_ Text
_) -> forall a b. a -> Either a b
Left (forall e. Error e => e -> [Char]
displayError Bech32DecodeError
err)

        -- The input was not valid Bech32. Attempt to deserialise it as hex.
        Left (Bech32DecodingError DecodingError
_) ->
          forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first
            (\RawBytesHexError
e -> [Char]
"Invalid stake pool verification key: " forall a. [a] -> [a] -> [a]
++ forall e. Error e => e -> [Char]
displayError RawBytesHexError
e) forall a b. (a -> b) -> a -> b
$
          forall a.
SerialiseAsRawBytes a =>
AsType a -> ByteString -> Either RawBytesHexError a
deserialiseFromRawBytesHex AsType (VerificationKey KesKey)
asType ([Char] -> ByteString
BSC.pack [Char]
str)

pKesVerificationKeyFile :: Parser VerificationKeyFile
pKesVerificationKeyFile :: Parser VerificationKeyFile
pKesVerificationKeyFile =
  [Char] -> VerificationKeyFile
VerificationKeyFile forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    ( forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
        (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"kes-verification-key-file"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
Opt.metavar [Char]
"FILE"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. [Char] -> Mod f a
Opt.help [Char]
"Filepath of the hot KES verification key."
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. HasCompleter f => Completer -> Mod f a
Opt.completer ([Char] -> Completer
Opt.bashCompleter [Char]
"file")
        )
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    forall s. IsString s => Mod OptionFields s -> Parser s
Opt.strOption
        (  forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
Opt.long [Char]
"hot-kes-verification-key-file"
        forall a. Semigroup a => a -> a -> a
<> forall (f :: * -> *) a. Mod f a
Opt.internal
        )
    )

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
   pMa