Test.Cleveland.Internal.Actions.Originate

Machinery for the variadic originate function.

Documentation

class ModifyOriginationData od where

Type class implementing modifications to origination data.

Methods

setBalance :: Mutez -> od large -> od large

setLarge :: od 'NotLarge -> od 'IsLarge

Instances

ModifyOriginationData UntypedOriginateData

Defined in Test.Cleveland.Internal.Actions.Originate

Methods

setBalance :: forall (large :: LargeOrigination). Mutez -> UntypedOriginateData large -> UntypedOriginateData large

setLarge :: UntypedOriginateData 'NotLarge -> UntypedOriginateData 'IsLarge

ModifyOriginationData (OriginateData cp st vd)

Defined in Test.Cleveland.Internal.Actions.Originate

Methods

setBalance :: forall (large :: LargeOrigination). Mutez -> OriginateData cp st vd large -> OriginateData cp st vd large

setLarge :: OriginateData cp st vd 'NotLarge -> OriginateData cp st vd 'IsLarge

ModifyOriginationData (TypedOriginateData cp st vd)

Defined in Test.Cleveland.Internal.Actions.Originate

Methods

setBalance :: forall (large :: LargeOrigination). Mutez -> TypedOriginateData cp st vd large -> TypedOriginateData cp st vd large

setLarge :: TypedOriginateData cp st vd 'NotLarge -> TypedOriginateData cp st vd 'IsLarge

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

(ModifyOriginationData (ContractOriginateData ct), OriginateFunc ct bal 'IsLarge r, CheckDupLarge isLarge, isLarge ~ 'NotLarge) => OriginateFunc ct bal isLarge (Large -> r)

Defined in Test.Cleveland.Internal.Actions.Originate

Methods

originate'r :: ContractOriginateData ct isLarge -> Large -> r

class (forall ct bal large a. OFConstraint ct large (m a) => OriginateFunc ct bal large (m a)) => MonadOriginate m

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

Instances

(forall ct (bal :: HasBalance) (large :: LargeOrigination) (a :: k). OFConstraint ct large (m a) => OriginateFunc ct bal large (m a)) => MonadOriginate (m :: k -> Type)

Defined in Test.Cleveland.Internal.Actions.Originate

type OFConstraint ct large r = (ContractClass ct, Originator (ContractOriginateData ct large) r)

Convenience synonym.

type family CheckDupLarge mod :: Constraint where ...

Type family raising a type error on IsLarge argument. Used to improve error reporting for OriginateFunc instances with equality constraints.

Equations

CheckDupLarge 'IsLarge = TypeError ('Text "Large is specified more than once.")

CheckDupLarge 'NotLarge = ()

type family CheckDupBalance mod :: Constraint where ...

Type family raising a type error on HasBalance argument. Used to improve error reporting for OriginateFunc instances with equality constraints.

Equations

CheckDupBalance 'HasBalance = TypeError ('Text "Balance is specified more than once.")

CheckDupBalance 'NoBalance = ()

data HasBalance

Simple flag to track duplicate balance specification.

Constructors

NoBalance

HasBalance

class ContractClass contract => OriginateFunc contract (bal :: HasBalance) isLarge 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.

Minimal complete definition

Nothing

Methods

originate'r :: HasCallStack => ContractOriginateData contract isLarge -> r

default originate'r :: (HasCallStack, Originator (ContractOriginateData contract isLarge) r) => ContractOriginateData contract isLarge -> r

Instances

OFConstraint ct large (ClevelandOpsBatch a) => OriginateFunc ct bal large (ClevelandOpsBatch a)

The terminating case for batched transfer.

Defined in Test.Cleveland.Internal.Actions.Originate

Methods

originate'r :: ContractOriginateData ct large -> ClevelandOpsBatch a

(ModifyOriginationData (ContractOriginateData ct), OriginateFunc ct bal 'IsLarge r, CheckDupLarge isLarge, isLarge ~ 'NotLarge) => OriginateFunc ct bal isLarge (Large -> r)

Defined in Test.Cleveland.Internal.Actions.Originate

Methods

originate'r :: ContractOriginateData ct isLarge -> Large -> r

(ModifyOriginationData (ContractOriginateData ct), OriginateFunc ct 'HasBalance isLarge r, CheckDupBalance bal, bal ~ 'NoBalance) => OriginateFunc ct bal isLarge (Mutez -> r)

Defined in Test.Cleveland.Internal.Actions.Originate

Methods

originate'r :: ContractOriginateData ct isLarge -> Mutez -> r

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

Catchall incoherent instance to report argument errors.

Defined in Test.Cleveland.Internal.Actions.Originate

Methods

originate'r :: ContractOriginateData ct large -> x -> r

OFConstraint ct large (ReaderT cap base a) => OriginateFunc ct bal large (ReaderT cap base a)

The terminating case for Cleveland monads.

Defined in Test.Cleveland.Internal.Actions.Originate

Methods

originate'r :: ContractOriginateData ct large -> ReaderT cap base a

class ContractClass contract where

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

Associated Types

type ContractStorage contract

type ContractOriginateData contract :: LargeOrigination -> Type

Methods

initialData :: ContractAlias -> ContractStorage contract -> contract -> ContractOriginateData contract 'NotLarge

Instances

ContractClass Contract

Defined in Test.Cleveland.Internal.Actions.Originate

Associated Types

type ContractStorage Contract

type ContractOriginateData Contract :: LargeOrigination -> Type

Methods

initialData :: ContractAlias -> ContractStorage Contract -> Contract -> ContractOriginateData Contract 'NotLarge

ContractClass (Contract cp st vd)

Defined in Test.Cleveland.Internal.Actions.Originate

Associated Types

type ContractStorage (Contract cp st vd)

type ContractOriginateData (Contract cp st vd) :: LargeOrigination -> Type

Methods

initialData :: ContractAlias -> ContractStorage (Contract cp st vd) -> Contract cp st vd -> ContractOriginateData (Contract cp st vd) 'NotLarge

ContractClass (TypedContract cp st vd)

Defined in Test.Cleveland.Internal.Actions.Originate

Associated Types

type ContractStorage (TypedContract cp st vd)

type ContractOriginateData (TypedContract cp st vd) :: LargeOrigination -> Type

Methods

initialData :: ContractAlias -> ContractStorage (TypedContract cp st vd) -> TypedContract cp st vd -> ContractOriginateData (TypedContract cp st vd) 'NotLarge

class Originator od res where

Class implementing actual origination.

Methods

originateFn :: HasCallStack => od -> res

Low-level polymorphic origination function. It takes UntypedOriginateData, TypedOriginateData or OriginateData, and returns correspondingly an Address, or a ContractHandle, in a suitable monad.

Instances

(a ~ ContractAddress, MonadOpsInternal m) => Originator (UntypedOriginateData 'NotLarge) (m a)

Defined in Test.Cleveland.Internal.Actions.Originate

Methods

originateFn :: UntypedOriginateData 'NotLarge -> m a

(HasClevelandCaps caps, base ~ ClevelandBaseMonad caps, a ~ ContractAddress) => Originator (UntypedOriginateData 'IsLarge) (ReaderT caps base a)

Defined in Test.Cleveland.Internal.Actions.Originate

Methods

originateFn :: UntypedOriginateData 'IsLarge -> ReaderT caps base a

(a ~ ContractHandle cp st vd, MonadOpsInternal m, Originator (UntypedOriginateData large) (m ContractAddress)) => Originator (OriginateData cp st vd large) (m a)

Defined in Test.Cleveland.Internal.Actions.Originate

Methods

originateFn :: OriginateData cp st vd large -> m a

(a ~ ContractHandle cp st vd, MonadOpsInternal m, Originator (UntypedOriginateData large) (m ContractAddress), NiceStorage st, NiceViewsDescriptor vd, NiceParameter cp) => Originator (TypedOriginateData cp st vd large) (m a)

Defined in Test.Cleveland.Internal.Actions.Originate

Methods

originateFn :: TypedOriginateData cp st vd large -> m a

originate :: forall contract r. (HasCallStack, OriginateFunc contract 'NoBalance 'NotLarge 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.