Michelson.Typed.Entrypoints

Utilities for lightweight entrypoints support.

Documentation

data EpAddress

Address with optional entrypoint name attached to it. TODO: come up with better name?

Constructors

EpAddress

Fields

• eaAddress :: Address

  Address itself

• eaEntrypoint :: EpName

  Entrypoint name (might be empty)

Instances

Eq EpAddress

Defined in Michelson.Typed.Entrypoints

Methods

(==) :: EpAddress -> EpAddress -> Bool

(/=) :: EpAddress -> EpAddress -> Bool

Ord EpAddress

Defined in Michelson.Typed.Entrypoints

Methods

compare :: EpAddress -> EpAddress -> Ordering

(<) :: EpAddress -> EpAddress -> Bool

(<=) :: EpAddress -> EpAddress -> Bool

(>) :: EpAddress -> EpAddress -> Bool

(>=) :: EpAddress -> EpAddress -> Bool

max :: EpAddress -> EpAddress -> EpAddress

min :: EpAddress -> EpAddress -> EpAddress

Show EpAddress

Defined in Michelson.Typed.Entrypoints

Methods

showsPrec :: Int -> EpAddress -> ShowS

show :: EpAddress -> String

showList :: [EpAddress] -> ShowS

Generic EpAddress

Defined in Michelson.Typed.Entrypoints

Associated Types

type Rep EpAddress :: Type -> Type

Methods

from :: EpAddress -> Rep EpAddress x

to :: Rep EpAddress x -> EpAddress

NFData EpAddress

Defined in Michelson.Typed.Entrypoints

Methods

rnf :: EpAddress -> ()

Buildable EpAddress

Defined in Michelson.Typed.Entrypoints

Methods

build :: EpAddress -> Builder

IsoValue EpAddress

Defined in Michelson.Typed.Haskell.Value

Associated Types

type ToT EpAddress :: T

Methods

toVal :: EpAddress -> Value (ToT EpAddress)

fromVal :: Value (ToT EpAddress) -> EpAddress

TypeHasDoc EpAddress

Defined in Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions EpAddress :: FieldDescriptions

Methods

typeDocName :: Proxy EpAddress -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy EpAddress -> WithinParens -> Markdown

typeDocDependencies :: Proxy EpAddress -> [SomeDocDefinitionItem]

typeDocHaskellRep :: TypeDocHaskellRep EpAddress

typeDocMichelsonRep :: TypeDocMichelsonRep EpAddress

type Rep EpAddress

Defined in Michelson.Typed.Entrypoints

