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

setDelegate :: KeyHash -> 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

setDelegate :: forall (large :: LargeOrigination). KeyHash -> 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

setDelegate :: forall (large :: LargeOrigination). KeyHash -> 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

setDelegate :: forall (large :: LargeOrigination). KeyHash -> 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

(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 :: ContractOriginateData ct (GetLarge props) -> Large -> r

class (MonadOpsInternal m, forall ct props a. Originator (ContractOriginateData ct (GetLarge 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. Originator (ContractOriginateData ct (GetLarge props)) (m a) => OriginateFunc ct props (m a)) => MonadOriginate m

Defined in Test.Cleveland.Internal.Actions.Originate

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

Convenience synonym for constraints used in OriginateFunc instances.

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 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"

data Prop

Enum for props we track duplicates of.

Constructors

PropBalance

PropDelegate

PropLarge

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.

Minimal complete definition

Nothing

Methods

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

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

Instances

Originator (ContractOriginateData ct (GetLarge props)) (ClevelandOpsBatch a) => OriginateFunc ct props (ClevelandOpsBatch a)

The terminating case for batched transfer.

Defined in Test.Cleveland.Internal.Actions.Originate

Methods

originate'r :: ContractOriginateData 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 :: ContractOriginateData 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 :: ContractOriginateData 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 :: ContractOriginateData 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 :: ContractOriginateData ct (GetLarge props) -> x -> r

Originator (ContractOriginateData ct (GetLarge 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 :: ContractOriginateData ct (GetLarge props) -> 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, 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.