-
Notifications
You must be signed in to change notification settings - Fork 156
/
GovAction.hs
426 lines (401 loc) · 19.9 KB
/
GovAction.hs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoImplicitPrelude #-}
module Cardano.DbSync.Era.Universal.Insert.GovAction (
insertConstitution,
insertCostModel,
insertCredDrepHash,
insertDrep,
insertDrepDistr,
insertGovActionProposal,
insertParamProposal,
insertVotingProcedures,
insertCommitteeHash,
insertVotingAnchor,
resolveGovActionProposal,
updateRatified,
updateExpired,
updateEnacted,
)
where
import Cardano.BM.Trace (Trace)
import qualified Cardano.Crypto as Crypto
import Cardano.Db (DbWord64 (..))
import qualified Cardano.Db as DB
import Cardano.DbSync.Cache (queryOrInsertRewardAccount, queryPoolKeyOrInsert)
import Cardano.DbSync.Cache.Types (Cache (..), CacheNew (..))
import qualified Cardano.DbSync.Era.Shelley.Generic as Generic
import Cardano.DbSync.Era.Shelley.Generic.ParamProposal
import Cardano.DbSync.Era.Universal.Insert.Other (toDouble)
import Cardano.DbSync.Era.Util (liftLookupFail)
import Cardano.DbSync.Error
import Cardano.DbSync.Ledger.Types
import Cardano.DbSync.Util
import Cardano.DbSync.Util.Bech32 (serialiseDrepToBech32)
import Cardano.Ledger.BaseTypes
import qualified Cardano.Ledger.BaseTypes as Ledger
import Cardano.Ledger.CertState (DRep (..))
import Cardano.Ledger.Coin (Coin)
import qualified Cardano.Ledger.Coin as Ledger
import Cardano.Ledger.Compactible (Compactible (..))
import Cardano.Ledger.Conway.Core (DRepVotingThresholds (..), PoolVotingThresholds (..))
import Cardano.Ledger.Conway.Governance
import qualified Cardano.Ledger.Credential as Ledger
import Cardano.Ledger.DRep (DRepState (..))
import Cardano.Ledger.Keys (KeyRole (..))
import qualified Cardano.Ledger.Plutus.CostModels as Ledger
import Cardano.Ledger.Plutus.Language (Language)
import Cardano.Ledger.Shelley.API (Coin (..))
import Cardano.Prelude
import Control.Monad.Extra (whenJust)
import Control.Monad.Trans.Control (MonadBaseControl)
import qualified Data.Aeson as Aeson
import qualified Data.ByteString.Lazy.Char8 as LBS
import qualified Data.Map.Strict as Map
import qualified Data.Text.Encoding as Text
import Database.Persist.Sql (SqlBackend)
import Ouroboros.Consensus.Cardano.Block (StandardConway, StandardCrypto)
insertGovActionProposal ::
forall m.
(MonadIO m, MonadBaseControl IO m) =>
Cache ->
DB.BlockId ->
DB.TxId ->
Maybe EpochNo ->
Maybe (StrictMaybe (Committee StandardConway)) ->
(Word64, ProposalProcedure StandardConway) ->
ExceptT SyncNodeError (ReaderT SqlBackend m) ()
insertGovActionProposal cache blkId txId govExpiresAt mmCommittee (index, pp) = do
addrId <-
lift $ queryOrInsertRewardAccount cache CacheNew $ pProcReturnAddr pp
votingAnchorId <- lift $ insertVotingAnchor txId DB.GovActionAnchor $ pProcAnchor pp
mParamProposalId <- lift $
case pProcGovAction pp of
ParameterChange _ pparams _ ->
Just <$> insertParamProposal blkId txId (convertConwayParamProposal pparams)
_ -> pure Nothing
prevGovActionDBId <- case mprevGovAction of
Nothing -> pure Nothing
Just prevGovActionId -> Just <$> resolveGovActionProposal prevGovActionId
govActionProposalId <-
lift $
DB.insertGovActionProposal $
DB.GovActionProposal
{ DB.govActionProposalTxId = txId
, DB.govActionProposalIndex = index
, DB.govActionProposalPrevGovActionProposal = prevGovActionDBId
, DB.govActionProposalDeposit = Generic.coinToDbLovelace $ pProcDeposit pp
, DB.govActionProposalReturnAddress = addrId
, DB.govActionProposalExpiration = unEpochNo <$> govExpiresAt
, DB.govActionProposalVotingAnchorId = Just votingAnchorId
, DB.govActionProposalType = Generic.toGovAction $ pProcGovAction pp
, DB.govActionProposalDescription = Text.decodeUtf8 $ LBS.toStrict $ Aeson.encode (pProcGovAction pp)
, DB.govActionProposalParamProposal = mParamProposalId
, DB.govActionProposalRatifiedEpoch = Nothing
, DB.govActionProposalEnactedEpoch = Nothing
, DB.govActionProposalDroppedEpoch = Nothing
, DB.govActionProposalExpiredEpoch = Nothing
}
case pProcGovAction pp of
TreasuryWithdrawals mp _ -> lift $ mapM_ (insertTreasuryWithdrawal govActionProposalId) (Map.toList mp)
UpdateCommittee _ removed added q -> lift $ insertNewCommittee govActionProposalId removed added q
NewConstitution _ constitution -> lift $ insertConstitution txId govActionProposalId constitution
_ -> pure ()
where
mprevGovAction :: Maybe (GovActionId StandardCrypto) = case pProcGovAction pp of
ParameterChange prv _ _ -> unGovPurposeId <$> strictMaybeToMaybe prv
HardForkInitiation prv _ -> unGovPurposeId <$> strictMaybeToMaybe prv
NoConfidence prv -> unGovPurposeId <$> strictMaybeToMaybe prv
UpdateCommittee prv _ _ _ -> unGovPurposeId <$> strictMaybeToMaybe prv
NewConstitution prv _ -> unGovPurposeId <$> strictMaybeToMaybe prv
_ -> Nothing
insertTreasuryWithdrawal gaId (rwdAcc, coin) = do
addrId <-
queryOrInsertRewardAccount cache CacheNew rwdAcc
DB.insertTreasuryWithdrawal $
DB.TreasuryWithdrawal
{ DB.treasuryWithdrawalGovActionProposalId = gaId
, DB.treasuryWithdrawalStakeAddressId = addrId
, DB.treasuryWithdrawalAmount = Generic.coinToDbLovelace coin
}
insertNewCommittee ::
DB.GovActionProposalId ->
Set (Ledger.Credential 'ColdCommitteeRole StandardCrypto) ->
Map (Ledger.Credential 'ColdCommitteeRole StandardCrypto) EpochNo ->
UnitInterval ->
ReaderT SqlBackend m ()
insertNewCommittee gapId removed added q = do
insertNewCommitteeInfo gapId q
insertMembers gapId removed added q
insertNewCommitteeInfo gapId q =
void . DB.insertNewCommitteeInfo $
DB.NewCommitteeInfo
{ DB.newCommitteeInfoGovActionProposalId = gapId
, DB.newCommitteeInfoQuorumNumerator = fromIntegral $ numerator r
, DB.newCommitteeInfoQuorumDenominator = fromIntegral $ denominator r
}
where
r = unboundRational q -- TODO work directly with Ratio Word64. This is not currently supported in ledger
insertMembers gapId removed added q = do
whenJust mmCommittee $ \mCommittee -> do
-- Nothing means we're not in Conway so it can't happen.
let committee = updatedCommittee removed added q mCommittee
mapM_ (insertNewMember gapId) (Map.toList $ committeeMembers committee)
insertNewMember gapId (cred, e) = do
chId <- insertCommitteeHash cred
void . DB.insertNewCommitteeMember $
DB.NewCommitteeMember
{ DB.newCommitteeMemberGovActionProposalId = gapId
, DB.newCommitteeMemberCommitteeHashId = chId
, DB.newCommitteeMemberExpirationEpoch = unEpochNo e
}
--------------------------------------------------------------------------------------
-- PROPOSAL
--------------------------------------------------------------------------------------
resolveGovActionProposal ::
MonadIO m =>
GovActionId StandardCrypto ->
ExceptT SyncNodeError (ReaderT SqlBackend m) DB.GovActionProposalId
resolveGovActionProposal gaId = do
gaTxId <-
liftLookupFail "resolveGovActionProposal.queryTxId" $
DB.queryTxId $
Generic.unTxHash $
gaidTxId gaId
let (GovActionIx index) = gaidGovActionIx gaId
liftLookupFail "resolveGovActionProposal.queryGovActionProposalId" $
DB.queryGovActionProposalId gaTxId (fromIntegral index) -- TODO: Use Word32?
insertParamProposal ::
(MonadBaseControl IO m, MonadIO m) =>
DB.BlockId ->
DB.TxId ->
ParamProposal ->
ReaderT SqlBackend m DB.ParamProposalId
insertParamProposal blkId txId pp = do
cmId <- maybe (pure Nothing) (fmap Just . insertCostModel blkId) (pppCostmdls pp)
DB.insertParamProposal $
DB.ParamProposal
{ DB.paramProposalRegisteredTxId = txId
, DB.paramProposalEpochNo = unEpochNo <$> pppEpochNo pp
, DB.paramProposalKey = pppKey pp
, DB.paramProposalMinFeeA = fromIntegral <$> pppMinFeeA pp
, DB.paramProposalMinFeeB = fromIntegral <$> pppMinFeeB pp
, DB.paramProposalMaxBlockSize = fromIntegral <$> pppMaxBlockSize pp
, DB.paramProposalMaxTxSize = fromIntegral <$> pppMaxTxSize pp
, DB.paramProposalMaxBhSize = fromIntegral <$> pppMaxBhSize pp
, DB.paramProposalKeyDeposit = Generic.coinToDbLovelace <$> pppKeyDeposit pp
, DB.paramProposalPoolDeposit = Generic.coinToDbLovelace <$> pppPoolDeposit pp
, DB.paramProposalMaxEpoch = fromIntegral . unEpochInterval <$> pppMaxEpoch pp
, DB.paramProposalOptimalPoolCount = fromIntegral <$> pppOptimalPoolCount pp
, DB.paramProposalInfluence = fromRational <$> pppInfluence pp
, DB.paramProposalMonetaryExpandRate = toDouble <$> pppMonetaryExpandRate pp
, DB.paramProposalTreasuryGrowthRate = toDouble <$> pppTreasuryGrowthRate pp
, DB.paramProposalDecentralisation = toDouble <$> pppDecentralisation pp
, DB.paramProposalEntropy = Generic.nonceToBytes =<< pppEntropy pp
, DB.paramProposalProtocolMajor = getVersion . Ledger.pvMajor <$> pppProtocolVersion pp
, DB.paramProposalProtocolMinor = fromIntegral . Ledger.pvMinor <$> pppProtocolVersion pp
, DB.paramProposalMinUtxoValue = Generic.coinToDbLovelace <$> pppMinUtxoValue pp
, DB.paramProposalMinPoolCost = Generic.coinToDbLovelace <$> pppMinPoolCost pp
, -- New for Alonzo
DB.paramProposalCoinsPerUtxoSize = Generic.coinToDbLovelace <$> pppCoinsPerUtxo pp
, DB.paramProposalCostModelId = cmId
, DB.paramProposalPriceMem = realToFrac <$> pppPriceMem pp
, DB.paramProposalPriceStep = realToFrac <$> pppPriceStep pp
, DB.paramProposalMaxTxExMem = DbWord64 <$> pppMaxTxExMem pp
, DB.paramProposalMaxTxExSteps = DbWord64 <$> pppMaxTxExSteps pp
, DB.paramProposalMaxBlockExMem = DbWord64 <$> pppMaxBlockExMem pp
, DB.paramProposalMaxBlockExSteps = DbWord64 <$> pppMaxBlockExSteps pp
, DB.paramProposalMaxValSize = DbWord64 . fromIntegral <$> pppMaxValSize pp
, DB.paramProposalCollateralPercent = fromIntegral <$> pppCollateralPercentage pp
, DB.paramProposalMaxCollateralInputs = fromIntegral <$> pppMaxCollateralInputs pp
, -- New for Conway
DB.paramProposalPvtMotionNoConfidence = toDouble . pvtMotionNoConfidence <$> pppPoolVotingThresholds pp
, DB.paramProposalPvtCommitteeNormal = toDouble . pvtCommitteeNormal <$> pppPoolVotingThresholds pp
, DB.paramProposalPvtCommitteeNoConfidence = toDouble . pvtCommitteeNoConfidence <$> pppPoolVotingThresholds pp
, DB.paramProposalPvtHardForkInitiation = toDouble . pvtHardForkInitiation <$> pppPoolVotingThresholds pp
, DB.paramProposalPvtppSecurityGroup = toDouble . pvtPPSecurityGroup <$> pppPoolVotingThresholds pp
, DB.paramProposalDvtMotionNoConfidence = toDouble . dvtMotionNoConfidence <$> pppDRepVotingThresholds pp
, DB.paramProposalDvtCommitteeNormal = toDouble . dvtCommitteeNormal <$> pppDRepVotingThresholds pp
, DB.paramProposalDvtCommitteeNoConfidence = toDouble . dvtCommitteeNoConfidence <$> pppDRepVotingThresholds pp
, DB.paramProposalDvtUpdateToConstitution = toDouble . dvtUpdateToConstitution <$> pppDRepVotingThresholds pp
, DB.paramProposalDvtHardForkInitiation = toDouble . dvtHardForkInitiation <$> pppDRepVotingThresholds pp
, DB.paramProposalDvtPPNetworkGroup = toDouble . dvtPPNetworkGroup <$> pppDRepVotingThresholds pp
, DB.paramProposalDvtPPEconomicGroup = toDouble . dvtPPEconomicGroup <$> pppDRepVotingThresholds pp
, DB.paramProposalDvtPPTechnicalGroup = toDouble . dvtPPTechnicalGroup <$> pppDRepVotingThresholds pp
, DB.paramProposalDvtPPGovGroup = toDouble . dvtPPGovGroup <$> pppDRepVotingThresholds pp
, DB.paramProposalDvtTreasuryWithdrawal = toDouble . dvtTreasuryWithdrawal <$> pppDRepVotingThresholds pp
, DB.paramProposalCommitteeMinSize = DbWord64 . fromIntegral <$> pppCommitteeMinSize pp
, DB.paramProposalCommitteeMaxTermLength = DbWord64 . fromIntegral . unEpochInterval <$> pppCommitteeMaxTermLength pp
, DB.paramProposalGovActionLifetime = fromIntegral . unEpochInterval <$> pppGovActionLifetime pp
, DB.paramProposalGovActionDeposit = DbWord64 . fromIntegral <$> pppGovActionDeposit pp
, DB.paramProposalDrepDeposit = DbWord64 . fromIntegral <$> pppDRepDeposit pp
, DB.paramProposalDrepActivity = fromIntegral . unEpochInterval <$> pppDRepActivity pp
}
insertConstitution :: (MonadIO m, MonadBaseControl IO m) => DB.TxId -> DB.GovActionProposalId -> Constitution StandardConway -> ReaderT SqlBackend m ()
insertConstitution txId gapId constitution = do
votingAnchorId <- insertVotingAnchor txId DB.OtherAnchor $ constitutionAnchor constitution
void . DB.insertConstitution $
DB.Constitution
{ DB.constitutionGovActionProposalId = gapId
, DB.constitutionVotingAnchorId = votingAnchorId
, DB.constitutionScriptHash = Generic.unScriptHash <$> strictMaybeToMaybe (constitutionScript constitution)
}
--------------------------------------------------------------------------------------
-- VOTING PROCEDURES
--------------------------------------------------------------------------------------
insertVotingProcedures ::
(MonadIO m, MonadBaseControl IO m) =>
Trace IO Text ->
Cache ->
DB.TxId ->
(Voter StandardCrypto, [(GovActionId StandardCrypto, VotingProcedure StandardConway)]) ->
ExceptT SyncNodeError (ReaderT SqlBackend m) ()
insertVotingProcedures trce cache txId (voter, actions) =
mapM_ (insertVotingProcedure trce cache txId voter) (zip [0 ..] actions)
insertVotingProcedure ::
(MonadIO m, MonadBaseControl IO m) =>
Trace IO Text ->
Cache ->
DB.TxId ->
Voter StandardCrypto ->
(Word16, (GovActionId StandardCrypto, VotingProcedure StandardConway)) ->
ExceptT SyncNodeError (ReaderT SqlBackend m) ()
insertVotingProcedure trce cache txId voter (index, (gaId, vp)) = do
govActionId <- resolveGovActionProposal gaId
votingAnchorId <- whenMaybe (strictMaybeToMaybe $ vProcAnchor vp) $ lift . insertVotingAnchor txId DB.OtherAnchor
(mCommitteeVoterId, mDRepVoter, mStakePoolVoter) <- case voter of
CommitteeVoter cred -> do
khId <- lift $ insertCommitteeHash cred
pure (Just khId, Nothing, Nothing)
DRepVoter cred -> do
drep <- lift $ insertCredDrepHash cred
pure (Nothing, Just drep, Nothing)
StakePoolVoter poolkh -> do
poolHashId <- lift $ queryPoolKeyOrInsert "insertVotingProcedure" trce cache CacheNew False poolkh
pure (Nothing, Nothing, Just poolHashId)
void
. lift
. DB.insertVotingProcedure
$ DB.VotingProcedure
{ DB.votingProcedureTxId = txId
, DB.votingProcedureIndex = index
, DB.votingProcedureGovActionProposalId = govActionId
, DB.votingProcedureCommitteeVoter = mCommitteeVoterId
, DB.votingProcedureDrepVoter = mDRepVoter
, DB.votingProcedurePoolVoter = mStakePoolVoter
, DB.votingProcedureVoterRole = Generic.toVoterRole voter
, DB.votingProcedureVote = Generic.toVote $ vProcVote vp
, DB.votingProcedureVotingAnchorId = votingAnchorId
}
insertVotingAnchor :: (MonadIO m, MonadBaseControl IO m) => DB.TxId -> DB.AnchorType -> Anchor StandardCrypto -> ReaderT SqlBackend m DB.VotingAnchorId
insertVotingAnchor txId anchorType anchor =
DB.insertAnchor $
DB.VotingAnchor
{ DB.votingAnchorTxId = txId
, DB.votingAnchorUrl = DB.VoteUrl $ Ledger.urlToText $ anchorUrl anchor -- TODO: Conway check unicode and size of URL
, DB.votingAnchorDataHash = Generic.safeHashToByteString $ anchorDataHash anchor
, DB.votingAnchorType = anchorType
}
insertCommitteeHash :: (MonadBaseControl IO m, MonadIO m) => Ledger.Credential kr StandardCrypto -> ReaderT SqlBackend m DB.CommitteeHashId
insertCommitteeHash cred = do
DB.insertCommitteeHash
DB.CommitteeHash
{ DB.committeeHashRaw = Generic.unCredentialHash cred
, DB.committeeHashHasScript = Generic.hasCredScript cred
}
--------------------------------------------------------------------------------------
-- DREP
--------------------------------------------------------------------------------------
insertDrep :: (MonadBaseControl IO m, MonadIO m) => DRep StandardCrypto -> ReaderT SqlBackend m DB.DrepHashId
insertDrep = \case
DRepCredential cred -> insertCredDrepHash cred
DRepAlwaysAbstain -> DB.insertAlwaysAbstainDrep
DRepAlwaysNoConfidence -> DB.insertAlwaysNoConfidence
insertCredDrepHash :: (MonadBaseControl IO m, MonadIO m) => Ledger.Credential 'DRepRole StandardCrypto -> ReaderT SqlBackend m DB.DrepHashId
insertCredDrepHash cred = do
DB.insertDrepHash
DB.DrepHash
{ DB.drepHashRaw = Just bs
, DB.drepHashView = serialiseDrepToBech32 bs
, DB.drepHashHasScript = Generic.hasCredScript cred
}
where
bs = Generic.unCredentialHash cred
insertDrepDistr :: forall m. (MonadBaseControl IO m, MonadIO m) => EpochNo -> PulsingSnapshot StandardConway -> ReaderT SqlBackend m ()
insertDrepDistr e pSnapshot = do
drepsDB <- mapM mkEntry (Map.toList $ psDRepDistr pSnapshot)
DB.insertManyDrepDistr drepsDB
where
mkEntry :: (DRep StandardCrypto, Ledger.CompactForm Coin) -> ReaderT SqlBackend m DB.DrepDistr
mkEntry (drep, coin) = do
drepId <- insertDrep drep
pure $
DB.DrepDistr
{ DB.drepDistrHashId = drepId
, DB.drepDistrAmount = fromIntegral $ unCoin $ fromCompact coin
, DB.drepDistrEpochNo = unEpochNo e
, DB.drepDistrActiveUntil = unEpochNo <$> isActiveEpochNo drep
}
isActiveEpochNo :: DRep StandardCrypto -> Maybe EpochNo
isActiveEpochNo = \case
DRepAlwaysAbstain -> Nothing
DRepAlwaysNoConfidence -> Nothing
DRepCredential cred -> drepExpiry <$> Map.lookup cred (psDRepState pSnapshot)
insertCostModel ::
(MonadBaseControl IO m, MonadIO m) =>
DB.BlockId ->
Map Language Ledger.CostModel ->
ReaderT SqlBackend m DB.CostModelId
insertCostModel _blkId cms =
DB.insertCostModel $
DB.CostModel
{ DB.costModelHash = Crypto.abstractHashToBytes $ Crypto.serializeCborHash $ Ledger.mkCostModels cms
, DB.costModelCosts = Text.decodeUtf8 $ LBS.toStrict $ Aeson.encode cms
}
updateRatified ::
forall m.
(MonadBaseControl IO m, MonadIO m) =>
EpochNo ->
[GovActionState StandardConway] ->
ExceptT SyncNodeError (ReaderT SqlBackend m) ()
updateRatified epochNo ratifiedActions = do
forM_ ratifiedActions $ \action -> do
gaId <- resolveGovActionProposal $ gasId action
lift $ DB.updateGovActionRatified gaId (unEpochNo epochNo)
updateExpired ::
forall m.
(MonadBaseControl IO m, MonadIO m) =>
EpochNo ->
[GovActionId StandardCrypto] ->
ExceptT SyncNodeError (ReaderT SqlBackend m) ()
updateExpired epochNo ratifiedActions = do
forM_ ratifiedActions $ \action -> do
gaId <- resolveGovActionProposal action
lift $ DB.updateGovActionRatified gaId (unEpochNo epochNo)
updateEnacted ::
forall m.
(MonadBaseControl IO m, MonadIO m) =>
EpochNo ->
GovRelation StrictMaybe StandardConway ->
ExceptT SyncNodeError (ReaderT SqlBackend m) ()
updateEnacted epochNo enactedState = do
whenJust (strictMaybeToMaybe (grPParamUpdate enactedState)) $ \prevId -> do
gaId <- resolveGovActionProposal $ getPrevId prevId
lift $ DB.updateGovActionEnacted gaId (unEpochNo epochNo)
whenJust (strictMaybeToMaybe (grHardFork enactedState)) $ \prevId -> do
gaId <- resolveGovActionProposal $ getPrevId prevId
lift $ DB.updateGovActionEnacted gaId (unEpochNo epochNo)
whenJust (strictMaybeToMaybe (grCommittee enactedState)) $ \prevId -> do
gaId <- resolveGovActionProposal $ getPrevId prevId
lift $ DB.updateGovActionEnacted gaId (unEpochNo epochNo)
whenJust (strictMaybeToMaybe (grConstitution enactedState)) $ \prevId -> do
gaId <- resolveGovActionProposal $ getPrevId prevId
lift $ DB.updateGovActionEnacted gaId (unEpochNo epochNo)
where
getPrevId = unGovPurposeId