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