Use Liqwid-Labs/plutarch

- Removed `Utils.Value` -- not being used/better is provided with
  liqwid-plutarch-extra
- uses `Liqwid-Labs/plutarch`
- uses `Liqwid-Labs/plutarch-numeric`
- uses `Liqwid-Labs/plutarch-safemoney`
- uses `Liqwid-Labs/liqwid-plutarch-extra`

agora/Agora/AuthorityToken.hs

@@ -25,8 +25,8 @@ import Plutarch.Api.V1 (
   PTxOut (..),
  )
 import Plutarch.Api.V1.AssocMap (PMap (PMap))
-import Plutarch.Api.V1.Extra (passetClass, passetClassValueOf)
-import Plutarch.Api.V1.Value (PValue (PValue))
+import Plutarch.Api.V1.AssetClass (passetClass, passetClassValueOf)
+import "plutarch" Plutarch.Api.V1.Value (PValue (PValue))
 import Plutarch.Builtin (pforgetData)
 import Plutus.V1.Ledger.Value (AssetClass (AssetClass))
 

agora/Agora/Effect.hs

@@ -10,7 +10,7 @@ module Agora.Effect (makeEffect) where
 import Agora.AuthorityToken (singleAuthorityTokenBurned)
 import Agora.Utils (tcassert, tclet, tcmatch, tctryFrom)
 import Plutarch.Api.V1 (PCurrencySymbol, PScriptPurpose (PSpending), PTxInfo, PTxOutRef, PValidator, PValue)
-import Plutarch.TryFrom (PTryFrom)
+import Plutarch.TryFrom ()
 import Plutus.V1.Ledger.Value (CurrencySymbol)
 
 --------------------------------------------------------------------------------

agora/Agora/Effect/GovernorMutation.hs

@@ -31,7 +31,7 @@ import Plutarch.Api.V1 (
   PValidator,
   PValue,
  )
