Test.Cleveland.Internal.Actions.Originate

Machinery for the variadic originate function.

Documentation

data Large

Mark a contract that doesn't fit into the origination size limit. This will execute multiple origination steps.

Such origination cannot be batched (it simply may not fit).

Constructors

Large

Instances

(OFConstraints ct 'PropLarge props r, GetLarge props ~ 'NotLarge) => OriginateFunc ct props (Large -> r)

Set large origination.

Defined in Test.Cleveland.Internal.Actions.Originate

Methods

originate'r :: OriginateData (ContractOriginateType ct) (GetLarge props) -> Large -> r

data Prop

Enum for props we track duplicates of.

Constructors

PropBalance

PropDelegate

PropLarge

class (MonadOpsInternal m, forall ct props a. TerminatingOFConstraints ct props m a => OriginateFunc ct props (m a)) => MonadOriginate m

A convenient synonym class to require the terminating instance for a given monad without leaking too much implementation detail.

Instances

(MonadOpsInternal m, forall ct (props :: [Prop]) a. TerminatingOFConstraints ct props m a => OriginateFunc ct props (m a)) => MonadOriginate m

Defined in Test.Cleveland.Internal.Actions.Originate

type ContractStorage contract = ContractStorage' (ContractOriginateType contract)

class ContractClass contract where

Type class that abstracts different contract types for the purpose of origination.

Associated Types

type ContractOriginateType contract :: OriginationType

Methods

initialStorageAndContract :: ContractStorage contract -> contract -> ODContractAndStorage (ContractOriginateType contract)

Instances

ContractClass Contract

Defined in Test.Cleveland.Internal.Actions.Originate

Associated Types

type ContractOriginateType Contract :: OriginationType

Methods

initialStorageAndContract :: ContractStorage Contract -> Contract -> ODContractAndStorage (ContractOriginateType Contract)

(NiceStorage st, NiceViewsDescriptor vd, NiceParameter cp) => ContractClass (TypedContract cp st vd)

Defined in Test.Cleveland.Internal.Actions.Originate

Associated Types

type ContractOriginateType (TypedContract cp st vd) :: OriginationType

Methods

initialStorageAndContract :: ContractStorage (TypedContract cp st vd) -> TypedContract cp st vd -> ODContractAndStorage (ContractOriginateType (TypedContract cp st vd))

ContractClass (Contract cp st vd)

Defined in Test.Cleveland.Internal.Actions.Originate

Associated Types

type ContractOriginateType (Contract cp st vd) :: OriginationType

Methods

initialStorageAndContract :: ContractStorage (Contract cp st vd) -> Contract cp st vd -> ODContractAndStorage (ContractOriginateType (Contract cp st vd))

class OriginateFunc contract (props :: [Prop]) r where

The class implementing a guarded "printf trick" for the originate function.

If you see GHC asking for this constraint, you most likely need to add MonadOriginate constraint on the return monad instead.

Methods

originate'r :: HasCallStack => OriginateData (ContractOriginateType contract) (GetLarge props) -> r

Instances

TerminatingOFConstraints ct props ClevelandOpsBatch a => OriginateFunc ct props (ClevelandOpsBatch a)

The terminating case for batched transfer.

Defined in Test.Cleveland.Internal.Actions.Originate

Methods

originate'r :: OriginateData (ContractOriginateType ct) (GetLarge props) -> ClevelandOpsBatch a

(OFConstraints ct 'PropLarge props r, GetLarge props ~ 'NotLarge) => OriginateFunc ct props (Large -> r)

Set large origination.

Defined in Test.Cleveland.Internal.Actions.Originate

Methods

originate'r :: OriginateData (ContractOriginateType ct) (GetLarge props) -> Large -> r

OFConstraints ct 'PropBalance props r => OriginateFunc ct props (Mutez -> r)

Set balance.

Defined in Test.Cleveland.Internal.Actions.Originate

Methods

originate'r :: OriginateData (ContractOriginateType ct) (GetLarge props) -> Mutez -> r

OFConstraints ct 'PropDelegate props r => OriginateFunc ct props (KeyHash -> r)

Set delegate.

Defined in Test.Cleveland.Internal.Actions.Originate

Methods

originate'r :: OriginateData (ContractOriginateType ct) (GetLarge props) -> KeyHash -> r

