Defines a generalized way to declare entrypoints for various parameter types.

When defining instances of this typeclass, set concrete deriv argument and leave variable cp argument. Also keep in mind, that in presence of explicit default entrypoint, all other Or arms should be callable, though you can put this burden on user if very necessary.

Methods of this typeclass aim to better type-safety when making up an implementation and they may be not too convenient to use; users should exploit their counterparts.

Which entrypoints given parameter declares.

Note that usually this function should not be used as constraint, use ParameterDeclaresEntrypoints for this purpose.

Parameter declares some entrypoints.

This is a version of ParameterHasEntrypoints which we actually use in constraints. When given type is a sum type or newtype, we refer to ParameterHasEntrypoints instance, otherwise this instance is not necessary.

Get all entrypoints declared for parameter.

Lookup for entrypoint type by name.

Does not treat default entrypoints in a special way.

Derive annotations for given parameter.

Get type of entrypoint with given name, fail if not found.

Prepare call to given entrypoint.

This does not treat calls to default entrypoint in a special way. To call default entrypoint properly use parameterEntrypointCallDefault.

Get type of entrypoint with given name, fail if not found.

Call the default entrypoint.

Ensure that there is no explicit "default" entrypoint.

Similar to ForbidExplicitDefaultEntrypoint, but in a version which the compiler can work with (and which produces errors confusing for users :/)

Call root entrypoint safely.

Which entrypoint to call.

We intentionally distinguish default and non-default cases because this makes API more details-agnostic.

Universal entrypoint lookup.

When we call a Lorentz contract we should pass entrypoint name and corresponding argument. Ideally we want to statically check that parameter has entrypoint with given name and argument. Constraint defined by this type class holds for contract with parameter cp that have entrypoint matching name with type arg.

In order to check this property statically, we need to know entrypoint name in compile time, EntrypointRef type serves this purpose. If entrypoint name is not known, one can use TrustEpName wrapper to take responsibility for presence of this entrypoint.

If you want to call a function which has this constraint, you have two options: 1. Pass contract parameter cp using type application, pass EntrypointRef as a value and pass entrypoint argument. Type system will check that cp has an entrypoint with given reference and type. 2. Pass EpName wrapped into TrustEpName and entrypoint argument. In this case passing contract parameter is not necessary, you do not even have to know it.

HasEntrypointArg constraint specialized to default entrypoint.

Checks that the given parameter consists of some specific entrypoint. Similar as HasEntrypointArg but ensures that the argument matches the following datatype.

Check that the given entrypoint has some fields inside. This interface allows for an abstraction of contract parameter so that it requires some *minimal* specification, but not a concrete one.

This wrapper allows to pass untyped EpName and bypass checking that entrypoint with given name and type exists.

Universal entrypoint calling.

Ensure that all declared entrypoints are unique.

No entrypoints declared, parameter type will serve as argument type of the only existing entrypoint (default one).

Implementation of ParameterHasEntrypoints which fits for case when your contract exposes multiple entrypoints via having sum type as its parameter.

In particular, each constructor would produce a homonymous entrypoint with argument type equal to type of constructor field (each constructor should have only one field). Constructor called Default will designate the default entrypoint.

Extension of EpdPlain on parameters being defined as several nested datatypes.

In particular, this will traverse sum types recursively, stopping at Michelson primitives (like Natural) and constructors with number of fields different from one.

It does not assign names to intermediate nodes of Or tree, only to the very leaves.

If some entrypoint arguments have custom IsoValue instance, this derivation way will not work. As a workaround, you can wrap your argument into some primitive (e.g. :!).

Extension of EpdPlain on parameters being defined as several nested datatypes.

In particular, it will traverse the immediate sum type, and require another ParameterHasEntrypoints for the inner complex datatypes. Only those inner types are considered which are the only fields in their respective constructors. Inner types should not themselves declare default entrypoint, we enforce this for better modularity. Each top-level constructor will be treated as entrypoint even if it contains a complex datatype within, in such case that would be an entrypoint corresponding to intermediate node in or tree.

Comparing to EpdRecursive this gives you more control over where and how entrypoints will be derived.

Extension of EpdPlain, EpdRecursive, and EpdDelegate which allow specifying root annotation for the parameters.

Wrap parameter into this to locally assign a way to derive entrypoints for it.

A special type which wraps over a primitive type and states that it has entrypoints (one).

Assuming that any type can have entrypoints makes use of Lorentz entrypoints too annoying, so for declaring entrypoints for not sum types we require an explicit wrapper.