Merge branch 'main' into misha/plutus-update

mlabs/lendex-demo/Main.hs

@@ -4,38 +4,32 @@ module Main where
 import Prelude
 
 import Control.Monad (when)
-
-import Control.Monad.IO.Class
-import Data.Functor
+import Control.Monad.IO.Class (MonadIO(liftIO))
+import Data.Functor (void)
 import Data.Monoid (Last(..))
 
+import Ledger.Constraints (mustPayToPubKey)
+import Playground.Contract (TokenName, Wallet(..))
+import Plutus.Contract hiding (when)
+import Plutus.Contracts.Currency qualified as Currency
+import Plutus.PAB.Simulator qualified as Simulator
 import Plutus.V1.Ledger.Crypto (PubKeyHash(..))
 import Plutus.V1.Ledger.Contexts (pubKeyHash)
-import Playground.Contract
-import Plutus.V1.Ledger.Value (CurrencySymbol)
-import qualified Plutus.V1.Ledger.Value as Value
-import Plutus.PAB.Simulator qualified as Simulator
+import Plutus.V1.Ledger.Tx (txId)
+import Plutus.V1.Ledger.Value qualified as Value
 import Wallet.Emulator.Wallet qualified as Wallet
 
-import Ledger.Constraints
-import Plutus.V1.Ledger.Tx
-import Plutus.Contract hiding (when)
-
-import Mlabs.Plutus.PAB
-import qualified Mlabs.Data.Ray as R
-import Mlabs.System.Console.PrettyLogger
-
+import Mlabs.Data.Ray qualified as R
+import Mlabs.Plutus.PAB ( call, printBalance, waitForLast )
+import Mlabs.Lending.Contract qualified as Contract
+import Mlabs.Lending.Contract.Simulator.Handler qualified as Handler
 import Mlabs.Lending.Logic.Types hiding (Wallet(..), User(..))
-import Mlabs.Lending.Contract
-
-import qualified Plutus.Contracts.Currency as Currency
-
-import Mlabs.Lending.Contract.Simulator.Handler
-import Mlabs.System.Console.Utils
+import Mlabs.System.Console.PrettyLogger ( logNewLine )
+import Mlabs.System.Console.Utils ( logAction, logMlabs )
 
 -- | Console demo for Lendex with simulator
 main :: IO ()
-main = runSimulator lendexId initContract $ do
+main = Handler.runSimulator lendexId initContract $ do
   cur    <- activateInit wAdmin
   Simulator.waitNSlots 10
   admin  <- activateAdmin wAdmin
@@ -54,26 +48,26 @@ main = runSimulator lendexId initContract $ do
   test (unlines [ "Users deposit funds (100 coins in each currrency)."
                 , "They receive equal amount of aTokens."]
        ) $ do
-    call user1 $ Deposit 100 coin1
-    call user2 $ Deposit 100 coin2
-    call user3 $ Deposit 100 coin3
+    call user1 $ Contract.Deposit 100 coin1
+    call user2 $ Contract.Deposit 100 coin2
+    call user3 $ Contract.Deposit 100 coin3
 
   test "User 1 borrows 60 Euros" $ do
-    call user1 $ SetUserReserveAsCollateral
+    call user1 $ Contract.SetUserReserveAsCollateral
                   { setCollateral'asset           = coin1
                   , setCollateral'useAsCollateral = True
                   , setCollateral'portion         = 1 R.% 1
                   }
-    call user1 $ Borrow 60 coin2 (toInterestRateFlag StableRate)
+    call user1 $ Contract.Borrow 60 coin2 (Contract.toInterestRateFlag StableRate)
 
   test "User 3 withdraws 25 Liras" $ do
-    call user3 $ Withdraw 25 coin3
+    call user3 $ Contract.Withdraw 25 coin3
 
   test (unlines [ "Rate of Euros becomes high and User1's collateral is not enough."
                 , "User2 liquidates part of the borrow"]
        ) $ do
-    call oracle $ SetAssetPrice coin2 (R.fromInteger 2)
-    call user2 $ LiquidationCall
+    call oracle $ Contract.SetAssetPrice coin2 (R.fromInteger 2)
+    call user2 $ Contract.LiquidationCall
                   { liquidationCall'collateral     = coin1
                   , liquidationCall'debtUser       = (toPubKeyHash w1)
                   , liquidationCall'debtAsset      = coin2
@@ -82,7 +76,7 @@ main = runSimulator lendexId initContract $ do
                   }
 
   test "User 1 repays 20 coins of the loan" $ do
