budget estimation refactoring and cleanup

Author: mikekeke

examples/ex-units/app/Main.hs

@@ -14,30 +14,31 @@ import Data.Text qualified as Text
 import Data.UUID.V4 qualified as UUID
 import Ledger (PubKeyHash)
 import LockSpend (lockThenSpend)
+
 -- import LockSpendSingle (lockThenSpendSingle)
 import Plutus.PAB.Core.ContractInstance.STM (Activity (Active))
 import Servant.Client (BaseUrl (BaseUrl), Scheme (Http))
 import System.Directory (listDirectory)
-import System.Environment (getArgs, setEnv, getEnv)
+import System.Environment (getArgs, getEnv, setEnv)
 import System.FilePath ((</>))
 import Wallet.Types (ContractInstanceId (ContractInstanceId))
 import Prelude
 
+{- | For running fast live tests using Plutip's local cluster,
+ needed only for debugging period
+-}
 main :: IO ()
 main = do
-  -- TODO: export PATH=$PATH:/home/mike/dev/mlabs/local-cluster/node-bins
-  let clusterDir = "/home/mike/dev/mlabs/local-cluster/data"
-  [sockPath] <- getArgs
+  [sockPath, clusterDir, cliDir] <- getArgs
   setEnv "CARDANO_NODE_SOCKET_PATH" sockPath
-  getEnv "PATH" >>= \p -> setEnv "PATH" (p ++ ":/home/mike/dev/mlabs/local-cluster/node-bins")
+  getEnv "PATH" >>= \p -> setEnv "PATH" (p ++ ":" ++ cliDir)
   let nodeInfo = BPI.NodeInfo Mainnet sockPath
 
   cEnv <- mkContractEnv nodeInfo clusterDir
-  res <- BPI.runContract cEnv lockThenSpend 
-  -- res <- BPI.runContract cEnv lockThenSpendSingle
+  res <- BPI.runContract cEnv lockThenSpend
   putStrLn $ case res of
-      Right _ -> "=== OK ==="
-      Left e -> "=== FAILED ===\n" ++ show e 
+    Right _ -> "=== OK ==="
+    Left e -> "=== FAILED ===\n" ++ show e
 
 mkContractEnv :: Monoid w => BPI.NodeInfo -> FilePath -> IO (ContractEnvironment w)
 mkContractEnv nodeInfo clusterDir = do
@@ -47,36 +48,36 @@ mkContractEnv nodeInfo clusterDir = do
   pkhs <- getPkhs clusterDir
   return $
     ContractEnvironment
