-- SPDX-FileCopyrightText: 2021 Oxhead Alpha
-- SPDX-License-Identifier: LicenseRef-MIT-OA

-- | Functions to originate smart contracts via @octez-client@ and node RPC.
module Morley.Client.Action.Origination
  ( originateContract
  , originateContracts
  , originateUntypedContract
  -- Lorentz version
  , lOriginateContract
  , lOriginateContracts

  -- * Large originations
  , originateLargeContracts
  , originateLargeContract
  , originateLargeUntypedContract
  -- Lorentz version
  , lOriginateLargeContracts
  , lOriginateLargeContract

  -- Datatypes for batch originations
  , LOriginationData (..)
  , OriginationData (..)
  ) where

import Data.Default (def)
import Lorentz qualified as L
import Lorentz.Constraints
import Morley.Client.Action.Common
import Morley.Client.Action.Operation
import Morley.Client.Action.Origination.Large
import Morley.Client.Action.Transaction (runTransactions)
import Morley.Client.Logging
import Morley.Client.RPC.Class
import Morley.Client.RPC.Error
import Morley.Client.RPC.Types
import Morley.Client.TezosClient
import Morley.Client.Types
import Morley.Michelson.TypeCheck (typeCheckContractAndStorage, typeCheckingWith)
import Morley.Michelson.Typed (Contract, IsoValue(..), SomeContractAndStorage(..), Value)
import Morley.Michelson.Typed.Scope
import Morley.Michelson.Untyped qualified as U
import Morley.Tezos.Address
import Morley.Tezos.Address.Alias
import Morley.Tezos.Core
import Morley.Util.Exception

-- | Originate given contracts with given initial storages. Returns
-- operation hash (or @Nothing@ in case empty list was provided)
-- and originated contracts' addresses.
originateContracts
  :: forall m env.
     ( HasTezosRpc m
     , HasTezosClient m
     , WithClientLog env m
     )
  => ImplicitAddressWithAlias
  -> [OriginationData]
  -> m (Maybe OperationHash, [ContractAddress])
originateContracts :: forall (m :: * -> *) env.
(HasTezosRpc m, HasTezosClient m, WithClientLog env m) =>
ImplicitAddressWithAlias
-> [OriginationData] -> m (Maybe OperationHash, [ContractAddress])
originateContracts ImplicitAddressWithAlias
sender [OriginationData]
originations = do
  (Maybe OperationHash
opHash, [OperationInfo Result]
res) <- ImplicitAddressWithAlias
-> [OperationInfo ClientInput]
-> m (Maybe OperationHash, [OperationInfo Result])
forall (m :: * -> *) env.
(HasTezosRpc m, HasTezosClient m, WithClientLog env m) =>
ImplicitAddressWithAlias
-> [OperationInfo ClientInput]
-> m (Maybe OperationHash, [OperationInfo Result])
runOperations ImplicitAddressWithAlias
sender (OriginationInfo ClientInput -> OperationInfo ClientInput
OriginationData -> OperationInfo ClientInput
forall i. OriginationInfo i -> OperationInfo i
OpOriginate (OriginationData -> OperationInfo ClientInput)
-> [OriginationData] -> [OperationInfo ClientInput]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [OriginationData]
originations)
  (Maybe OperationHash, [ContractAddress])
-> m (Maybe OperationHash, [ContractAddress])
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe OperationHash
opHash, [OperationInfo Result] -> [OriginationInfo Result]
forall {i}. [OperationInfo i] -> [OriginationInfo i]
getOriginations [OperationInfo Result]
res)
  where
    getOriginations :: [OperationInfo i] -> [OriginationInfo i]
getOriginations = (OperationInfo i -> Maybe (OriginationInfo i))
-> [OperationInfo i] -> [OriginationInfo i]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe \case
      OpOriginate OriginationInfo i
r -> OriginationInfo i -> Maybe (OriginationInfo i)
forall a. a -> Maybe a
Just OriginationInfo i
r
      OpReveal{} -> Maybe (OriginationInfo i)
forall a. Maybe a
Nothing
      OperationInfo i
_ -> Text -> Maybe (OriginationInfo i)
forall a. HasCallStack => Text -> a
error Text
"Unexpectedly not origination"

-- | Originate single contract
originateContract
  :: forall m cp st env.
     ( HasTezosRpc m
     , HasTezosClient m
     , WithClientLog env m
     , StorageScope st
     , ParameterScope cp
     )
  => AliasBehavior
  -> ContractAlias
  -> ImplicitAddressWithAlias
  -> Mutez
  -> Contract cp st
  -> Value st
  -> Maybe Mutez
  -> Maybe L.KeyHash
  -> m (OperationHash, ContractAddress)
originateContract :: forall (m :: * -> *) (cp :: T) (st :: T) env.
(HasTezosRpc m, HasTezosClient m, WithClientLog env m,
 StorageScope st, ParameterScope cp) =>
AliasBehavior
-> ContractAlias
-> ImplicitAddressWithAlias
-> Mutez
-> Contract cp st
-> Value st
-> Maybe Mutez
-> Maybe KeyHash
-> m (OperationHash, ContractAddress)
originateContract AliasBehavior
odAliasBehavior ContractAlias
odName ImplicitAddressWithAlias
sender' Mutez
odBalance Contract cp st
odContract Value st
odStorage Maybe Mutez
odMbFee Maybe KeyHash
odDelegate = do
  (Maybe OperationHash
hash, [ContractAddress]
contracts) <- ImplicitAddressWithAlias
-> [OriginationData] -> m (Maybe OperationHash, [ContractAddress])
forall (m :: * -> *) env.
(HasTezosRpc m, HasTezosClient m, WithClientLog env m) =>
ImplicitAddressWithAlias
-> [OriginationData] -> m (Maybe OperationHash, [ContractAddress])
originateContracts ImplicitAddressWithAlias
sender' [OriginationData{Maybe Mutez
Maybe KeyHash
Mutez
ContractAlias
Value st
Contract cp st
AliasBehavior
odAliasBehavior :: AliasBehavior
odName :: ContractAlias
odBalance :: Mutez
odContract :: Contract cp st
odStorage :: Value st
odMbFee :: Maybe Mutez
odDelegate :: Maybe KeyHash
odAliasBehavior :: AliasBehavior
odName :: ContractAlias
odBalance :: Mutez
odContract :: Contract cp st
odStorage :: Value st
odDelegate :: Maybe KeyHash
odMbFee :: Maybe Mutez
..}]
  Maybe OperationHash
-> [ContractAddress] -> m (OperationHash, ContractAddress)
forall (m :: * -> *).
HasTezosRpc m =>
Maybe OperationHash
-> [ContractAddress] -> m (OperationHash, ContractAddress)
singleOriginatedContract Maybe OperationHash
hash [ContractAddress]
contracts

-- | Originate a single untyped contract
originateUntypedContract
  :: forall m env.
     ( HasTezosRpc m
     , HasTezosClient m
     , WithClientLog env m
     )
  => AliasBehavior
  -> ContractAlias
  -> ImplicitAddressWithAlias
  -> Mutez
  -> U.Contract
  -> U.Value
  -> Maybe Mutez
  -> Maybe L.KeyHash
  -> m (OperationHash, ContractAddress)
originateUntypedContract :: forall (m :: * -> *) env.
(HasTezosRpc m, HasTezosClient m, WithClientLog env m) =>
AliasBehavior
-> ContractAlias
-> ImplicitAddressWithAlias
-> Mutez
-> Contract
-> Value
-> Maybe Mutez
-> Maybe KeyHash
-> m (OperationHash, ContractAddress)
originateUntypedContract AliasBehavior
aliasBehavior ContractAlias
name ImplicitAddressWithAlias
sender' Mutez
balance Contract
uContract Value
initialStorage Maybe Mutez
mbFee Maybe KeyHash
mbDelegate = do
  SomeContractAndStorage Contract cp st
contract Value st
storage <-
    m (Either (TcError' ExpandedOp) SomeContractAndStorage)
-> m SomeContractAndStorage
forall (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
m (Either e a) -> m a
throwLeft (m (Either (TcError' ExpandedOp) SomeContractAndStorage)
 -> m SomeContractAndStorage)
-> (TypeCheckResult ExpandedOp SomeContractAndStorage
    -> m (Either (TcError' ExpandedOp) SomeContractAndStorage))
-> TypeCheckResult ExpandedOp SomeContractAndStorage
-> m SomeContractAndStorage
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Either (TcError' ExpandedOp) SomeContractAndStorage
-> m (Either (TcError' ExpandedOp) SomeContractAndStorage)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either (TcError' ExpandedOp) SomeContractAndStorage
 -> m (Either (TcError' ExpandedOp) SomeContractAndStorage))
-> (TypeCheckResult ExpandedOp SomeContractAndStorage
    -> Either (TcError' ExpandedOp) SomeContractAndStorage)
-> TypeCheckResult ExpandedOp SomeContractAndStorage
-> m (Either (TcError' ExpandedOp) SomeContractAndStorage)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TypeCheckOptions
-> TypeCheckResult ExpandedOp SomeContractAndStorage
-> Either (TcError' ExpandedOp) SomeContractAndStorage
forall op a.
TypeCheckOptions -> TypeCheckResult op a -> Either (TcError' op) a
typeCheckingWith TypeCheckOptions
forall a. Default a => a
def (TypeCheckResult ExpandedOp SomeContractAndStorage
 -> m SomeContractAndStorage)
-> TypeCheckResult ExpandedOp SomeContractAndStorage
-> m SomeContractAndStorage
forall a b. (a -> b) -> a -> b
$
      Contract
-> Value -> TypeCheckResult ExpandedOp SomeContractAndStorage
typeCheckContractAndStorage Contract
uContract Value
initialStorage
  AliasBehavior
-> ContractAlias
-> ImplicitAddressWithAlias
-> Mutez
-> Contract cp st
-> Value st
-> Maybe Mutez
-> Maybe KeyHash
-> m (OperationHash, ContractAddress)
forall (m :: * -> *) (cp :: T) (st :: T) env.
(HasTezosRpc m, HasTezosClient m, WithClientLog env m,
 StorageScope st, ParameterScope cp) =>
AliasBehavior
-> ContractAlias
-> ImplicitAddressWithAlias
-> Mutez
-> Contract cp st
-> Value st
-> Maybe Mutez
-> Maybe KeyHash
-> m (OperationHash, ContractAddress)
originateContract AliasBehavior
aliasBehavior ContractAlias
name ImplicitAddressWithAlias
sender' Mutez
balance Contract cp st
contract Value st
storage Maybe Mutez
mbFee Maybe KeyHash
mbDelegate

-- | Lorentz version of 'originateContracts'
lOriginateContracts
  :: forall m env.
     ( HasTezosRpc m
     , HasTezosClient m
     , WithClientLog env m
     )
  => ImplicitAddressWithAlias
  -> [LOriginationData]
  -> m (Maybe OperationHash, [ContractAddress])
lOriginateContracts :: forall (m :: * -> *) env.
(HasTezosRpc m, HasTezosClient m, WithClientLog env m) =>
ImplicitAddressWithAlias
-> [LOriginationData] -> m (Maybe OperationHash, [ContractAddress])
lOriginateContracts ImplicitAddressWithAlias
sender' [LOriginationData]
originations =
  ImplicitAddressWithAlias
-> [OriginationData] -> m (Maybe OperationHash, [ContractAddress])
forall (m :: * -> *) env.
(HasTezosRpc m, HasTezosClient m, WithClientLog env m) =>
ImplicitAddressWithAlias
-> [OriginationData] -> m (Maybe OperationHash, [ContractAddress])
originateContracts ImplicitAddressWithAlias
sender' ([OriginationData] -> m (Maybe OperationHash, [ContractAddress]))
-> [OriginationData] -> m (Maybe OperationHash, [ContractAddress])
forall a b. (a -> b) -> a -> b
$ (LOriginationData -> OriginationData)
-> [LOriginationData] -> [OriginationData]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
map LOriginationData -> OriginationData
convertLOriginationData [LOriginationData]
originations

-- | Originate single Lorentz contract
lOriginateContract
  :: forall m cp st vd env.
     ( HasTezosRpc m
     , HasTezosClient m
     , WithClientLog env m
     , NiceStorage st
     , NiceParameterFull cp
     )
  => AliasBehavior
  -> ContractAlias
  -> ImplicitAddressWithAlias
  -> Mutez
  -> L.Contract cp st vd
  -> st
  -> Maybe Mutez
  -> Maybe L.KeyHash
  -> m (OperationHash, ContractAddress)
lOriginateContract :: forall (m :: * -> *) cp st vd env.
(HasTezosRpc m, HasTezosClient m, WithClientLog env m,
 NiceStorage st, NiceParameterFull cp) =>
AliasBehavior
-> ContractAlias
-> ImplicitAddressWithAlias
-> Mutez
-> Contract cp st vd
-> st
-> Maybe Mutez
-> Maybe KeyHash
-> m (OperationHash, ContractAddress)
lOriginateContract AliasBehavior
lodAliasBehavior ContractAlias
lodName ImplicitAddressWithAlias
sender' Mutez
lodBalance Contract cp st vd
lodContract st
lodStorage Maybe Mutez
lodMbFee Maybe KeyHash
lodDelegate = do
  (Maybe OperationHash
hash, [ContractAddress]
contracts) <- ImplicitAddressWithAlias
-> [LOriginationData] -> m (Maybe OperationHash, [ContractAddress])
forall (m :: * -> *) env.
(HasTezosRpc m, HasTezosClient m, WithClientLog env m) =>
ImplicitAddressWithAlias
-> [LOriginationData] -> m (Maybe OperationHash, [ContractAddress])
lOriginateContracts ImplicitAddressWithAlias
sender' [LOriginationData{st
Maybe Mutez
Maybe KeyHash
Contract cp st vd
Mutez
ContractAlias
AliasBehavior
lodAliasBehavior :: AliasBehavior
lodName :: ContractAlias
lodBalance :: Mutez
lodContract :: Contract cp st vd
lodStorage :: st
lodMbFee :: Maybe Mutez
lodDelegate :: Maybe KeyHash
lodAliasBehavior :: AliasBehavior
lodName :: ContractAlias
lodBalance :: Mutez
lodContract :: Contract cp st vd
lodStorage :: st
lodDelegate :: Maybe KeyHash
lodMbFee :: Maybe Mutez
..}]
  forall (m :: * -> *).
HasTezosRpc m =>
Maybe OperationHash
-> [ContractAddress] -> m (OperationHash, ContractAddress)
singleOriginatedContract @m Maybe OperationHash
hash [ContractAddress]
contracts

--------------------------------------------------------------------------------
-- Large Originations
--------------------------------------------------------------------------------

-- | Automated multi-step origination process for contracts that don't fit into
-- the origination limit. See "Morley.Client.Action.Origination.Large".
originateLargeContracts
  :: forall m env.
     ( HasTezosRpc m
     , HasTezosClient m
     , WithClientLog env m
     )
  => ImplicitAddressWithAlias
  -> [OriginationData]
  -> m (Maybe OperationHash, [ContractAddress])
originateLargeContracts :: forall (m :: * -> *) env.
(HasTezosRpc m, HasTezosClient m, WithClientLog env m) =>
ImplicitAddressWithAlias
-> [OriginationData] -> m (Maybe OperationHash, [ContractAddress])
originateLargeContracts sender' :: ImplicitAddressWithAlias
sender'@(AddressWithAlias KindedAddress 'AddressKindImplicit
senderAddress Alias 'AddressKindImplicit
_) [OriginationData]
largeOriginations = do
  -- calculate large contract originators
  let originators :: [LargeOriginationData]
originators = (OriginationData -> LargeOriginationData)
-> [OriginationData] -> [LargeOriginationData]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
map OriginationData -> LargeOriginationData
mkLargeOriginationData [OriginationData]
largeOriginations
  -- originate them. Note: we use the operation hash from here even tho the
  -- large contracts are originated in another one, because those happen in
  -- several different transactions.
  (Maybe OperationHash
opHash, [ContractAddress]
originatorsAddr) <- ImplicitAddressWithAlias
-> [OriginationData] -> m (Maybe OperationHash, [ContractAddress])
forall (m :: * -> *) env.
(HasTezosRpc m, HasTezosClient m, WithClientLog env m) =>
ImplicitAddressWithAlias
-> [OriginationData] -> m (Maybe OperationHash, [ContractAddress])
originateContracts ImplicitAddressWithAlias
sender' ([OriginationData] -> m (Maybe OperationHash, [ContractAddress]))
-> [OriginationData] -> m (Maybe OperationHash, [ContractAddress])
forall a b. (a -> b) -> a -> b
$
    (LargeOriginationData -> OriginationData)
-> [LargeOriginationData] -> [OriginationData]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
map (KindedAddress 'AddressKindImplicit
-> LargeOriginationData -> OriginationData
mkLargeOriginatorData KindedAddress 'AddressKindImplicit
senderAddress) [LargeOriginationData]
originators
  -- run all the transactions needed (for each large contract originator)
  -- Note: it is not possible to run these all at once, because the node won't
  -- accept a transaction batch where the sum of the storage cost is over 16k,
  -- so here we need to run them one by one.
  (Element [TransactionData]
 -> m (Maybe (OperationHash, [OperationInfo Result])))
-> [TransactionData] -> m ()
forall t (m :: * -> *) b.
(Container t, Monad m) =>
(Element t -> m b) -> t -> m ()
mapM_ (ImplicitAddressWithAlias
-> [TransactionData]
-> m (Maybe (OperationHash, [OperationInfo Result]))
forall (m :: * -> *) env.
(HasTezosRpc m, HasTezosClient m, WithClientLog env m) =>
ImplicitAddressWithAlias
-> [TransactionData]
-> m (Maybe (OperationHash, [OperationInfo Result]))
runTransactions ImplicitAddressWithAlias
sender' ([TransactionData]
 -> m (Maybe (OperationHash, [OperationInfo Result])))
-> (TransactionData -> [TransactionData])
-> TransactionData
-> m (Maybe (OperationHash, [OperationInfo Result]))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TransactionData -> [TransactionData] -> [TransactionData]
forall a. a -> [a] -> [a]
: [])) ([TransactionData] -> m ())
-> ([[TransactionData]] -> [TransactionData])
-> [[TransactionData]]
-> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[TransactionData]] -> [TransactionData]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[TransactionData]] -> m ()) -> [[TransactionData]] -> m ()
forall a b. (a -> b) -> a -> b
$
    (ContractAddress -> LargeOriginationData -> [TransactionData])
-> [ContractAddress]
-> [LargeOriginationData]
-> [[TransactionData]]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith ContractAddress -> LargeOriginationData -> [TransactionData]
mkLargeOriginatorTransactions [ContractAddress]
originatorsAddr [LargeOriginationData]
originators
  -- get the addresses of the originated large contracts back from the originators
  -- and remember their addresses with their aliases
  [ContractAddress]
originatedContracts <- (ContractAddress -> OriginationData -> m ContractAddress)
-> [ContractAddress] -> [OriginationData] -> m [ContractAddress]
forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> m c) -> [a] -> [b] -> m [c]
zipWithM ContractAddress -> OriginationData -> m ContractAddress
forall (m :: * -> *).
(HasTezosRpc m, HasTezosClient m) =>
ContractAddress -> OriginationData -> m ContractAddress
retrieveLargeContracts [ContractAddress]
originatorsAddr [OriginationData]
largeOriginations
  return (Maybe OperationHash
opHash, [ContractAddress]
originatedContracts)

-- | Originate a single large contract
originateLargeContract
  :: forall m cp st env.
     ( HasTezosRpc m
     , HasTezosClient m
     , WithClientLog env m
     , StorageScope st
     , ParameterScope cp
     )
  => AliasBehavior
  -> ContractAlias
  -> ImplicitAddressWithAlias
  -> Mutez
  -> Contract cp st
  -> Value st
  -> Maybe Mutez
  -> Maybe L.KeyHash
  -> m (OperationHash, ContractAddress)
originateLargeContract :: forall (m :: * -> *) (cp :: T) (st :: T) env.
(HasTezosRpc m, HasTezosClient m, WithClientLog env m,
 StorageScope st, ParameterScope cp) =>
AliasBehavior
-> ContractAlias
-> ImplicitAddressWithAlias
-> Mutez
-> Contract cp st
-> Value st
-> Maybe Mutez
-> Maybe KeyHash
-> m (OperationHash, ContractAddress)
originateLargeContract AliasBehavior
odAliasBehavior ContractAlias
odName ImplicitAddressWithAlias
sender' Mutez
odBalance Contract cp st
odContract Value st
odStorage Maybe Mutez
odMbFee Maybe KeyHash
odDelegate = do
  (Maybe OperationHash
hash, [ContractAddress]
contracts) <- ImplicitAddressWithAlias
-> [OriginationData] -> m (Maybe OperationHash, [ContractAddress])
forall (m :: * -> *) env.
(HasTezosRpc m, HasTezosClient m, WithClientLog env m) =>
ImplicitAddressWithAlias
-> [OriginationData] -> m (Maybe OperationHash, [ContractAddress])
originateLargeContracts ImplicitAddressWithAlias
sender' [OriginationData{Maybe Mutez
Maybe KeyHash
Mutez
ContractAlias
Value st
Contract cp st
AliasBehavior
odAliasBehavior :: AliasBehavior
odName :: ContractAlias
odBalance :: Mutez
odContract :: Contract cp st
odStorage :: Value st
odDelegate :: Maybe KeyHash
odMbFee :: Maybe Mutez
odAliasBehavior :: AliasBehavior
odName :: ContractAlias
odBalance :: Mutez
odContract :: Contract cp st
odStorage :: Value st
odMbFee :: Maybe Mutez
odDelegate :: Maybe KeyHash
..}]
  forall (m :: * -> *).
HasTezosRpc m =>
Maybe OperationHash
-> [ContractAddress] -> m (OperationHash, ContractAddress)
singleOriginatedContract @m Maybe OperationHash
hash [ContractAddress]
contracts

-- | Originate a single untyped large contract
originateLargeUntypedContract
  :: forall m env.
     ( HasTezosRpc m
     , HasTezosClient m
     , WithClientLog env m
     )
  => AliasBehavior
  -> ContractAlias
  -> ImplicitAddressWithAlias
  -> Mutez
  -> U.Contract
  -> U.Value
  -> Maybe Mutez
  -> Maybe L.KeyHash
  -> m (OperationHash, ContractAddress)
originateLargeUntypedContract :: forall (m :: * -> *) env.
(HasTezosRpc m, HasTezosClient m, WithClientLog env m) =>
AliasBehavior
-> ContractAlias
-> ImplicitAddressWithAlias
-> Mutez
-> Contract
-> Value
-> Maybe Mutez
-> Maybe KeyHash
-> m (OperationHash, ContractAddress)
originateLargeUntypedContract AliasBehavior
aliasBehavior ContractAlias
name ImplicitAddressWithAlias
sender' Mutez
balance Contract
uContract Value
initialStorage Maybe Mutez
mbFee Maybe KeyHash
mbDelegate = do
  SomeContractAndStorage Contract cp st
contract Value st
storage <-
    m (Either (TcError' ExpandedOp) SomeContractAndStorage)
-> m SomeContractAndStorage
forall (m :: * -> *) e a.
(MonadThrow m, Exception e) =>
m (Either e a) -> m a
throwLeft (m (Either (TcError' ExpandedOp) SomeContractAndStorage)
 -> m SomeContractAndStorage)
-> (TypeCheckResult ExpandedOp SomeContractAndStorage
    -> m (Either (TcError' ExpandedOp) SomeContractAndStorage))
-> TypeCheckResult ExpandedOp SomeContractAndStorage
-> m SomeContractAndStorage
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Either (TcError' ExpandedOp) SomeContractAndStorage
-> m (Either (TcError' ExpandedOp) SomeContractAndStorage)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either (TcError' ExpandedOp) SomeContractAndStorage
 -> m (Either (TcError' ExpandedOp) SomeContractAndStorage))
-> (TypeCheckResult ExpandedOp SomeContractAndStorage
    -> Either (TcError' ExpandedOp) SomeContractAndStorage)
-> TypeCheckResult ExpandedOp SomeContractAndStorage
-> m (Either (TcError' ExpandedOp) SomeContractAndStorage)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TypeCheckOptions
-> TypeCheckResult ExpandedOp SomeContractAndStorage
-> Either (TcError' ExpandedOp) SomeContractAndStorage
forall op a.
TypeCheckOptions -> TypeCheckResult op a -> Either (TcError' op) a
typeCheckingWith TypeCheckOptions
forall a. Default a => a
def (TypeCheckResult ExpandedOp SomeContractAndStorage
 -> m SomeContractAndStorage)
-> TypeCheckResult ExpandedOp SomeContractAndStorage
-> m SomeContractAndStorage
forall a b. (a -> b) -> a -> b
$
      Contract
-> Value -> TypeCheckResult ExpandedOp SomeContractAndStorage
typeCheckContractAndStorage Contract
uContract Value
initialStorage
  AliasBehavior
-> ContractAlias
-> ImplicitAddressWithAlias
-> Mutez
-> Contract cp st
-> Value st
-> Maybe Mutez
-> Maybe KeyHash
-> m (OperationHash, ContractAddress)
forall (m :: * -> *) (cp :: T) (st :: T) env.
(HasTezosRpc m, HasTezosClient m, WithClientLog env m,
 StorageScope st, ParameterScope cp) =>
AliasBehavior
-> ContractAlias
-> ImplicitAddressWithAlias
-> Mutez
-> Contract cp st
-> Value st
-> Maybe Mutez
-> Maybe KeyHash
-> m (OperationHash, ContractAddress)
originateLargeContract AliasBehavior
aliasBehavior ContractAlias
name ImplicitAddressWithAlias
sender' Mutez
balance Contract cp st
contract Value st
storage Maybe Mutez
mbFee Maybe KeyHash
mbDelegate

-- | Lorentz version of 'originateLargeContracts'
lOriginateLargeContracts
  :: forall m env.
     ( HasTezosRpc m
     , HasTezosClient m
     , WithClientLog env m
     )
  => ImplicitAddressWithAlias
  -> [LOriginationData]
  -> m (Maybe OperationHash, [ContractAddress])
lOriginateLargeContracts :: forall (m :: * -> *) env.
(HasTezosRpc m, HasTezosClient m, WithClientLog env m) =>
ImplicitAddressWithAlias
-> [LOriginationData] -> m (Maybe OperationHash, [ContractAddress])
lOriginateLargeContracts ImplicitAddressWithAlias
sender' [LOriginationData]
originations =
  ImplicitAddressWithAlias
-> [OriginationData] -> m (Maybe OperationHash, [ContractAddress])
forall (m :: * -> *) env.
(HasTezosRpc m, HasTezosClient m, WithClientLog env m) =>
ImplicitAddressWithAlias
-> [OriginationData] -> m (Maybe OperationHash, [ContractAddress])
originateLargeContracts ImplicitAddressWithAlias
sender' ([OriginationData] -> m (Maybe OperationHash, [ContractAddress]))
-> [OriginationData] -> m (Maybe OperationHash, [ContractAddress])
forall a b. (a -> b) -> a -> b
$ (LOriginationData -> OriginationData)
-> [LOriginationData] -> [OriginationData]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
map LOriginationData -> OriginationData
convertLOriginationData [LOriginationData]
originations

-- | Originate a single large Lorentz contract
lOriginateLargeContract
  :: forall m cp st vd env.
     ( HasTezosRpc m
     , HasTezosClient m
     , WithClientLog env m
     , NiceStorage st
     , NiceParameter cp
     )
  => AliasBehavior
  -> ContractAlias
  -> ImplicitAddressWithAlias
  -> Mutez
  -> L.Contract cp st vd
  -> st
  -> Maybe Mutez
  -> Maybe L.KeyHash
  -> m (OperationHash, ContractAddress)
lOriginateLargeContract :: forall (m :: * -> *) cp st vd env.
(HasTezosRpc m, HasTezosClient m, WithClientLog env m,
 NiceStorage st, NiceParameter cp) =>
AliasBehavior
-> ContractAlias
-> ImplicitAddressWithAlias
-> Mutez
-> Contract cp st vd
-> st
-> Maybe Mutez
-> Maybe KeyHash
-> m (OperationHash, ContractAddress)
lOriginateLargeContract AliasBehavior
lodAliasBehavior ContractAlias
lodName ImplicitAddressWithAlias
sender' Mutez
lodBalance Contract cp st vd
lodContract st
lodStorage Maybe Mutez
lodMbFee Maybe KeyHash
lodDelegate = do
  (Maybe OperationHash
hash, [ContractAddress]
contracts) <- ImplicitAddressWithAlias
-> [LOriginationData] -> m (Maybe OperationHash, [ContractAddress])
forall (m :: * -> *) env.
(HasTezosRpc m, HasTezosClient m, WithClientLog env m) =>
ImplicitAddressWithAlias
-> [LOriginationData] -> m (Maybe OperationHash, [ContractAddress])
lOriginateLargeContracts ImplicitAddressWithAlias
sender' [LOriginationData{st
Maybe Mutez
Maybe KeyHash
Contract cp st vd
Mutez
ContractAlias
AliasBehavior
lodAliasBehavior :: AliasBehavior
lodName :: ContractAlias
lodBalance :: Mutez
lodContract :: Contract cp st vd
lodStorage :: st
lodDelegate :: Maybe KeyHash
lodMbFee :: Maybe Mutez
lodAliasBehavior :: AliasBehavior
lodName :: ContractAlias
lodBalance :: Mutez
lodContract :: Contract cp st vd
lodStorage :: st
lodMbFee :: Maybe Mutez
lodDelegate :: Maybe KeyHash
..}]
  forall (m :: * -> *).
HasTezosRpc m =>
Maybe OperationHash
-> [ContractAddress] -> m (OperationHash, ContractAddress)
singleOriginatedContract @m Maybe OperationHash
hash [ContractAddress]
contracts

--------------------------------------------------------------------------------
-- Utilities
--------------------------------------------------------------------------------

-- | Lorentz version of 'OriginationData'
data LOriginationData = forall cp st vd. (NiceParameter cp, NiceStorage st)
  => LOriginationData
  { LOriginationData -> AliasBehavior
lodAliasBehavior :: AliasBehavior
  , LOriginationData -> ContractAlias
lodName :: ContractAlias
  , LOriginationData -> Mutez
lodBalance :: Mutez
  , ()
lodContract :: L.Contract cp st vd
  , ()
lodStorage :: st
  , LOriginationData -> Maybe KeyHash
lodDelegate :: Maybe L.KeyHash
  , LOriginationData -> Maybe Mutez
lodMbFee :: Maybe Mutez
  }

convertLOriginationData :: LOriginationData -> OriginationData
convertLOriginationData :: LOriginationData -> OriginationData
convertLOriginationData LOriginationData {st
Maybe Mutez
Maybe KeyHash
Contract cp st vd
Mutez
ContractAlias
AliasBehavior
lodAliasBehavior :: LOriginationData -> AliasBehavior
lodName :: LOriginationData -> ContractAlias
lodBalance :: LOriginationData -> Mutez
lodContract :: ()
lodStorage :: ()
lodDelegate :: LOriginationData -> Maybe KeyHash
lodMbFee :: LOriginationData -> Maybe Mutez
lodAliasBehavior :: AliasBehavior
lodName :: ContractAlias
lodBalance :: Mutez
lodContract :: Contract cp st vd
lodStorage :: st
lodDelegate :: Maybe KeyHash
lodMbFee :: Maybe Mutez
..} = case Contract cp st vd
lodContract of
  (Contract cp st vd
_ :: L.Contract cp st vd) ->
    OriginationData
      { odAliasBehavior :: AliasBehavior
odAliasBehavior = AliasBehavior
lodAliasBehavior
      , odName :: ContractAlias
odName = ContractAlias
lodName
      , odBalance :: Mutez
odBalance = Mutez
lodBalance
      , odContract :: Contract (ToT cp) (ToT st)
odContract = Contract cp st vd -> Contract (ToT cp) (ToT st)
forall cp st vd. Contract cp st vd -> Contract (ToT cp) (ToT st)
L.toMichelsonContract Contract cp st vd
lodContract
      , odStorage :: Value (ToT st)
odStorage = st -> Value (ToT st)
forall a. IsoValue a => a -> Value (ToT a)
toVal st
lodStorage
      , odDelegate :: Maybe KeyHash
odDelegate = Maybe KeyHash
lodDelegate
      , odMbFee :: Maybe Mutez
odMbFee = Maybe Mutez
lodMbFee
      }

-- | Checks that the origination result for a single contract is indeed one.
singleOriginatedContract
  :: forall m. HasTezosRpc m
  => Maybe OperationHash -> [ContractAddress]
  -> m (OperationHash, ContractAddress)
singleOriginatedContract :: forall (m :: * -> *).
HasTezosRpc m =>
Maybe OperationHash
-> [ContractAddress] -> m (OperationHash, ContractAddress)
singleOriginatedContract Maybe OperationHash
mbHash [ContractAddress]
contracts = case [ContractAddress]
contracts of
  [ContractAddress
addr] -> case Maybe OperationHash
mbHash of
    Just OperationHash
hash -> (OperationHash, ContractAddress)
-> m (OperationHash, ContractAddress)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (OperationHash
hash, ContractAddress
addr)
    Maybe OperationHash
Nothing -> IncorrectRpcResponse -> m (OperationHash, ContractAddress)
forall (m :: * -> *) e a. (MonadThrow m, Exception e) => e -> m a
throwM (IncorrectRpcResponse -> m (OperationHash, ContractAddress))
-> IncorrectRpcResponse -> m (OperationHash, ContractAddress)
forall a b. (a -> b) -> a -> b
$ IncorrectRpcResponse
RpcOriginatedNoContracts
  [ContractAddress]
_ ->  IncorrectRpcResponse -> m (OperationHash, ContractAddress)
forall (m :: * -> *) e a. (MonadThrow m, Exception e) => e -> m a
throwM (IncorrectRpcResponse -> m (OperationHash, ContractAddress))
-> IncorrectRpcResponse -> m (OperationHash, ContractAddress)
forall a b. (a -> b) -> a -> b
$ [ContractAddress] -> IncorrectRpcResponse
RpcOriginatedMoreContracts [ContractAddress]
contracts