Lorentz.Instr

Documentation

nop :: s :-> s

drop :: (a & s) :-> s

dup :: (a & s) :-> (a & (a & s))

swap :: (a & (b & s)) :-> (b & (a & s))

push :: forall t s. (KnownValue t, NoOperation t, NoBigMap t, IsoValue t) => t -> s :-> (t & s)

some :: (a & s) :-> (Maybe a & s)

none :: forall a s. KnownValue a => s :-> (Maybe a & s)

unit :: s :-> (() & s)

ifNone :: (s :-> s') -> ((a & s) :-> s') -> (Maybe a & s) :-> s'

pair :: (a & (b & s)) :-> ((a, b) & s)

car :: ((a, b) & s) :-> (a & s)

cdr :: ((a, b) & s) :-> (b & s)

left :: forall a b s. KnownValue b => (a & s) :-> (Either a b & s)

right :: forall a b s. KnownValue a => (b & s) :-> (Either a b & s)

ifLeft :: ((a & s) :-> s') -> ((b & s) :-> s') -> (Either a b & s) :-> s'

nil :: KnownValue p => s :-> (List p & s)

cons :: (a & (List a & s)) :-> (List a & s)

size :: SizeOpHs c => (c & s) :-> (Natural & s)

emptySet :: KnownCValue e => s :-> (Set e & s)

emptyMap :: (KnownCValue k, KnownValue v) => s :-> (Map k v & s)

map :: (MapOpHs c, IsoMapOpRes c b) => ((MapOpInpHs c & s) :-> (b & s)) -> (c & s) :-> (MapOpResHs c b & s)

iter :: IterOpHs c => ((IterOpElHs c & s) :-> s) -> (c & s) :-> s

mem :: MemOpHs c => (MemOpKeyHs c & (c & s)) :-> (Bool & s)

get :: GetOpHs c => (GetOpKeyHs c & (c & s)) :-> (Maybe (GetOpValHs c) & s)

update :: UpdOpHs c => (UpdOpKeyHs c & (UpdOpParamsHs c & (c & s))) :-> (c & s)

failingWhenPresent :: forall c k s v st e. (MemOpHs c, k ~ MemOpKeyHs c, KnownValue e, st ~ (k & (v & (c & s)))) => (forall s0. (k ': s0) :-> (e ': s0)) -> st :-> st

Helper instruction.

Checks whether given key present in the storage and fails if it is. This instruction leaves stack intact.

updateNew :: forall c k s e. (UpdOpHs c, MemOpHs c, k ~ UpdOpKeyHs c, k ~ MemOpKeyHs c, KnownValue e) => (forall s0. (k ': s0) :-> (e ': s0)) -> (k & (UpdOpParamsHs c & (c & s))) :-> (c & s)

Like update, but throw an error on attempt to overwrite existing entry.

if_ :: (s :-> s') -> (s :-> s') -> (Bool & s) :-> s'

ifCons :: ((a & (List a & s)) :-> s') -> (s :-> s') -> (List a & s) :-> s'

loop :: (s :-> (Bool & s)) -> (Bool & s) :-> s

loopLeft :: ((a & s) :-> (Either a b & s)) -> (Either a b & s) :-> (b & s)

lambda :: (KnownValue i, KnownValue o) => Lambda i o -> s :-> (Lambda i o & s)

exec :: (a & (Lambda a b & s)) :-> (b & s)

