h&ٙ      !"#$%&'()*+,-./0123456789:;< = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                                                                                                                                                                                                                                                                    # 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-client0Data necessary for morley client initialization.  morley-client7URL of tezos endpoint on which operations are performed  morley-clientPath to  octez-client/ binary through which operations are performed  morley-clientPath to  octez-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-clientMake appropriate * based on verbosity specified by the user.   Safe-Inferred;!#$%&'(),./01245789:;<>?f 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:;<>? morley-clientLike servant's  QueryParam1, but the value is fixed as a type-level string. Safe-Inferred;!#$%&'(),./01245789:;<>?!O  morley-client*Type class that provides interaction with  octez-client binary morley-clientSign an operation with  octez-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-clientRetrieves a list with all known aliases and respective addresses.Note that an alias can be ambiguous: it can refer to BOTH a contract and an implicit account. When an alias "abc" is ambiguous, the list will contain two entries: '("abc", "KT1...") ("key:abc", "tz1...")+TODO [#910]: Cache this and turn it into a  !." 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.# morley-client,How to save the originated contract address.$ morley-client1Don't save the newly originated contract address.% morley-clientIf an alias already exists, keep it, don't save the newly originated contract address.& morley-clientIf an alias already exists, replace it with the address of the newly originated contract.' morley-clientIf an alias already exists, throw an exception without doing the origination  "!#$%&'  "!#$%&' Safe-Inferred;!#$%&'(),./01245789:;<>?"95 morley-clientDesignates types whose  instance produces only "#s.+,-./01234589:;501234+,-./89:;  Safe-Inferred;!#$%&'(),./01245789:;<>?8)H morley-clientResult storage of run_code RPC endpoint call.Actual resulting JSON has more contents, but currently we're interested only in resulting storage.K morley-clientData required for calling run_code RPC endpoint.e morley-client:Contents of an operation that can appear in RPC responses.f morley-clientOperation with kind  transaction.g morley-clientOperation with kind that we don't support yet (but need to parse to something).h morley-client $operation in Tezos docs.n morley-client removes delegate,  sets ito morley-clientAll the data needed to perform key revealing through Tezos RPC interfacer 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.html morley-client1Some operation data accompanied with common data. morley-clientData that is common for transaction and origination operations. 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-client Details of a BadStack error. 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-clientGas limit for a single block. 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-client can be missing when default entrypoint is called with Unit value. Usually it happens when destination is an implicit account. In our structures  is not optional because missing case is equivalent to explicit calling of default with Unit. morley-clientCreate  based on current blockchain protocol parameters and sender info. This data is used for operation simulation.num_operations= parameter can be used for smarter gas limit estimation. If , the gas limit is set to , but that puts a hard low limit on the number of operations that will fit into one batch. If num_operations' is set, then gas limit is estimated as \mathrm{min}\left(\mathbf{hard\_gas\_limit\_per\_operation}, \left\lceil \frac{\mathbf{hard\_gas\_limit\_per\_block}} {num\_operations}\right\rceil\right) This works well enough for the case of many small operations, but will break when there is one big one and a lot of small ones. That said, specifying num_operations will work in all cases where not specifying it would, and then some, so it's recommended to specify it whenever possible.num_operations is assumed to be greater than 0', otherwise it'll be silently ignored.Fee isn't accounted during operation simulation, so it's safe to use zero amount. Real operation fee is calculated later using  octez-client. morley-client?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~hijklmnZ[\]?@ABCDEFGWXYefgabcd^_`rstuvwxyzopqKLMNOPQRSTUVHIJ{|}~<=>  Safe-Inferred;!#$%&'(),./01245789:;<>?C  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-client"Address not registered as delegate 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. morley-clientThe address in question.  Safe-Inferred;!#$%&'(),./01245789:;<>?O morley-client?X 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?Y morley-client.We use this wrapper to avoid orphan instances.$ Safe-Inferred;!#$%&'(),./01245789:;<>?Z<=>?@DCABEFGHIJKLVUTSRQPOMNWXYZ[\]^_`abcdefghijklmnopqrsvtuwxyz{|}~ Safe-Inferred;!#$%&'(),./01245789:;<>?d  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  octez-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:;<>?h  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:;<>?i Safe-Inferred;!#$%&'(),./01245789:;<>?k  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:;<>?r  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-client,Sets the environment variable for disabling  octez-client's "not a mainnet" warning morley-clientConvert / to the textual representation used by RPC and  octez-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  octez-client as a stdin Safe-Inferred;!#$%&'(),./01245789:;<>?w  morley-clientRuntime environment for  octez-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  octez-client , see its config subcommands (e. g. octez-client config show8). Only the field we are interested in is present here. morley-client4Representation of address secret key encryption type morley-client+An object that can be put as argument to a  octez-client command-line call. morley-client,Render an object as a command-line argument. morley-client For reading  octez-client config. morley-client?y morley-client'Function to parse baker fee from given  octez-client output. Safe-Inferred;!#$%&'(),./01245789:;<>?0 morley-clientWhether an alias is associated with an implicit address, a contract address, or both. morley-client/Looks up the address associated with the given addressOrAlias."When the alias is associated with both$ an implicit and a contract address:The  instance will throw a ', unless the alias is prefixed with  implicit: or  contract: to disambiguate.The : instance will return the address with the requested kind. morley-client-Looks up the alias associated with the given addressOrAlias."When the alias is associated with both$ an implicit and a contract address:The  instance will throw a (, unless the alias is prefixed with  implicit: or  contract: to disambiguate.The  instance will return the alias of the address with the requested kind.The primary (and probably only) reason this function exists is that octez-client sign> command only works with aliases. It was reported upstream:  +https://gitlab.com/tezos/tezos/-/issues/836. morley-client5Datatype that represents modes for calling node from  octez-client. morley-clientMode in which  octez-client doesn't perform any actual RPC calls to the node and use mock instead. morley-clientNormal mode in which  octez-client. performs all necessary RPC calls to the node. morley-clientA data type for all  predicatable errors that can happen during  octez-client usage. morley-client octez-client call unexpectedly failed (returned non-zero exit code). The error contains the error code, stdout and stderr contents. 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  octez-client fails from time to time. morley-client-A parse error occurred during config parsing. morley-client octez-client8 produced a cryptographic primitive that we can't parse. morley-client octez-client) produced an address that we can't parse. morley-client octez-client. produced invalid output for parsing baker fee morley-client octez-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-clientoctez-client sign bytes" produced unexpected output format morley-client octez-client produced invalid output for parsing secret key encryption type. morley-client3Tried to save alias, but such alias already exists. morley-clientExpected an alias to be associated with either an implicit address or a contract address, but it was associated with both. morley-clientExpected an alias to be associated with either an implicit address or a contract address, but it was associated with a transaction rollup address. morley-client"Sign an arbtrary bytestring using  octez-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-clientCall  octez-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  octez-client configuration. morley-client"Calc baker fee for transfer using  octez-client. morley-client%Calc baker fee for origination using  octez-client. morley-client#Calc baker fee for revealing using  octez-client. Note that  octez-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  octez-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-clientCall  octez-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-client/Looks up the address associated with the given addressOrAlias. Will throw a  if addressOrAlias is an alias and:the alias does not exist.6the alias exists but its address is of the wrong kind."When the alias is associated with both$ an implicit and a contract address:The  instance will throw a ', unless the alias is prefixed with  implicit: or  contract: to disambiguate.The : instance will return the address with the requested kind. morley-client/Looks up the address associated with the given addressOrAlias. Will return  if addressOrAlias is an alias and:the alias does not exist.6the alias exists but its address is of the wrong kind."When the alias is associated with both$ an implicit and a contract address:The  instance will throw a ', unless the alias is prefixed with  implicit: or  contract: to disambiguate.The : instance will return the address with the requested kind. morley-client-Looks up the alias associated with the given addressOrAlias. Will throw a  if addressOrAlias:4is an address that is not associated with any alias. is an alias that does not exist.=is an alias that exists but its address is of the wrong kind."When the alias is associated with both$ an implicit and a contract address:The  instance will throw a (, unless the alias is prefixed with  implicit: or  contract: to disambiguate.The  instance will return the alias. morley-client-Looks up the alias associated with the given addressOrAlias. Will return  if addressOrAlias:4is an address that is not associated with any alias. is an alias that does not exist.=is an alias that exists but its address is of the wrong kind."When the alias is associated with both$ an implicit and a contract address:The  instance will throw a (, unless the alias is prefixed with  implicit: or  contract: to disambiguate.The  instance will return the alias. morley-clientFinds the implicit/contract addresses assigned to the given alias.5Note that an alias can be ambiguous: it can refer to both a contract and an implicit account. When an alias "abc" is ambiguous, !octez-client list known contracts3 will return two entries with the following format: abc: KT1... key:abc: tz1...So, in order to check whether the alias is ambiguous, we check whether both "abc" and "key:abc" are present in the output.If only "abc" is present, then we know it's not ambiguous (and it refers to either$ a contract or an implicit account). morley-clientCalls !octez-client list known contracts and returns a list of (alias, address) pairs.5Note that an alias can be ambiguous: it can refer to both a contract and an implicit account. When an alias "abc" is ambiguous, the list will contain two entries: '("abc", "KT1...") ("key:abc", "tz1...") morley-client+Could not find an address with given alias. morley-clientExpected an alias to be associated with an implicit address, but it was associated with a contract address, or vice-versa. morley-client+Could not find an alias with given address. morley-client Exit code morley-clientstdout morley-clientstderr 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:;<>?u!" #$%&'$#$%&' Safe-Inferred;!#$%&'(),./01245789:;<>? morley-client&Runtime environment for morley client. morley-clientEnvironment for  octez-client. morley-clientAction used to log messages. morley-client=Pass if you want to sign operations manually or leave it to  octez-client. morley-client)Environment necessary to make HTTP calls. morley-clientRun  action within given 1. Retry action in case of invalid counter error. morley-client Construct . octez-client path is taken from  , but can be overridden using MORLEY_TEZOS_CLIENT environment variable.Node data is taken from  octez-client" config and can be overridden by  .The rest is taken from   as is.   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-When an error happens, we will get a list of  in response. This list often contains more than one item. We tested which errors are returned in certain scenarios and added handling of such scenarios here. We don't rely on any specific order of errors and on the number of errors. For example, in case of bad parameter this number can be different. 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.00 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:;<>?u 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. Returns operation hash and a list of RPC responses, or $ in case an empty list was provided. morley-clientPerform sequence of transactions to the contract. Returns operation hash and a list of RPC responses. morley-clientLorentz version of  Safe-Inferred;!#$%&'(),./01245789:;<>? morley-clientReveal given key.Note that sender is implicitly defined by the key being revealed, as you can only reveal your own key.This is a variation of key revealing method that tries to use solely RPC. morley-clientReveal given key.Note that sender is implicitly defined by the key being revealed, as you can only reveal your own key. 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:;<>?Q morley-client> setDelegateOp bob charly, * Become a registered delegate himself: registerDelegateOp bob%Smart Contracts can also delegate to registered delegates, but can't be registered delegates themselves. morley-clientRegister the sender as its delegate and become a "registered delegate" Alias for "setDelegateOp sender (Just sender)) Safe-Inferred;!#$%&'(),./01245789:;<>?5 Safe-Inferred;!#$%&'(),./01245789:;<>?˻  "!#$%&'+,-./01234 +,-./01234 "!#$%&' 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./2./3./456789::;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk l m n o o p q r s t t u v v w x x y z { | } ~                                                                                                                                                                                                                                                                                                                                                                                                                               LMNOPRQ%&&((O../+    ********morley-client-0.3.0-inplaceMorley.Client.Logging Morley.ClientMorley.Client.InitMorley.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.AppMorley.Client.OnlyRPC$Morley.Client.Action.SizeCalculationMorley.Client.ParserMorley.Client.UtilMorley.Client.TezosClient.Types Morley.Client.TezosClient.ParserMorley.Client.TezosClient.ImplMorley.Client.FullMorley.Client.Action.Common&Morley.Client.Action.Origination.LargeMorley.Client.Action.Operation Morley.Client.Action.TransactionMorley.Client.Action.Reveal Morley.Client.Action.OriginationMorley.Client.Action.DelegationMorley.Util.BatchingMorley.Client.Action.Batched Morley.UtilBimap Data.AesonObjectMorley.Client.RPC MorleyClientMMorleyClientEnvMorley.Client.TezosClientLTransactionDataMorley.Client.ActionPaths_morley_clientco-log-core-0.3.2.0-fad404ce86eddb1d1c4f905c254a128b894f353d6d4e57091a003b71ace7eee0 Colog.Core.IOlogFlushco-log-0.5.0.0-97f3fde2fdf8c1ac9b35e5940b545b66918d20a119abfa9f05eab95ed2dc01af Colog.Message logExceptionlogError logWarninglogInfologDebugoptparse-applicative-0.16.1.0-2cced070c6f7f98f076734a566e2d3e941bd08b2b41f2d85447234fa6eef7e65Options.Applicative.Types ParserInfo WithClientLogClientLogActionMorleyClientConfigmccEndpointUrlmccTezosClientPathmccMbTezosClientDataDir mccVerbosity mccSecretKey$fShowMorleyClientConfigmccEndpointUrlLmccMbTezosClientDataDirL mccSecretKeyLmccTezosClientPathL mccVerbosityL mkLogActionmorleyClientAesonOptions newClientEnvQueryFixedParam$fHasClientm:>HasTezosClient signBytesgenKey genFreshKey revealKeyrememberContractgetAliasesAndAddressesgetKeyPassword AliasBehavior DontSaveAliasKeepDuplicateAliasOverwriteDuplicateAliasForbidDuplicateAlias$fEqAliasBehavior$fOrdAliasBehavior$fEnumAliasBehavior OperationInfo OpTransfer OpOriginateOpReveal OpDelegationOperationInfoDescriptor TransferInfoOriginationInfo RevealInfoDelegationInfo ToJSONObject$fToJSONObjectOperationInfo$fToJSONOperationInfo _OpTransfer _OpOriginate _OpReveal _OpDelegationMonitorHeadsStepMonitorHeadsStopMonitorHeadsContinueCalcSize csProgram csStoragecsGascsLegacy ScriptSize ssScriptSize RunCodeResult rcrStorageRunCodercScript rcStoragercInputrcAmount rcBalance rcChainIdrcNowrcLevelrcSourcercPayerGetBigMapResultGetBigMapNotFound GetBigMapbmKeybmTypeOperationMetadataunOperationMetadataOperationRespWithMeta orwmResponse orwmMetadata OperationRespTransactionOpResp OtherOpRespBlockOperationboHash boContentsDelegationOperation doDelegateRevealOperation roPublicKeyOriginationOperation ooBalance ooDelegateooScriptOriginationScriptosCode osStorageTransactionOperationtoAmount toDestination toParametersWithCommonOperationData wcoCommon wcoCustomCommonOperationData codSourcecodFee codCounter codGasLimitcodStorageLimitParametersInternal piEntrypointpiValue AppliedResultarConsumedMilliGas arStorageSizearPaidStorageDiffarOriginatedContractsarAllocatedDestinationContractsOperationResultOperationAppliedOperationFailed InternalErrorCounterInThePast UnrevealedKeyFailureRunError RuntimeErrorScriptRejectedBadContractParameterInvalidConstantInvalidContractInconsistentTypesInvalidPrimitiveInvalidSyntacticConstantErrorInvalidExpressionKindInvalidContractNotationUnexpectedContract IllFormedTypeUnexpectedOperationREEmptyTransactionScriptOverflowGasExhaustedOperationMutezAdditionOverflowMutezSubtractionUnderflowMutezMultiplicationOverflowCantPayStorageFee BalanceTooLowPreviouslyRevealedKeyNonExistingContractInvalidB58CheckUnregisteredDelegateFailedUnDelegationDelegateAlreadyActiveIllTypedContract IllTypedDataBadStackForbiddenZeroAmountTicketProtocolParametersppOriginationSizeppHardGasLimitPerOperationppHardStorageLimitPerOperationppMinimalBlockDelay ppCostPerByteppHardGasLimitPerBlockBlockIdHeadId 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$fBuildableIntOpEvent$fFromJSONInternalOperationData$fDefaultFeeConstants$fHasCLReaderBlockId$fBuildableBlockId$fToHttpApiDataBlockId$fBuildableBadStackInformation$fFromJSONBadStackInformation$fBuildableRunError$fFromJSONRunError$fFromJSONInternalError$fBuildableInternalError$fMonoidAppliedResult$fSemigroupAppliedResult$fFromJSONOperationResult$fFromJSONInternalOperation$fFromJSONRunMetadata$fFromJSONOperationContent$fFromJSONRunOperationResult$fFromJSONCommonOperationData$fToJSONCommonOperationData!$fFromJSONWithCommonOperationData$fToJSONWithCommonOperationData$fToJSONObjectRevealOperation$fToJSONRevealOperation!$fToJSONObjectDelegationOperation$fToJSONDelegationOperation!$fOperationInfoDescriptorRPCInput$fFromJSONOperationMetadata$fShowAppliedResult$fShowInternalError$fShowRunError$fEqBadStackInformation$fShowBadStackInformation $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_PreviouslyRevealedKey_UnregisteredDelegatewcoCommonDataLWaitForOperationErrorWaitForOperationBlockoutWaitForOperationStreamingErrorIncorrectRpcResponseRpcUnexpectedSizeRpcOriginatedNoContractsRpcOriginatedMoreContractsUnexpectedErrorsUnexpectedRunErrorsUnexpectedInternalErrors RunCodeErrorsClientRpcErrorContractFailed BadParameterEmptyTransaction ShiftOverflow GasExhaustionKeyAlreadyRevealedDelegateNotRegisteredClientInternalError$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$fShowTimeoutErrorMorleyOnlyRpcMunMorleyOnlyRpcMMorleyOnlyRpcEnv moreLogAction moreClientEnvmoreSecretKeysmkMorleyOnlyRpcEnvrunMorleyOnlyRpcM$fHasTezosRpcMorleyOnlyRpcM$fRunClientMorleyOnlyRpcM)$fHasLogMorleyOnlyRpcEnvMsgMorleyOnlyRpcM$fExceptionUnsupportedByOnlyRPC$fHasTezosClientMorleyOnlyRpcM!$fExceptionMorleyOnlyRpcException$fShowMorleyOnlyRpcException$fEqMorleyOnlyRpcException$fShowUnsupportedByOnlyRPC$fEqUnsupportedByOnlyRPC$fFunctorMorleyOnlyRpcM$fApplicativeMorleyOnlyRpcM$fMonadMorleyOnlyRpcM+$fMonadReaderMorleyOnlyRpcEnvMorleyOnlyRpcM$fMonadIOMorleyOnlyRpcM$fMonadThrowMorleyOnlyRpcM$fMonadCatchMorleyOnlyRpcM$fMonadMaskMorleyOnlyRpcM$fMonadUnliftIOMorleyOnlyRpcMcomputeUntypedContractSizecomputeContractSizemorley-1.19.0-inplace Morley.CLIaddressOrAliasOption parserInfo TransferArgstaSender taDestinationtaAmount taParametertaMbFeeGetScriptSizeArgs ssScriptFile ssStorage OriginateArgsoaMbContractFileoaContractNameoaInitialBalanceoaInitialStorageoaOriginateFromoaMbFee oaDelegate ClientArgsRaw Originate GetScriptSizeTransfer GetBalanceGetBlockHeaderGetBlockOperations ClientArgsmorleyClientInfoclientConfigParseroriginateArgsOptionmbContractFileOptioncontractNameOption baseUrlReaderRunContractParameters 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$fCmdArgConstrained$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$fShowFeeParserExceptionFindAddressResultFARUnambiguous FARAmbiguousFARNoneResolveResolvedAddress ResolvedAliasresolveAddressEithergetAliasEither ResolveErrorREAliasNotFound REWrongKindREAddressNotFoundCallMode MockupMode ClientModeTezosClientErrorUnexpectedClientFailureAlreadyRevealedInvalidOperationHashCounterIsAlreadyUsed EConnresetConfigParseErrorTezosClientCryptoParseErrorTezosClientParseAddressErrorTezosClientParseFeeError!TezosClientUnexpectedOutputFormatCantRevealContractContractSenderEmptyImplicitContract$TezosClientUnexpectedSignatureOutput#TezosClientParseEncryptionTypeErrorDuplicateAliasAmbiguousAlias AliasTxRollupregisterDelegate getPublicKey getSecretKey importKeygetTezosClientConfigcalcTransferFeecalcOriginationFee calcRevealFeecallTezosClientcallTezosClientStrictresolveAddressresolveAddressMaybegetAlias getAliasMaybe findAddress$fBuildableResolveError$fBuildableTezosClientError$fExceptionTezosClientError$fResolveSomeAddressOrAlias$fResolveAddressOrAlias$fShowResolveError$fShowTezosClientErrormceTezosClient mceLogAction mceSecretKey mceClientEnvrunMorleyClientM$fFunctorMorleyClientM$fApplicativeMorleyClientM$fMonadMorleyClientM)$fMonadReaderMorleyClientEnvMorleyClientM$fMonadIOMorleyClientM$fMonadThrowMorleyClientM$fMonadCatchMorleyClientM$fMonadMaskMorleyClientM$fMonadUnliftIOMorleyClientM mceClientEnvL mceLogActionL mceSecretKeyLmceTezosClientLmkMorleyClientEnv$fHasTezosRpcMorleyClientM$fRunClientMorleyClientM$fHasTezosClientMorleyClientM'$fHasLogMorleyClientEnvMsgMorleyClientM"$fHasTezosClientEnvMorleyClientEnv ClientInput RevealData rdPublicKeyrdMbFeeDelegationData ddDelegateddMbFeeOriginationDataodAliasBehaviorodName odBalance odContract odStorage odDelegateodMbFeeTransactionDataTD tdReceivertdAmounttdEpNametdParamtdMbFeeOperationConstantsocLastBlockHashocBlockConstantsocFeeConstants ocCounterbuildTxDataWithAliastoParametersInternalsmkOriginationScriptpreProcessOperationgetAppliedResultshandleOperationResultrunErrorsToClientErrorrevealKeyUnlessRevealed computeFee convergingFeecomputeStorageLimitupdateCommonData stubSignatureaddOperationPrefixprepareOpForInjection$fBuildableTransactionData$$fOperationInfoDescriptorClientInputLargeOriginatorStoreLargeOriginatorParamSomeLargeContractOriginatorLargeOriginationDatalargeOriginatorlargeContractDatamkLargeOriginationDatamkSomeLargeContractOriginatorlargeContractOriginatordivideValueInChunksmkOriginationLambdamkLargeOriginatorStoremkLargeOriginatorDatamkLargeOriginatorTransactionsretrieveLargeContractsResult runOperationsrunOperationsNonEmptydryRunOperationsNonEmpty$fOperationInfoDescriptorResult$fSingIRunModeRealRun$fSingIRunModeDryRunrunTransactionslRunTransactionstransfer lTransferLOriginationDatalodAliasBehaviorlodName lodBalance lodContract lodStorage lodDelegatelodMbFeeoriginateContractsoriginateContractoriginateUntypedContractlOriginateContractslOriginateContractoriginateLargeContractsoriginateLargeContractoriginateLargeUntypedContractlOriginateLargeContractslOriginateLargeContract setDelegateOpregisterDelegateOp 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.TypesBoolData.Aeson.Types.ToJSONToJSONbase GHC.MaybeNothingJustBadStackInformation parseBlockIddefaultParametersInternal Morley.Michelson.Untyped.AliasesContractKindedAddress'fromBS ppRequestservant-client-core-0.19-dd32a08c0621051646874ca2c5966b33454ec7cfca8f96481f66452028511548Servant.Client.Core.RequestRequest ppResponsetimeoutIntervalMorleyOnlyRpcExceptionUnsupportedByOnlyRPC clientParserendpointOption blockIdOptionServant.Client.Core.BaseUrlBaseUrl$Morley.Michelson.Untyped.EntrypointsEpNameValue mtl-2.2.2Control.Monad.Reader.Class MonadReaderMorley.Tezos.Address.AliasSomeAddressOrAliasAddressOrAlias callListKnownMorley.Tezos.Crypto PublicKey SecretKeyreadProcessWithExitCode'divideInChunksMorley.Michelson.Typed.AliasesMorley.Tezos.AddressImplicitAddressContractAddress RunResultRunModeinjectionRetryCountrunOperationsNonEmptyHelperrunTransactionsNonEmptysingleOriginatedContractbInput bParseOutputGHC.BaseMonad Applicative runOperationMversiongetDataFileName getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDir