add remaining scripts, export to json file, fix compile

agora-scripts/Options.hs

@@ -23,14 +23,14 @@ opt =
       ( Opt.long "config"
           <> Opt.short 'c'
           <> Opt.metavar "CONFIG_PATH"
-          <> Opt.value "./"
+          <> Opt.value "./agora-scripts/agora-params.json"
           <> Opt.help "The path where the script configuration is."
       )
     <*> Opt.strOption
       ( Opt.long "output"
           <> Opt.short 'o'
           <> Opt.metavar "OUTPUT_PATH"
-          <> Opt.value "./"
+          <> Opt.value "./agora-scripts/agora-scripts.json"
           <> Opt.help "Output where generated scripts will be."
       )
 

agora-scripts/Scripts.hs

@@ -5,23 +5,40 @@ Description: Export scripts given configuration.
 
 Export scripts given configuration.
 -}
-module Scripts (main) where
+module Main (main) where
 
+import Agora.AuthorityToken (AuthorityToken, authorityTokenPolicy)
 import Agora.Governor (Governor (Governor))
 import Agora.Governor qualified as Governor
-import Agora.Governor.Scripts (governorPolicy)
+import Agora.Governor.Scripts (
+  authorityTokenFromGovernor,
+  authorityTokenSymbolFromGovernor,
+  governorPolicy,
+  governorValidator,
+  proposalFromGovernor,
+  stakeFromGovernor,
+ )
+import Agora.Proposal (Proposal)
+import Agora.Proposal.Scripts (proposalPolicy, proposalValidator)
 import Agora.SafeMoney (GTTag)
-import Agora.ScriptInfo (PolicyInfo, mkPolicyInfo)
+import Agora.ScriptInfo (PolicyInfo, ValidatorInfo, mkPolicyInfo, mkValidatorInfo)
+import Agora.Stake (Stake)
+import Agora.Stake.Scripts (stakePolicy, stakeValidator)
+import Agora.Treasury (treasuryValidator)
 import Control.Monad ((>=>))
 import Data.Aeson qualified as Aeson
 import GHC.Generics qualified as GHC
 import Options (Options (..), parseOptions)
+import Plutarch.Api.V1 (mintingPolicySymbol, mkMintingPolicy)
 import Plutarch.SafeMoney (Tagged)
 import Plutus.V1.Ledger.Api (TxOutRef)
-import Plutus.V1.Ledger.Value (AssetClass)
+import Plutus.V1.Ledger.Value (AssetClass, CurrencySymbol)
+import Plutus.V1.Ledger.Value qualified as Value
 import System.Exit (exitFailure)
+import Text.Printf (printf)
 
-data ScriptsConfig = ScriptsConfig
+-- | Params required for creating script export.
+data ScriptParams = ScriptParams
   { governorInitialSpend :: TxOutRef
   , gtClassRef :: Tagged GTTag AssetClass
   , maximumCosigners :: Integer
@@ -29,38 +46,68 @@ data ScriptsConfig = ScriptsConfig
   deriving anyclass (Aeson.ToJSON, Aeson.FromJSON)
   deriving stock (Show, Eq, GHC.Generic)
 
+-- | Scripts that get exported.
 data AgoraScripts = AgoraScripts
   { governorPolicyInfo :: PolicyInfo
+  , governorValidatorInfo :: ValidatorInfo
+  , stakePolicyInfo :: PolicyInfo
+  , stakeValidatorInfo :: ValidatorInfo
+  , proposalPolicyInfo :: PolicyInfo
+  , proposalValidatorInfo :: ValidatorInfo
+  , treasuryValidatorInfo :: ValidatorInfo
+  , authorityTokenPolicyInfo :: PolicyInfo
   }
   deriving anyclass (Aeson.ToJSON, Aeson.FromJSON)
   deriving stock (Show, Eq, GHC.Generic)
 
 main :: IO ()
 main = do
-  putStrLn "Hello, world!"
-
   options <- parseOptions
 
   params <-
-    Aeson.eitherDecodeFileStrict @ScriptsConfig options.config
+    Aeson.eitherDecodeFileStrict @ScriptParams options.config
       >>= either (putStrLn >=> const exitFailure) pure
 
   let scripts = agoraScripts params
 
-  print params
-  print scripts
+  Aeson.encodeFile options.output scripts
 
-  pure ()
+  printf "Done! Wrote to %s\n" options.output
 
-agoraScripts :: ScriptsConfig -> AgoraScripts
-agoraScripts config =
+-- | Create scripts from params.
+agoraScripts :: ScriptParams -> AgoraScripts
+agoraScripts params =
   AgoraScripts
     { governorPolicyInfo = mkPolicyInfo (governorPolicy governor)
+    , governorValidatorInfo = mkValidatorInfo (governorValidator governor)
+    , stakePolicyInfo = mkPolicyInfo (stakePolicy params.gtClassRef)
+    , stakeValidatorInfo = mkValidatorInfo (stakeValidator stake)
+    , proposalPolicyInfo = mkPolicyInfo (proposalPolicy governorSTAssetClass)
+    , proposalValidatorInfo = mkValidatorInfo (proposalValidator proposal)
+    , treasuryValidatorInfo = mkValidatorInfo (treasuryValidator authorityTokenSymbol)
+    , authorityTokenPolicyInfo = mkPolicyInfo (authorityTokenPolicy authorityToken)
     }
   where
+    governor :: Governor
     governor =
       Governor
-        { Governor.gstOutRef = config.governorInitialSpend
-        , Governor.gtClassRef = config.gtClassRef
-        , Governor.maximumCosigners = config.maximumCosigners
+        { Governor.gstOutRef = params.governorInitialSpend
+        , Governor.gtClassRef = params.gtClassRef
+        , Governor.maximumCosigners = params.maximumCosigners
         }
+
+    authorityToken :: AuthorityToken
+    authorityToken = authorityTokenFromGovernor governor
+
+    authorityTokenSymbol :: CurrencySymbol
+    authorityTokenSymbol = authorityTokenSymbolFromGovernor governor
+
+    governorSTAssetClass :: AssetClass
+    governorSTAssetClass =
+      Value.assetClass (mintingPolicySymbol $ mkMintingPolicy $ governorPolicy governor) ""
+
+    proposal :: Proposal
+    proposal = proposalFromGovernor governor
+
+    stake :: Stake
+    stake = stakeFromGovernor governor

agora-scripts/agora-params.json

@@ -0,0 +1,11 @@
+{
+  "governorInitialSpend": {
+    "txOutRefId": "0b2086cbf8b6900f8cb65e012de4516cb66b5cb08a9aaba12a8b88be",
+    "txOutRefIdx": 0
+  },
+  "gtClassRef": [
+    "",
+    ""
+  ],
+  "maximumCosigners": 5
+}