Michelson.Runtime

Interpreter and typechecker of a contract in Morley language.

High level interface for end user

originateContract :: FilePath -> OriginationOperation -> ("verbose" :! Bool) -> IO Address

Originate a contract. Returns the address of the originated contract.

runContract :: Maybe Timestamp -> Word64 -> Mutez -> FilePath -> Value -> Contract -> TxData -> ("verbose" :! Bool) -> ("dryRun" :! Bool) -> IO ()

Run a contract. The contract is originated first (if it's not already) and then we pretend that we send a transaction to it.

transfer :: Maybe Timestamp -> Word64 -> FilePath -> Address -> TxData -> ("verbose" :! Bool) -> ("dryRun" :? Bool) -> IO ()

Send a transaction to given address with given parameters.

Other helpers

parseContract :: Maybe FilePath -> Text -> Either ParserException (Contract' ParsedOp)

Parse a contract from Text.

parseExpandContract :: Maybe FilePath -> Text -> Either ParserException Contract

Parse a contract from Text and expand macros.

readAndParseContract :: Maybe FilePath -> IO (Contract' ParsedOp)

Read and parse a contract from give path or stdin (if the argument is Nothing). The contract is not expanded.

prepareContract :: Maybe FilePath -> IO Contract

Read a contract using readAndParseContract, expand and flatten. The contract is not type checked.

typeCheckWithDb :: FilePath -> Contract -> IO (Either TCError SomeContract)

Re-exports

data ContractState

State of a contract with code.

Constructors

ContractState

Fields

• csBalance :: !Mutez

  Amount of mutez owned by this contract.

• csStorage :: !Value

  Storage value associated with this contract.

• csContract :: !Contract

  Contract itself (untyped).

• csTypedContract :: !(Maybe SomeContract)
• csTypedStorage :: !(Maybe SomeValue)

  We keep typed representation of contract code and storage in form, that hides their actual type in order to simplify the rest of the code (e.g. avoid type parameters for ContractState and so on). They are made optional in order to perform safe parsing from JSON (we simply return Nothing in this parser and use getTypedStorage or getTypedContract that optionally typecheck storage or contract code).

Instances

Show ContractState

Defined in Michelson.Runtime.GState

Methods

showsPrec :: Int -> ContractState -> ShowS

show :: ContractState -> String

showList :: [ContractState] -> ShowS

ToJSON ContractState

Defined in Michelson.Runtime.GState

Methods

toJSON :: ContractState -> Value

toEncoding :: ContractState -> Encoding

toJSONList :: [ContractState] -> Value

toEncodingList :: [ContractState] -> Encoding

FromJSON ContractState

Defined in Michelson.Runtime.GState

Methods

parseJSON :: Value -> Parser ContractState

parseJSONList :: Value -> Parser [ContractState]

Buildable ContractState

Defined in Michelson.Runtime.GState

Methods

build :: ContractState -> Builder

data AddressState

State of an arbitrary address.

Constructors

ASSimple !Mutez

For contracts without code we store only its balance.

ASContract !ContractState

For contracts with code we store more state represented by ContractState.

Instances

Show AddressState

Defined in Michelson.Runtime.GState

Methods

showsPrec :: Int -> AddressState -> ShowS

show :: AddressState -> String

showList :: [AddressState] -> ShowS

Generic AddressState

Defined in Michelson.Runtime.GState

Associated Types

type Rep AddressState :: Type -> Type

Methods

from :: AddressState -> Rep AddressState x

to :: Rep AddressState x -> AddressState

ToJSON AddressState

Defined in Michelson.Runtime.GState

Methods

toJSON :: AddressState -> Value

toEncoding :: AddressState -> Encoding

toJSONList :: [AddressState] -> Value

toEncodingList :: [AddressState] -> Encoding

FromJSON AddressState

Defined in Michelson.Runtime.GState

Methods

parseJSON :: Value -> Parser AddressState

parseJSONList :: Value -> Parser [AddressState]

Buildable AddressState

Defined in Michelson.Runtime.GState

Methods

build :: AddressState -> Builder

type Rep AddressState

Defined in Michelson.Runtime.GState

type Rep AddressState = D1 (MetaData "AddressState" "Michelson.Runtime.GState" "morley-0.4.0-79hq8tlMULq833S07vUm65" False) (C1 (MetaCons "ASSimple" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Mutez)) :+: C1 (MetaCons "ASContract" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 ContractState)))

data TxData

Data associated with a particular transaction.

Constructors

TxData

Fields

• tdSenderAddress :: !Address
• tdParameter :: !Value
• tdAmount :: !Mutez

Instances

Eq TxData

Defined in Michelson.Runtime.TxData

Methods

(==) :: TxData -> TxData -> Bool

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

Show TxData

Defined in Michelson.Runtime.TxData

Methods

showsPrec :: Int -> TxData -> ShowS

show :: TxData -> String

showList :: [TxData] -> ShowS

For testing

data InterpreterOp

Operations executed by interpreter. In our model one Michelson's operation (operation type in Michelson) corresponds to 0 or 1 interpreter operation.

Note: Address is not part of TxData, because TxData is supposed to be provided by the user, while Address can be computed by our code.

Constructors

OriginateOp !OriginationOperation

Originate a contract.

TransferOp Address TxData

Send a transaction to given address which is assumed to be the address of an originated contract.

Instances

Show InterpreterOp

Defined in Michelson.Runtime

Methods

showsPrec :: Int -> InterpreterOp -> ShowS

show :: InterpreterOp -> String

showList :: [InterpreterOp] -> ShowS

data InterpreterRes

Result of a single execution of interpreter.

Constructors

InterpreterRes

Fields

• _irGState :: !GState

  New GState.

• _irOperations :: [InterpreterOp]

  List of operations to be added to the operations queue.

• _irUpdates :: ![GStateUpdate]

  Updates applied to GState.

• _irInterpretResults :: [(Address, InterpretResult)]

  During execution a contract can print logs and in the end it returns a pair. All logs and returned values are kept until all called contracts are executed. In the end they are printed.

• _irSourceAddress :: !(Maybe Address)

  As soon as transfer operation is encountered, this address is set to its input.

• _irRemainingSteps :: !RemainingSteps

  Now much gas all remaining executions can consume.

Instances

Show InterpreterRes

Defined in Michelson.Runtime

Methods

showsPrec :: Int -> InterpreterRes -> ShowS

show :: InterpreterRes -> String

showList :: [InterpreterRes] -> ShowS

Semigroup InterpreterRes

Defined in Michelson.Runtime

Methods

(<>) :: InterpreterRes -> InterpreterRes -> InterpreterRes

sconcat :: NonEmpty InterpreterRes -> InterpreterRes

stimes :: Integral b => b -> InterpreterRes -> InterpreterRes

data InterpreterError' a

Errors that can happen during contract interpreting. Type parameter a determines how contracts will be represented in these errors, e.g. Address

Constructors

IEUnknownContract !a

The interpreted contract hasn't been originated.

IEInterpreterFailed !a !InterpretError

Interpretation of Michelson contract failed.

IEAlreadyOriginated !a !ContractState

A contract is already originated.

IEUnknownSender !a

Sender address is unknown.

IEUnknownManager !a

Manager address is unknown.

IENotEnoughFunds !a !Mutez

Sender doesn't have enough funds.

IEZeroTransaction !a

Sending 0tz towards an address.

IEFailedToApplyUpdates !GStateUpdateError

Failed to apply updates to GState.

IEIllTypedContract !TCError

A contract is ill-typed.

IEIllTypedStorage !TCError

Contract storage is ill-typed

IEIllTypedParameter !TCError

Contract parameter is ill-typed

Instances

Show a => Show (InterpreterError' a)

Defined in Michelson.Runtime

Methods

showsPrec :: Int -> InterpreterError' a -> ShowS

show :: InterpreterError' a -> String

showList :: [InterpreterError' a] -> ShowS

(Typeable a, Show a, Buildable a) => Exception (InterpreterError' a)

Defined in Michelson.Runtime

Methods

toException :: InterpreterError' a -> SomeException

fromException :: SomeException -> Maybe (InterpreterError' a)

displayException :: InterpreterError' a -> String

Buildable a => Buildable (InterpreterError' a)

Defined in Michelson.Runtime

Methods

build :: InterpreterError' a -> Builder

type InterpreterError = InterpreterError' Address

interpreterPure :: Timestamp -> RemainingSteps -> GState -> [InterpreterOp] -> Either InterpreterError InterpreterRes

Implementation of interpreter outside IO. It reads operations, interprets them one by one and updates state accordingly. Each operation from the passed list is fully interpreted before the next one is considered.

To avoid warnings (can't generate lenses only for some fields)

irInterpretResults :: Lens' InterpreterRes [(Address, InterpretResult)]

irUpdates :: Lens' InterpreterRes [GStateUpdate]