type Rep EpAddress = D1 ('MetaData "EpAddress" "Michelson.Typed.Entrypoints" "morley-1.9-inplace" 'False) (C1 ('MetaCons "EpAddress" 'PrefixI 'True) (S1 ('MetaSel ('Just "eaAddress") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Address) :*: S1 ('MetaSel ('Just "eaEntrypoint") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 EpName)))

type ToT EpAddress

Defined in Michelson.Typed.Haskell.Value

type ToT EpAddress = 'TAddress

type TypeDocFieldDescriptions EpAddress

Defined in Michelson.Typed.Haskell.Doc

type TypeDocFieldDescriptions EpAddress = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))]

data ParseEpAddressError

Constructors

ParseEpAddressBadAddress ParseAddressError

ParseEpAddressRawBadAddress ParseAddressRawError

ParseEpAddressBadEntryopint ByteString UnicodeException

ParseEpAddressBadRefAnn Text

ParseEpAddressRefAnnError EpNameFromRefAnnError

ParseEpAddressInvalidLength Int

Instances

Eq ParseEpAddressError

Defined in Michelson.Typed.Entrypoints

Methods

(==) :: ParseEpAddressError -> ParseEpAddressError -> Bool

(/=) :: ParseEpAddressError -> ParseEpAddressError -> Bool

Show ParseEpAddressError

Defined in Michelson.Typed.Entrypoints

Methods

showsPrec :: Int -> ParseEpAddressError -> ShowS

show :: ParseEpAddressError -> String

showList :: [ParseEpAddressError] -> ShowS

Generic ParseEpAddressError

Defined in Michelson.Typed.Entrypoints

Associated Types

type Rep ParseEpAddressError :: Type -> Type

Methods

from :: ParseEpAddressError -> Rep ParseEpAddressError x

to :: Rep ParseEpAddressError x -> ParseEpAddressError

NFData ParseEpAddressError

Defined in Michelson.Typed.Entrypoints

Methods

rnf :: ParseEpAddressError -> ()

Buildable ParseEpAddressError

Defined in Michelson.Typed.Entrypoints

Methods

build :: ParseEpAddressError -> Builder

type Rep ParseEpAddressError

Defined in Michelson.Typed.Entrypoints

type Rep ParseEpAddressError = D1 ('MetaData "ParseEpAddressError" "Michelson.Typed.Entrypoints" "morley-1.9-inplace" 'False) ((C1 ('MetaCons "ParseEpAddressBadAddress" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 ParseAddressError)) :+: (C1 ('MetaCons "ParseEpAddressRawBadAddress" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 ParseAddressRawError)) :+: C1 ('MetaCons "ParseEpAddressBadEntryopint" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 ByteString) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 UnicodeException)))) :+: (C1 ('MetaCons "ParseEpAddressBadRefAnn" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Text)) :+: (C1 ('MetaCons "ParseEpAddressRefAnnError" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 EpNameFromRefAnnError)) :+: C1 ('MetaCons "ParseEpAddressInvalidLength" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Int)))))

formatEpAddress :: EpAddress -> Text

mformatEpAddress :: EpAddress -> MText

parseEpAddress :: Text -> Either ParseEpAddressError EpAddress

Parse an address which can be suffixed with entrypoint name (e.g. "tz1faswCTDciRzE4oJ9jn2Vm2dvjeyA9fUzU%entrypoint").

unsafeParseEpAddress :: HasCallStack => Text -> EpAddress

parseEpAddressRaw :: ByteString -> Either ParseEpAddressError EpAddress

Parses byte representation of entrypoint address.

For every address

KT1QbdJ7M7uAQZwLpvzerUyk7LYkJWDL7eDh%foo%bar

we get the following byte representation

01afab866e7f1e74f9bba388d66b246276ce50bf4700666f6f25626172
______________________________________//__/____
              address                     %   ep1  % ep2

unsafeParseEpAddressRaw :: ByteString -> EpAddress

data ParamNotes (t :: T)

Annotations for contract parameter declaration.

Following the Michelson specification, this type has the following invariants: 1. No entrypoint name is duplicated. 2. If default entrypoint is explicitly assigned, no "arm" remains uncallable.

Constructors

ParamNotesUnsafe

Fields

• pnNotes :: Notes t
• pnRootAnn :: RootAnn

Instances

Eq (ParamNotes t)

Defined in Michelson.Typed.Entrypoints

Methods

(==) :: ParamNotes t -> ParamNotes t -> Bool

(/=) :: ParamNotes t -> ParamNotes t -> Bool

Show (ParamNotes t)

Defined in Michelson.Typed.Entrypoints

Methods

showsPrec :: Int -> ParamNotes t -> ShowS

show :: ParamNotes t -> String

showList :: [ParamNotes t] -> ShowS

Generic (ParamNotes t)

Defined in Michelson.Typed.Entrypoints

Associated Types

type Rep (ParamNotes t) :: Type -> Type

Methods

from :: ParamNotes t -> Rep (ParamNotes t) x

to :: Rep (ParamNotes t) x -> ParamNotes t

NFData (ParamNotes t)

Defined in Michelson.Typed.Entrypoints

Methods

rnf :: ParamNotes t -> ()

type Rep (ParamNotes t)

Defined in Michelson.Typed.Entrypoints

type Rep (ParamNotes t) = D1 ('MetaData "ParamNotes" "Michelson.Typed.Entrypoints" "morley-1.9-inplace" 'False) (C1 ('MetaCons "ParamNotesUnsafe" 'PrefixI 'True) (S1 ('MetaSel ('Just "pnNotes") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Notes t)) :*: S1 ('MetaSel ('Just "pnRootAnn") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 RootAnn)))

pattern ParamNotes :: Notes t -> RootAnn -> ParamNotes t

starParamNotes :: SingI t => ParamNotes t

Parameter without annotations.

data ArmCoord

Constructors

AcLeft

AcRight

Instances

Eq ArmCoord

Defined in Michelson.Typed.Entrypoints

Methods

(==) :: ArmCoord -> ArmCoord -> Bool

(/=) :: ArmCoord -> ArmCoord -> Bool

Show ArmCoord

Defined in Michelson.Typed.Entrypoints

Methods

showsPrec :: Int -> ArmCoord -> ShowS

show :: ArmCoord -> String

showList :: [ArmCoord] -> ShowS

Generic ArmCoord

Defined in Michelson.Typed.Entrypoints

Associated Types

type Rep ArmCoord :: Type -> Type

Methods

from :: ArmCoord -> Rep ArmCoord x

to :: Rep ArmCoord x -> ArmCoord

NFData ArmCoord

Defined in Michelson.Typed.Entrypoints

Methods

rnf :: ArmCoord -> ()

Buildable ArmCoord

Defined in Michelson.Typed.Entrypoints

Methods

build :: ArmCoord -> Builder

type Rep ArmCoord

Defined in Michelson.Typed.Entrypoints

type Rep ArmCoord = D1 ('MetaData "ArmCoord" "Michelson.Typed.Entrypoints" "morley-1.9-inplace" 'False) (C1 ('MetaCons "AcLeft" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "AcRight" 'PrefixI 'False) (U1 :: Type -> Type))

type ArmCoords = [ArmCoord]

Coordinates of "arm" in Or tree, used solely in error messages.

data ParamEpError

Errors specific to parameter type declaration (entrypoints).

Constructors

ParamEpDuplicatedNames (NonEmpty EpName)

ParamEpUncallableArm ArmCoords

Instances

Eq ParamEpError

Defined in Michelson.Typed.Entrypoints

Methods

(==) :: ParamEpError -> ParamEpError -> Bool

(/=) :: ParamEpError -> ParamEpError -> Bool

Show ParamEpError

Defined in Michelson.Typed.Entrypoints

Methods

showsPrec :: Int -> ParamEpError -> ShowS

show :: ParamEpError -> String

showList :: [ParamEpError] -> ShowS

Generic ParamEpError

Defined in Michelson.Typed.Entrypoints

Associated Types

type Rep ParamEpError :: Type -> Type

Methods

from :: ParamEpError -> Rep ParamEpError x

to :: Rep ParamEpError x -> ParamEpError

NFData ParamEpError

Defined in Michelson.Typed.Entrypoints

Methods

rnf :: ParamEpError -> ()

Buildable ParamEpError

Defined in Michelson.Typed.Entrypoints

Methods

build :: ParamEpError -> Builder

type Rep ParamEpError

Defined in Michelson.Typed.Entrypoints

type Rep ParamEpError = D1 ('MetaData "ParamEpError" "Michelson.Typed.Entrypoints" "morley-1.9-inplace" 'False) (C1 ('MetaCons "ParamEpDuplicatedNames" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (NonEmpty EpName))) :+: C1 ('MetaCons "ParamEpUncallableArm" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 ArmCoords)))

mkParamNotes :: Notes t -> RootAnn -> Either ParamEpError (ParamNotes t)

Construct ParamNotes performing all necessary checks.

data EpLiftSequence (arg :: T) (param :: T) where

Describes how to construct full contract parameter from given entrypoint argument.

This could be just wrapper over Value arg -> Value param, but we cannot use Value type in this module easily.

Constructors

EplArgHere :: EpLiftSequence arg arg

EplWrapLeft :: (KnownT subparam, KnownT r) => EpLiftSequence arg subparam -> EpLiftSequence arg ('TOr subparam r)

EplWrapRight :: (KnownT l, KnownT subparam) => EpLiftSequence arg subparam -> EpLiftSequence arg ('TOr l subparam)

Instances

Eq (EpLiftSequence arg param)

Defined in Michelson.Typed.Entrypoints

Methods

(==) :: EpLiftSequence arg param -> EpLiftSequence arg param -> Bool

(/=) :: EpLiftSequence arg param -> EpLiftSequence arg param -> Bool

Show (EpLiftSequence arg param)

Defined in Michelson.Typed.Entrypoints

Methods

showsPrec :: Int -> EpLiftSequence arg param -> ShowS

show :: EpLiftSequence arg param -> String

showList :: [EpLiftSequence arg param] -> ShowS

NFData (EpLiftSequence param arg)

Defined in Michelson.Typed.Entrypoints

Methods

rnf :: EpLiftSequence param arg -> ()

Buildable (EpLiftSequence arg param)

Defined in Michelson.Typed.Entrypoints

Methods

build :: EpLiftSequence arg param -> Builder

data EntrypointCallT (param :: T) (arg :: T)

Reference for calling a specific entrypoint of type arg.

Constructors

ParameterScope arg => EntrypointCall

Fields

• epcName :: EpName

  Name of entrypoint.

• epcParamProxy :: Proxy param

  Proxy of parameter, to make parameter type more easily fetchable.

• epcLiftSequence :: EpLiftSequence arg param

  How to call this entrypoint in the corresponding contract.

Instances

Eq (EntrypointCallT param arg)

Defined in Michelson.Typed.Entrypoints

Methods

(==) :: EntrypointCallT param arg -> EntrypointCallT param arg -> Bool

(/=) :: EntrypointCallT param arg -> EntrypointCallT param arg -> Bool

Show (EntrypointCallT param arg)

Defined in Michelson.Typed.Entrypoints

Methods

showsPrec :: Int -> EntrypointCallT param arg -> ShowS

show :: EntrypointCallT param arg -> String

showList :: [EntrypointCallT param arg] -> ShowS

NFData (EntrypointCallT param arg)

Defined in Michelson.Typed.Entrypoints

Methods

rnf :: EntrypointCallT param arg -> ()

Buildable (EntrypointCallT param arg)

Defined in Michelson.Typed.Entrypoints

Methods

build :: EntrypointCallT param arg -> Builder

epcPrimitive :: forall p. (ParameterScope p, ForbidOr p) => EntrypointCallT p p

Call parameter which has no entrypoints, always safe.

epcCallRootUnsafe :: ParameterScope param => EntrypointCallT param param

Construct EntrypointCallT which calls no entrypoint and assumes that there is no explicit "default" one.

Validity of such operation is not ensured.

data SomeEntrypointCallT (arg :: T)

EntrypointCallT with hidden parameter type.

This requires argument to satisfy ParameterScope constraint. Strictly speaking, entrypoint argument may one day start having different set of constraints comparing to ones applied to parameter, but this seems unlikely.

Constructors

forall param.ParameterScope param => SomeEpc (EntrypointCallT param arg)

Instances

Eq (SomeEntrypointCallT arg)

Defined in Michelson.Typed.Entrypoints

Methods

(==) :: SomeEntrypointCallT arg -> SomeEntrypointCallT arg -> Bool

(/=) :: SomeEntrypointCallT arg -> SomeEntrypointCallT arg -> Bool

Show (SomeEntrypointCallT arg)

Defined in Michelson.Typed.Entrypoints

Methods

showsPrec :: Int -> SomeEntrypointCallT arg -> ShowS

show :: SomeEntrypointCallT arg -> String

showList :: [SomeEntrypointCallT arg] -> ShowS

NFData (SomeEntrypointCallT arg)

Defined in Michelson.Typed.Entrypoints

Methods

rnf :: SomeEntrypointCallT arg -> ()

Buildable (SomeEntrypointCallT arg)

Defined in Michelson.Typed.Entrypoints

Methods

build :: SomeEntrypointCallT arg -> Builder

sepcCallRootUnsafe :: ParameterScope param => SomeEntrypointCallT param

Construct SomeEntrypointCallT which calls no entrypoint and assumes that there is no explicit "default" one.

Validity of such operation is not ensured.

sepcPrimitive :: forall t. (ParameterScope t, ForbidOr t) => SomeEntrypointCallT t

Call parameter which has no entrypoints, always safe.

sepcName :: SomeEntrypointCallT arg -> EpName

type family ForbidOr (t :: T) :: Constraint where ...

Equations

ForbidOr ('TOr l r) = TypeError ('Text "Cannot apply to sum type parameter " :<>: 'ShowType ('TOr l r))

ForbidOr _ = ()

data MkEntrypointCallRes param where

Constructors

MkEntrypointCallRes :: ParameterScope arg => Notes arg -> EntrypointCallT param arg -> MkEntrypointCallRes param

mkEntrypointCall :: ParameterScope param => EpName -> ParamNotes param -> Maybe (MkEntrypointCallRes param)

Build EntrypointCallT.

Here we accept entrypoint name and type information for the parameter of target contract.

Returns Nothing if entrypoint is not found.

tyImplicitAccountParam :: ParamNotes 'TUnit

Parameter type of implicit account.

Re-exports

newtype EpName

Entrypoint name.

There are two properties we care about:

1. Special treatment of the default entrypoint name. default is prohibited in the CONTRACT instruction and in values of address and contract types. However, it is not prohibited in the SELF instruction. Hence, the value inside EpName can be "default", so that we can distinguish SELF and SELF %default. It is important to distinguish them because their binary representation that is inserted into blockchain is different. For example, typechecking SELF %default consumes more gas than SELF. In this module, we provide several smart constructors with different handling of default, please use the appropriate one for your use case.
2. The set of permitted characters. Intuitively, an entrypoint name should be valid only if it is a valid annotation (because entrypoints are defined using field annotations). However, it is not enforced in Tezos. It is not clear whether this behavior is intended. There is an upstream issue which received bug label, so probably it is considered a bug. Currently we treat it as a bug and deviate from upstream implementation by probiting entrypoint names that are not valid annotations. If Tezos developers fix it soon, we will be happy. If they don't, we should (maybe temporarily) remove this limitation from our code. There is an issue in our repo as well.

Constructors

EpNameUnsafe

Fields

• unEpName :: Text

Instances

Eq EpName

Defined in Michelson.Untyped.Entrypoints

Methods

(==) :: EpName -> EpName -> Bool

(/=) :: EpName -> EpName -> Bool

Ord EpName

Defined in Michelson.Untyped.Entrypoints

Methods

compare :: EpName -> EpName -> Ordering

(<) :: EpName -> EpName -> Bool

(<=) :: EpName -> EpName -> Bool

(>) :: EpName -> EpName -> Bool

(>=) :: EpName -> EpName -> Bool

max :: EpName -> EpName -> EpName

min :: EpName -> EpName -> EpName

Show EpName

Defined in Michelson.Untyped.Entrypoints

Methods

showsPrec :: Int -> EpName -> ShowS

show :: EpName -> String

showList :: [EpName] -> ShowS

Generic EpName

Defined in Michelson.Untyped.Entrypoints

Associated Types

type Rep EpName :: Type -> Type

Methods

from :: EpName -> Rep EpName x

to :: Rep EpName x -> EpName

ToJSON EpName

Defined in Michelson.Untyped.Entrypoints

Methods

toJSON :: EpName -> Value

toEncoding :: EpName -> Encoding

toJSONList :: [EpName] -> Value

toEncodingList :: [EpName] -> Encoding

FromJSON EpName

Defined in Michelson.Untyped.Entrypoints

Methods

parseJSON :: Value -> Parser EpName

parseJSONList :: Value -> Parser [EpName]

NFData EpName

Defined in Michelson.Untyped.Entrypoints

Methods

rnf :: EpName -> ()

Buildable EpName

Defined in Michelson.Untyped.Entrypoints

Methods

build :: EpName -> Builder

HasCLReader EpName

Defined in Michelson.Untyped.Entrypoints

Methods

getReader :: ReadM EpName

getMetavar :: String

type Rep EpName

Defined in Michelson.Untyped.Entrypoints

type Rep EpName = D1 ('MetaData "EpName" "Michelson.Untyped.Entrypoints" "morley-1.9-inplace" 'True) (C1 ('MetaCons "EpNameUnsafe" 'PrefixI 'True) (S1 ('MetaSel ('Just "unEpName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)))

pattern DefEpName :: EpName

This is a bidirectional pattern that can be used for two purposes:

1. Construct an EpName referring to the default entrypoint.
2. Use it in pattern-matching or in equality comparison to check whether EpName refers to the default entrypoint. This is trickier because there are two possible EpName values referring to the default entrypoints. DefEpName will match only the most common one (no entrypoint). However, there is a special case: SELF instruction can have explicit %default reference. For this reason, it is recommended to use isDefEpName instead. Pattern-matching on DefEpName is still permitted for backwards compatibility and for the cases when you are sure that EpName does not come from the SELF instruction.

epNameFromParamAnn :: FieldAnn -> Maybe EpName

Make up EpName from annotation in parameter type declaration.

Returns Nothing if no entrypoint is assigned here.

epNameToParamAnn :: EpName -> FieldAnn

Turn entrypoint name into annotation for contract parameter declaration.

epNameFromRefAnn :: FieldAnn -> Either EpNameFromRefAnnError EpName

Make up EpName from annotation which is reference to an entrypoint. Note that it's more common for Michelson to prohibit explicit default entrypoint reference.

Specifically, %default annotation is probitited in values of address and contract types. It's also prohibited in the CONTRACT instruction. However, there is an exception: SELF %default is a perfectly valid instruction. Hence, when you construct an EpName from an annotation that's part of SELF, you should use epNameFromSelfAnn instead.

epNameToRefAnn :: EpName -> FieldAnn

Turn entrypoint name into annotation used as reference to entrypoint.

data EpNameFromRefAnnError

Constructors

InEpNameBadAnnotation FieldAnn

Instances

Eq EpNameFromRefAnnError

Defined in Michelson.Untyped.Entrypoints

Methods

(==) :: EpNameFromRefAnnError -> EpNameFromRefAnnError -> Bool

(/=) :: EpNameFromRefAnnError -> EpNameFromRefAnnError -> Bool

Show EpNameFromRefAnnError

Defined in Michelson.Untyped.Entrypoints

Methods

showsPrec :: Int -> EpNameFromRefAnnError -> ShowS

show :: EpNameFromRefAnnError -> String

showList :: [EpNameFromRefAnnError] -> ShowS

Generic EpNameFromRefAnnError

Defined in Michelson.Untyped.Entrypoints

Associated Types

type Rep EpNameFromRefAnnError :: Type -> Type

Methods

from :: EpNameFromRefAnnError -> Rep EpNameFromRefAnnError x

to :: Rep EpNameFromRefAnnError x -> EpNameFromRefAnnError

NFData EpNameFromRefAnnError

Defined in Michelson.Untyped.Entrypoints

Methods

rnf :: EpNameFromRefAnnError -> ()

Buildable EpNameFromRefAnnError

Defined in Michelson.Untyped.Entrypoints

Methods

build :: EpNameFromRefAnnError -> Builder

type Rep EpNameFromRefAnnError

Defined in Michelson.Untyped.Entrypoints

type Rep EpNameFromRefAnnError = D1 ('MetaData "EpNameFromRefAnnError" "Michelson.Untyped.Entrypoints" "morley-1.9-inplace" 'False) (C1 ('MetaCons "InEpNameBadAnnotation" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 FieldAnn)))