(TypeError (('Text "Incorrect argument for the 'originate' function: " ':<>: 'ShowType x) ':$$: 'Text "If in doubt, try adding a type annotation.") :: Constraint, Bottom) => OriginateFunc ct props (x -> r)

Catchall incoherent instance to report argument errors.

Defined in Test.Cleveland.Internal.Actions.Originate

Methods

originate'r :: OriginateData (ContractOriginateType ct) (GetLarge props) -> x -> r

TerminatingOFConstraints ct props (ReaderT cap base) a => OriginateFunc ct props (ReaderT cap base a)

The terminating case for Cleveland monads.

Defined in Test.Cleveland.Internal.Actions.Originate

Methods

originate'r :: OriginateData (ContractOriginateType ct) (GetLarge props) -> ReaderT cap base a

type family OriginationResult a where ...

Equations

OriginationResult 'OTUntyped = ContractAddress

OriginationResult ('OTTypedMorley cp st vd) = ContractHandle cp st vd

OriginationResult ('OTTypedLorentz cp st vd) = ContractHandle cp st vd

class MonadOpsInternal m => Originator large m where

Class doing actual origination.

Methods

doOriginate :: HasCallStack => OriginateData oty large -> m ContractAddress

Instances

MonadCleveland caps m => Originator 'IsLarge m

Defined in Test.Cleveland.Internal.Actions.Originate

Methods

doOriginate :: forall (oty :: OriginationType). HasCallStack => OriginateData oty 'IsLarge -> m ContractAddress

MonadOpsInternal m => Originator 'NotLarge m

Defined in Test.Cleveland.Internal.Actions.Originate

Methods

doOriginate :: forall (oty :: OriginationType). HasCallStack => OriginateData oty 'NotLarge -> m ContractAddress

type family ContractStorage' contract where ...

Equations

ContractStorage' 'OTUntyped = Value

ContractStorage' ('OTTypedMorley _ st _) = st

ContractStorage' ('OTTypedLorentz _ st _) = st

type family GetLarge a where ...

Convert a list of props into LargeOrigination.

Equations

GetLarge ('PropLarge ': _) = 'IsLarge

GetLarge (_ ': xs) = GetLarge xs

GetLarge '[] = 'NotLarge

type family PropName a where ...

Pretty prop name.

Equations

PropName 'PropBalance = "Balance"

PropName 'PropDelegate = "Delegate"

PropName 'PropLarge = "Large"

type family CheckDupProp name props where ...

Type family raising a type error if element is in list. Used to improve error reporting for OriginateFunc instances with equality constraints.

Equations

CheckDupProp name (name ': _) = TypeError ('Text (PropName name) ':<>: 'Text " is specified more than once.")

CheckDupProp name (_ ': xs) = CheckDupProp name xs

CheckDupProp _ '[] = ()

type OFConstraints ct prop props r = (OriginateFunc ct (prop ': props) r, CheckDupProp prop props)

Convenience synonym for constraints used in OriginateFunc instances.

type TerminatingOFConstraints ct props m a = (Originator (GetLarge props) m, a ~ OriginationResult (ContractOriginateType ct))

Common constraints for terminating OriginateFunc cases.

originate :: forall contract r. (HasCallStack, ContractClass contract, OriginateFunc contract '[] r) => ContractAlias -> ContractStorage contract -> contract -> r

Originate a new contract with given data.

Can accept untypted or Lorentz contracts as-is. With typed Michelson contracts, you need to wrap the contract in TypedContract specifying its Haskell-land parameter, storage types and view descriptors, e.g.

originate "typed contract" defaultStorage $ TypedContract @Param @Storage @() michelsonContract

Storage type can be auto-deduced in most cases, so you can skip it with @_.

After the mandatory arguments, you can add Large or a Mutez value, e.g. by using tz quasi-quoter:

originate "contract" initialStorage contract Large
originate "contract" initialStorage contract [tz|123micro|]
originate "contract" initialStorage contract [tz|123micro|] Large

The order is arbitrary, but each can be specified at most once.

initialData :: ContractClass contract => ContractAlias -> ContractStorage contract -> contract -> OriginateData (ContractOriginateType contract) 'NotLarge

originateFn :: (HasCallStack, Originator large m) => OriginateData ot large -> m (OriginationResult ot)

Low-level polymorphic origination function. It takes arbitrary OriginateData, and, depending on whether the data is typed or not, returns respectively a ContractHandle, or a ContractAddress, in a suitable monad (or an applicative functor in case of batched originations).