Options for dfsTraverseInstr family of functions.

Describes how intermediate nodes in instruction tree are accounted.

Traverse a typed instruction in depth-first order.

The dsInstrStep and dsValueStep actions will be applied in bottom-to-top order, i.e. first to the children of a node, then to the node itself.

Specialization of dfsTraverseInstr for case when changing the instruction is not required.

Specialization of dfsTraverseInstr which only modifies given instruction.

Whether this instruction is a real Michelson instruction.

Only the root is in question, children in the instruction tree are not accounted for.

>>> isMichelsonInstr (Seq Nop Nop)
True

>>> isMichelsonInstr (Ext $ COMMENT_ITEM "comment")
False

This function is helpful e.g. in debugger.

There are many ways to represent a sequence of more than 2 instructions. E. g. for i1; i2; i3 it can be Seq i1 $ Seq i2 i3 or Seq (Seq i1 i2) i3. This function enforces a particular structure. Specifically, it makes each Seq have a single instruction (i. e. not Seq) in its second argument. This function also erases redundant Nops.

Please note that this function is not recursive, it does not linearize contents of IF and similar instructions.

"Deep" version of linearizeLeft. It recursively linearizes instructions stored in other instructions.

Specialization of dfsMapValue for case when changing the value is not required.

Specialization of dfsMapValue for case when changing the value is not required.

Traverse a value in depth-first order.

Traverse a value in depth-first order.

If value is a string, return the stored string.

If value is a bytestring, return the stored bytestring.

Takes a selector which checks whether a value can be converted to something. Recursively applies it to all values. Collects extracted values in a list.

Result of splitting a storage Value of st on the stack s.

The idea behind this is to either: prove that the whole Value can be put on the stack without containing a single big_map or to split it into: a Value containing its big_maps and an instruction to reconstruct the storage.

The main idea behind this is to create a large storage in Michelson code to then create a contract using CREATE_CONTRACT. Note: a simpler solution would have been to replace big_map Values with an EMPTY_BIG_MAP followed by many UPDATE to push its content, but sadly a bug (tezostezos1154) prevents this from being done.

Splits the given storage Value into a PushableStorageSplit.

This is based off the fact that the only storages that cannot be directly PUSHed are the ones that contain BigMaps and tickets. See difference between StorageScope and ConstantScope.

So what we do here is to create a Value as small as possible with all the big_maps in it (if any) and an Instr that can use it to rebuild the original storage Value.

Note: This is done this way to avoid using EMPTY_BIG_MAP instructions, see PushableStorageSplit for motivation.

Check whether instruction fails at each execution path or have at least one non-failing path.

This function assumes that given instruction contains no dead code (contract with dead code cannot be valid Michelson contract) and may behave in unexpected way if such is present. Term "dead code" includes instructions which render into empty Michelson, like Morley extensions. On the other hand, this function does not traverse the whole instruction tree; performs fastest on left-growing combs.

Often we already have information about instruction failure, use this function only in cases when this info is actually unavailable or hard to use.

A wrapper around either typechecked Anns or unchecked NonEmpty of AnyAnn. Annotations on some instructions aren't typechecked, hence these two constructors.

Helper for instrAnns.

Get annotations from a typed Instr. This doesn't recurse, use with dfsFoldInstr to collect all annotations in a tree/sequence.