Add awaitTxConfirmedUntilSlot and move the initial wait for the chain-index response to the contract

Change-type: patch
Signed-off-by: Giovanni Garufi <giovanni@mlabs.city>

Author: nazrhom

bot-plutus-interface.cabal

@@ -85,6 +85,7 @@ library
     BotPlutusInterface.Types
     BotPlutusInterface.UtxoParser
     BotPlutusInterface.Server
+    BotPlutusInterface.Helpers
   build-depends:
     , aeson                      ^>=1.5.0.0
     , attoparsec                 >=0.13.2.2

examples/plutus-game/plutus-game.cabal

@@ -81,6 +81,7 @@ library
     , cardano-crypto
     , cardano-ledger-alonzo
     , containers
+    , bot-plutus-interface
     , data-default
     , data-default-class
     , directory

src/BotPlutusInterface/Contract.hs

@@ -179,41 +179,33 @@ awaitTxStatusChange contractEnv txId = do
   -- The depth (in blocks) after which a transaction cannot be rolled back anymore (from Plutus.ChainIndex.TxIdState)
   let chainConstant = 8
 
-  ciTxState <- findChainIndexTxLoop
-  case ciTxState of
+  mTx <- queryChainIndexForTxState
+  case mTx of
     Nothing -> pure Unknown
     Just txState -> do
-      awaitNBlocks @w contractEnv chainConstant
+      awaitNBlocks @w contractEnv (chainConstant + 1)
       -- Check if the tx is still present in chain-index, in case of a rollback
       -- we might not find it anymore.
-      ciTxState' <- findChainIndexTxLoop
+      ciTxState' <- queryChainIndexForTxState
       case ciTxState' of
         Nothing -> pure Unknown
         Just _ -> do
           blk <- fromInteger <$> currentBlock contractEnv
           -- This will set the validity correctly based on the txState.
-          -- The tx will always be committed, as we wait for chainConstant blocks
+          -- The tx will always be committed, as we wait for chainConstant + 1 blocks
           let status = transactionStatus blk txState txId
           pure $ fromRight Unknown status
   where
     -- Attempts to find the tx in chain index. If the tx does not appear after
     -- 5 blocks we give up
-    findChainIndexTxLoop :: Eff effs (Maybe TxIdState)
-    findChainIndexTxLoop = go 0
-      where
-        go :: Int -> Eff effs (Maybe TxIdState)
-        go n = do
-          mTx <- join . preview _TxIdResponse <$> (queryChainIndex @w $ TxFromTxId txId)
-          case mTx of
-            Just tx -> do
-              blk <- fromInteger <$> currentBlock contractEnv
-              pure . Just $ fromTx blk tx
-            Nothing -> do
-              if n >= 5
-                then pure Nothing
-                else do
-                  _ <- awaitNBlocks @w contractEnv 1
-                  go (n + 1)
+    queryChainIndexForTxState :: Eff effs (Maybe TxIdState)
+    queryChainIndexForTxState = do
+      mTx <- join . preview _TxIdResponse <$> (queryChainIndex @w $ TxFromTxId txId)
+      case mTx of
+        Just tx -> do
+          blk <- fromInteger <$> currentBlock contractEnv
+          pure . Just $ fromTx blk tx
+        Nothing -> pure Nothing
 
 -- | This will FULLY balance a transaction
 balanceTx ::

src/BotPlutusInterface/Helpers.hs

@@ -0,0 +1,25 @@
+module BotPlutusInterface.Helpers (awaitTxConfirmedUntilSlot) where
+
+import Control.Lens (review)
+import Data.Text (pack)
+import Ledger (Slot, TxId)
+import Plutus.Contract.Error (AsContractError, _OtherContractError)
+import Plutus.Contract.Request (RollbackState (Unknown), awaitTxStatusChange, currentSlot, waitNSlots)
+import Plutus.Contract.Types (Contract, throwError)
+import Prelude
+
+awaitTxConfirmedUntilSlot :: forall w s e. (AsContractError e) => TxId -> Slot -> Contract w s e ()
+awaitTxConfirmedUntilSlot i maxSlot = go 0
+  where
+    go :: Integer -> Contract w s e ()
+    go n = do
+      mTx <- awaitTxStatusChange i
+      case mTx of
+        Unknown -> do
+          curSlot <- currentSlot
+          if curSlot >= maxSlot
+            then throwError @e $ review _OtherContractError $ pack $ "Could not find tx after maxAttempts. ID: " ++ show i
+            else do
+              _ <- waitNSlots 20
+              go (n + 1)
+        _ -> pure ()