Safe Haskell	None
Language	Haskell2010

Michelson.Interpret

Contents

Internals

Description

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

Synopsis

data ContractEnv = ContractEnv {
- ceNow :: Timestamp
- ceMaxSteps :: RemainingSteps
- ceBalance :: Mutez
- ceContracts :: TcOriginatedContracts
- ceSelf :: Address
- ceSource :: Address
- ceSender :: Address
- ceAmount :: Mutez
- ceChainId :: ChainId
- ceOperationHash :: Maybe OperationHash
- ceGlobalCounter :: GlobalCounter
- ceLevel :: Natural
}
data InterpreterState = InterpreterState {
- isMorleyLogs :: MorleyLogs
- isRemainingSteps :: RemainingSteps
- isOriginationNonce :: OriginationIndex
}
isMorleyLogsL :: Lens' InterpreterState MorleyLogs
data MichelsonFailed where
- MichelsonFailedWith :: KnownT t => Value t -> MichelsonFailed
- MichelsonArithError :: (Typeable n, Typeable m, Typeable instr) => ArithError (Value' instr n) (Value' instr m) -> MichelsonFailed
- MichelsonGasExhaustion :: MichelsonFailed
- MichelsonFailedTestAssert :: Text -> MichelsonFailed
newtype RemainingSteps = RemainingSteps Word64
data SomeItStack where
- SomeItStack :: ExtInstr inp -> Rec StkEl inp -> SomeItStack
newtype MorleyLogs = MorleyLogs [Text]
noMorleyLogs :: MorleyLogs
pickMorleyLogs :: MorleyLogs -> [Text]
interpret :: Contract cp st -> EntrypointCallT cp arg -> Value arg -> Value st -> ContractEnv -> ContractReturn st
interpretInstr :: ContractEnv -> Instr inp out -> Rec Value inp -> Either MichelsonFailed (Rec Value out)
interpretInstrAnnotated :: ContractEnv -> Instr inp out -> Rec Value inp -> Either MichelsonFailed (Rec StkEl out)
type ContractReturn st = (Either MichelsonFailed ([Operation], Value st), InterpreterState)
mkInitStack :: Value param -> ParamNotes param -> Value st -> Notes st -> Rec StkEl (ContractInp param st)
fromFinalStack :: Rec StkEl (ContractOut st) -> ([Operation], Value st)
newtype InterpretError = InterpretError (MichelsonFailed, MorleyLogs)
data InterpretResult where
- InterpretResult :: StorageScope st => {..} -> InterpretResult
type EvalM m = (MonadReader ContractEnv m, InterpreterStateMonad m, MonadError MichelsonFailed m)
class Monad m => InterpreterStateMonad m where
- getInterpreterState :: m InterpreterState
- putInterpreterState :: InterpreterState -> m ()
- stateInterpreterState :: (InterpreterState -> (a, InterpreterState)) -> m a
- modifyInterpreterState :: (InterpreterState -> InterpreterState) -> m ()
data StkEl t = StkEl {
- seValue :: Value t
- seVarAnn :: VarAnn
- seNotes :: Notes t
}
type InstrRunner m = forall inp out. Instr inp out -> Rec StkEl inp -> m (Rec StkEl out)
runInstr :: EvalM m => InstrRunner m
runInstrNoGas :: EvalM m => InstrRunner m
runUnpack :: forall t. UnpackedValScope t => ByteString -> Either UnpackError (Value t)
initInterpreterState :: ContractEnv -> InterpreterState
handleContractReturn :: StorageScope st => ContractReturn st -> Either InterpretError InterpretResult
runInstrImpl :: EvalM m => InstrRunner m -> InstrRunner m

Documentation

data ContractEnv Source #

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 :: TcOriginatedContracts
Mapping from existing contracts' addresses to their executable representation.
ceSelf :: Address
Address of the interpreted contract.
ceSource :: Address
The contract that initiated the current transaction.
ceSender :: Address
The contract that initiated the current internal transaction.
ceAmount :: Mutez
Amount of the current transaction.
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.
ceGlobalCounter :: GlobalCounter
A global counter that is used to ensure newly created contracts have unique addresses.
ceLevel :: Natural
Number of blocks before the given one in the chain

Instances

Instances details

InterpreterStateMonad (ExceptT MichelsonFailed $ (ReaderT ContractEnv $ State InterpreterState)) Source #

Instance details

Defined in Michelson.Interpret

Methods

getInterpreterState :: (ExceptT MichelsonFailed $ (ReaderT ContractEnv $ State InterpreterState)) InterpreterState Source #

putInterpreterState :: InterpreterState -> (ExceptT MichelsonFailed $ (ReaderT ContractEnv $ State InterpreterState)) () Source #

stateInterpreterState :: (InterpreterState -> (a, InterpreterState)) -> (ExceptT MichelsonFailed $ (ReaderT ContractEnv $ State InterpreterState)) a Source #

modifyInterpreterState :: (InterpreterState -> InterpreterState) -> (ExceptT MichelsonFailed $ (ReaderT ContractEnv $ State InterpreterState)) () Source #

data InterpreterState Source #

Constructors

InterpreterState
Fields isMorleyLogs :: MorleyLogs isRemainingSteps :: RemainingSteps isOriginationNonce :: OriginationIndex

Instances

Instances details

Show InterpreterState Source #
Instance details Defined in Michelson.Interpret Methods showsPrec :: Int -> InterpreterState -> ShowS # show :: InterpreterState -> String # showList :: [InterpreterState] -> ShowS #
Generic InterpreterState Source #
Instance details Defined in Michelson.Interpret Associated Types type Rep InterpreterState :: Type -> Type # Methods from :: InterpreterState -> Rep InterpreterState x # to :: Rep InterpreterState x -> InterpreterState #
NFData InterpreterState Source #
Instance details Defined in Michelson.Interpret Methods rnf :: InterpreterState -> () #
InterpreterStateMonad (ExceptT MichelsonFailed $ (ReaderT ContractEnv $ State InterpreterState)) Source #
Instance details Defined in Michelson.Interpret Methods getInterpreterState :: (ExceptT MichelsonFailed $ (ReaderT ContractEnv $ State InterpreterState)) InterpreterState Source # putInterpreterState :: InterpreterState -> (ExceptT MichelsonFailed $ (ReaderT ContractEnv $ State InterpreterState)) () Source # stateInterpreterState :: (InterpreterState -> (a, InterpreterState)) -> (ExceptT MichelsonFailed $ (ReaderT ContractEnv $ State InterpreterState)) a Source # modifyInterpreterState :: (InterpreterState -> InterpreterState) -> (ExceptT MichelsonFailed $ (ReaderT ContractEnv $ State InterpreterState)) () Source #
type Rep InterpreterState Source #
Instance details Defined in Michelson.Interpret type Rep InterpreterState = D1 ('MetaData "InterpreterState" "Michelson.Interpret" "morley-1.12.0-inplace" 'False) (C1 ('MetaCons "InterpreterState" 'PrefixI 'True) (S1 ('MetaSel ('Just "isMorleyLogs") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 MorleyLogs) :: (S1 ('MetaSel ('Just "isRemainingSteps") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 RemainingSteps) :: S1 ('MetaSel ('Just "isOriginationNonce") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 OriginationIndex))))

isMorleyLogsL :: Lens' InterpreterState MorleyLogs Source #

data MichelsonFailed where Source #

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

Constructors

MichelsonFailedWith :: KnownT t => Value t -> MichelsonFailed
MichelsonArithError :: (Typeable n, Typeable m, Typeable instr) => ArithError (Value' instr n) (Value' instr m) -> MichelsonFailed
MichelsonGasExhaustion :: MichelsonFailed
MichelsonFailedTestAssert :: Text -> MichelsonFailed

Instances

Instances details

Eq MichelsonFailed Source #
Instance details Defined in Michelson.Interpret Methods (==) :: MichelsonFailed -> MichelsonFailed -> Bool # (/=) :: MichelsonFailed -> MichelsonFailed -> Bool #
Show MichelsonFailed Source #
Instance details Defined in Michelson.Interpret Methods showsPrec :: Int -> MichelsonFailed -> ShowS # show :: MichelsonFailed -> String # showList :: [MichelsonFailed] -> ShowS #
NFData MichelsonFailed Source #
Instance details Defined in Michelson.Interpret Methods rnf :: MichelsonFailed -> () #
Buildable MichelsonFailed Source #
Instance details Defined in Michelson.Interpret Methods build :: MichelsonFailed -> Builder #
InterpreterStateMonad (ExceptT MichelsonFailed $ (ReaderT ContractEnv $ State InterpreterState)) Source #
Instance details Defined in Michelson.Interpret Methods getInterpreterState :: (ExceptT MichelsonFailed $ (ReaderT ContractEnv $ State InterpreterState)) InterpreterState Source # putInterpreterState :: InterpreterState -> (ExceptT MichelsonFailed $ (ReaderT ContractEnv $ State InterpreterState)) () Source # stateInterpreterState :: (InterpreterState -> (a, InterpreterState)) -> (ExceptT MichelsonFailed $ (ReaderT ContractEnv $ State InterpreterState)) a Source # modifyInterpreterState :: (InterpreterState -> InterpreterState) -> (ExceptT MichelsonFailed $ (ReaderT ContractEnv $ State InterpreterState)) () Source #

newtype RemainingSteps Source #

Constructors

RemainingSteps Word64

Instances

Instances details

Eq RemainingSteps Source #
Instance details Defined in Michelson.Interpret Methods (==) :: RemainingSteps -> RemainingSteps -> Bool # (/=) :: RemainingSteps -> RemainingSteps -> Bool #
Num RemainingSteps Source #
Instance details Defined in Michelson.Interpret Methods (+) :: RemainingSteps -> RemainingSteps -> RemainingSteps # (-) :: RemainingSteps -> RemainingSteps -> RemainingSteps # (*) :: RemainingSteps -> RemainingSteps -> RemainingSteps # negate :: RemainingSteps -> RemainingSteps # abs :: RemainingSteps -> RemainingSteps # signum :: RemainingSteps -> RemainingSteps # fromInteger :: Integer -> RemainingSteps #
Ord RemainingSteps Source #
Instance details Defined in 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 #
Show RemainingSteps Source #
Instance details Defined in Michelson.Interpret Methods showsPrec :: Int -> RemainingSteps -> ShowS # show :: RemainingSteps -> String # showList :: [RemainingSteps] -> ShowS #
Generic RemainingSteps Source #
Instance details Defined in Michelson.Interpret Associated Types type Rep RemainingSteps :: Type -> Type # Methods from :: RemainingSteps -> Rep RemainingSteps x # to :: Rep RemainingSteps x -> RemainingSteps #
NFData RemainingSteps Source #
Instance details Defined in Michelson.Interpret Methods rnf :: RemainingSteps -> () #
Buildable RemainingSteps Source #
Instance details Defined in Michelson.Interpret Methods build :: RemainingSteps -> Builder #
type Rep RemainingSteps Source #
Instance details Defined in Michelson.Interpret type Rep RemainingSteps = D1 ('MetaData "RemainingSteps" "Michelson.Interpret" "morley-1.12.0-inplace" 'True) (C1 ('MetaCons "RemainingSteps" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Word64)))

data SomeItStack where Source #

Constructors

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

newtype MorleyLogs Source #

Morley logs for interpreter state that are stored in reverse order.

Constructors

MorleyLogs [Text]

Instances

Instances details

Eq MorleyLogs Source #
Instance details Defined in Michelson.Interpret Methods (==) :: MorleyLogs -> MorleyLogs -> Bool # (/=) :: MorleyLogs -> MorleyLogs -> Bool #
Show MorleyLogs Source #
Instance details Defined in Michelson.Interpret Methods showsPrec :: Int -> MorleyLogs -> ShowS # show :: MorleyLogs -> String # showList :: [MorleyLogs] -> ShowS #
Generic MorleyLogs Source #
Instance details Defined in Michelson.Interpret Associated Types type Rep MorleyLogs :: Type -> Type # Methods from :: MorleyLogs -> Rep MorleyLogs x # to :: Rep MorleyLogs x -> MorleyLogs #
NFData MorleyLogs Source #
Instance details Defined in Michelson.Interpret Methods rnf :: MorleyLogs -> () #
Default MorleyLogs Source #
Instance details Defined in Michelson.Interpret Methods def :: MorleyLogs #
Buildable MorleyLogs Source #
Instance details Defined in Michelson.Interpret Methods build :: MorleyLogs -> Builder #
type Rep MorleyLogs Source #
Instance details Defined in Michelson.Interpret type Rep MorleyLogs = D1 ('MetaData "MorleyLogs" "Michelson.Interpret" "morley-1.12.0-inplace" 'True) (C1 ('MetaCons "MorleyLogs" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Text])))

noMorleyLogs :: MorleyLogs Source #

pickMorleyLogs :: MorleyLogs -> [Text] Source #

interpret :: Contract cp st -> EntrypointCallT cp arg -> Value arg -> Value st -> ContractEnv -> ContractReturn st Source #

interpretInstr :: ContractEnv -> Instr inp out -> Rec Value inp -> Either MichelsonFailed (Rec Value out) Source #

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

Mostly for testing purposes.

interpretInstrAnnotated :: ContractEnv -> Instr inp out -> Rec Value inp -> Either MichelsonFailed (Rec StkEl out) Source #

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

Mostly for testing purposes.

type ContractReturn st = (Either MichelsonFailed ([Operation], Value st), InterpreterState) Source #

mkInitStack :: Value param -> ParamNotes param -> Value st -> Notes st -> Rec StkEl (ContractInp param st) Source #

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

newtype InterpretError Source #

Constructors

InterpretError (MichelsonFailed, MorleyLogs)

Instances

Instances details

Show InterpretError Source #
Instance details Defined in Michelson.Interpret Methods showsPrec :: Int -> InterpretError -> ShowS # show :: InterpretError -> String # showList :: [InterpretError] -> ShowS #
Generic InterpretError Source #
Instance details Defined in Michelson.Interpret Associated Types type Rep InterpretError :: Type -> Type # Methods from :: InterpretError -> Rep InterpretError x # to :: Rep InterpretError x -> InterpretError #
Buildable InterpretError Source #
Instance details Defined in Michelson.Interpret Methods build :: InterpretError -> Builder #
type Rep InterpretError Source #
Instance details Defined in Michelson.Interpret type Rep InterpretError = D1 ('MetaData "InterpretError" "Michelson.Interpret" "morley-1.12.0-inplace" 'True) (C1 ('MetaCons "InterpretError" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (MichelsonFailed, MorleyLogs))))

data InterpretResult where Source #

Constructors

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

Instances

Instances details

Show InterpretResult Source #
Instance details Defined in Michelson.Interpret Methods showsPrec :: Int -> InterpretResult -> ShowS # show :: InterpretResult -> String # showList :: [InterpretResult] -> ShowS #

type EvalM m = (MonadReader ContractEnv m, InterpreterStateMonad m, MonadError MichelsonFailed m) Source #

class Monad m => InterpreterStateMonad m where Source #

Minimal complete definition

Nothing

Methods

getInterpreterState :: m InterpreterState Source #

putInterpreterState :: InterpreterState -> m () Source #

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

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

Instances

Instances details

InterpreterStateMonad (ExceptT MichelsonFailed $ (ReaderT ContractEnv $ State InterpreterState)) Source #

Instance details

Defined in Michelson.Interpret

Methods

getInterpreterState :: (ExceptT MichelsonFailed $ (ReaderT ContractEnv $ State InterpreterState)) InterpreterState Source #

putInterpreterState :: InterpreterState -> (ExceptT MichelsonFailed $ (ReaderT ContractEnv $ State InterpreterState)) () Source #

stateInterpreterState :: (InterpreterState -> (a, InterpreterState)) -> (ExceptT MichelsonFailed $ (ReaderT ContractEnv $ State InterpreterState)) a Source #

modifyInterpreterState :: (InterpreterState -> InterpreterState) -> (ExceptT MichelsonFailed $ (ReaderT ContractEnv $ State InterpreterState)) () Source #

data StkEl t Source #

Constructors

StkEl
Fields seValue :: Value t seVarAnn :: VarAnn seNotes :: Notes t

Instances

Instances details

Eq (StkEl t) Source #
Instance details Defined in Michelson.Interpret Methods (==) :: StkEl t -> StkEl t -> Bool # (/=) :: StkEl t -> StkEl t -> Bool #
Show (StkEl t) Source #
Instance details Defined in Michelson.Interpret Methods showsPrec :: Int -> StkEl t -> ShowS # show :: StkEl t -> String # showList :: [StkEl t] -> ShowS #

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

runInstr :: EvalM m => InstrRunner m Source #

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

runInstrNoGas :: EvalM m => InstrRunner m Source #

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

Unpacks given raw data into a typed value.

Internals

initInterpreterState :: ContractEnv -> InterpreterState Source #

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

runInstrImpl :: EvalM m => InstrRunner m -> InstrRunner m Source #

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