-import Plutarch.Api.V1.Extra (pvalueOf)
+import "liqwid-plutarch-extra" Plutarch.Api.V1.Value (pvalueOf)
 import Plutarch.DataRepr (
   DerivePConstantViaData (..),
   PDataFields,

agora/Agora/Governor.hs

@@ -54,9 +54,12 @@ import Plutarch.DataRepr (
   PIsDataReprInstances (PIsDataReprInstances),
  )
 import Plutarch.Lift (PConstantDecl, PUnsafeLiftDecl (..))
-import Plutarch.SafeMoney (Tagged (..), puntag)
+import Data.Tagged (Tagged (..))
+import Plutarch.Extra.Comonad (pextract)
 import Plutarch.TryFrom (PTryFrom (..))
 import Plutarch.Unsafe (punsafeCoerce)
+import Plutarch.SafeMoney (PDiscrete (..))
+import Plutarch.Extra.TermCont (pmatchC)
 
 --------------------------------------------------------------------------------
 
@@ -188,9 +191,13 @@ governorDatumValid = phoistAcyclic $
         pletFields @'["execute", "draft", "vote"] $
           pfield @"proposalThresholds" # datum
 
-    execute <- tclet $ puntag thresholds.execute
-    draft <- tclet $ puntag thresholds.draft
-    vote <- tclet $ puntag thresholds.vote
+    PDiscrete execute' <- pmatchC thresholds.execute
+    PDiscrete draft' <- pmatchC thresholds.draft
+    PDiscrete vote' <- pmatchC thresholds.vote
+
+    execute <- tclet $ pextract # execute'
+    draft <- tclet $ pextract # draft'
+    vote <- tclet $ pextract # vote'
 
     pure $
       foldr1

agora/Agora/Governor/Scripts.hs

@@ -110,21 +110,23 @@ import Plutarch.Api.V1 (
   mkValidator,
   validatorHash,
  )
-import Plutarch.Api.V1.Extra (
+import Plutarch.Api.V1.AssetClass (
   passetClass,
   passetClassValueOf,
  )
-import Plutarch.Map.Extra (
+import Plutarch.Extra.Map (
   pkeys,
   plookup,
   plookup',
  )
+import Plutarch.Extra.Comonad ( pextract)
 import Plutarch.SafeMoney (
   PDiscrete,
-  puntag,
   pvalueDiscrete',
  )
-import Plutarch.TryFrom (ptryFrom)
+import Plutarch.TryFrom ()
+import Plutarch.SafeMoney (PDiscrete (..))
+import Plutarch.Extra.TermCont (pmatchC)
 
 --------------------------------------------------------------------------------
 
@@ -629,8 +631,9 @@ governorValidator gov =
 
           winner <- tclet $ mustBePJust # "No winning outcome" # maybeWinner
 
+          PDiscrete minimumVotes' <- pmatchC $ pfromData $ pfield @"execute" # proposalInputDatumF.thresholds
           let highestVote = pfromData $ psndBuiltin # winner
-              minimumVotes = puntag $ pfromData $ pfield @"execute" # proposalInputDatumF.thresholds
+              minimumVotes = pextract # minimumVotes'
 
           tcassert "Higgest vote doesn't meet the minimum requirement" $ minimumVotes #<= highestVote
 

agora/Agora/Proposal.hs

@@ -57,7 +57,8 @@ import Plutarch.Lift (
   PConstantDecl,
   PUnsafeLiftDecl (..),
  )
-import Plutarch.SafeMoney (PDiscrete, Tagged)
+import Plutarch.SafeMoney (PDiscrete)
+import Data.Tagged (Tagged)
 import Plutarch.TryFrom (PTryFrom (PTryFromExcess, ptryFrom'))
 import Plutarch.Unsafe (punsafeCoerce)
 import Plutus.V1.Ledger.Api (DatumHash, PubKeyHash, ValidatorHash)

agora/Agora/Proposal/Scripts.hs

@@ -44,10 +44,13 @@ import Plutarch.Api.V1 (
   PTxInfo (PTxInfo),
   PValidator,
  )
-import Plutarch.Api.V1.Extra (passetClass, passetClassValueOf)
-import Plutarch.Map.Extra (plookup)
-import Plutarch.SafeMoney (puntag)
+import Plutarch.Api.V1.AssetClass (passetClass, passetClassValueOf)
+import Plutarch.Extra.Map (plookup)
+import Plutarch.Extra.Comonad (pextract)
+import Plutarch.SafeMoney (PDiscrete (..))
 import Plutus.V1.Ledger.Value (AssetClass (AssetClass))
+import Plutarch.Extra.TermCont (pmatchC)
+
 
 {- | Policy for Proposals.
 
@@ -253,8 +256,9 @@ proposalValidator proposal =
                   PProposalVotes $
                     pupdate
                       # plam
-                        ( \votes ->
-                            pcon $ PJust $ votes + (puntag stakeInF.stakedAmount)
+                        ( \votes -> unTermCont $ do
+                            PDiscrete v <- pmatchC stakeInF.stakedAmount
+                            pure $ pcon $ PJust $ votes + (pextract # v)
                         )
                       # voteFor
                       # m

agora/Agora/Proposal/Time.hs

@@ -50,7 +50,7 @@ import Plutarch.Lift (
   PConstantDecl,
   PUnsafeLiftDecl (..),
  )
-import Plutarch.Numeric (AdditiveSemigroup ((+)))
+import Plutarch.Numeric.Additive (AdditiveSemigroup ((+)))
 import Plutarch.Unsafe (punsafeCoerce)
 import Plutus.V1.Ledger.Time (POSIXTime)
 import PlutusTx qualified
@@ -259,7 +259,7 @@ isDraftPeriod ::
     )
 isDraftPeriod = phoistAcyclic $
   plam $ \config s' -> pmatch s' $ \(PProposalStartingTime s) ->
-    proposalTimeWithin # s # (s + pfield @"draftTime" # config)
+    proposalTimeWithin # s # (s + (pfield @"draftTime" # config))
 
 -- | True if the 'PProposalTime' is in the voting period.
 isVotingPeriod ::

agora/Agora/SafeMoney.hs

@@ -18,7 +18,7 @@ module Agora.SafeMoney (
 
 import Plutus.V1.Ledger.Value (AssetClass (AssetClass))
 
-import Plutarch.SafeMoney
+import Data.Tagged ( Tagged(Tagged) )
 
 --------------------------------------------------------------------------------
 -- Tags

agora/Agora/Stake.hs

@@ -66,12 +66,9 @@ import Agora.Utils (
   tcmatch,
  )
 import Control.Applicative (Const)
-import Plutarch.Api.V1.Extra (PAssetClass, passetClassValueOf)
-import Plutarch.Numeric ()
-import Plutarch.SafeMoney (
-  PDiscrete,
-  Tagged (..),
- )
+import Plutarch.Api.V1.AssetClass (PAssetClass, passetClassValueOf)
+import Data.Tagged (Tagged (..) )
+import Plutarch.SafeMoney (PDiscrete)
 import Plutarch.TryFrom (PTryFrom (PTryFromExcess, ptryFrom'))
 
 --------------------------------------------------------------------------------

agora/Agora/Stake/Scripts.hs

@@ -37,14 +37,13 @@ import Plutarch.Api.V1 (
   mintingPolicySymbol,
   mkMintingPolicy,
  )
-import Plutarch.Api.V1.Extra (passetClass, passetClassValueOf, pvalueOf)
+import Plutarch.Api.V1.AssetClass (passetClass, passetClassValueOf, pvalueOf)
 import Plutarch.Internal (punsafeCoerce)
-import Plutarch.Numeric
+import Plutarch.Numeric.Additive ( AdditiveMonoid(zero), AdditiveSemigroup((+)) )
+import Data.Tagged (Tagged (..), untag)
 import Plutarch.SafeMoney (
-  Tagged (..),
   pdiscreteValue',
   pvalueDiscrete',
-  untag,
  )
 import Plutus.V1.Ledger.Value (AssetClass (AssetClass))
 import Prelude hiding (Num (..))

agora/Agora/Treasury.hs

@@ -16,13 +16,13 @@ import GHC.Generics qualified as GHC
 import Generics.SOP
 import Plutarch.Api.V1 (PValidator)
 import Plutarch.Api.V1.Contexts (PScriptPurpose (PMinting))
-import Plutarch.Api.V1.Value (PValue)
+import "plutarch" Plutarch.Api.V1.Value (PValue)
 import Plutarch.DataRepr (
   DerivePConstantViaData (..),
   PIsDataReprInstances (PIsDataReprInstances),
  )
 import Plutarch.Lift (PConstantDecl (..), PLifted (..), PUnsafeLiftDecl)
-import Plutarch.TryFrom (PTryFrom)
+import Plutarch.TryFrom ()
 import Plutus.V1.Ledger.Value (CurrencySymbol)
 import PlutusTx qualified
 

agora/Agora/Utils.hs

@@ -97,12 +97,13 @@ import Plutarch.Api.V1 (
   mkMintingPolicy,
  )
 import Plutarch.Api.V1.AssocMap (PMap (PMap))
-import Plutarch.Api.V1.Extra (PAssetClass, passetClassValueOf, pvalueOf)
-import Plutarch.Api.V1.Value (PValue (PValue))
+import Plutarch.Api.V1.AssetClass (PAssetClass, passetClassValueOf, pvalueOf)
+import "plutarch" Plutarch.Api.V1.Value (PValue (PValue))
 import Plutarch.Builtin (pforgetData, ppairDataBuiltin)
-import Plutarch.Map.Extra (pkeys)
 import Plutarch.Reducible (Reducible (Reduce))
-import Plutarch.TryFrom (PTryFrom (PTryFromExcess), ptryFrom)
+import Plutarch.TryFrom (PTryFrom (PTryFromExcess))
+import Plutarch.Extra.Map (pkeys)
+
 
 --------------------------------------------------------------------------------
 -- TermCont-based combinators. Some of these will live in plutarch eventually.

agora/Agora/Utils/Value.hs

@@ -1,93 +0,0 @@
-{-# OPTIONS_GHC -Wno-unused-imports #-}
-{-# OPTIONS_GHC -Wno-unused-top-binds #-}
-
-module Agora.Utils.Value (pgeq, pleq, pgt, plt) where
-
-import Agora.Utils (tcmatch)
-import Plutarch.Api.V1.AssocMap (PMap (PMap))
-import Plutarch.Api.V1.These (PTheseData (..))
-import Plutarch.Api.V1.Tuple (ptupleFromBuiltin)
-import Plutarch.Api.V1.Value (PCurrencySymbol, PTokenName, PValue)
-import Plutarch.Lift (PUnsafeLiftDecl)
-import Plutarch.List (pconvertLists)
-import Plutarch.Monadic qualified as P
-
-punionVal ::
-  Term
-    s
-    ( PValue
-        :--> PValue
-        :--> PMap
-              PCurrencySymbol
-              (PMap PTokenName (PTheseData PInteger PInteger))
-    )
-punionVal = undefined
-
--- | Determines if a condition is true for all values in a map.
-pmapAll ::
-  (PUnsafeLiftDecl v, PIsData v) =>
-  Term s ((v :--> PBool) :--> PMap k v :--> PBool)
-pmapAll = plam $ \f m -> unTermCont $ do
-  PMap builtinMap <- tcmatch m
-
-  let getV = plam $ \bip ->
-        let tuple = pfromData $ ptupleFromBuiltin (pdata bip)
-         in pfromData $ pfield @"_1" # tuple
-
-  let vs = pmap # getV # builtinMap
-  pure $ pall # f # vs
-
-pcheckPred ::
-  forall {s :: S}.
-  Term
-    s
-    ( (PTheseData PInteger PInteger :--> PBool)
-        :--> PValue
-        :--> PValue
-        :--> PBool
-    )
-pcheckPred = plam $ \_f _l _r -> undefined
-
---  let inner :: Term s (PMap PTokenName (PTheseData PInteger PInteger) :--> PBool)
---      inner = pmapAll # f
---  pmapAll # inner # (punionVal # l # r)
-
-pcheckBinRel ::
-  forall {s :: S}.
-  Term
-    s
-    ( (PInteger :--> PInteger :--> PBool)
-        :--> PValue
-        :--> PValue
-        :--> PBool
-    )
-pcheckBinRel = plam $ \f l r ->
-  let unThese :: Term s (PTheseData PInteger PInteger :--> PBool)
-      unThese = plam $ \k' ->
-        pmatch k' $ \case
-          PDThis r -> f # (pfield @"_0" # r) # 0
-          PDThat r -> f # 0 # (pfield @"_0" # r)
-          PDThese r -> f # (pfield @"_0" # r) # (pfield @"_1" # r)
-   in pcheckPred # unThese # l # r
-
--- | Establishes if a value is less than or equal to another.
-pleq :: Term s (PValue :--> PValue :--> PBool)
-pleq = plam $ \v0 v1 -> (pcheckBinRel # pleq') # v0 # v1
-
-pleq' :: Term s (PInteger :--> PInteger :--> PBool)
-pleq' = plam $ \m n -> m #<= n
-
--- | Establishes if a value is strictly less than another.
-plt :: Term s (PValue :--> PValue :--> PBool)
-plt = plam $ \v0 v1 -> (pcheckBinRel # plt') # v0 # v1
-
-plt' :: Term s (PInteger :--> PInteger :--> PBool)
-plt' = plam $ \m n -> m #< n
-
--- | Establishes if a value is greater than or equal to another.
-pgeq :: Term s (PValue :--> PValue :--> PBool)
-pgeq = plam $ \v0 v1 -> pnot #$ plt # v0 # v1
-
--- | Establishes if a value is strictly greater than another.
-pgt :: Term s (PValue :--> PValue :--> PBool)
-pgt = plam $ \v0 v1 -> pnot #$ pleq # v0 # v1