-    call user1 $ Repay 20 coin1 (toInterestRateFlag StableRate)
+    call user1 $ Contract.Repay 20 coin1 (Contract.toInterestRateFlag StableRate)
 
   liftIO $ putStrLn "Fin (Press enter to Exit)"
   where
@@ -99,12 +93,12 @@ main = runSimulator lendexId initContract $ do
       where
         wals = [1,2,3]
 
-initContract :: InitContract
+initContract :: Handler.InitContract
 initContract = do
   ownPK <- pubKeyHash <$> ownPubKey
   logInfo @String "Start forge"
   cur   <-
-      mapError (toLendexError . show @Currency.CurrencyError)
+      mapError (Contract.toLendexError . show @Currency.CurrencyError)
       (Currency.mintContract ownPK (fmap (, amount) [token1, token2, token3]))
   let cs = Currency.currencySymbol cur
   tell $ Last (Just cs)
@@ -128,21 +122,21 @@ initContract = do
 -----------------------------------------------------------------------
 -- activate handlers
 
-activateInit :: Wallet -> Sim CurrencySymbol
+activateInit :: Wallet -> Handler.Sim Value.CurrencySymbol
 activateInit wal = do
-  wid <- Simulator.activateContract wal Init
+  wid <- Simulator.activateContract wal Handler.Init
   cur <- waitForLast wid
   void $ Simulator.waitUntilFinished wid
   pure cur
 
-activateAdmin :: Wallet -> Sim ContractInstanceId
-activateAdmin wal = Simulator.activateContract wal Admin
+activateAdmin :: Wallet -> Handler.Sim ContractInstanceId
+activateAdmin wal = Simulator.activateContract wal Handler.Admin
 
-activateUser :: Wallet -> Sim ContractInstanceId
-activateUser wal = Simulator.activateContract wal User
+activateUser :: Wallet -> Handler.Sim ContractInstanceId
+activateUser wal = Simulator.activateContract wal Handler.User
 
-activateOracle :: Wallet -> Sim ContractInstanceId
-activateOracle wal = Simulator.activateContract wal Oracle
+activateOracle :: Wallet -> Handler.Sim ContractInstanceId
+activateOracle wal = Simulator.activateContract wal Handler.Oracle
 
 -----------------------------------------------------------------------
 -- constants
@@ -173,8 +167,8 @@ aToken2 = Value.tokenName "aEuro"
 aToken3 = Value.tokenName "aLira"
 aAda    = Value.tokenName "aAda"
 