-      { cePABConfig = mkPabConf pparams (Text.pack paramsFile) clusterDir (head pkhs),
-        ceContractState = contractState,
-        ceContractInstanceId = contractInstanceID
+      { cePABConfig = mkPabConf pparams (Text.pack paramsFile) clusterDir (head pkhs)
+      , ceContractState = contractState
+      , ceContractInstanceId = contractInstanceID
       }
 
 getPparams :: BPI.NodeInfo -> FilePath -> IO (ProtocolParameters, FilePath)
 getPparams nodeInfo clusterDir = do
-  pparams :: ProtocolParameters <- getOrFailM $ BPI.protocolParams nodeInfo
+  pparams :: ProtocolParameters <- getOrFailM $ BPI.queryProtocolParams nodeInfo
   let ppath = clusterDir </> "pparams.json"
   JSON.encodeFile ppath pparams
   return (pparams, ppath)
 
 mkPabConf :: ProtocolParameters -> Text -> FilePath -> PubKeyHash -> PABConfig
 mkPabConf pparams pparamsFile clusterDir ownPkh =
   PABConfig
-    { pcCliLocation = Local,
-      pcNetwork = Mainnet,
-      pcChainIndexUrl = BaseUrl Http "localhost" 9083 "",
-      pcPort = 9080,
-      pcProtocolParams = pparams,
-      pcTipPollingInterval = 1_000_000,
-      pcSlotConfig = def,
-      pcOwnPubKeyHash = ownPkh,
-      pcScriptFileDir = Text.pack $ clusterDir </> "bot-plutus-interface/scripts",
-      pcSigningKeyFileDir = Text.pack $ clusterDir </> "bot-plutus-interface/signing-keys",
-      pcTxFileDir = Text.pack $ clusterDir </> "bot-plutus-interface/txs",
-      pcDryRun = False,
-      pcLogLevel = Error,
-      pcProtocolParamsFile = pparamsFile,
-      pcEnableTxEndpoint = True
+    { pcCliLocation = Local
+    , pcNetwork = Mainnet
+    , pcChainIndexUrl = BaseUrl Http "localhost" 9083 ""
+    , pcPort = 9080
+    , pcProtocolParams = pparams
+    , pcTipPollingInterval = 1_000_000
+    , pcSlotConfig = def
+    , pcOwnPubKeyHash = ownPkh
+    , pcScriptFileDir = Text.pack $ clusterDir </> "bot-plutus-interface/scripts"
+    , pcSigningKeyFileDir = Text.pack $ clusterDir </> "bot-plutus-interface/signing-keys"
+    , pcTxFileDir = Text.pack $ clusterDir </> "bot-plutus-interface/txs"
+    , pcDryRun = False
+    , pcLogLevel = Error
+    , pcProtocolParamsFile = pparamsFile
+    , pcEnableTxEndpoint = True
     }
 
 getPkhs :: FilePath -> IO [PubKeyHash]

examples/ex-units/src/LockSpendSingle.hs

@@ -4,31 +4,35 @@ import Prelude
 
 import Data.Map qualified as Map
 import Data.Text (Text)
-import Ledger
-    ( CardanoTx,
-      Address,
-      ScriptContext,
-      TxId,
-      Validator,
-      getCardanoTxId,
-      scriptAddress,
-      unitDatum,
-      unitRedeemer,
-      validatorHash )
+import Ledger (
+  Address,
+  CardanoTx,
+  ScriptContext,
+  TxId,
+  Validator,
+  getCardanoTxId,
+  scriptAddress,
+  unitDatum,
+  unitRedeemer,
+  validatorHash,
+ )
 import Ledger.Constraints qualified as Constraints
-import Plutus.Contract
-    ( Contract, submitTx, awaitTxConfirmed, submitTxConstraintsWith )
+import Ledger.Typed.Scripts.Validators qualified as Validators
+import Plutus.Contract (
+  Contract,
+  awaitTxConfirmed,
+  submitTx,
+  submitTxConstraintsWith,
+ )
 import Plutus.Contract qualified as Contract
 import Plutus.PAB.Effects.Contract.Builtin (EmptySchema)
-import Ledger.Typed.Scripts.Validators qualified as Validators
 import Plutus.V1.Ledger.Ada qualified as Value
 import PlutusTx qualified
 
 lockThenSpendSingle :: Contract () EmptySchema Text (TxId, CardanoTx)
 lockThenSpendSingle =
   lockAtScript >> Contract.waitNSlots 1 >> spendFromScript
 
-
 lockAtScript :: Contract () EmptySchema Text (TxId, CardanoTx)
 lockAtScript = do
   let constr =
@@ -56,7 +60,6 @@ spendFromScript = do
       awaitTxConfirmed $ getCardanoTxId tx
       pure (getCardanoTxId tx, tx)
 
-
 -- Always true Script and spending contract
 
 {-# INLINEABLE mkValidator #-}

src/BotPlutusInterface/BodyBuilder.hs

@@ -1,13 +1,16 @@
 {-# LANGUAGE AllowAmbiguousTypes #-}
+
+{- | Module provides the way of building ".raw" transactions with execution budget
+ estimated with `Cardano.Api` tools.
+-}
 module BotPlutusInterface.BodyBuilder (buildRaw) where
 
 import BotPlutusInterface.CardanoCLI qualified as CardanoCLI
 import BotPlutusInterface.Effects (PABEffect, estimateBudget)
-import BotPlutusInterface.Files
-  ( DummyPrivKey,
-  )
-import BotPlutusInterface.Estimate (TxFile (Raw), getMaxBudgets)
-import BotPlutusInterface.Types (PABConfig)
+import BotPlutusInterface.Files (
+  DummyPrivKey,
+ )
+import BotPlutusInterface.Types (PABConfig, TxFile (Raw))
 import Control.Monad.Freer (Eff, Member)
 import Control.Monad.Trans.Either (firstEitherT, newEitherT, runEitherT)
 import Data.Kind (Type)
@@ -17,8 +20,13 @@ import Data.Text qualified as Text
 import Ledger (ExBudget, Tx)
 import Ledger.Crypto (PubKeyHash)
 import Prelude
+import BotPlutusInterface.Estimate (getMaxBudgets)
 
-
+{- | Build and save raw transaction (transaction body) with estimated execution budgets using `CardanoCLI`.
+ It builds first transaction body with 0 budget for all spending inputs and minting policies,
+ then uses body of this transaction to estimate execution budget
+ and build final body with budget set.
+-}
 buildRaw ::
   forall (w :: Type) (effs :: [Type -> Type]).
   Member (PABEffect w) effs =>
@@ -27,16 +35,16 @@ buildRaw ::
   Tx ->
   Eff effs (Either Text ExBudget)
 buildRaw pabConf privKeys tx = runEitherT $ do
-  buildDraftTxBody 
-    >>= estimateBudgetByDraftBody 
+  buildDraftTxBody
+    >>= estimateBudgetByDraftBody
     >>= buildBodyUsingEstimatedBudget
   where
     buildDraftTxBody = newEitherT $ CardanoCLI.buildDraftTx @w pabConf privKeys tx
 
-    estimateBudgetByDraftBody path = 
+    estimateBudgetByDraftBody path =
       firstEitherT toText . newEitherT $ estimateBudget @w (Raw path)
 
-    buildBodyUsingEstimatedBudget exBudget = 
+    buildBodyUsingEstimatedBudget exBudget =
       newEitherT $
         CardanoCLI.buildTx @w
           pabConf

src/BotPlutusInterface/Effects.hs

@@ -23,13 +23,15 @@ module BotPlutusInterface.Effects (
 ) where
 
 import BotPlutusInterface.ChainIndex (handleChainIndexReq)
-import BotPlutusInterface.Estimate (TxFile)
 import BotPlutusInterface.Estimate qualified as Estimate
 import BotPlutusInterface.Types (
+  BudgetEstimationError,
   CLILocation (..),
   ContractEnvironment,
   ContractState (ContractState),
   LogLevel (..),
+  TxBudget,
+  TxFile,
  )
 import Cardano.Api (AsType, FileError, HasTextEnvelope, TextEnvelopeDescr, TextEnvelopeError)
 import Cardano.Api qualified
@@ -85,7 +87,7 @@ data PABEffect (w :: Type) (r :: Type) where
   ListDirectory :: FilePath -> PABEffect w [FilePath]
   UploadDir :: Text -> PABEffect w ()
   QueryChainIndex :: ChainIndexQuery -> PABEffect w ChainIndexResponse
-  EstimateBudget :: TxFile -> PABEffect w (Either Estimate.BudgetEstimationError Estimate.TxBudgets)
+  EstimateBudget :: TxFile -> PABEffect w (Either BudgetEstimationError TxBudget)
 
 handlePABEffect ::
   forall (w :: Type) (effs :: [Type -> Type]).
@@ -129,7 +131,7 @@ handlePABEffect contractEnv =
         QueryChainIndex query ->
           handleChainIndexReq contractEnv.cePABConfig query
         EstimateBudget txPath ->
-          Estimate.budgetByFile txPath
+          Estimate.estimateBudget contractEnv.cePABConfig txPath
     )
 
 printLog' :: LogLevel -> LogLevel -> String -> IO ()
@@ -180,7 +182,7 @@ estimateBudget ::
   forall (w :: Type) (effs :: [Type -> Type]).
   Member (PABEffect w) effs =>
   TxFile ->
-  Eff effs (Either Estimate.BudgetEstimationError Estimate.TxBudgets)
+  Eff effs (Either BudgetEstimationError TxBudget)
 estimateBudget = send @(PABEffect w) . EstimateBudget
 
 createDirectoryIfMissing ::