dip :: forall a s s'. (s :-> s') -> (a & s) :-> (a & s')

failWith :: KnownValue a => (a & s) :-> t

failText :: MText -> s :-> t

Fail with a given message.

failTagged :: KnownValue a => MText -> (a & s) :-> t

Fail with a given message and the top of the current stack.

failUsing :: (IsoValue a, KnownValue a, NoOperation a, NoBigMap a) => a -> s :-> t

Fail with the given Haskell value.

failUnexpected :: HasCallStack => MText -> s :-> t

Fail, providing a reference to the place in the code where this function is called.

Like error in Haskell code, this instruction is for internal errors only.

cast :: KnownValue a => (a & s) :-> (a & s)

pack :: forall a s. (KnownValue a, NoOperation a, NoBigMap a) => (a & s) :-> (ByteString & s)

unpack :: forall a s. (KnownValue a, NoOperation a, NoBigMap a) => (ByteString & s) :-> (Maybe a & s)

concat :: ConcatOpHs c => (c & (c & s)) :-> (c & s)

concat' :: ConcatOpHs c => (List c & s) :-> (c & s)

slice :: SliceOpHs c => (Natural & (Natural & (c & s))) :-> (Maybe c & s)

isNat :: (Integer & s) :-> (Maybe Natural & s)

add :: ArithOpHs Add n m => (n & (m & s)) :-> (ArithResHs Add n m & s)

sub :: ArithOpHs Sub n m => (n & (m & s)) :-> (ArithResHs Sub n m & s)

rsub :: ArithOpHs Sub n m => (m & (n & s)) :-> (ArithResHs Sub n m & s)

mul :: ArithOpHs Mul n m => (n & (m & s)) :-> (ArithResHs Mul n m & s)

ediv :: EDivOpHs n m => (n & (m & s)) :-> (Maybe (EDivOpResHs n m, EModOpResHs n m) & s)

abs :: UnaryArithOpHs Abs n => (n & s) :-> (UnaryArithResHs Abs n & s)

neg :: UnaryArithOpHs Neg n => (n & s) :-> (UnaryArithResHs Neg n & s)

lsl :: ArithOpHs Lsl n m => (n & (m & s)) :-> (ArithResHs Lsl n m & s)

lsr :: ArithOpHs Lsr n m => (n & (m & s)) :-> (ArithResHs Lsr n m & s)

or :: ArithOpHs Or n m => (n & (m & s)) :-> (ArithResHs Or n m & s)

and :: ArithOpHs And n m => (n & (m & s)) :-> (ArithResHs And n m & s)

xor :: ArithOpHs Xor n m => (n & (m & s)) :-> (ArithResHs Xor n m & s)

not :: UnaryArithOpHs Not n => (n & s) :-> (UnaryArithResHs Not n & s)

compare :: ArithOpHs Compare n m => (n & (m & s)) :-> (ArithResHs Compare n m & s)

eq0 :: UnaryArithOpHs Eq' n => (n & s) :-> (UnaryArithResHs Eq' n & s)

neq0 :: UnaryArithOpHs Neq n => (n & s) :-> (UnaryArithResHs Neq n & s)

lt0 :: UnaryArithOpHs Lt n => (n & s) :-> (UnaryArithResHs Lt n & s)

gt0 :: UnaryArithOpHs Gt n => (n & s) :-> (UnaryArithResHs Gt n & s)

le0 :: UnaryArithOpHs Le n => (n & s) :-> (UnaryArithResHs Le n & s)

ge0 :: UnaryArithOpHs Ge n => (n & s) :-> (UnaryArithResHs Ge n & s)

int :: (Natural & s) :-> (Integer & s)

self :: forall cp s. s :-> (ContractAddr cp & s)

contract :: KnownValue p => (Address & s) :-> (Maybe (ContractAddr p) & s)

transferTokens :: forall p s. (KnownValue p, NoOperation p, NoBigMap p) => (p & (Mutez & (ContractAddr p & s))) :-> (Operation & s)

setDelegate :: (Maybe KeyHash & s) :-> (Operation & s)

createAccount :: (KeyHash & (Maybe KeyHash & (Bool & (Mutez & s)))) :-> (Operation & (Address & s))

createContract :: forall p g s. (KnownValue p, NoOperation p, KnownValue g, NoOperation g, NoBigMap p, CanHaveBigMap g) => ('[(p, g)] :-> '[(List Operation, g)]) -> (KeyHash & (Maybe KeyHash & (Bool & (Bool & (Mutez & (g & s)))))) :-> (Operation & (Address & s))

implicitAccount :: (KeyHash & s) :-> (ContractAddr () & s)

now :: s :-> (Timestamp & s)

amount :: s :-> (Mutez & s)

balance :: s :-> (Mutez & s)

checkSignature :: (PublicKey & (Signature & (ByteString & s))) :-> (Bool & s)

sha256 :: (ByteString & s) :-> (ByteString & s)

sha512 :: (ByteString & s) :-> (ByteString & s)

blake2B :: (ByteString & s) :-> (ByteString & s)

hashKey :: (PublicKey & s) :-> (KeyHash & s)

stepsToQuota :: s :-> (Natural & s)

source :: s :-> (Address & s)

Warning: Using source is considered a bad practice. Consider using sender instead until further investigation

sender :: s :-> (Address & s)

address :: (ContractAddr a & s) :-> (Address & s)

class LorentzFunctor (c :: Type -> Type) where

Methods

lmap :: KnownValue b => ((a ': s) :-> (b ': s)) -> (c a ': s) :-> (c b ': s)

Instances

LorentzFunctor Maybe

Defined in Lorentz.Instr

Methods

lmap :: KnownValue b => ((a ': s) :-> (b ': s)) -> (Maybe a ': s) :-> (Maybe b ': s)