-startParams :: CurrencySymbol -> StartParams
-startParams cur = StartParams
+startParams :: Value.CurrencySymbol -> Contract.StartParams
+startParams cur = Contract.StartParams
   { sp'coins = fmap (\(coin, aCoin) -> CoinCfg
                                         { coinCfg'coin = coin
                                         , coinCfg'rate = R.fromInteger 1
@@ -189,7 +183,7 @@ startParams cur = StartParams
   }
   where
 
-toCoin :: CurrencySymbol -> TokenName -> Coin
+toCoin :: Value.CurrencySymbol -> TokenName -> Coin
 toCoin cur tn = Value.AssetClass (cur, tn)
 
 --------------------------------------------------------------------

mlabs/nft-demo/Main.hs

@@ -2,26 +2,25 @@
 module Main where
 
 import Prelude
-import Control.Monad.IO.Class
-import Data.Functor
-import PlutusTx.Prelude (ByteString)
 
+import Control.Monad.IO.Class ( MonadIO(liftIO) )
+import Data.Functor ( void )
+import Playground.Contract ( Wallet(Wallet) )
+import Plutus.Contract ( ContractInstanceId )
 import Plutus.PAB.Simulator qualified as Simulator
-import Playground.Contract
-import Plutus.Contract
-
-import Mlabs.Nft.Logic.Types
-import Mlabs.Nft.Contract.Simulator.Handler
-import qualified Mlabs.Nft.Contract as Nft
-import qualified Mlabs.Data.Ray as R
+import PlutusTx.Prelude (ByteString)
 
-import Mlabs.Plutus.PAB
-import Mlabs.System.Console.PrettyLogger
-import Mlabs.System.Console.Utils
+import Mlabs.Nft.Logic.Types ( NftId )
+import Mlabs.Nft.Contract qualified as Nft
+import Mlabs.Nft.Contract.Simulator.Handler qualified as Handler
+import Mlabs.Data.Ray qualified as R
+import Mlabs.Plutus.PAB ( call, printBalance, waitForLast )
+import Mlabs.System.Console.PrettyLogger ( logNewLine )
+import Mlabs.System.Console.Utils ( logAction, logMlabs )
 
 -- | Main function to run simulator
 main :: IO ()
-main = runSimulator startParams $ do
+main = Handler.runSimulator startParams $ do
   let users = [1, 2, 3]
   logMlabs
   test "Init users" users (pure ())
@@ -56,27 +55,27 @@ main = runSimulator startParams $ do
 -- handlers
 
 -- | Instanciates start NFT endpoint in the simulator to the given wallet
-activateStartNft :: Wallet -> Sim NftId
+activateStartNft :: Wallet -> Handler.Sim NftId
 activateStartNft wal = do
-  wid <- Simulator.activateContract wal StartNft
+  wid <- Simulator.activateContract wal Handler.StartNft
   nftId <- waitForLast wid
   void $ Simulator.waitUntilFinished wid
   pure nftId
 
 -- | Instanciates user actions endpoint in the simulator to the given wallet
-activateUser :: NftId -> Wallet -> Sim ContractInstanceId
+activateUser :: NftId -> Wallet -> Handler.Sim ContractInstanceId
 activateUser nid wal = do
-  Simulator.activateContract wal $ User nid
+  Simulator.activateContract wal $ Handler.User nid
 
 -------------------------------------------------------------
 -- Script helpers
 
 -- | Call buy NFT endpoint
-buy :: ContractInstanceId -> Integer -> Maybe Integer -> Sim ()
+buy :: ContractInstanceId -> Integer -> Maybe Integer -> Handler.Sim ()
 buy cid price newPrice = call cid (Nft.Buy price newPrice)
 
 -- | Call set price for NFT endpoint
-setPrice :: ContractInstanceId -> Maybe Integer -> Sim ()
+setPrice :: ContractInstanceId -> Maybe Integer -> Handler.Sim ()
 setPrice cid newPrice = call cid (Nft.SetPrice newPrice)
 
 -------------------------------------------------------------

mlabs/src/Mlabs/Control/Check.hs

@@ -8,10 +8,10 @@ module Mlabs.Control.Check(
   , isUnitRangeRay
 ) where
 
-import Control.Monad.Except (MonadError(..))
-
 import PlutusTx.Prelude
+import Control.Monad.Except (MonadError(..))
 import qualified PlutusTx.Ratio as R
+
 import Mlabs.Data.Ray (Ray)
 import qualified Mlabs.Data.Ray as Ray
 import           Prelude (String)

mlabs/src/Mlabs/Control/Monad/State.hs

@@ -12,8 +12,8 @@ module Mlabs.Control.Monad.State(
 import PlutusTx.Prelude
 import Prelude (String)
 
-import Control.Monad.Except       hiding (Functor(..))
-import Control.Monad.State.Strict hiding (Functor(..))
+import Control.Monad.Except ( MonadError(..) )
+import Control.Monad.State.Strict ( StateT(..), gets, MonadState(..) )
 
 -- | State update of plutus contracts
 type PlutusState st = StateT st (Either String)

mlabs/src/Mlabs/Data/List.hs

@@ -6,10 +6,10 @@ module Mlabs.Data.List(
   , mapM_
 ) where
 
-import           PlutusTx.Prelude hiding (take, mapM_)
-import           Mlabs.Data.Ord (comparing)
-import           Prelude (Monad)
-import qualified Prelude as Hask
+import qualified Prelude as Hask (Monad, seq)
+import PlutusTx.Prelude hiding (take, mapM_)
+
+import Mlabs.Data.Ord (comparing)
 
 {-# INLINABLE take #-}
 -- | 'take' @n@, applied to a list @xs@, returns the prefix of @xs@
@@ -93,7 +93,7 @@ sortBy cmp = mergeAll . sequences
 
 
 {-# INLINABLE mapM_ #-}
-mapM_ :: Monad f => (a -> f ()) -> [a] -> f ()
+mapM_ :: Hask.Monad f => (a -> f ()) -> [a] -> f ()
 mapM_ f = \case
   []   -> return ()
   a:as -> do

mlabs/src/Mlabs/Data/Ord.hs

@@ -3,7 +3,7 @@ module Mlabs.Data.Ord(
   comparing
 ) where
 
-import PlutusTx.Prelude
+import PlutusTx.Prelude ( Ordering, Ord(compare) )
 
 {-# INLINABLE comparing #-}
 -- |

mlabs/src/Mlabs/Data/Ray.hs

@@ -19,16 +19,15 @@ module Mlabs.Data.Ray(
   , properFraction
 ) where
 
-import Data.Aeson
-
-import GHC.Generics
-
-import qualified Prelude as Hask
-import           PlutusTx (IsData, Lift)
-import           PlutusCore.Default (DefaultUni)
-import           PlutusTx.Prelude hiding (fromInteger, fromRational, recip, (%), round, properFraction, toRational)
-import           Playground.Contract (ToSchema)
-import qualified PlutusTx.Ratio as R
+import PlutusTx.Prelude hiding (fromInteger, fromRational, recip, (%), round, properFraction, toRational)
+
+import Data.Aeson ( FromJSON, ToJSON )
+import GHC.Generics ( Generic )
+import Playground.Contract (ToSchema)
+import PlutusCore.Default (DefaultUni)
+import PlutusTx (IsData, Lift)
+import PlutusTx.Ratio qualified as R
+import Prelude qualified as Hask
 
 {-# INLINABLE base #-}
 -- | Base precision (27 precision digits are allowed)

mlabs/src/Mlabs/Demo/Contract/Burn.hs

@@ -21,14 +21,11 @@ module Mlabs.Demo.Contract.Burn
   ( burnScrAddress
   , burnValHash
   ) where
-
-import PlutusTx.Prelude hiding (Monoid(..), Semigroup(..))
 
-import qualified Ledger as Ledger
-import Ledger.Contexts
-import Ledger.Scripts
+import Ledger ( ValidatorHash, Address, ScriptContext, Validator, validatorHash )
 import qualified Ledger.Typed.Scripts.Validators as Validators
-import qualified PlutusTx as PlutusTx
+import PlutusTx qualified
+import PlutusTx.Prelude ( Bool(False) )
 
 {-# INLINABLE mkValidator #-}
 -- | A validator script that can be used to burn any tokens sent to it.

mlabs/src/Mlabs/Demo/Contract/Mint.hs

@@ -33,26 +33,24 @@ module Mlabs.Demo.Contract.Mint
 
 import PlutusTx.Prelude hiding (Monoid(..), Semigroup(..), null)
 
-import Plutus.Contract as Contract
-import qualified Ledger as Ledger
-import qualified Ledger.Ada as Ada
-import qualified Ledger.Constraints as Constraints
-import Ledger.Contexts
-import Ledger.Scripts
-import qualified Ledger.Typed.Scripts as Scripts
-import Ledger.Value (CurrencySymbol, TokenName)
-import qualified Ledger.Value as Value
-import qualified PlutusTx as PlutusTx
-
-import Control.Monad
+import Control.Monad (void)
 import Data.Aeson (FromJSON, ToJSON)
-import Data.Text hiding (all, filter, foldr)
-import Data.Void
+import Data.Text (Text)
 import GHC.Generics (Generic)
+import Ledger qualified
+import Ledger.Ada qualified as Ada
+import Ledger.Constraints qualified as Constraints
+import Ledger.Contexts (scriptContextTxInfo, ScriptContext, TxInfo, txInfoForge, txInfoOutputs, TxOut, txOutAddress, txOutValue)
+import Ledger.Value (CurrencySymbol, TokenName)
+import Ledger.Value qualified as Value
+import Ledger.Scripts (MintingPolicy, Datum(Datum), mkMintingPolicyScript)
+import Ledger.Typed.Scripts qualified as Scripts
+import Plutus.Contract as Contract
+import PlutusTx qualified
 import Prelude (Semigroup(..))
 import Schema (ToSchema)
-
-import Mlabs.Demo.Contract.Burn
+import Data.Void (Void)
+import Mlabs.Demo.Contract.Burn (burnScrAddress, burnValHash)
 
 ------------------------------------------------------------------------------
 -- On-chain code.