| Safe Haskell | Safe-Inferred |
|---|---|
| Language | Haskell2010 |
Test.Cleveland.Internal.Actions.Originate
Description
Machinery for the variadic originate function.
Synopsis
- data Large = Large
- data Prop
- class (MonadOpsInternal m, forall ct props a. TerminatingOFConstraints ct props m a => OriginateFunc ct props (m a)) => MonadOriginate m
- type ContractStorage contract = ContractStorage' (ContractOriginateType contract)
- class ContractClass contract where
- type ContractOriginateType contract :: OriginationType
- initialStorageAndContract :: ContractStorage contract -> contract -> ODContractAndStorage (ContractOriginateType contract)
- class OriginateFunc contract (props :: [Prop]) r where
- originate'r :: HasCallStack => OriginateData (ContractOriginateType contract) (GetLarge props) -> r
- type family OriginationResult a where ...
- class MonadOpsInternal m => Originator large m where
- doOriginate :: HasCallStack => OriginateData oty large -> m ContractAddress
- type family ContractStorage' contract where ...
- type family GetLarge a where ...
- type family PropName a where ...
- type family CheckDupProp name props where ...
- type OFConstraints ct prop props r = (OriginateFunc ct (prop ': props) r, CheckDupProp prop props)
- type TerminatingOFConstraints ct props m a = (Originator (GetLarge props) m, a ~ OriginationResult (ContractOriginateType ct))
- originate :: forall contract r. (HasCallStack, ContractClass contract, OriginateFunc contract '[] r) => ContractAlias -> ContractStorage contract -> contract -> r
- initialData :: ContractClass contract => ContractAlias -> ContractStorage contract -> contract -> OriginateData (ContractOriginateType contract) 'NotLarge
- originateFn :: (HasCallStack, Originator large m) => OriginateData ot large -> m (OriginationResult ot)
Documentation
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) Source # | Set large origination. |
Defined in Test.Cleveland.Internal.Actions.Originate Methods originate'r :: OriginateData (ContractOriginateType ct) (GetLarge props) -> Large -> r Source # | |
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 Source #
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 Source # | |
Defined in Test.Cleveland.Internal.Actions.Originate | |
type ContractStorage contract = ContractStorage' (ContractOriginateType contract) Source #
class ContractClass contract where Source #
Type class that abstracts different contract types for the purpose of origination.
Associated Types
type ContractOriginateType contract :: OriginationType Source #
Methods
initialStorageAndContract :: ContractStorage contract -> contract -> ODContractAndStorage (ContractOriginateType contract) Source #
Instances
class OriginateFunc contract (props :: [Prop]) r where Source #
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 Source #
Instances
type family OriginationResult a where ... Source #
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 Source #
Class doing actual origination.
Methods
doOriginate :: HasCallStack => OriginateData oty large -> m ContractAddress Source #
Instances
| MonadCleveland caps m => Originator 'IsLarge m Source # | |
Defined in Test.Cleveland.Internal.Actions.Originate Methods doOriginate :: forall (oty :: OriginationType). HasCallStack => OriginateData oty 'IsLarge -> m ContractAddress Source # | |
| MonadOpsInternal m => Originator 'NotLarge m Source # | |
Defined in Test.Cleveland.Internal.Actions.Originate Methods doOriginate :: forall (oty :: OriginationType). HasCallStack => OriginateData oty 'NotLarge -> m ContractAddress Source # | |
type family ContractStorage' contract where ... Source #
Equations
| ContractStorage' 'OTUntyped = Value | |
| ContractStorage' ('OTTypedMorley _ st _) = st | |
| ContractStorage' ('OTTypedLorentz _ st _) = st |
type family GetLarge a where ... Source #
Convert a list of props into LargeOrigination.
type family PropName a where ... Source #
Pretty prop name.
Equations
| PropName 'PropBalance = "Balance" | |
| PropName 'PropDelegate = "Delegate" | |
| PropName 'PropLarge = "Large" |
type family CheckDupProp name props where ... Source #
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) Source #
Convenience synonym for constraints used in OriginateFunc instances.
type TerminatingOFConstraints ct props m a = (Originator (GetLarge props) m, a ~ OriginationResult (ContractOriginateType ct)) Source #
Common constraints for terminating OriginateFunc cases.
originate :: forall contract r. (HasCallStack, ContractClass contract, OriginateFunc contract '[] r) => ContractAlias -> ContractStorage contract -> contract -> r Source #
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 Source #
originateFn :: (HasCallStack, Originator large m) => OriginateData ot large -> m (OriginationResult ot) Source #
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).