h&54      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                 # Safe-Inferred;!#$%&'(),./01245789:;<>? 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. Safe-Inferred;!#$%&'(),./01245789:;<>?  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.   Safe-Inferred;!#$%&'(),./01245789:;<>?  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. morley-client/Add header, required by the Tezos RPC interface   Safe-Inferred;!#$%&'(),./01245789:;<>?f  morley-clientLike servant's  QueryParam1, but the value is fixed as a type-level string.   Safe-Inferred;!#$%&'(),./01245789:;<>?  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-client.Associate the given contract with alias. The  variable indicates whether or not we should replace already existing contract alias or not. 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-clientRegister a given address as delegate TODO [#869] move to HasTezosRpc 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.   Safe-Inferred;!#$%&'(),./01245789:;<>? morley-clientDesignates types whose  instance produces only  !s. "#$ "#$ Safe-Inferred;!#$%&'(),./01245789:;<>?.g&1 morley-clientResult storage of run_code RPC endpoint call.Actual resulting JSON has more contents, but currently we're interested only in resulting storage.4 morley-clientData required for calling run_code RPC endpoint.N morley-client:Contents of an operation that can appear in RPC responses.O morley-clientOperation with kind  transaction.P morley-clientOperation with kind that we don't support yet (but need to parse to something).Q morley-client $operation in Tezos docs.U morley-clientAll the data needed to perform key revealing through Tezos RPC interfaceX 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.htmle morley-client1Some operation data accompanied with common data.i morley-clientData that is common for transaction and origination operations.z morley-clientWe need to count number of destination contracts that are new to the chain in order to calculate proper storage_limit~ 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. morley-client4An operation assumed a contract counter in the past. 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. morley-client%Transfer of 0 to an implicit account. 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). morley-clientProtocol-wide constants.There are more constants, but currently, we are using only these in our code. morley-client,Byte size cost for originating new contract. morley-client!Gas limit for a single operation. morley-client%Storage limit for a single operation. morley-client?Minimal delay between two blocks, this constant is new in V010. 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-clientParse  in its textual representation in the same format as submitted via RPC. morley-clientp can be missing when default entrypoint is called with Unit value. Usually it happens when destination is an implicit account. In our structures p is not optional because missing case is equivalent to explicit calling of default with Unit. morley-clientCreate i 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?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~tuvwxyzQRSTijklmnoCDEF()*+,-./0@ABNOPJKLMGHI{|}XYZ[\]^_pqrsUVW456789:;<=>?123`abcdefgh%&'~  Safe-Inferred;!#$%&'(),./01245789:;<>?95  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 ~. 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-client#Smart or implicit 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.  Safe-Inferred;!#$%&'(),./01245789:;<>?E< morley-client?N> 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?Ok morley-client.We use this wrapper to avoid orphan instances." Safe-Inferred;!#$%&'(),./01245789:;<>?PM %&'()-,*+./012345?>=<;:9867@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`adbcefghijonmklpqrstuzyxvw{|}~  Safe-Inferred;!#$%&'(),./01245789:;<>?Y  morley-client Similar to , but retries once on timeout. morley-clientConvert a bytestring to a string assuming this bytestring stores something readable in UTF-8 encoding. morley-clientPretty print a servant2's request. Note that we print only some part of : method, request path and query, request body. We don't print other things that are subjectively less interesting such as HTTP version or media type. But feel free to add them if you want. morley-clientPretty print a servant's response. Note that we print only status and body, the rest looks not so interesting in our case.If response is not human-readable text in UTF-8 encoding it will print some garbage. Apparently we don't make such requests for now. 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-client Timeout for ,  and  helpers in microseconds. 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). Safe-Inferred;!#$%&'(),./01245789:;<>?Z Safe-Inferred;!#$%&'(),./01245789:;<>?a  morley-client(A structure with all the parameters for  morley-client8The parameter value should have the same "structure" as cp, except it _may_ also have big_map IDs. E.g. if the contract's parameter is 4pair (big_map string string) (big_map string string), then  may be one of: 4pair (big_map string string) (big_map string string)  pair nat (big_map string string)  pair (big_map string string) nat  pair nat nat ... where nat represents a big_map ID. morley-client6The storage value should have the same "structure" as st, except it _may_ also have big_map IDs. See the documentation of . 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 stdin Safe-Inferred;!#$%&'(),./01245789:;<>?f  morley-clientRuntime environment for  tezos-client bindings. 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-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-client For reading tezos-client config. morley-client?h( morley-client'Function to parse baker fee from given  tezos-client output. Safe-Inferred;!#$%&'(),./01245789:;<>?i 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.   Safe-Inferred;!#$%&'(),./01245789:;<>?}) morley-client5Datatype that represents modes for calling node from  tezos-client. morley-clientMode in which  tezos-client doesn't perform any actual RPC calls to the node and use mock instead. morley-clientNormal mode in which  tezos-client. performs all necessary RPC calls to the node. 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-client6Call tezos-client to list known addresses or contracts morley-clientReturn  corresponding to given . morley-clientReturn  corresponding to given . 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-client Variant of readProcessWithExitCode that prints a better error in case of an exception in the inner readProcessWithExitCode call. 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%%# Safe-Inferred;!#$%&'(),./01245789:;<>?~>  Safe-Inferred;!#$%&'(),./01245789:;<>? morley-client0Data necessary for morley client initialization. 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. Safe-Inferred;!#$%&'(),./01245789:;<>? morley-clientParser for the  morley-client executable. morley-clientParses URL of the Tezos node. morley-client$Generic parser to read an option of  type. morley-client!Utility reader to use in parsing .$$ Safe-Inferred;!#$%&'(),./01245789:;<>?  morley-clientThis exception is thrown when something goes wrong in supported methods. morley-clientThis exception is thrown in methods that are completely unsupported. 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.   Safe-Inferred;!#$%&'(),./01245789:;<>? morley-clientRun  action within given 1. Retry action in case of invalid counter error. Safe-Inferred;!#$%&'(),./01245789:;<>? 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-clientHandle a result of an operation: throw errors if there was an error, return a nonempty list of applied results if there weren't. 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.** Safe-Inferred;!#$%&'(),./01245789:;<>?  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-clientReturns strict bytes chunks that fit into transaction limits of the input. 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 creation Safe-Inferred;!#$%&'(),./01245789:;<>? morley-client?Type family which is used to determine the output type of the runOperationsNonEmptyHelper. morley-clientFlag that is used to determine runOperationsNonEmptyHelper behaviour. 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=How many times to retry if an operation fails after injection 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. morley-clientPerform non-empty sequence of operations and either dry-run and return estimated limits and fees or perform operation injection. Behaviour is defined via RunMode flag argument. Safe-Inferred;!#$%&'(),./01245789:;<>? 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  Safe-Inferred;!#$%&'(),./01245789:;<>? morley-clientReveal given key.This is a variation of key revealing method that tries to use solely RPC. TODO [#873] remove HasTezosClient dependency morley-client?Reveal given key. TODO [#873] remove HasTezosClient dependency Safe-Inferred;!#$%&'(),./01245789:;<>?  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 morley-clientChecks that the origination result for a single contract is indeed one.' Safe-Inferred;!#$%&'(),./01245789:;<>?3 Safe-Inferred;!#$%&'(),./01245789:;<>?   Safe-Inferred;!#$%&'(),./01245789:;<>?  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-client-All the provided input, in some sort of DList morley-client&Parser for output when it is available 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.1 Safe-Inferred;!#$%&'(),./01245789:;<>? 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-clientA helper to run some operation. It accepts 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.( Safe-Inferred<!#$%&'(),./01245789:;<>?)*+,-.,-/,-0,-1,-23456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWWXYZ[\\]^^_``abcdefghijkklmmnoppqrrstuvwxxyz{{|}}~                                                                                                                                                                 %=>?@DBCAE$%&&@,,-)     ((((((((morley-client-0.2.1-inplaceMorley.Client.Logging Morley.ClientMorley.Client.RPC.AesonMorley.Client.RPC.HttpClient!Morley.Client.RPC.QueryFixedParamMorley.Client.TezosClient.ClassMorley.Client.TypesMorley.Client.RPC.TypesMorley.Client.RPC.ErrorMorley.Client.RPC.ClassMorley.Client.RPC.GettersMorley.Client.RPC.APIMorley.Client.App$Morley.Client.Action.SizeCalculationMorley.Client.UtilMorley.Client.TezosClient.Types Morley.Client.TezosClient.ParserMorley.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.Batched Data.AesonObjectMorley.Client.RPCMorley.Client.TezosClient MorleyClientMMorleyClientEnvLTransactionDataMorley.Client.ActionPaths_morley_clientco-log-core-0.3.1.0-401f8a79e4dab1441384e4be380b2aa5acaa4301a2a7ceb7eec1113999555fef Colog.Core.IOlogFlushco-log-0.4.0.2-ff910e956f464f2710faa0394424a3124f27ccac2a394cd692ce140a56abd047 Colog.Message logExceptionlogError logWarninglogInfologDebugoptparse-applicative-0.16.1.0-2cced070c6f7f98f076734a566e2d3e941bd08b2b41f2d85447234fa6eef7e65Options.Applicative.Types ParserInfo WithClientLogClientLogActionmorleyClientAesonOptions newClientEnvQueryFixedParam$fHasClientm:>HasTezosClient signBytesgenKey genFreshKey revealKeyrememberContractresolveAddressMaybegetAliasregisterDelegategetKeyPassword OperationInfo OpTransfer OpOriginateOpRevealOperationInfoDescriptor TransferInfoOriginationInfo RevealInfo ToJSONObject$fToJSONObjectOperationInfo$fToJSONOperationInfo _OpTransfer _OpOriginate _OpRevealMonitorHeadsStepMonitorHeadsStopMonitorHeadsContinueCalcSize csProgram csStoragecsGascsLegacy ScriptSize ssScriptSize RunCodeResult rcrStorageRunCodercScript rcStoragercInputrcAmount rcBalance rcChainIdrcNowrcLevelrcSourcercPayerGetBigMapResultGetBigMapNotFound GetBigMapbmKeybmTypeOperationMetadataunOperationMetadataOperationRespWithMeta orwmResponse orwmMetadata OperationRespTransactionOpResp OtherOpRespBlockOperationboHash boContentsRevealOperation roPublicKeyOriginationOperation ooBalanceooScriptOriginationScriptosCode osStorageTransactionOperationtoAmount toDestination toParametersWithCommonOperationData wcoCommon wcoCustomCommonOperationData codSourcecodFee codCounter codGasLimitcodStorageLimitParametersInternal piEntrypointpiValue AppliedResultarConsumedMilliGas arStorageSizearPaidStorageDiffarOriginatedContractsarAllocatedDestinationContractsOperationResultOperationAppliedOperationFailed InternalErrorCounterInThePast UnrevealedKeyFailureRunError RuntimeErrorScriptRejectedBadContractParameterInvalidConstantInvalidContractInconsistentTypesInvalidPrimitiveInvalidSyntacticConstantErrorInvalidExpressionKindInvalidContractNotationUnexpectedContract IllFormedTypeUnexpectedOperationREEmptyTransactionScriptOverflowGasExhaustedOperationMutezAdditionOverflowMutezSubtractionUnderflowMutezMultiplicationOverflowCantPayStorageFee BalanceTooLowPreviouslyRevealedKeyNonExistingContractInvalidB58CheckProtocolParametersppOriginationSizeppHardGasLimitPerOperationppHardStorageLimitPerOperationppMinimalBlockDelay ppCostPerByteBlockIdHeadId FinalHeadId GenesisIdLevelId BlockHashId AtDepthId FeeConstantsfcBase fcMutezPerGasfcMutezPerOpByte BlockHash unBlockHash BlockHeader bhTimestampbhLevel bhPredecessorbhHashBlockHeaderNoHash bhnhTimestamp bhnhLevelbhnhPredecessorBlockConstants bcProtocol bcChainIdbcHeaderbcHash IntOpEvent ioeSourceioeTypeioeTag ioePayloadInternalOperationDataIODEvent IODIgnoredInternalOperationioDataioResult RunMetadatarmOperationResultrmInternalOperationResultsOperationContentunOperationContent OperationHashunOperationHashRunOperationResultrrOperationContentsPreApplyOperation paoProtocol paoBranch paoContents paoSignature RunOperation roOperation roChainIdRunOperationInternal roiBranch roiContents roiSignatureForgeOperationfoBranch foContentsOperationInputRPCInputmkCommonOperationData$fFromJSONIntOpEvent$fFromJSONInternalOperationData$fDefaultFeeConstants$fHasCLReaderBlockId$fBuildableBlockId$fToHttpApiDataBlockId$fBuildableRunError$fFromJSONRunError$fFromJSONInternalError$fBuildableInternalError$fMonoidAppliedResult$fSemigroupAppliedResult$fFromJSONOperationResult$fFromJSONInternalOperation$fFromJSONRunMetadata$fFromJSONOperationContent$fFromJSONRunOperationResult$fFromJSONCommonOperationData$fToJSONCommonOperationData!$fFromJSONWithCommonOperationData$fToJSONWithCommonOperationData$fToJSONObjectRevealOperation$fToJSONRevealOperation!$fOperationInfoDescriptorRPCInput$fFromJSONOperationMetadata$fShowAppliedResult$fShowInternalError$fShowRunError $fShowBlockId $fEqBlockId $fEqBlockHash$fOrdBlockHash$fShowBlockHash$fBuildableBlockHash$fToJSONBlockHash$fFromJSONBlockHash$fToHttpApiDataBlockHash$fEqOperationHash$fShowOperationHash$fFromJSONOperationHash$fBuildableOperationHash$fFromJSONOperationRespWithMeta$fFromJSONOperationResp$fFromJSONTransactionOperation"$fToJSONObjectTransactionOperation$fToJSONTransactionOperation$fFromJSONParametersInternal$fToJSONParametersInternal$fToJSONPreApplyOperation$fToJSONRunOperationInternal$fToJSONForgeOperation"$fToJSONObjectOriginationOperation$fToJSONOriginationOperation$fToJSONOriginationScript$fToJSONRunOperation$fToJSONGetBigMap$fToJSONCalcSize$fToJSONRunCode$fFromJSONBlockHeaderNoHash$fFromJSONScriptSize$fFromJSONBlockConstants$fFromJSONBlockHeader$fToJSONBlockHeader$fFromJSONProtocolParameters$fFromJSONBlockOperation$fFromJSONOriginationScript$fFromJSONGetBigMapResult$fFromJSONRunCodeResult _RuntimeError_ScriptRejected_BadContractParameter_InvalidConstant_InconsistentTypes_InvalidPrimitive_InvalidSyntacticConstantError_InvalidExpressionKind_InvalidContractNotation_UnexpectedContract_IllFormedType_UnexpectedOperation_REEmptyTransaction_ScriptOverflow_GasExhaustedOperation_PreviouslyRevealedKeywcoCommonDataLWaitForOperationErrorWaitForOperationBlockoutWaitForOperationStreamingErrorIncorrectRpcResponseRpcUnexpectedSizeRpcOriginatedNoContractsRpcNoOperationsRunRpcOriginatedMoreContractsUnexpectedErrorsUnexpectedRunErrorsUnexpectedInternalErrors RunCodeErrorsClientRpcErrorContractFailed BadParameterEmptyTransaction ShiftOverflow GasExhaustionKeyAlreadyRevealedClientInternalError$fExceptionClientRpcError$fBuildableClientRpcError$fExceptionRunCodeErrors$fBuildableRunCodeErrors$fExceptionUnexpectedErrors$fBuildableUnexpectedErrors$fExceptionIncorrectRpcResponse$fBuildableIncorrectRpcResponse $fExceptionWaitForOperationError $fBuildableWaitForOperationError$fShowWaitForOperationError$fShowIncorrectRpcResponse$fShowUnexpectedErrors$fShowRunCodeErrors$fShowClientRpcError HasTezosRpc getBlockHashgetCounterAtBlockgetBlockHeadergetScriptSizeAtBlockgetBlockConstantsgetBlockOperationsgetBlockOperationHashesgetProtocolParametersAtBlockrunOperationAtBlockpreApplyOperationsAtBlockforgeOperationAtBlockinjectOperationgetContractScriptAtBlockgetContractStorageAtBlockgetContractBigMapAtBlockgetBigMapValueAtBlockgetBigMapValuesAtBlockgetBalanceAtBlockgetDelegateAtBlockrunCodeAtBlock getChainIdgetManagerKeyAtBlockwaitForOperation ValueNotFoundValueDecodeFailurereadContractBigMapValuereadBigMapValueMaybereadBigMapValuereadAllBigMapValuesMaybereadAllBigMapValues getContractgetImplicitContractCountergetContractsParameterTypesgetContractStoragegetBigMapValuegetBigMapValues getHeadBlock getCountergetProtocolParameters runOperationpreApplyOperationsforgeOperationgetContractScriptgetContractBigMap getBalance getScriptSize getDelegaterunCode getManagerKey$$fBuildableContractGetCounterAttempt$$fExceptionContractGetCounterAttempt$fBuildableValueDecodeFailure$fExceptionValueDecodeFailure$fBuildableValueNotFound$fExceptionValueNotFound$fExceptionContractNotFound$fBuildableContractNotFound$fShowContractNotFound$fShowValueNotFound$fShowValueDecodeFailure$fShowContractGetCounterAttempt NodeMethods getScriptgetStorageAtBlock getBigMap monitorHeads nodeMethods$fToHttpApiDataKindedAddress'$fToHttpApiDataAddress'runRequestAcceptStatusImplthrowClientErrorImplgetBlockHashImplgetCounterImplgetBlockHeaderImplgetBlockConstantsImplgetBlockOperationsImplgetBlockOperationHashesImplgetProtocolParametersImplrunOperationImplpreApplyOperationsImplforgeOperationImplinjectOperationImplgetContractScriptImplgetContractStorageAtBlockImplgetContractBigMapImplgetScriptSizeAtBlockImplgetBigMapValueAtBlockImplgetBigMapValuesAtBlockImplgetBalanceImplgetDelegateImplgetManagerKeyImpl runCodeImplgetChainIdImplwaitForOperationImplretryOnTimeout failOnTimeoutretryOnceOnTimeoutwaitBeforeRetryhandleInvalidCounterRpc$fExceptionTimeoutError$fBuildableTimeoutError$fShowTimeoutErrorcomputeUntypedContractSizecomputeContractSizeRunContractParameters rcpContract rcpParameter rcpStorage rcpBalancercpNowrcpLevel rcpAmount rcpSender rcpSourcedisableAlphanetWarningepNameToTezosEpextractAddressesFromValuerunContractParameters withAmount withBalance withLevelwithNow withSender withSource runContractreadScrubbedBytesscrubbedBytesToStringTezosClientEnvtceEndpointUrltceTezosClientPathtceMbTezosClientDataDirTezosClientConfig tcEndpointUrlSecretKeyEncryptionUnencryptedKey EncryptedKey LedgerKeyCmdArgtoCmdArg$fCmdArgAddressOrAlias $fCmdArgAlias$fCmdArgOperationHash$fCmdArgBaseUrl$fCmdArgContract'$fCmdArgValue' $fCmdArgMutez$fCmdArgEpName$fCmdArgByteString$fCmdArgConstrainedAddress$fCmdArgKindedAddress$fCmdArgSecretKey$fCmdArgWord16 $fCmdArgText $fCmdArgText0$fFromJSONTezosClientConfig$fShowTezosClientConfig$fEqSecretKeyEncryption$fShowSecretKeyEncryptionCalcOriginationFeeDatacofdFrom cofdBalancecofdMbFromPassword cofdContract cofdStorage cofdBurnCapCalcTransferFeeDatactfdTo ctfdParamctfdEp ctfdAmountHasTezosClientEnvtezosClientEnvLtceEndpointUrlLtceMbTezosClientDataDirLtceTezosClientPathL$fToJSONCalcTransferFeeDataparseBakerFeeFromOutputparseSecretKeyEncryption$fBuildableFeeParserException$fExceptionFeeParserException,$fShowErrorComponentUnexpectedEncryptionType-$fBuildableSecretKeyEncryptionParserException&$fEqSecretKeyEncryptionParserException($fShowSecretKeyEncryptionParserException$fEqUnexpectedEncryptionType$fOrdUnexpectedEncryptionType$fShowUnexpectedEncryptionType$fEqFeeParserException$fShowFeeParserExceptionMorleyClientEnv'mceTezosClient mceLogAction mceSecretKey mceClientEnv mceClientEnvL mceLogActionL mceSecretKeyLmceTezosClientL#$fHasTezosClientEnvMorleyClientEnv'TezosClientErrorUnexpectedClientFailureUnknownAddressAliasUnknownAddressAlreadyRevealedInvalidOperationHashCounterIsAlreadyUsed EConnresetConfigParseErrorTezosClientCryptoParseErrorTezosClientParseAddressErrorTezosClientParseFeeError!TezosClientUnexpectedOutputFormatCantRevealContractContractSenderEmptyImplicitContract$TezosClientUnexpectedSignatureOutput#TezosClientParseEncryptionTypeError getPublicKey getSecretKey importKeygetTezosClientConfigcalcTransferFeecalcOriginationFee calcRevealFeecallTezosClientcallTezosClientStrictresolveAddress$fBuildableTezosClientError$fExceptionTezosClientError$fShowTezosClientError$fEqTezosClientErrorMorleyClientConfigmccEndpointUrlmccTezosClientPathmccMbTezosClientDataDir mccVerbosity mccSecretKey$fShowMorleyClientConfigmccEndpointUrlLmccMbTezosClientDataDirL mccSecretKeyLmccTezosClientPathL mccVerbosityLmkMorleyClientEnv mkLogActionmorley-1.18.0-inplace Morley.CLIaddressOrAliasOption parserInfo TransferArgstaSender taDestinationtaAmount taParametertaMbFeeGetScriptSizeArgs ssScriptFile ssStorage OriginateArgsoaMbContractFileoaContractNameoaInitialBalanceoaInitialStorageoaOriginateFromoaMbFee ClientArgsRaw Originate GetScriptSizeTransfer GetBalanceGetBlockHeaderGetBlockOperations ClientArgsmorleyClientInfoclientConfigParseroriginateArgsOptionmbContractFileOptioncontractNameOption 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 ocCounterbuildTxDataWithAliastoParametersInternalsmkOriginationScriptpreProcessOperationgetAppliedResultshandleOperationResultrevealKeyUnlessRevealed computeFee convergingFeecomputeStorageLimitupdateCommonData stubSignatureaddOperationPrefixprepareOpForInjection$fBuildableTransactionData$$fOperationInfoDescriptorClientInputLargeOriginatorStoreLargeOriginatorParamSomeLargeContractOriginatorLargeOriginationDatalargeOriginatorlargeContractDatamkLargeOriginationDatamkSomeLargeContractOriginatorlargeContractOriginatordivideValueInChunksmkOriginationLambdamkLargeOriginatorStoremkLargeOriginatorDatamkLargeOriginatorTransactionsretrieveLargeContractsDuplicateAliasResult runOperationsrunOperationsNonEmptydryRunOperationsNonEmpty$fOperationInfoDescriptorResult$fSingIRunModeRealRun$fSingIRunModeDryRun$fBuildableDuplicateAlias$fExceptionDuplicateAlias$fShowDuplicateAliasrunTransactionslRunTransactionstransfer lTransferLOriginationDatalodReplaceExistinglodName lodBalance lodContract lodStoragelodMbFeeoriginateContractsoriginateContractoriginateUntypedContractlOriginateContractslOriginateContractoriginateLargeContractsoriginateLargeContractoriginateLargeUntypedContractlOriginateLargeContractslOriginateLargeContract BatchingM BatchingErrorInsufficientOutput ExtraOutputUnexpectedElement runBatchingunsafeRunBatchingsubmitThenParse$fBuildableBatchingError$fApplicativeBatchingM$fFunctorBatchingMOperationsBatchunOperationsBatchrunTransactionMoriginateContractM revealKeyMrunOperationsBatch $fBuildableBatchedOperationError$fFunctorOperationsBatch$fApplicativeOperationsBatch Colog.MonadWithLogMessageColog.Core.Action LogActionaeson-2.0.3.0-e0f5ab06b7f6f1ab573ad563aed54aec5fca51ff6b361cecf3b07d9601efe081Data.Aeson.Types.InternalOptions fixRequestghc-prim GHC.TypesBoolbase GHC.MaybeNothingData.Aeson.Types.ToJSONToJSON parseBlockIddefaultParametersInternal Morley.Michelson.Untyped.AliasesContractKindedAddress'fromBS ppRequestservant-client-core-0.19-dd32a08c0621051646874ca2c5966b33454ec7cfca8f96481f66452028511548Servant.Client.Core.RequestRequest ppResponsetimeoutInterval$Morley.Michelson.Untyped.EntrypointsEpNameValue mtl-2.2.2Control.Monad.Reader.Class MonadReaderCallMode MockupMode ClientModeMorley.Tezos.Address.AliasAddressOrAliasMorley.Tezos.Address KindedAddressAlias callListKnownMorley.Tezos.Crypto PublicKey SecretKeyreadProcessWithExitCode' clientParserendpointOption blockIdOptionServant.Client.Core.BaseUrlBaseUrlMorleyOnlyRpcExceptionUnsupportedByOnlyRPCdivideInChunksMorley.Michelson.Typed.AliasesImplicitAddressContractAddress RunResultRunModeinjectionRetryCountrunOperationsNonEmptyHelpersingleOriginatedContractbInput bParseOutputGHC.BaseMonad Applicative runOperationMversiongetDataFileName getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDir