Morley.Michelson.Interpret

Module, containing function to interpret Michelson instructions against given context and input stack.

Documentation

data ContractEnv

Environment for contract execution.

Constructors

ContractEnv

Fields

• ceNow :: Timestamp

  Timestamp returned by the NOW instruction.

• ceMaxSteps :: RemainingSteps

  Number of steps after which execution unconditionally terminates.

• ceBalance :: Mutez

  Current amount of mutez of the current contract.

• ceContracts :: Map ContractAddress ContractState

  Information stored about the existing contracts.

• ceSelf :: ContractAddress

  Address of the interpreted contract.

• ceSource :: L1Address

  The contract that initiated the current transaction. Note that this contract should in normal operation be an implicit account.

• ceSender :: L1Address

  The contract that initiated the current internal transaction. This may either be an implicit account or a smart contract.

• ceAmount :: Mutez

  Amount of the current transaction.

• ceVotingPowers :: VotingPowers

  Distribution of voting power.

• ceChainId :: ChainId

  Identifier of the current chain.

• ceOperationHash :: Maybe OperationHash

  Hash of the currently executed operation, required for correct contract address computation in CREATE_CONTRACT instruction.

• ceLevel :: Natural

  Number of blocks before the given one in the chain

• ceErrorSrcPos :: ErrorSrcPos

  Current source position information

• ceMinBlockTime :: Natural

  Minimum time between blocks

data InterpreterState

Constructors

InterpreterState

Fields

• isRemainingSteps :: RemainingSteps
• isGlobalCounter :: GlobalCounter
• isBigMapCounter :: BigMapCounter

Instances

Generic InterpreterState

Defined in Morley.Michelson.Interpret

Associated Types

type Rep InterpreterState :: Type -> Type

Methods

from :: InterpreterState -> Rep InterpreterState x

to :: Rep InterpreterState x -> InterpreterState

Show InterpreterState

Defined in Morley.Michelson.Interpret

Methods

showsPrec :: Int -> InterpreterState -> ShowS

show :: InterpreterState -> String

showList :: [InterpreterState] -> ShowS

NFData InterpreterState

Defined in Morley.Michelson.Interpret

Methods

rnf :: InterpreterState -> ()

Monad m => InterpreterStateMonad (StateT InterpreterState m)

Defined in Morley.Michelson.Interpret

Methods

getInterpreterState :: StateT InterpreterState m InterpreterState

putInterpreterState :: InterpreterState -> StateT InterpreterState m ()

stateInterpreterState :: (InterpreterState -> (a, InterpreterState)) -> StateT InterpreterState m a

modifyInterpreterState :: (InterpreterState -> InterpreterState) -> StateT InterpreterState m ()

(Monad m, Monoid w) => InterpreterStateMonad (RWST r w InterpreterState m)

Defined in Morley.Michelson.Interpret

Methods

getInterpreterState :: RWST r w InterpreterState m InterpreterState

putInterpreterState :: InterpreterState -> RWST r w InterpreterState m ()

stateInterpreterState :: (InterpreterState -> (a, InterpreterState)) -> RWST r w InterpreterState m a

modifyInterpreterState :: (InterpreterState -> InterpreterState) -> RWST r w InterpreterState m ()

type Rep InterpreterState

Defined in Morley.Michelson.Interpret

type Rep InterpreterState = D1 ('MetaData "InterpreterState" "Morley.Michelson.Interpret" "morley-1.18.0-inplace" 'False) (C1 ('MetaCons "InterpreterState" 'PrefixI 'True) (S1 ('MetaSel ('Just "isRemainingSteps") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 RemainingSteps) :*: (S1 ('MetaSel ('Just "isGlobalCounter") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 GlobalCounter) :*: S1 ('MetaSel ('Just "isBigMapCounter") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 BigMapCounter))))

data MichelsonFailed where

Represents [FAILED] state of a Michelson program. Contains value that was on top of the stack when FAILWITH was called.

Constructors

MichelsonFailedWith :: (SingI t, ConstantScope t) => Value t -> MichelsonFailed

MichelsonArithError :: (Typeable n, Typeable m) => ArithError (Value n) (Value m) -> MichelsonFailed

MichelsonGasExhaustion :: MichelsonFailed

MichelsonFailedTestAssert :: Text -> MichelsonFailed

MichelsonUnsupported :: Text -> MichelsonFailed

Instances

Show MichelsonFailed

Defined in Morley.Michelson.Interpret

Methods

showsPrec :: Int -> MichelsonFailed -> ShowS

show :: MichelsonFailed -> String

showList :: [MichelsonFailed] -> ShowS

NFData MichelsonFailed

Defined in Morley.Michelson.Interpret

Methods

rnf :: MichelsonFailed -> ()

Buildable MichelsonFailed

Defined in Morley.Michelson.Interpret

Methods

build :: MichelsonFailed -> Builder

Eq MichelsonFailed

Defined in Morley.Michelson.Interpret

Methods

(==) :: MichelsonFailed -> MichelsonFailed -> Bool

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

data MichelsonFailureWithStack

Carries a MichelsonFailed error and the ErrorSrcPos at which it was raised

Constructors

MichelsonFailureWithStack

Fields

• mfwsFailed :: MichelsonFailed
• mfwsErrorSrcPos :: ErrorSrcPos

Instances

Generic MichelsonFailureWithStack

Defined in Morley.Michelson.Interpret

Associated Types

type Rep MichelsonFailureWithStack :: Type -> Type

Methods

from :: MichelsonFailureWithStack -> Rep MichelsonFailureWithStack x

to :: Rep MichelsonFailureWithStack x -> MichelsonFailureWithStack

Show MichelsonFailureWithStack

Defined in Morley.Michelson.Interpret

Methods

showsPrec :: Int -> MichelsonFailureWithStack -> ShowS

show :: MichelsonFailureWithStack -> String

showList :: [MichelsonFailureWithStack] -> ShowS

NFData MichelsonFailureWithStack

Defined in Morley.Michelson.Interpret

Methods

rnf :: MichelsonFailureWithStack -> ()

Buildable MichelsonFailureWithStack

Defined in Morley.Michelson.Interpret

Methods

build :: MichelsonFailureWithStack -> Builder

Eq MichelsonFailureWithStack

Defined in Morley.Michelson.Interpret

Methods

(==) :: MichelsonFailureWithStack -> MichelsonFailureWithStack -> Bool

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

type Rep MichelsonFailureWithStack

Defined in Morley.Michelson.Interpret

type Rep MichelsonFailureWithStack = D1 ('MetaData "MichelsonFailureWithStack" "Morley.Michelson.Interpret" "morley-1.18.0-inplace" 'False) (C1 ('MetaCons "MichelsonFailureWithStack" 'PrefixI 'True) (S1 ('MetaSel ('Just "mfwsFailed") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 MichelsonFailed) :*: S1 ('MetaSel ('Just "mfwsErrorSrcPos") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 ErrorSrcPos)))

newtype RemainingSteps

Constructors

RemainingSteps Word64

Instances

Generic RemainingSteps

Defined in Morley.Michelson.Interpret

Associated Types

type Rep RemainingSteps :: Type -> Type

Methods

from :: RemainingSteps -> Rep RemainingSteps x

to :: Rep RemainingSteps x -> RemainingSteps

Num RemainingSteps

Defined in Morley.Michelson.Interpret

Methods

(+) :: RemainingSteps -> RemainingSteps -> RemainingSteps

(-) :: RemainingSteps -> RemainingSteps -> RemainingSteps

(*) :: RemainingSteps -> RemainingSteps -> RemainingSteps

negate :: RemainingSteps -> RemainingSteps

abs :: RemainingSteps -> RemainingSteps

signum :: RemainingSteps -> RemainingSteps

fromInteger :: Integer -> RemainingSteps

Show RemainingSteps

Defined in Morley.Michelson.Interpret

Methods

showsPrec :: Int -> RemainingSteps -> ShowS

show :: RemainingSteps -> String

showList :: [RemainingSteps] -> ShowS

NFData RemainingSteps

Defined in Morley.Michelson.Interpret

Methods

rnf :: RemainingSteps -> ()

Buildable RemainingSteps

Defined in Morley.Michelson.Interpret

Methods

build :: RemainingSteps -> Builder

Eq RemainingSteps

Defined in Morley.Michelson.Interpret

Methods

(==) :: RemainingSteps -> RemainingSteps -> Bool

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

Ord RemainingSteps

Defined in Morley.Michelson.Interpret

Methods

compare :: RemainingSteps -> RemainingSteps -> Ordering

(<) :: RemainingSteps -> RemainingSteps -> Bool

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

(>) :: RemainingSteps -> RemainingSteps -> Bool

(>=) :: RemainingSteps -> RemainingSteps -> Bool

max :: RemainingSteps -> RemainingSteps -> RemainingSteps

min :: RemainingSteps -> RemainingSteps -> RemainingSteps

type Rep RemainingSteps

Defined in Morley.Michelson.Interpret

type Rep RemainingSteps = D1 ('MetaData "RemainingSteps" "Morley.Michelson.Interpret" "morley-1.18.0-inplace" 'True) (C1 ('MetaCons "RemainingSteps" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Word64)))

data SomeItStack where

Constructors

SomeItStack :: ExtInstr inp -> Rec StkEl inp -> SomeItStack

newtype MorleyLogs

Morley logs appearing as interpreter result.

Constructors

MorleyLogs

Fields

• unMorleyLogs :: [Text]

Instances

Monoid MorleyLogs

Defined in Morley.Michelson.Interpret

Methods

mempty :: MorleyLogs

mappend :: MorleyLogs -> MorleyLogs -> MorleyLogs

mconcat :: [MorleyLogs] -> MorleyLogs

Semigroup MorleyLogs

Defined in Morley.Michelson.Interpret

Methods

(<>) :: MorleyLogs -> MorleyLogs -> MorleyLogs

sconcat :: NonEmpty MorleyLogs -> MorleyLogs

stimes :: Integral b => b -> MorleyLogs -> MorleyLogs

Generic MorleyLogs

Defined in Morley.Michelson.Interpret

Associated Types

type Rep MorleyLogs :: Type -> Type

Methods

from :: MorleyLogs -> Rep MorleyLogs x

to :: Rep MorleyLogs x -> MorleyLogs

Show MorleyLogs

Defined in Morley.Michelson.Interpret

Methods

showsPrec :: Int -> MorleyLogs -> ShowS

show :: MorleyLogs -> String

showList :: [MorleyLogs] -> ShowS

NFData MorleyLogs

Defined in Morley.Michelson.Interpret

Methods

rnf :: MorleyLogs -> ()

Buildable MorleyLogs

Defined in Morley.Michelson.Interpret

Methods

build :: MorleyLogs -> Builder

Eq MorleyLogs

Defined in Morley.Michelson.Interpret

Methods

(==) :: MorleyLogs -> MorleyLogs -> Bool

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

type Rep MorleyLogs

Defined in Morley.Michelson.Interpret

type Rep MorleyLogs = D1 ('MetaData "MorleyLogs" "Morley.Michelson.Interpret" "morley-1.18.0-inplace" 'True) (C1 ('MetaCons "MorleyLogs" 'PrefixI 'True) (S1 ('MetaSel ('Just "unMorleyLogs") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Text])))

buildMorleyLogs :: MorleyLogsBuilder -> MorleyLogs

newtype MorleyLogsBuilder

Morley logs accumulator, for incremental building.

Constructors

MorleyLogsBuilder (Endo [Text])

Instances

Monoid MorleyLogsBuilder

Defined in Morley.Michelson.Interpret

Methods

mempty :: MorleyLogsBuilder

mappend :: MorleyLogsBuilder -> MorleyLogsBuilder -> MorleyLogsBuilder

mconcat :: [MorleyLogsBuilder] -> MorleyLogsBuilder

Semigroup MorleyLogsBuilder

Defined in Morley.Michelson.Interpret

Methods

(<>) :: MorleyLogsBuilder -> MorleyLogsBuilder -> MorleyLogsBuilder

sconcat :: NonEmpty MorleyLogsBuilder -> MorleyLogsBuilder

stimes :: Integral b => b -> MorleyLogsBuilder -> MorleyLogsBuilder

Generic MorleyLogsBuilder

Defined in Morley.Michelson.Interpret

Associated Types

type Rep MorleyLogsBuilder :: Type -> Type

Methods

from :: MorleyLogsBuilder -> Rep MorleyLogsBuilder x

to :: Rep MorleyLogsBuilder x -> MorleyLogsBuilder

Default MorleyLogsBuilder

Defined in Morley.Michelson.Interpret

Methods

def :: MorleyLogsBuilder

One MorleyLogsBuilder

Defined in Morley.Michelson.Interpret

Associated Types

type OneItem MorleyLogsBuilder

Methods

one :: OneItem MorleyLogsBuilder -> MorleyLogsBuilder

type Rep MorleyLogsBuilder

Defined in Morley.Michelson.Interpret

type Rep MorleyLogsBuilder = D1 ('MetaData "MorleyLogsBuilder" "Morley.Michelson.Interpret" "morley-1.18.0-inplace" 'True) (C1 ('MetaCons "MorleyLogsBuilder" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Endo [Text]))))

type OneItem MorleyLogsBuilder

Defined in Morley.Michelson.Interpret

type OneItem MorleyLogsBuilder = Text

interpret :: Contract cp st -> EntrypointCallT cp arg -> Value arg -> Value st -> GlobalCounter -> BigMapCounter -> ContractEnv -> ContractReturn st

interpretInstr :: ContractEnv -> Instr inp out -> Rec Value inp -> Either MichelsonFailureWithStack (Rec Value out)

Interpret an instruction in vacuum, putting no extra constraints on its execution.

Mostly for testing purposes.

interpretInstrAnnotated :: ContractEnv -> Instr inp out -> Rec Value inp -> Either MichelsonFailureWithStack (Rec StkEl out)

Interpret an instruction in vacuum, putting no extra constraints on its execution while preserving its annotations.

Mostly for testing purposes.

type ContractReturn st = (Either MichelsonFailureWithStack ([Operation], Value st), (InterpreterState, MorleyLogs))

mkInitStack :: Value param -> Value st -> Rec StkEl (ContractInp param st)

fromFinalStack :: Rec StkEl (ContractOut st) -> ([Operation], Value st)

newtype InterpretError

Constructors

InterpretError (MichelsonFailureWithStack, MorleyLogs)

Instances

Generic InterpretError

Defined in Morley.Michelson.Interpret

Associated Types

type Rep InterpretError :: Type -> Type

Methods

from :: InterpretError -> Rep InterpretError x

to :: Rep InterpretError x -> InterpretError

Show InterpretError

Defined in Morley.Michelson.Interpret

Methods

showsPrec :: Int -> InterpretError -> ShowS

show :: InterpretError -> String

showList :: [InterpretError] -> ShowS

Buildable InterpretError

Defined in Morley.Michelson.Interpret

Methods

build :: InterpretError -> Builder

type Rep InterpretError

Defined in Morley.Michelson.Interpret

type Rep InterpretError = D1 ('MetaData "InterpretError" "Morley.Michelson.Interpret" "morley-1.18.0-inplace" 'True) (C1 ('MetaCons "InterpretError" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (MichelsonFailureWithStack, MorleyLogs))))

data InterpretResult where

Constructors

InterpretResult

Fields

• :: StorageScope st
• => { iurOps :: [Operation]
•    , iurNewStorage :: Value st
•    , iurNewState :: InterpreterState
•    , iurMorleyLogs :: MorleyLogs
•    } -> InterpretResult

Instances

Show InterpretResult

Defined in Morley.Michelson.Interpret

Methods

showsPrec :: Int -> InterpretResult -> ShowS

show :: InterpretResult -> String

showList :: [InterpretResult] -> ShowS

type EvalM m = (MonadReader ContractEnv m, InterpreterStateMonad m, MonadWriter MorleyLogsBuilder m, MonadError MichelsonFailureWithStack m)

class Monad m => InterpreterStateMonad m where

Minimal complete definition

Nothing

Methods

getInterpreterState :: m InterpreterState

putInterpreterState :: InterpreterState -> m ()

stateInterpreterState :: (InterpreterState -> (a, InterpreterState)) -> m a

modifyInterpreterState :: (InterpreterState -> InterpreterState) -> m ()

Instances

InterpreterStateMonad m => InterpreterStateMonad (ExceptT e m)

Defined in Morley.Michelson.Interpret

Methods

getInterpreterState :: ExceptT e m InterpreterState

putInterpreterState :: InterpreterState -> ExceptT e m ()

stateInterpreterState :: (InterpreterState -> (a, InterpreterState)) -> ExceptT e m a

modifyInterpreterState :: (InterpreterState -> InterpreterState) -> ExceptT e m ()

InterpreterStateMonad m => InterpreterStateMonad (ReaderT r m)

Defined in Morley.Michelson.Interpret

Methods

getInterpreterState :: ReaderT r m InterpreterState

putInterpreterState :: InterpreterState -> ReaderT r m ()

stateInterpreterState :: (InterpreterState -> (a, InterpreterState)) -> ReaderT r m a

modifyInterpreterState :: (InterpreterState -> InterpreterState) -> ReaderT r m ()

Monad m => InterpreterStateMonad (StateT InterpreterState m)

Defined in Morley.Michelson.Interpret

Methods

getInterpreterState :: StateT InterpreterState m InterpreterState

putInterpreterState :: InterpreterState -> StateT InterpreterState m ()

stateInterpreterState :: (InterpreterState -> (a, InterpreterState)) -> StateT InterpreterState m a

modifyInterpreterState :: (InterpreterState -> InterpreterState) -> StateT InterpreterState m ()

InterpreterStateMonad m => InterpreterStateMonad (StateT w m)

Defined in Morley.Michelson.Interpret

Methods

getInterpreterState :: StateT w m InterpreterState

putInterpreterState :: InterpreterState -> StateT w m ()

stateInterpreterState :: (InterpreterState -> (a, InterpreterState)) -> StateT w m a

modifyInterpreterState :: (InterpreterState -> InterpreterState) -> StateT w m ()

(InterpreterStateMonad m, Monoid w) => InterpreterStateMonad (WriterT w m)

Defined in Morley.Michelson.Interpret

Methods

getInterpreterState :: WriterT w m InterpreterState

putInterpreterState :: InterpreterState -> WriterT w m ()

stateInterpreterState :: (InterpreterState -> (a, InterpreterState)) -> WriterT w m a

modifyInterpreterState :: (InterpreterState -> InterpreterState) -> WriterT w m ()

(Monad m, Monoid w) => InterpreterStateMonad (RWST r w InterpreterState m)

Defined in Morley.Michelson.Interpret

Methods

getInterpreterState :: RWST r w InterpreterState m InterpreterState

putInterpreterState :: InterpreterState -> RWST r w InterpreterState m ()

stateInterpreterState :: (InterpreterState -> (a, InterpreterState)) -> RWST r w InterpreterState m a

modifyInterpreterState :: (InterpreterState -> InterpreterState) -> RWST r w InterpreterState m ()

(InterpreterStateMonad m, Monoid w) => InterpreterStateMonad (RWST r w s m)

Defined in Morley.Michelson.Interpret

Methods

getInterpreterState :: RWST r w s m InterpreterState

putInterpreterState :: InterpreterState -> RWST r w s m ()

stateInterpreterState :: (InterpreterState -> (a, InterpreterState)) -> RWST r w s m a

modifyInterpreterState :: (InterpreterState -> InterpreterState) -> RWST r w s m ()

newtype StkEl t

Constructors

StkEl

Fields

• seValue :: Value t

Instances

Show (StkEl t)

Defined in Morley.Michelson.Interpret

Methods

showsPrec :: Int -> StkEl t -> ShowS

show :: StkEl t -> String

showList :: [StkEl t] -> ShowS

Eq (StkEl t)

Defined in Morley.Michelson.Interpret

Methods

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

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

type InstrRunner m = forall inp out. Instr inp out -> Rec StkEl inp -> m (Rec StkEl out)

runInstr :: EvalM m => InstrRunner m

Function to change amount of remaining steps stored in State monad.

runInstrNoGas :: EvalM m => InstrRunner m

runUnpack :: forall t. UnpackedValScope t => ByteString -> Either UnpackError (Value t)

Unpacks given raw data into a typed value.

Internals

initInterpreterState :: GlobalCounter -> BigMapCounter -> ContractEnv -> InterpreterState

handleContractReturn :: StorageScope st => ContractReturn st -> Either InterpretError InterpretResult

runInstrImpl :: forall m. EvalM m => InstrRunner m -> InstrRunner m

Function to interpret Michelson instruction(s) against given stack.

assignBigMapIds

Arguments

:: MonadState BigMapCounter m

=> Bool

If true, assign a new ID even if the bigmap already has one. Otherwise, assign IDs only to bigmaps that don't have one yet.

-> Value t

-> m (Value t)

All big_maps stored in a chain have a globally unique ID.

We use this function to assign a new ID whenever a big_map is created.

Prisms

_MorleyLogs :: Iso' MorleyLogs [Text]