h&      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                      "None: "#$%&'(+-./12356789:<=>?Q morley-clientA specialization of  constraint to the  type. If we want to use another message type we can change this constraint and exported functions, presumably without breaking other code significantly. morley-client with fixed message parameter. morley-clientThis action can be used in combination with other actions to flush a handle every time you log anything.None: "#$%&'(+-./12356789:<=>?  morley-client We use these  to produce JSON encoding in the format that RPC expects. We are not using defaults from morley$ because we need a specific format.  None: "#$%&'(+-./12356789:<=>?  morley-client:Make servant client environment from morley client config.Note: Creating a new servant manager is a relatively expensive operation, so this function is not supposed to be called often.  None: "#$%&'(+-./12356789:<=>?  morley-clientLike servant's  QueryParam1, but the value is fixed as a type-level string.  None: "#$%&'(+-./12356789:<=>?   None: "#$%&'(+-./12356789:<=>?$# morley-clientResult storage of run_code RPC endpoint call.Actual resulting JSON has more contents, but currently we're interested only in resulting storage. morley-clientData required for calling run_code RPC endpoint., morley-client:Contents of an operation that can appear in RPC responses.- morley-clientOperation with kind  transaction.. morley-clientOperation with kind that we don't support yet (but need to parse to something)./ morley-client $operation in Tezos docs.3 morley-clientAll the data needed to perform key revealing through Tezos RPC interface6 morley-clientAll the data needed to perform contract origination through Tezos RPC interface> morley-clientAll the data needed to perform a transaction through Tezos RPC interface. For additional information, please refer to RPC documentation #http://tezos.gitlab.io/api/rpc.htmlC morley-clientData that is common for transaction and origination operations.T morley-clientWe need to count number of destination contracts that are new to the chain in order to calculate proper storage_limitX morley-clientErrors that are sent as part of an "Internal Server Error" response (HTTP code 500).We call them internal because of the HTTP code, but we shouldn't treat them as internal. They can be easily triggered by making a failing operation.Y morley-client4An operation assumed a contract counter in the past.Z morley-clientOne tried to apply a manager operation without revealing the manager public key.[ morley-client$Failure reported without specific id\ morley-clientErrors that are sent as part of operation result in an OK response (status 200). They are semi-formally defined as errors that can happen when a contract is executed and something goes wrong.j morley-client%Transfer of 0 to an implicit account.k morley-clientA contract failed due to the detection of an overflow. It seems to happen if a too big value is passed to shift instructions (as second argument).t morley-clientProtocol-wide constants.There are more constants, but currently, we are using only these in our code.v morley-client,Byte size cost for originating new contract.w morley-client!Gas limit for a single operation.x morley-client%Storage limit for a single operation.y morley-client?Minimal delay between two blocks, this constant is new in V010.z morley-clientBurn cost per storage byte{ morley-client'A block identifier as submitted to RPC.A block can be referenced by head, genesis, level or block hash| morley-client'Identifier referring to the head block.} morley-clientIdentifier of the most recent block guaranteed to have been finalized. See: https://web.archive.org/web/20220305165609/https://tezos.gitlab.io/protocols/tenderbake.html#operations~ morley-client*Identifier referring to the genesis block. morley-client-Identifier referring to a block by its level. morley-clientIdenfitier referring to a block by its hash in Base58Check notation. morley-client4Identifier of a block at specific depth relative to head. morley-clientThe whole block header. morley-clientDesignates an input RPC data that we supply to perform an operation. morley-clientCreate C based on current blockchain protocol parameters and sender info. This data is used for operation simulation.Fee isn't accounted during operation simulation, so it's safe to use zero amount. Real operation fee is calculated later using 'tezos-client'. morley-client?@ABCDEFGHIJKLMNOPQRSTUVWX[YZ\]^_`abcdefghijklmnopqrstuvwxyz{|}~NOPQRST{|}~/012CDEFGHI()*+%&',-.UVW6789:;<=JKLMtuvwxyz345 !"#$>?@AB\]^_`abcdefghijklmnopqrsX[YZNone: "#$%&'(+-./12356789:<=>?/  morley-clientErrors that we can throw when we get a response from a node that doesn't match our expectations. It means that either the node we are talking to misbehaves or our code is incorrect. morley-clientErrors that we don't expect to happen, but they can be reported by the server. morley-clientErrors that can happen during run_code endpoint call. These errors returned along with 500 code, so we have to handle them a bit differently in comparison to other run errors that are returned as a part of successful JSON response. morley-clientErrors that can happen in the RPC part when a user tries to make failing actions. morley-client$Smart contract execution has failed. morley-client7Parameter passed to a contract does not match its type. morley-client%Transfer of 0 to an implicit account. morley-client:A smart contract execution failed due to a shift overflow. morley-client5A smart contract execution failed due gas exhaustion. morley-client A key has already been revealed. morley-clientAn error that RPC considers internal occurred. These errors are considered internal by mistake, they are actually quite realistic and normally indicate bad user action. Currently we put X. here as is, because it's easy for a user of  morley-client to work with this type. In #284 we will consider more errors and maybe some of them will need to be mapped into something more user-friendly, then we will reconsider this approach. morley-clientSmart contract address. morley-client#Value the contract has failed with. morley-clientSmart contract address. morley-clientValue passed as parameter. morley-clientReceiver address. morley-clientSmart contract address. morley-clientSmart contract address. morley-client%The address corresponding to the key. None: "#$%&'(+-./12356789:<=>?9 morley-client?B morley-client2Failed to decode received value to the given type. morley-client,Read big_map value of given contract by key.!If the contract contains several big_map?C`None: "#$%&'(+-./12356789:<=>?D* $#"! %&'()*+,-./0123456789:;<=>?B@ACDIHGEFJKLMNOTSRPQUVWXZ[Y\srqponmlkjihgfedcba`_]^tuzyxvw{~|} None: "#$%&'(+-./12356789:<=>?J& morley-client Similar to , but retries once on timeout. morley-clientHelper function that retries a monadic action in case action hasn't succeed in . In case retry didn't help, error that indicates timeout is thrown. morley-clientHelper function that consider action failed in case of timeout, because it's unsafe to perform some of the actions twice. E.g. performing two  action can lead to a situation when operation is injected twice. morley-clientHelper function that retries action once in case of timeout. If retry ended up with timeout as well, action is considered failed. It's safe to retry read-only actions that don't update chain state or  tezos-client config/environment. morley-clientWait for a reasonable amount of time before retrying an action that failed due to invalid counter. The waiting time depends on protocol parameters. morley-clientRetry action if it failed due to invalid counter (already used one). None: "#$%&'(+-./12356789:<=>?O( morley-client(A structure with all the parameters for  morley-clientSets the environment variable for disabling tezos-client "not a mainnet" warning morley-clientConvert < to the textual representation used by RPC and tezos-client. morley-client/Extract all addresses value from given untyped .Note that it returns all values that can be used as an address. However, some of fetched values can never be used as an address. morley-clientInitializes the parameters for  with sensible defaults.Use the with*' lenses to set any optional parameters. morley-clientRun contract with given parameter and storage and get new storage without injecting anything to the chain. morley-clientFunction for relatively safe getting password from stdin. After reading bytes are converted to  ScrubbedBytes., thus it's harder to accidentally leak them. morley-clientConvert  ScrubbedBytes to String, so that it can be passed to  tezos-client as a stdinNone: "#$%&'(+-./12356789:<=>?[ morley-clientRuntime environment for  tezos-client bindings. morley-client3Optional prefix for aliases that will be passed to  tezos-client&. If you call some function and pass foo < to it when the prefix is provided, it will be prepened to foo. So  prefix.foo will be passed to  tezos-client. Note that the prefix will be only applied in functions such as   and ! that work directly with  tezos-client( contract cache and add addresses to it. morley-client4URL of tezos node on which operations are performed. morley-clientPath to tezos client binary through which operations are performed. morley-client$Path to tezos client data directory. morley-clientConfiguration maintained by  tezos-client , see its config subcommands (e. g. tezos-client config show8). Only the field we are interested in is present here. morley-client4Representation of address secret key encryption type morley-client"Representation of an address that  tezos-client7 uses. It can be an address itself or a textual alias. morley-client"Address itself, can be used as is. morley-client%Address alias, should be resolved by  tezos-client. morley-client Either an , or an . The difference is that = needs to be prefixed (if alias prefix is non-empty), while  doesn't. morley-clientA hint for constructing an alias when generating an address or remembering a contract. Resulting  most likely will differ from this as we tend to prefix aliases, but a user should be able to recognize your alias visually. For instance, passing "alice" as a hint may result into "myTest.alice" alias being created. morley-clientUnsafely extract  from . Do NOT use the result with . morley-client tezos-client can associate addresses with textual aliases. This type denotes such an alias. morley-clientUnsafely extract  from . Do NOT use the result with . morley-clientAn object that can be put as argument to a tezos-client command-line call. morley-client,Render an object as a command-line argument. morley-clientCoerce  to . Unless you know for a fact that prefix is empty, this is unsafe. morley-clientCoerce  to . Unless you know for a fact that prefix is empty, this is unsafe. morley-clientMake  from  morley-clientMake  from  morley-client Creates an  with the given address. morley-client For reading tezos-client config. morley-client?]5 morley-client'Function to parse baker fee from given  tezos-client output.None: "#$%&'(+-./12356789:<=>?f" morley-client*Type class that provides interaction with  tezos-client binary morley-clientSign an operation with  tezos-client. morley-clientGenerate a secret key and store it with given alias. If a key with this alias already exists, the corresponding address will be returned and no state will be changed. morley-client=Generate a secret key and store it with given alias. Unlike  this function overwrites the existing key when given alias is already stored. morley-client9Reveal public key associated with given implicit account. morley-clientWait until operation known by some hash is included into the chain. morley-client.Associate the given contract with alias. The  variable indicates whether or not we should replace already existing contract alias or not. morley-clientSaves  via  tezos-client+ with given alias or hint associated. The  variable indicates whether or not we should replace already existing alias key or not. The returned 5 is the alias under which the key will be accessible. morley-clientRetrieve an address from given address or alias. If address or alias does not exist returns  morley-client+Retrieve an alias from given address using  tezos-client. The primary (and probably only) reason this function exists is that tezos-client sign= command only works with aliases. It was reported upstream:  +https://gitlab.com/tezos/tezos/-/issues/836. morley-clientGet public key for given address. Public keys are often used when interacting with the multising contracts morley-client$Register a given address as delegate morley-clientRetrieve the current  tezos-client config. morley-client2Calculate fee for transfer using `--dry-run` flag. morley-client5Calculate fee for origination using `--dry-run` flag. morley-clientGet password for secret key associated with given address in case this key is password-protected. Obtained password is used in two places: * 1) In  signBytes call. * 2) in  revealKey call.None: "#$%&'(+-./12356789:<=>?h morley-client&Runtime environment for morley client. morley-clientEnvironment for  tezos-client. morley-clientAction used to log messages. morley-clientPass if you want to sign operations manually or leave it to tezos-client morley-client)Environment necessary to make HTTP calls.  None: "#$%&'(+-./12356789:<=>?z% morley-clientA data type for all  predicatable errors that can happen during  tezos-client usage. morley-client tezos-client call unexpectedly failed (returned non-zero exit code). The error contains the error code, stdout and stderr contents. morley-client*Could not find an address with given name. morley-clientCould not find an address. morley-client4Public key of the given address is already revealed. morley-clientCan't wait for inclusion of operation with given hash because the hash is invalid. morley-clientError that indicates when given counter is already used for given contract. morley-clientNetwork error with which  tezos-client fails from time to time. morley-client-A parse error occurred during config parsing. morley-client tezos-client8 produced a cryptographic primitive that we can't parse. morley-client tezos-client) produced an address that we can't parse. morley-client tezos-client. produced invalid output for parsing baker fee morley-client tezos-client: printed a string that doesn't match the format we expect. morley-client1Given alias is a contract and cannot be revealed. morley-clientGiven contract is a source of a transfer or origination operation. morley-client*Given alias is an empty implicit contract. morley-clienttezos-client sign bytes" produced unexpected output format morley-client tezos-client produced invalid output for parsing secret key encryption type. morley-client"Sign an arbtrary bytestring using  tezos-client3. Secret key of the address corresponding to give  must be known. morley-clientGenerate a new secret key and save it with given alias. If an address with given alias already exists, it will be returned and no state will be changed. morley-clientGenerate a new secret key and save it with given alias. If an address with given alias already exists, it will be removed and replaced with a fresh one. morley-clientReveal public key corresponding to the given alias. Fails if it's already revealed. morley-clientRegister alias as delegate morley-clientReturn  corresponding to given  , covered in Maybe . Return Nothing if address alias is unknown morley-clientReturn  corresponding to given . morley-clientReturn  corresponding to given . morley-clientThis function blocks until operation with given hash is included into blockchain. morley-client2Save a contract with given address and alias. If replaceExisting is False and a contract with given alias already exists, this function does nothing. morley-clientRead  tezos-client configuration. morley-client"Calc baker fee for transfer using  tezos-client. morley-client%Calc baker fee for origination using  tezos-client. morley-client#Calc baker fee for revealing using  tezos-client. Note that  tezos-client does not support passing an address here, at least at the moment of writing. morley-clientGet password for secret key associated with given address in case this key is password-protected morley-clientCall  tezos-client with given arguments. Arguments defined by config are added automatically. The second argument specifies what should be done in failure case. It takes stdout and stderr output. Possible handling: $Parse a specific error and throw it.Parse an expected error that shouldn't cause a failure. Return True in this case.#Detect an unexpected error, return False. In this case  will be throw. morley-client%Call tezos-client and expect success. morley-client0Prefix an alias with the value available in any . morley-clientReturn  corresponding to given . morley-client Exit code morley-clientstdout morley-clientstderr morley-client(Name of address which is eventually used morley-client0Address that is not present in local tezos cache morley-client/Address alias that has already revealed its key morley-client Raw counter morley-client Raw address morley-client!Address alias of implicit account morley-client"Address alias of implicit contract''"None: "#$%&'(+-./12356789:<=>?{None: "#$%&'(+-./12356789:<=>?  morley-client0Data necessary for morley client initialization. morley-client3Optional prefix for aliases that will be passed to  tezos-client. morley-client7URL of tezos endpoint on which operations are performed morley-clientPath to  tezos-client/ binary through which operations are performed morley-clientPath to  tezos-client data directory. morley-clientVerbosity level. 0 means that only important messages will be printed. The greater this value is, the more messages will be printed during execution. After some small unspecified limit increasing this value does not change anything. morley-client%Custom secret key to use for signing. morley-client Construct . tezos-client path is taken from , but can be overridden using MORLEY_TEZOS_CLIENT environment variable.Node data is taken from  tezos-client" config and can be overridden by .The rest is taken from  as is. morley-clientMake appropriate * based on verbosity specified by the user.None: "#$%&'(+-./12356789:<=>? morley-client$Generic parser to read an option of  type. morley-client!Utility reader to use in parsing .None: "#$%&'(+-./12356789:<=>? morley-clientMonad that implements  and  classes and can be used for high-level actions as an alternative to #. morley-clientEnvironment used by . morley-clientAction used to log messages. morley-client)Environment necessary to make HTTP calls. morley-client3In-memory secret keys that can be used for signing. morley-client Construct .Full 5 is not passed because we need just 2 things from it.(Log action is built the same way as for $.*All secret keys are passed as an argument. morley-clientRun  action within given 1. Retry action in case of invalid counter error.  None; "#$%&'(+-./012356789:<=>? morley-clientRun  action within given 1. Retry action in case of invalid counter error.None: "#$%&'(+-./12356789:<=>? morley-client4Standard operation input in morley-client interface. morley-client(Data for a single origination in a batch morley-client)Data for a single transaction in a batch. morley-client Helper for  and %. morley-clientDatatype that contains various values required for chain operations. morley-client1Block in which operations is going to be injected morley-client.Information about block: chain_id and protocol morley-clientInformation about fees morley-clientSender counter morley-clientBuilds 9 with additional info about receiver's alias, if present. morley-client>Preprocess chain operation in order to get required constants. morley-clientPerform runOperation or preApplyOperations and combine the results.If an error occurs, this function tries to turn errors returned by RPC into !. If it can't do the conversion,  will be thrown. morley-client-Reveal key for implicit address if necessary.7Throws an error if given address is a contract address. morley-clientCompute fee for operation. morley-client"convergingFee mkOperation countFee% tries to find the most minimal fee F and the respective operation Op so that mkOperation F = Op and countFee Op <= F. morley-clientCompute storage limit based on the results of the operations application and given ProtocolParameters. morley-clientUpdate common operation data based on preliminary run which estimates storage and gas limits and fee.Reference implementation adds 100 gas and 20 bytes to the limits for safety.))None: "#$%&'(+-./12356789:<=>?  morley-client#Storage of the originator contract. morley-client%Parameter of the originator contract. morley-client7Contains the 'Value heavy' with all the large contract big_maps and tickets, the , for it as well as the lambda to use there. morley-clientJust a utility type to hold  and its large contract . morley-clientLarge Originator contract.Only keeps track of the "owner" address and either - the heavy entries and packed lambda to do the generation (if still loading), or - the resulting address of the originated large contract.If the large contract was originated any call will result in a failure containing its address. Any call from an address that's not the "owner" will result in a failure. morley-client4Returns bytes that fit into transaction limits from .Note: these have the original order, meaning they should be given to the originator contract from last to first. morley-client3Generates the lambda to originate a large contract. morley-clientHelper to create a  . morley-clientMakes  of the 5 that will generate the large contract of the given  for the sender . morley-clientMakes all the ( to feed the origination lambda into a  from the  of the latter. morley-clientFetches back the 1 of the large contract generated by a completed  process. It also uses the large contract ( to associate it to the expected alias. morley-client%initial storage of the large contract morley-clientlarge contract morley-client+balance to tranfer during contract creation morley-client+instruction to recreate the initial storage morley-clientlarge contract morley-client+balance to tranfer during contract creationNone: "#$%&'(+-./12356789:<=>?p morley-client"Designates output of an operation. morley-clientPerform sequence of operations.Returns operation hash (or Nothing in case empty list was provided) and result of each operation (nothing for transactions and an address for originated contracts morley-client)Perform non-empty sequence of operations.Returns operation hash and result of each operation (nothing for transactions and an address for originated contracts). morley-client+Perform dry-run for sequence of operations. Returned  AppliedResult contains information about estimated limits, storage changes, etc. Additionally, estimated fees are returned.None: "#$%&'(+-./12356789:<=>?L morley-clientLorentz version of . morley-clientPerform sequence of transactions to the contract, each transactions should be defined via EntrypointParam t. Returns operation hash and block in which this operation appears or Nothing! in case empty list was provided. morley-clientLorentz version of None: "#$%&'(+-./12356789:<=>? morley-clientReveal given key.This is a variation of key revealing method that tries to use solely RPC. morley-clientReveal given key.None: "#$%&'(+-./12356789:<=>?U  morley-clientLorentz version of  morley-clientOriginate given contracts with given initial storages. Returns operation hash (or Nothing in case empty list was provided) and originated contracts' addresses. morley-clientOriginate single contract morley-client#Originate a single untyped contract morley-clientLorentz version of  morley-client!Originate single Lorentz contract morley-clientAutomated multi-step origination process for contracts that don't fit into the origination limit. See &Morley.Client.Action.Origination.Large. morley-client!Originate a single large contract morley-client)Originate a single untyped large contract morley-clientLorentz version of  morley-client)Originate a single large Lorentz contract&None: "#$%&'(+-./12356789:<=>?+/None: "#$%&'(+-./12356789:<=>? \]^_`abcdefghijklmnopqrs{|}~{|}~ \]^_`abcdefghijklmnopqrsNone: "#$%&'(+-./12356789:<=>? morley-client+Records operations to be executed in batch.'Chronologically, this works in 3 steps:Form the list of input items i;Perform the batch operation;Parse output items o into result a, maybe producing error e.However in code we usually want steps 1 and 3 to be grouped and step 2 to be delayed -  facilitates this separation. Note that  is fundamentally not a monad, rather just an applicative, because within a batch you cannot use result of one operation in another operation. morley-clientErrors that can occur during batching, usually because the underlying function that performs batch operation returns output that does not match the provided input. morley-clientThe function that executes the batch returned less elements in output than were provided at input. morley-clientThe function that executes the batch returned more elements in output than were provided at input. morley-clientUser-provided parsing method failed. Usually this means that output does not correspond to provided input. morley-clientRun recorded operations sequence using the given batch executor. morley-client Similar to , for cases when the given batch executor is guaranteed to return the output respective to the provided input. morley-client/This is the basic primitive for all actions in .It records that given input item should be put to batch, and once operation is actually performed, the result should be parsed with given method.1None: "#$%&'(+-./12356789:<=>? morley-client#Where the batched operations occur.Example: runOperationsBatch mySender $ do addr <- originateContractM ... runTransactionM ... return addr Note that this is not a  , rather an  - use -XApplicativeDo extension for nicer experience. morley-client#Perform transaction within a batch. morley-client#Perform origination within a batch. morley-client%Perform key revealing within a batch. morley-clientExecute a batch.'None; "#$%&'(+-./12356789:<=>?()*()+(),()-()./0123456789:;<=>?@ABCDDEFFGHIJKLMNOOPQQRSTUVWWXYZZ[\\]^__`abbcdeffghijkllmnoopqrstuvwxyz{|}~                                                                                                                                       !$ !#$%%(() ''''''''morley-client-0.1.2-inplaceMorley.Client.Logging Morley.ClientMorley.Client.RPC.AesonMorley.Client.RPC.HttpClient!Morley.Client.RPC.QueryFixedParamMorley.Client.TypesMorley.Client.RPC.TypesMorley.Client.RPC.ErrorMorley.Client.RPC.ClassMorley.Client.RPC.GettersMorley.Client.RPC.APIMorley.Client.AppMorley.Client.UtilMorley.Client.TezosClient.Types Morley.Client.TezosClient.ParserMorley.Client.TezosClient.ClassMorley.Client.EnvMorley.Client.TezosClient.ImplMorley.Client.InitMorley.Client.ParserMorley.Client.OnlyRPCMorley.Client.FullMorley.Client.Action.Common&Morley.Client.Action.Origination.LargeMorley.Client.Action.Operation Morley.Client.Action.TransactionMorley.Client.Action.Reveal Morley.Client.Action.OriginationMorley.Util.BatchingMorley.Client.Action.BatchedMorley.Client.RPCgenKeyrememberContractMorley.Client.TezosClient MorleyClientMMorleyClientEnvLTransactionDataMorley.Client.ActionPaths_morley_clientco-log-0.4.0.1-2133e6b1c1b5a9c001c6d15bc2dfb5e2a7f017b1aa560036ef3e8c64003b12ca Colog.Message logExceptionlogError logWarninglogInfologDebugoptparse-applicative-0.16.1.0-bd03f81a3b1d13ae7834403fafe2ff2fd9b28b3d967ca0f391246f0c199fafafOptions.Applicative.Types ParserInfo WithClientLogClientLogActionlogFlushmorleyClientAesonOptions newClientEnvQueryFixedParam$fHasClientm:> OperationInfo OpTransfer OpOriginateOpRevealOperationInfoDescriptor TransferInfoOriginationInfo RevealInfo _OpTransfer _OpOriginate _OpReveal RunCodeResult rcrStorageRunCodercScript rcStoragercInputrcAmount rcBalance rcChainIdrcSourcercPayerGetBigMapResultGetBigMapNotFound GetBigMapbmKeybmType OperationRespTransactionOpResp OtherOpRespBlockOperationboHash boContentsRevealOperation roPublicKeyOriginationOperation ooBalanceooScriptOriginationScriptosCode osStorageTransactionOperationtoAmount toDestination toParametersCommonOperationData codSourcecodFee codCounter codGasLimitcodStorageLimitParametersInternal piEntrypointpiValue AppliedResult arConsumedGas arStorageSizearPaidStorageDiffarOriginatedContractsarAllocatedDestinationContractsOperationResultOperationAppliedOperationFailed InternalErrorCounterInThePast UnrevealedKeyFailureRunError RuntimeErrorScriptRejectedBadContractParameterInvalidConstantInvalidContractInconsistentTypesInvalidPrimitiveInvalidSyntacticConstantErrorInvalidExpressionKindInvalidContractNotationUnexpectedContract IllFormedTypeUnexpectedOperationREEmptyTransactionScriptOverflowGasExhaustedOperationMutezAdditionOverflowMutezSubtractionUnderflowMutezMultiplicationOverflowCantPayStorageFee BalanceTooLowPreviouslyRevealedKeyNonExistingContractProtocolParametersppOriginationSizeppHardGasLimitPerOperationppHardStorageLimitPerOperationppMinimalBlockDelay ppCostPerByteBlockIdHeadId FinalHeadId GenesisIdLevelId BlockHashId AtDepthId FeeConstantsfcBase fcMutezPerGasfcMutezPerOpByte BlockHash unBlockHash BlockHeader bhTimestampbhLevel bhPredecessorbhHashBlockHeaderNoHash bhnhTimestamp bhnhLevelbhnhPredecessorBlockConstants bcProtocol bcChainIdbcHeaderbcHashInternalOperationunInternalOperation RunMetadatarmOperationResultrmInternalOperationResultsOperationContent OperationHashunOperationHashRunOperationResultrrOperationContentsPreApplyOperation paoProtocol paoBranch paoContents paoSignature RunOperation roOperation roChainIdRunOperationInternal roiBranch roiContents roiSignatureForgeOperationfoBranch foContentsOperationInput oiCommonDataoiCustomRPCInputcombineResultsmkCommonOperationData$fToJSONOperationInfo$fDefaultFeeConstants$fHasCLReaderBlockId$fBuildableBlockId$fToHttpApiDataBlockId$fBuildableRunError$fFromJSONRunError$fFromJSONInternalError$fBuildableInternalError$fMonoidAppliedResult$fSemigroupAppliedResult$fFromJSONOperationResult$fFromJSONInternalOperation$fFromJSONRunMetadata$fFromJSONOperationContent$fFromJSONRunOperationResult$fFromJSONCommonOperationData$fToJSONCommonOperationData$fToJSONOperationInput$fToJSONPreApplyOperation$fToJSONRunOperationInternal$fToJSONForgeOperation$fFromJSONTransactionOperation$fToJSONTransactionOperation$fToJSONOriginationOperation$fToJSONRevealOperation!$fOperationInfoDescriptorRPCInput$fFromJSONOperationResp$fShowAppliedResult$fShowInternalError$fShowRunError $fShowBlockId $fEqBlockId$fToJSONBlockHash$fFromJSONBlockHash$fEqOperationHash$fShowOperationHash$fFromJSONOperationHash$fBuildableOperationHash$fFromJSONParametersInternal$fToJSONParametersInternal$fToJSONOriginationScript$fToJSONRunOperation$fToJSONGetBigMap$fToJSONRunCode$fFromJSONBlockConstants$fFromJSONBlockHeaderNoHash$fFromJSONBlockHeader$fToJSONBlockHeader$fFromJSONProtocolParameters$fFromJSONBlockOperation$fFromJSONOriginationScript$fFromJSONGetBigMapResult$fFromJSONRunCodeResult _RuntimeError_ScriptRejected_BadContractParameter_InvalidConstant_InconsistentTypes_InvalidPrimitive_InvalidSyntacticConstantError_InvalidExpressionKind_InvalidContractNotation_UnexpectedContract_IllFormedType_UnexpectedOperation_REEmptyTransaction_ScriptOverflow_GasExhaustedOperation_PreviouslyRevealedKey oiCommonDataLIncorrectRpcResponseRpcUnexpectedSizeRpcOriginatedNoContractsRpcNoOperationsRunRpcOriginatedMoreContractsUnexpectedErrorsUnexpectedRunErrorsUnexpectedInternalErrors RunCodeErrorsClientRpcErrorContractFailed BadParameterEmptyTransaction ShiftOverflow GasExhaustionKeyAlreadyRevealedClientInternalError$fExceptionClientRpcError$fBuildableClientRpcError$fExceptionRunCodeErrors$fBuildableRunCodeErrors$fExceptionUnexpectedErrors$fBuildableUnexpectedErrors$fExceptionIncorrectRpcResponse$fBuildableIncorrectRpcResponse$fShowIncorrectRpcResponse$fShowUnexpectedErrors$fShowRunCodeErrors$fShowClientRpcError HasTezosRpc getBlockHashgetCounterAtBlockgetBlockHeadergetBlockConstantsgetBlockOperationsgetProtocolParametersAtBlockrunOperationAtBlockpreApplyOperationsAtBlockforgeOperationAtBlockinjectOperationgetContractScriptAtBlockgetContractStorageAtBlockgetContractBigMapAtBlockgetBigMapValueAtBlockgetBigMapValuesAtBlockgetBalanceAtBlockgetDelegateAtBlockrunCodeAtBlock getChainIdgetManagerKeyAtBlock ValueNotFoundValueDecodeFailurereadContractBigMapValuereadBigMapValueMaybereadBigMapValuereadAllBigMapValuesMaybereadAllBigMapValues getContractgetImplicitContractCountergetContractsParameterTypesgetContractStoragegetBigMapValuegetBigMapValues getHeadBlock getCountergetProtocolParameters runOperationpreApplyOperationsforgeOperationgetContractScriptgetContractBigMap getBalance getDelegaterunCode getManagerKey$$fBuildableContractGetCounterAttempt$$fExceptionContractGetCounterAttempt$fBuildableValueDecodeFailure$fExceptionValueDecodeFailure$fBuildableValueNotFound$fExceptionValueNotFound$fExceptionContractNotFound$fBuildableContractNotFound$fShowContractNotFound$fShowValueNotFound$fShowValueDecodeFailure$fShowContractGetCounterAttempt NodeMethods getScriptgetStorageAtBlock getBigMap nodeMethods$fToHttpApiDataAddress'runRequestAcceptStatusImplthrowClientErrorImplgetBlockHashImplgetCounterImplgetBlockHeaderImplgetBlockConstantsImplgetBlockOperationsImplgetProtocolParametersImplrunOperationImplpreApplyOperationsImplforgeOperationImplinjectOperationImplgetContractScriptImplgetContractStorageAtBlockImplgetContractBigMapImplgetBigMapValueAtBlockImplgetBigMapValuesAtBlockImplgetBalanceImplgetDelegateImplgetManagerKeyImpl runCodeImplgetChainIdImplretryOnTimeout failOnTimeoutretryOnceOnTimeoutwaitBeforeRetryhandleInvalidCounterRpc$fExceptionTimeoutError$fBuildableTimeoutError$fShowTimeoutErrorRunContractParameters rcpContract rcpParameter rcpStorage rcpBalance rcpAmount rcpSender rcpSourcedisableAlphanetWarningepNameToTezosEpextractAddressesFromValuerunContractParameters withAmount withBalance withSender withSource runContractreadScrubbedBytesscrubbedBytesToStringTezosClientEnvtceAliasPrefixtceEndpointUrltceTezosClientPathtceMbTezosClientDataDirTezosClientConfig tcEndpointUrlSecretKeyEncryptionUnencryptedKey EncryptedKey LedgerKeyAddressOrAliasAddressResolved AddressAliasAliasOrAliasHintAnAlias AnAliasHint AliasHintunsafeGetAliasHintTextAliasunsafeGetAliasTextCmdArgtoCmdArgunsafeCoerceAliasToAliasHintunsafeCoerceAliasHintToAliasmkAlias mkAliasHintaddressResolved$fCmdArgOperationHash$fCmdArgBaseUrl$fCmdArgContract'$fCmdArgValue' $fCmdArgMutez$fCmdArgEpName$fCmdArgByteString$fCmdArgAddress$fCmdArgSecretKey$fCmdArgWord16 $fCmdArgText $fCmdArgText0$fBuildableAddressOrAlias$fHasCLReaderAddressOrAlias$fCmdArgAddressOrAlias$fFromJSONTezosClientConfig$fShowTezosClientConfig$fEqSecretKeyEncryption$fShowSecretKeyEncryption$fShowAddressOrAlias$fEqAddressOrAlias$fOrdAddressOrAlias$fShowAliasOrAliasHint$fShowAliasHint$fIsStringAliasHint$fBuildableAliasHint$fSemigroupAliasHint$fMonoidAliasHint $fShowAlias $fEqAlias $fOrdAlias$fBuildableAlias $fCmdArgAliasCalcOriginationFeeDatacofdFrom cofdBalancecofdMbFromPassword cofdContract cofdStorage cofdBurnCapCalcTransferFeeDatactfdTo ctfdParamctfdEp ctfdAmountHasTezosClientEnvtezosClientEnvLtceAliasPrefixLtceEndpointUrlLtceMbTezosClientDataDirLtceTezosClientPathL$fToJSONCalcTransferFeeDataparseBakerFeeFromOutputparseSecretKeyEncryption$fBuildableFeeParserException$fExceptionFeeParserException,$fShowErrorComponentUnexpectedEncryptionType-$fBuildableSecretKeyEncryptionParserException&$fEqSecretKeyEncryptionParserException($fShowSecretKeyEncryptionParserException$fEqUnexpectedEncryptionType$fOrdUnexpectedEncryptionType$fShowUnexpectedEncryptionType$fEqFeeParserException$fShowFeeParserExceptionHasTezosClient signBytes genFreshKey revealKeywaitForOperation importKeyresolveAddressMaybegetAlias getPublicKeyregisterDelegategetTezosClientConfigcalcTransferFeecalcOriginationFeegetKeyPasswordMorleyClientEnv'mceTezosClient mceLogAction mceSecretKey mceClientEnv mceClientEnvL mceLogActionL mceSecretKeyLmceTezosClientL#$fHasTezosClientEnvMorleyClientEnv'TezosClientErrorUnexpectedClientFailureUnknownAddressAliasUnknownAddressAlreadyRevealedInvalidOperationHashCounterIsAlreadyUsed EConnresetConfigParseErrorTezosClientCryptoParseErrorTezosClientParseAddressErrorTezosClientParseFeeError!TezosClientUnexpectedOutputFormatCantRevealContractContractSenderEmptyImplicitContract$TezosClientUnexpectedSignatureOutput#TezosClientParseEncryptionTypeErrorwaitForOperationInclusion calcRevealFeecallTezosClientcallTezosClientStrict prefixName prefixNameMresolveAddress$fBuildableTezosClientError$fExceptionTezosClientError$fShowTezosClientError$fEqTezosClientErrorMorleyClientConfigmccAliasPrefixmccEndpointUrlmccTezosClientPathmccMbTezosClientDataDir mccVerbosity mccSecretKey$fShowMorleyClientConfigmccAliasPrefixLmccEndpointUrlLmccMbTezosClientDataDirL mccSecretKeyLmccTezosClientPathL mccVerbosityLmkMorleyClientEnv mkLogActionmorley-1.16.4-inplace Morley.CLI parserInfo TransferArgstaSender taDestinationtaAmount taParametertaMbFee OriginateArgsoaMbContractFileoaContractNameoaInitialBalanceoaInitialStorageoaOriginateFromoaMbFee ClientArgsRaw OriginateTransfer GetBalanceGetBlockHeaderGetBlockOperations ClientArgsmorleyClientInfoclientConfigParseraddressOrAliasOptionoriginateArgsOptionmbContractFileOptioncontractNameOption baseUrlReaderMorleyOnlyRpcMunMorleyOnlyRpcMMorleyOnlyRpcEnv moreLogAction moreClientEnvmoreSecretKeysmkMorleyOnlyRpcEnvrunMorleyOnlyRpcM$fHasTezosRpcMorleyOnlyRpcM$fRunClientMorleyOnlyRpcM)$fHasLogMorleyOnlyRpcEnvMsgMorleyOnlyRpcM$fExceptionUnsupportedByOnlyRPC$fHasTezosClientMorleyOnlyRpcM!$fExceptionMorleyOnlyRpcException$fShowMorleyOnlyRpcException$fEqMorleyOnlyRpcException$fShowUnsupportedByOnlyRPC$fEqUnsupportedByOnlyRPC$fFunctorMorleyOnlyRpcM$fApplicativeMorleyOnlyRpcM$fMonadMorleyOnlyRpcM+$fMonadReaderMorleyOnlyRpcEnvMorleyOnlyRpcM$fMonadIOMorleyOnlyRpcM$fMonadThrowMorleyOnlyRpcM$fMonadCatchMorleyOnlyRpcM$fMonadMaskMorleyOnlyRpcM$fMonadUnliftIOMorleyOnlyRpcMrunMorleyClientM$fHasTezosRpcMorleyClientM$fRunClientMorleyClientM$fHasTezosClientMorleyClientM($fHasLogMorleyClientEnv'MsgMorleyClientM$fFunctorMorleyClientM$fApplicativeMorleyClientM$fMonadMorleyClientM*$fMonadReaderMorleyClientEnv'MorleyClientM$fMonadIOMorleyClientM$fMonadThrowMorleyClientM$fMonadCatchMorleyClientM$fMonadMaskMorleyClientM$fMonadUnliftIOMorleyClientM ClientInput RevealData rdPublicKeyrdMbFeeOriginationDataodReplaceExistingodName odBalance odContract odStorageodMbFeeTransactionDataTD tdReceivertdAmounttdEpNametdParamtdMbFeeOperationConstantsocLastBlockHashocBlockConstantsocFeeConstants ocCounterbuildTxDataWithAliastoParametersInternalsmkOriginationScriptpreProcessOperationgetAppliedResultsrevealKeyUnlessRevealed computeFee convergingFeecomputeStorageLimitupdateCommonData stubSignatureaddOperationPrefixprepareOpForInjection$fBuildableTransactionData$$fOperationInfoDescriptorClientInputLargeOriginatorStoreLargeOriginatorParamSomeLargeContractOriginatorLargeOriginationDatalargeOriginatorlargeContractDatamkLargeOriginationDatamkSomeLargeContractOriginatorlargeContractOriginatordivideValueInChunksmkOriginationLambdamkLargeOriginatorStoremkLargeOriginatorDatamkLargeOriginatorTransactionsretrieveLargeContractsResult runOperationsrunOperationsNonEmptydryRunOperationsNonEmpty$fOperationInfoDescriptorResult$fSingIRunModeRealRun$fSingIRunModeDryRunrunTransactionslRunTransactionstransfer lTransferLOriginationDatalodReplaceExistinglodName lodBalance lodContract lodStoragelodMbFeeoriginateContractsoriginateContractoriginateUntypedContractlOriginateContractslOriginateContractoriginateLargeContractsoriginateLargeContractoriginateLargeUntypedContractlOriginateLargeContractslOriginateLargeContract BatchingM BatchingErrorInsufficientOutput ExtraOutputUnexpectedElement runBatchingunsafeRunBatchingsubmitThenParse$fBuildableBatchingError$fApplicativeBatchingM$fFunctorBatchingMOperationsBatchunOperationsBatchrunTransactionMoriginateContractM revealKeyMrunOperationsBatch $fBuildableBatchedOperationError$fFunctorOperationsBatch$fApplicativeOperationsBatch Colog.MonadWithLogMessageco-log-core-0.2.1.1-a28e10d5f051c4fdbb82677f9197f0c0ad889f4622545a23adbd2429c103ccb1Colog.Core.Action LogActionaeson-1.5.6.0-94ff836416b0ed15812e469a59ceb55147411bf7e2545cc06265a382f78d5410Data.Aeson.Types.InternalOptionsbase GHC.MaybeNothing Morley.Michelson.Untyped.AliasesContracttimeoutInterval$Morley.Michelson.Untyped.EntrypointsEpNameValue text-1.2.4.1Data.Text.InternalText mtl-2.2.2Control.Monad.Reader.Class MonadReaderghc-prim GHC.TypesBoolMorley.Tezos.Crypto SecretKeyMorley.Tezos.AddressAddress PublicKeyservant-client-core-0.18.3-a776d38bc5db4cf291ad9c7ba4f7ba93ed28ff43b7da997de9ddb420be952724Servant.Client.Core.BaseUrlBaseUrlMorley.Michelson.Typed.AliasesGHC.BaseMonad Applicativeversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName