Morley.Tezos.Core

Core primitive Tezos types.

Mutez

newtype Mutez

Mutez is a wrapper over integer data type. 1 mutez is 1 token (μTz).

The constructor is marked Unsafe since GHC does not warn on overflowing literals (exceeding custom Word63 type bounds), thus the resultant Mutez value may get truncated silently.

>>> UnsafeMutez 9223372036854775809
UnsafeMutez {unMutez = 1}

Constructors

UnsafeMutez

Fields

• unMutez :: Word63

Instances

FromJSON Mutez

Defined in Morley.Tezos.Core

Methods

parseJSON :: Value -> Parser Mutez

parseJSONList :: Value -> Parser [Mutez]

ToJSON Mutez

Defined in Morley.Tezos.Core

Methods

toJSON :: Mutez -> Value

toEncoding :: Mutez -> Encoding

toJSONList :: [Mutez] -> Value

toEncodingList :: [Mutez] -> Encoding

Bounded Mutez

Defined in Morley.Tezos.Core

Methods

minBound :: Mutez

maxBound :: Mutez

Enum Mutez

Defined in Morley.Tezos.Core

Methods

succ :: Mutez -> Mutez

pred :: Mutez -> Mutez

toEnum :: Int -> Mutez

fromEnum :: Mutez -> Int

enumFrom :: Mutez -> [Mutez]

enumFromThen :: Mutez -> Mutez -> [Mutez]

enumFromTo :: Mutez -> Mutez -> [Mutez]

enumFromThenTo :: Mutez -> Mutez -> Mutez -> [Mutez]

Generic Mutez

Defined in Morley.Tezos.Core

Associated Types

type Rep Mutez :: Type -> Type

Methods

from :: Mutez -> Rep Mutez x

to :: Rep Mutez x -> Mutez

Show Mutez

Defined in Morley.Tezos.Core

Methods

showsPrec :: Int -> Mutez -> ShowS

show :: Mutez -> String

showList :: [Mutez] -> ShowS

NFData Mutez

Defined in Morley.Tezos.Core

Methods

rnf :: Mutez -> ()

Eq Mutez

Defined in Morley.Tezos.Core

Methods

(==) :: Mutez -> Mutez -> Bool

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

Ord Mutez

Defined in Morley.Tezos.Core

Methods

compare :: Mutez -> Mutez -> Ordering

(<) :: Mutez -> Mutez -> Bool

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

(>) :: Mutez -> Mutez -> Bool

(>=) :: Mutez -> Mutez -> Bool

max :: Mutez -> Mutez -> Mutez

min :: Mutez -> Mutez -> Mutez

HasRPCRepr Mutez

Defined in Morley.AsRPC

Associated Types

type AsRPC Mutez

TypeHasDoc Mutez

Defined in Morley.Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions Mutez :: FieldDescriptions

Methods

typeDocName :: Proxy Mutez -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy Mutez -> WithinParens -> Markdown

typeDocDependencies :: Proxy Mutez -> [SomeDocDefinitionItem]

typeDocHaskellRep :: TypeDocHaskellRep Mutez

typeDocMichelsonRep :: TypeDocMichelsonRep Mutez

IsoValue Mutez

Defined in Morley.Michelson.Typed.Haskell.Value

Associated Types

type ToT Mutez :: T

Methods

toVal :: Mutez -> Value (ToT Mutez)

fromVal :: Value (ToT Mutez) -> Mutez

HasCLReader Mutez

Defined in Morley.Tezos.Core

Methods

getReader :: ReadM Mutez

getMetavar :: String

Buildable Mutez

Defined in Morley.Tezos.Core

Methods

build :: Mutez -> Doc

buildList :: [Mutez] -> Doc

type Rep Mutez

Defined in Morley.Tezos.Core

type Rep Mutez = D1 ('MetaData "Mutez" "Morley.Tezos.Core" "morley-1.20.0-inplace" 'True) (C1 ('MetaCons "UnsafeMutez" 'PrefixI 'True) (S1 ('MetaSel ('Just "unMutez") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Word63)))

type AsRPC Mutez

Defined in Morley.AsRPC

type AsRPC Mutez = Mutez

type TypeDocFieldDescriptions Mutez

Defined in Morley.Michelson.Typed.Haskell.Doc

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

type ToT Mutez

Defined in Morley.Michelson.Typed.Haskell.Value

type ToT Mutez = 'TMutez

tz :: QuasiQuoter

Quotes a Mutez value.

The value is in XTZ, i.e. 1e6 Mutez, with optional suffix representing a unit:

• k, kilo -- 1000 XTZ
• M, Mega, mega -- 1000000 XTZ
• m, milli -- 0.001 XTZ
• u, μ, micro -- 0.000001 XTZ

This is the safest and recommended way to create Mutez from a numeric literal.

The suffix can be separated from the number by whitespace. You can also use underscores as a delimiter (those will be ignored), and scientific notation, e.g. 123.456e6. Note that if the scientific notation represents a mutez fraction, that is a compile-time error.

>>> [tz|123|]
UnsafeMutez {unMutez = 123000000}

>>> [tz|123k|]
UnsafeMutez {unMutez = 123000000000}

>>> [tz|123 kilo|]
UnsafeMutez {unMutez = 123000000000}

>>> [tz|123M|]
UnsafeMutez {unMutez = 123000000000000}

>>> [tz|123 Mega|]
UnsafeMutez {unMutez = 123000000000000}

>>> [tz|123 mega|]
UnsafeMutez {unMutez = 123000000000000}

>>> [tz|123e6|]
UnsafeMutez {unMutez = 123000000000000}

>>> [tz|123m|]
UnsafeMutez {unMutez = 123000}

>>> [tz|123 milli|]
UnsafeMutez {unMutez = 123000}

>>> [tz|123u|]
UnsafeMutez {unMutez = 123}

>>> [tz|123μ|]
UnsafeMutez {unMutez = 123}

>>> [tz|123 micro|]
UnsafeMutez {unMutez = 123}

>>> [tz| 123.456_789 |]
UnsafeMutez {unMutez = 123456789}

>>> [tz|123.456u|]
...
... error:
...  • The number is a mutez fraction. The smallest possible subdivision is 0.000001 XTZ
...

>>> [tz|0.012_345_6|]
...
... error:
...  • The number is a mutez fraction. The smallest possible subdivision is 0.000001 XTZ
...

>>> [tz| 9223372.036854775807 M |]
UnsafeMutez {unMutez = 9223372036854775807}

>>> [tz| 9223372.036854775808 M |]
...
... error:
...  • The number is out of mutez bounds. It must be between 0 and 9223372036854.775807 XTZ (inclusive).
...

>>> [tz| -1 |]
...
... error:
...  • The number is out of mutez bounds. It must be between 0 and 9223372036854.775807 XTZ (inclusive).
...

mkMutez :: Integral i => i -> Either Text Mutez

Safely creates Mutez checking for overflow and underflow. Accepts a number of any type.

toMutez :: (Integral a, CheckIntSubType a Word63) => a -> Mutez

Safely create Mutez.

When constructing literals, you'll need to specify the type of the literal. GHC will check for literal overflow on builtin types like Word16 and Word32, but not on Word62 or Word63, so those can overflow silently.

It's recommended to use tz quasiquote for literals instead.

addMutez :: Mutez -> Mutez -> Maybe Mutez

Addition of Mutez values. Returns Nothing in case of overflow.

unsafeAddMutez :: HasCallStack => Mutez -> Mutez -> Mutez

Partial addition of Mutez, should be used only if you're sure there'll be no overflow.

subMutez :: Mutez -> Mutez -> Maybe Mutez

Subtraction of Mutez values. Returns Nothing when the subtrahend is greater than the minuend, and Just otherwise.

unsafeSubMutez :: HasCallStack => Mutez -> Mutez -> Mutez

Partial subtraction of Mutez, should be used only if you're sure there'll be no underflow.

mulMutez :: Integral a => Mutez -> a -> Maybe Mutez

Multiplication of Mutez and an integral number. Returns Nothing in case of overflow.

unsafeMulMutez :: Mutez -> Natural -> Mutez

Partial multiplication of Mutez and an Natural number. Should be used only if you're sure there'll be no overflow.

divModMutez :: Mutez -> Mutez -> Maybe (Word63, Mutez)

Euclidian division of two Mutez values.

divModMutezInt :: Integral a => Mutez -> a -> Maybe (Mutez, Mutez)

Euclidian division of Mutez and a number.

zeroMutez :: Mutez

oneMutez :: Mutez

prettyTez :: Mutez -> Text

>>> putTextLn $ prettyTez [tz|420u|]
0.00042 ꜩ

>>> putTextLn $ prettyTez [tz|42|]
42 ꜩ

Timestamp

newtype Timestamp

Time in the real world. Use the functions below to convert it to/from Unix time in seconds.

Constructors

Timestamp

Fields

• unTimestamp :: POSIXTime

Instances

FromJSON Timestamp

Defined in Morley.Tezos.Core

Methods

parseJSON :: Value -> Parser Timestamp

parseJSONList :: Value -> Parser [Timestamp]

ToJSON Timestamp

Defined in Morley.Tezos.Core

Methods

toJSON :: Timestamp -> Value

toEncoding :: Timestamp -> Encoding

toJSONList :: [Timestamp] -> Value

toEncodingList :: [Timestamp] -> Encoding

Data Timestamp

Defined in Morley.Tezos.Core

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Timestamp -> c Timestamp

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Timestamp

toConstr :: Timestamp -> Constr

dataTypeOf :: Timestamp -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Timestamp)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Timestamp)

gmapT :: (forall b. Data b => b -> b) -> Timestamp -> Timestamp

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Timestamp -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Timestamp -> r

gmapQ :: (forall d. Data d => d -> u) -> Timestamp -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Timestamp -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Timestamp -> m Timestamp

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Timestamp -> m Timestamp

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Timestamp -> m Timestamp

Generic Timestamp

Defined in Morley.Tezos.Core

Associated Types

type Rep Timestamp :: Type -> Type

Methods

from :: Timestamp -> Rep Timestamp x

to :: Rep Timestamp x -> Timestamp

Show Timestamp

Defined in Morley.Tezos.Core

Methods

showsPrec :: Int -> Timestamp -> ShowS

show :: Timestamp -> String

showList :: [Timestamp] -> ShowS

NFData Timestamp

Defined in Morley.Tezos.Core

Methods

rnf :: Timestamp -> ()

Eq Timestamp

Defined in Morley.Tezos.Core

Methods

(==) :: Timestamp -> Timestamp -> Bool

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

Ord Timestamp

Defined in Morley.Tezos.Core

Methods

compare :: Timestamp -> Timestamp -> Ordering

(<) :: Timestamp -> Timestamp -> Bool

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

(>) :: Timestamp -> Timestamp -> Bool

(>=) :: Timestamp -> Timestamp -> Bool

max :: Timestamp -> Timestamp -> Timestamp

min :: Timestamp -> Timestamp -> Timestamp

HasRPCRepr Timestamp

Defined in Morley.AsRPC

Associated Types

type AsRPC Timestamp

TypeHasDoc Timestamp

Defined in Morley.Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions Timestamp :: FieldDescriptions

Methods

typeDocName :: Proxy Timestamp -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy Timestamp -> WithinParens -> Markdown

typeDocDependencies :: Proxy Timestamp -> [SomeDocDefinitionItem]

typeDocHaskellRep :: TypeDocHaskellRep Timestamp

typeDocMichelsonRep :: TypeDocMichelsonRep Timestamp

IsoValue Timestamp

Defined in Morley.Michelson.Typed.Haskell.Value

Associated Types

type ToT Timestamp :: T

Methods

toVal :: Timestamp -> Value (ToT Timestamp)

fromVal :: Value (ToT Timestamp) -> Timestamp

Buildable Timestamp

Defined in Morley.Tezos.Core

Methods

build :: Timestamp -> Doc

buildList :: [Timestamp] -> Doc

type Rep Timestamp

Defined in Morley.Tezos.Core

type Rep Timestamp = D1 ('MetaData "Timestamp" "Morley.Tezos.Core" "morley-1.20.0-inplace" 'True) (C1 ('MetaCons "Timestamp" 'PrefixI 'True) (S1 ('MetaSel ('Just "unTimestamp") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 POSIXTime)))

type AsRPC Timestamp

Defined in Morley.AsRPC

type AsRPC Timestamp = Timestamp

type TypeDocFieldDescriptions Timestamp

Defined in Morley.Michelson.Typed.Haskell.Doc

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

type ToT Timestamp

Defined in Morley.Michelson.Typed.Haskell.Value

type ToT Timestamp = 'TTimestamp

timestampToSeconds :: Integral a => Timestamp -> a

timestampFromSeconds :: Integer -> Timestamp

timestampFromUTCTime :: UTCTime -> Timestamp

timestampToUTCTime :: Timestamp -> UTCTime

timestampPlusSeconds :: Timestamp -> Integer -> Timestamp

Add given amount of seconds to a Timestamp.

formatTimestamp :: Timestamp -> Text

Display timestamp in human-readable way as used by Michelson. Uses UTC timezone, though maybe we should take it as an argument.

NB: this will render timestamp with up to seconds precision.

parseTimestamp :: Text -> Maybe Timestamp

Parse textual representation of Timestamp.

timestampQuote :: QuasiQuoter

Quote a value of type Timestamp in yyyy-mm-ddThh:mm:ss[.sss]Z format.

>>> formatTimestamp [timestampQuote| 2019-02-21T16:54:12.2344523Z |]
"2019-02-21T16:54:12Z"

Inspired by 'time-quote' library.

getCurrentTime :: IO Timestamp

Return current time as Timestamp.

farFuture :: Timestamp

Timestamp which is always greater than result of getCurrentTime.

farPast :: Timestamp

Timestamp which is always less than result of getCurrentTime.

ChainId

newtype ChainId

Identifier of a network (babylonnet, mainnet, test network or other). Evaluated as hash of the genesis block.

The only operation supported for this type is packing. Use case: multisig contract, for instance, now includes chain ID into signed data "in order to add extra replay protection between the main chain and the test chain".

Constructors

UnsafeChainId

Fields

• unChainId :: ByteString

Instances

FromJSON ChainId

Defined in Morley.Tezos.Core

Methods

parseJSON :: Value -> Parser ChainId

parseJSONList :: Value -> Parser [ChainId]

ToJSON ChainId

Defined in Morley.Tezos.Core

Methods

toJSON :: ChainId -> Value

toEncoding :: ChainId -> Encoding

toJSONList :: [ChainId] -> Value

toEncodingList :: [ChainId] -> Encoding

Generic ChainId

Defined in Morley.Tezos.Core

Associated Types

type Rep ChainId :: Type -> Type

Methods

from :: ChainId -> Rep ChainId x

to :: Rep ChainId x -> ChainId

Show ChainId

Defined in Morley.Tezos.Core

Methods

showsPrec :: Int -> ChainId -> ShowS

show :: ChainId -> String

showList :: [ChainId] -> ShowS

NFData ChainId

Defined in Morley.Tezos.Core

Methods

rnf :: ChainId -> ()

Eq ChainId

Defined in Morley.Tezos.Core

Methods

(==) :: ChainId -> ChainId -> Bool

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

Ord ChainId

Defined in Morley.Tezos.Core

Methods

compare :: ChainId -> ChainId -> Ordering

(<) :: ChainId -> ChainId -> Bool

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

(>) :: ChainId -> ChainId -> Bool

(>=) :: ChainId -> ChainId -> Bool

max :: ChainId -> ChainId -> ChainId

min :: ChainId -> ChainId -> ChainId

HasRPCRepr ChainId

Defined in Morley.AsRPC

Associated Types

type AsRPC ChainId

TypeHasDoc ChainId

Defined in Morley.Michelson.Typed.Haskell.Doc

Associated Types

type TypeDocFieldDescriptions ChainId :: FieldDescriptions

Methods

typeDocName :: Proxy ChainId -> Text

typeDocMdDescription :: Markdown

typeDocMdReference :: Proxy ChainId -> WithinParens -> Markdown

typeDocDependencies :: Proxy ChainId -> [SomeDocDefinitionItem]

typeDocHaskellRep :: TypeDocHaskellRep ChainId

typeDocMichelsonRep :: TypeDocMichelsonRep ChainId

IsoValue ChainId

Defined in Morley.Michelson.Typed.Haskell.Value

Associated Types

type ToT ChainId :: T

Methods

toVal :: ChainId -> Value (ToT ChainId)

fromVal :: Value (ToT ChainId) -> ChainId

Buildable ChainId

Defined in Morley.Tezos.Core

Methods

build :: ChainId -> Doc

buildList :: [ChainId] -> Doc

type Rep ChainId

Defined in Morley.Tezos.Core

type Rep ChainId = D1 ('MetaData "ChainId" "Morley.Tezos.Core" "morley-1.20.0-inplace" 'True) (C1 ('MetaCons "UnsafeChainId" 'PrefixI 'True) (S1 ('MetaSel ('Just "unChainId") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ByteString)))

type AsRPC ChainId

Defined in Morley.AsRPC

type AsRPC ChainId = ChainId

type TypeDocFieldDescriptions ChainId

Defined in Morley.Michelson.Typed.Haskell.Doc

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

type ToT ChainId

Defined in Morley.Michelson.Typed.Haskell.Value

type ToT ChainId = 'TChainId

mkChainId :: ByteString -> Either ParseChainIdError ChainId

Construct chain ID from raw bytes.

dummyChainId :: ChainId

Identifier of a pseudo network.

formatChainId :: ChainId -> Text

Pretty print ChainId as it is displayed e.g. in octez-client rpc get chainsmain/chain_id call.

Example of produced value: NetXUdfLh6Gm88t.

mformatChainId :: ChainId -> MText

parseChainId :: Text -> Either ParseChainIdError ChainId

chainIdLength :: Int