From dd36d9e022813272b0deb39fcf42fe40a40cae6f Mon Sep 17 00:00:00 2001 From: Riccardo Montagnin Date: Fri, 19 Jan 2024 14:08:45 +0100 Subject: [PATCH 01/15] refactor: parse posts using events instead of messages --- utils/events.go | 33 +++++++++ x/filters/messages.go | 15 +++++ x/posts/handle_msg.go | 131 ------------------------------------ x/posts/handle_tx.go | 153 ++++++++++++++++++++++++++++++++++++++++++ x/posts/utils.go | 87 +++++++++++++++++++++++- 5 files changed, 287 insertions(+), 132 deletions(-) create mode 100644 utils/events.go delete mode 100644 x/posts/handle_msg.go create mode 100644 x/posts/handle_tx.go diff --git a/utils/events.go b/utils/events.go new file mode 100644 index 00000000..926847de --- /dev/null +++ b/utils/events.go @@ -0,0 +1,33 @@ +package utils + +import ( + abci "github.com/cometbft/cometbft/abci/types" + subspacestypes "github.com/desmos-labs/desmos/v6/x/subspaces/types" + juno "github.com/forbole/juno/v5/types" +) + +// ParseTxEvents parses the given events using the given parsers +func ParseTxEvents(tx *juno.Tx, eventsParsers map[string]func(tx *juno.Tx, event abci.Event) error) error { + for _, event := range tx.Events { + parseEvent, canBeParsed := eventsParsers[event.Type] + if !canBeParsed { + continue + } + + err := parseEvent(tx, event) + if err != nil { + return err + } + } + + return nil +} + +// GetSubspaceIDFromEvent returns the subspace ID from the given event +func GetSubspaceIDFromEvent(event abci.Event) (uint64, error) { + attribute, err := juno.FindAttributeByKey(event, subspacestypes.AttributeKeySubspaceID) + if err != nil { + return 0, err + } + return subspacestypes.ParseSubspaceID(attribute.Value) +} diff --git a/x/filters/messages.go b/x/filters/messages.go index 0963f87a..33bdea4d 100644 --- a/x/filters/messages.go +++ b/x/filters/messages.go @@ -1,9 +1,12 @@ package filters import ( + abci "github.com/cometbft/cometbft/abci/types" sdk "github.com/cosmos/cosmos-sdk/types" subspacestypes "github.com/desmos-labs/desmos/v6/x/subspaces/types" "github.com/forbole/juno/v5/types/config" + + "github.com/desmos-labs/athena/utils" ) var ( @@ -11,6 +14,18 @@ var ( cfg *Config ) +// ShouldEventBeParsed tells whether the given event should be parsed +func ShouldEventBeParsed(event abci.Event) bool { + parseCfg() + + subspaceID, err := utils.GetSubspaceIDFromEvent(event) + if err != nil { + return false + } + + return cfg.isSubspaceSupported(subspaceID) +} + // ShouldMsgBeParsed tells whether the given subspace is currently supported and its messages should be parsed func ShouldMsgBeParsed(msg sdk.Msg) bool { parseCfg() diff --git a/x/posts/handle_msg.go b/x/posts/handle_msg.go deleted file mode 100644 index 00a94e11..00000000 --- a/x/posts/handle_msg.go +++ /dev/null @@ -1,131 +0,0 @@ -package posts - -import ( - "github.com/cosmos/cosmos-sdk/x/authz" - - "github.com/desmos-labs/athena/x/filters" - - poststypes "github.com/desmos-labs/desmos/v6/x/posts/types" - - "github.com/desmos-labs/athena/types" - - "github.com/rs/zerolog/log" - - sdk "github.com/cosmos/cosmos-sdk/types" - juno "github.com/forbole/juno/v5/types" -) - -// HandleMsgExec implements modules.AuthzMessageModule -func (m *Module) HandleMsgExec(index int, _ *authz.MsgExec, _ int, executedMsg sdk.Msg, tx *juno.Tx) error { - return m.HandleMsg(index, executedMsg, tx) -} - -// HandleMsg implements modules.MessageModule -func (m *Module) HandleMsg(index int, msg sdk.Msg, tx *juno.Tx) error { - if len(tx.Logs) == 0 || !filters.ShouldMsgBeParsed(msg) { - return nil - } - - switch desmosMsg := msg.(type) { - case *poststypes.MsgCreatePost: - return m.handleMsgCreatePost(tx, index, desmosMsg) - - case *poststypes.MsgEditPost: - return m.handleMsgEditPost(tx, desmosMsg) - - case *poststypes.MsgDeletePost: - return m.handleMsgDeletePost(tx, desmosMsg) - - case *poststypes.MsgAddPostAttachment: - return m.handleMsgAddPostAttachment(tx, desmosMsg) - - case *poststypes.MsgRemovePostAttachment: - return m.handleMsgRemovePostAttachment(tx, desmosMsg) - - case *poststypes.MsgAnswerPoll: - return m.handleMsgAnswerPoll(tx, desmosMsg) - } - - log.Debug().Str("module", "reactions").Str("message", sdk.MsgTypeURL(msg)). - Int64("height", tx.Height).Msg("handled message") - - return nil -} - -// handleMsgCreatePost handles a MsgCreatePost -func (m *Module) handleMsgCreatePost(tx *juno.Tx, index int, msg *poststypes.MsgCreatePost) error { - event, err := tx.FindEventByType(index, poststypes.EventTypeCreatePost) - if err != nil { - return err - } - postIDStr, err := tx.FindAttributeByKey(event, poststypes.AttributeKeyPostID) - if err != nil { - return err - } - postID, err := poststypes.ParsePostID(postIDStr) - if err != nil { - return err - } - - // Update the post - err = m.updatePost(tx.Height, msg.SubspaceID, postID) - if err != nil { - return err - } - - // Update the post attachments - err = m.updatePostAttachments(tx.Height, msg.SubspaceID, postID) - if err != nil { - return err - } - - // Save the related transaction - return m.db.SavePostTx(types.NewPostTransaction(msg.SubspaceID, postID, tx.TxHash)) -} - -// handleMsgEditPost handles a MsgEditPost -func (m *Module) handleMsgEditPost(tx *juno.Tx, msg *poststypes.MsgEditPost) error { - // Update the post - err := m.updatePost(tx.Height, msg.SubspaceID, msg.PostID) - if err != nil { - return err - } - - // Save the related transaction - return m.db.SavePostTx(types.NewPostTransaction(msg.SubspaceID, msg.PostID, tx.TxHash)) -} - -// handleMsgDeletePost handles a MsgDeletePost -func (m *Module) handleMsgDeletePost(tx *juno.Tx, msg *poststypes.MsgDeletePost) error { - return m.db.DeletePost(tx.Height, msg.SubspaceID, msg.PostID) -} - -// handleMsgAddPostAttachment handles a MsgAddPostAttachment -func (m *Module) handleMsgAddPostAttachment(tx *juno.Tx, msg *poststypes.MsgAddPostAttachment) error { - // Update the attachments - err := m.updatePostAttachments(tx.Height, msg.SubspaceID, msg.PostID) - if err != nil { - return err - } - - // Store the related post transaction - return m.db.SavePostTx(types.NewPostTransaction(msg.SubspaceID, msg.PostID, tx.TxHash)) -} - -// handleMsgRemovePostAttachment handles a MsgRemovePostAttachment -func (m *Module) handleMsgRemovePostAttachment(tx *juno.Tx, msg *poststypes.MsgRemovePostAttachment) error { - // Delete the attachment - err := m.db.DeletePostAttachment(tx.Height, msg.SubspaceID, msg.PostID, msg.AttachmentID) - if err != nil { - return err - } - - // Store the related post transaction - return m.db.SavePostTx(types.NewPostTransaction(msg.SubspaceID, msg.PostID, tx.TxHash)) -} - -// handleMsgAnswerPoll handles a MsgAnswerPoll -func (m *Module) handleMsgAnswerPoll(tx *juno.Tx, msg *poststypes.MsgAnswerPoll) error { - answer := poststypes.NewUserAnswer(msg.SubspaceID, msg.PostID, msg.PollID, msg.AnswersIndexes, msg.Signer) - return m.db.SavePollAnswer(types.NewPollAnswer(answer, tx.Height)) -} diff --git a/x/posts/handle_tx.go b/x/posts/handle_tx.go new file mode 100644 index 00000000..0cfa40e4 --- /dev/null +++ b/x/posts/handle_tx.go @@ -0,0 +1,153 @@ +package posts + +import ( + abci "github.com/cometbft/cometbft/abci/types" + poststypes "github.com/desmos-labs/desmos/v6/x/posts/types" + juno "github.com/forbole/juno/v5/types" + + "github.com/desmos-labs/athena/types" + "github.com/desmos-labs/athena/utils" +) + +// HandleTx handles the transaction events +func (m *Module) HandleTx(tx *juno.Tx) error { + return utils.ParseTxEvents(tx, map[string]func(tx *juno.Tx, event abci.Event) error{ + poststypes.EventTypeCreatePost: m.parseCreatePostEvent, + }) +} + +// ------------------------------------------------------------------------------------------------------------------- + +// parseCreatePostEvent handles the creation of a new post +func (m *Module) parseCreatePostEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := utils.GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + + postID, err := GetPostIDFromEvent(event) + if err != nil { + return err + } + + // Update the post + err = m.updatePost(tx.Height, subspaceID, postID) + if err != nil { + return err + } + + // Update the post attachments + err = m.updatePostAttachments(tx.Height, subspaceID, postID) + if err != nil { + return err + } + + // Save the related transaction + return m.db.SavePostTx(types.NewPostTransaction(subspaceID, postID, tx.TxHash)) +} + +// parseEditPostEvent handles the edition of an existing post +func (m *Module) parseEditPostEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := utils.GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + + postID, err := GetPostIDFromEvent(event) + if err != nil { + return err + } + + // Update the post + err = m.updatePost(tx.Height, subspaceID, postID) + if err != nil { + return err + } + + // Save the related transaction + return m.db.SavePostTx(types.NewPostTransaction(subspaceID, postID, tx.TxHash)) +} + +// parseDeletePostEvent handles the deletion of an existing post +func (m *Module) parseDeletePostEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := utils.GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + + postID, err := GetPostIDFromEvent(event) + if err != nil { + return err + } + + return m.db.DeletePost(tx.Height, subspaceID, postID) +} + +// parseAddPostReactionEvent handles the addition of a reaction to an existing post +func (m *Module) parseAddPostAttachmentEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := utils.GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + + postID, err := GetPostIDFromEvent(event) + if err != nil { + return err + } + + // Update the attachments + err = m.updatePostAttachments(tx.Height, subspaceID, postID) + if err != nil { + return err + } + + // Store the related post transaction + return m.db.SavePostTx(types.NewPostTransaction(subspaceID, postID, tx.TxHash)) +} + +// parseRemovePostAttachmentEvent handles the removal of a reaction from an existing post +func (m *Module) parseRemovePostAttachmentEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := utils.GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + + postID, err := GetPostIDFromEvent(event) + if err != nil { + return err + } + + attachmentID, err := GetAttachmentIDFromEvent(event) + if err != nil { + return err + } + + // Delete the attachment + err = m.db.DeletePostAttachment(tx.Height, subspaceID, postID, attachmentID) + if err != nil { + return err + } + + // Store the related post transaction + return m.db.SavePostTx(types.NewPostTransaction(subspaceID, postID, tx.TxHash)) +} + +// parseAnswerPollEvent handles the answer to a poll +func (m *Module) parseAnswerPollEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := utils.GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + + postID, err := GetPostIDFromEvent(event) + if err != nil { + return err + } + + pollID, err := GetPollIDFromEvent(event) + if err != nil { + return err + } + + return m.updatePollAnswers(tx.Height, subspaceID, postID, pollID) +} diff --git a/x/posts/utils.go b/x/posts/utils.go index 3182e11f..22e0e40e 100644 --- a/x/posts/utils.go +++ b/x/posts/utils.go @@ -4,6 +4,10 @@ import ( "context" "fmt" + abci "github.com/cometbft/cometbft/abci/types" + "github.com/cosmos/cosmos-sdk/types/query" + "github.com/forbole/juno/v5/types/utils" + "github.com/forbole/juno/v5/node/remote" poststypes "github.com/desmos-labs/desmos/v6/x/posts/types" @@ -11,6 +15,35 @@ import ( "github.com/desmos-labs/athena/types" ) +// GetPostIDFromEvent returns the post ID from the given event +func GetPostIDFromEvent(event abci.Event) (uint64, error) { + attribute, err := utils.FindAttributeByKey(event, poststypes.AttributeKeyPostID) + if err != nil { + return 0, err + } + return poststypes.ParsePostID(attribute.Value) +} + +// GetAttachmentIDFromEvent returns the attachment ID from the given event +func GetAttachmentIDFromEvent(event abci.Event) (uint32, error) { + attribute, err := utils.FindAttributeByKey(event, poststypes.AttributeKeyAttachmentID) + if err != nil { + return 0, err + } + return poststypes.ParseAttachmentID(attribute.Value) +} + +// GetPollIDFromEvent returns the poll ID from the given event +func GetPollIDFromEvent(event abci.Event) (uint32, error) { + attribute, err := utils.FindAttributeByKey(event, poststypes.AttributeKeyPollID) + if err != nil { + return 0, err + } + return poststypes.ParseAttachmentID(attribute.Value) +} + +// ------------------------------------------------------------------------------------------------------------------- + // updatePost updates the stored data about the given post at the specified height func (m *Module) updatePost(height int64, subspaceID uint64, postID uint64) error { post, err := m.GetPost(height, subspaceID, postID) @@ -50,6 +83,7 @@ func (m *Module) updatePostAttachments(height int64, subspaceID uint64, postID u return nil } +// GetPostAttachments gets the attachments for the post having the given id func (m *Module) GetPostAttachments(height int64, subspaceID uint64, postID uint64) ([]types.PostAttachment, error) { var attachments []types.PostAttachment var nextKey []byte @@ -60,7 +94,9 @@ func (m *Module) GetPostAttachments(height int64, subspaceID uint64, postID uint &poststypes.QueryPostAttachmentsRequest{ SubspaceId: subspaceID, PostId: postID, - Pagination: nil, + Pagination: &query.PageRequest{ + Key: nextKey, + }, }, ) if err != nil { @@ -78,6 +114,55 @@ func (m *Module) GetPostAttachments(height int64, subspaceID uint64, postID uint return attachments, nil } +// updatePollAnswers updates the stored answers for the poll having the given id +func (m *Module) updatePollAnswers(height int64, subspaceID uint64, postID uint64, pollID uint32) error { + answers, err := m.GetPollAnswers(height, subspaceID, postID, pollID) + if err != nil { + return fmt.Errorf("error while getting poll answers: %s", err) + } + + for _, answer := range answers { + err = m.db.SavePollAnswer(answer) + if err != nil { + return err + } + } + + return nil +} + +// GetPollAnswers gets the answers for the poll having the given id +func (m *Module) GetPollAnswers(height int64, subspaceID uint64, postID uint64, pollID uint32) ([]types.PollAnswer, error) { + var answers []types.PollAnswer + var nextKey []byte + var stop = false + for !stop { + res, err := m.client.PollAnswers( + remote.GetHeightRequestContext(context.Background(), height), + &poststypes.QueryPollAnswersRequest{ + SubspaceId: subspaceID, + PostId: postID, + PollId: pollID, + Pagination: &query.PageRequest{ + Key: nextKey, + }, + }, + ) + if err != nil { + return nil, err + } + + for _, answer := range res.Answers { + answers = append(answers, types.NewPollAnswer(answer, height)) + } + + nextKey = res.Pagination.NextKey + stop = nextKey == nil + } + + return answers, nil +} + // updateParams updates the stored params with the ones for the given height func (m *Module) updateParams() error { height, err := m.node.LatestHeight() From 26a7516d9f98641278b5509dc69427c171f70375 Mon Sep 17 00:00:00 2001 From: Riccardo Montagnin Date: Fri, 19 Jan 2024 14:28:31 +0100 Subject: [PATCH 02/15] chore: added event logging --- utils/events.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/utils/events.go b/utils/events.go index 926847de..5ce5fe05 100644 --- a/utils/events.go +++ b/utils/events.go @@ -4,6 +4,7 @@ import ( abci "github.com/cometbft/cometbft/abci/types" subspacestypes "github.com/desmos-labs/desmos/v6/x/subspaces/types" juno "github.com/forbole/juno/v5/types" + "github.com/rs/zerolog/log" ) // ParseTxEvents parses the given events using the given parsers @@ -18,6 +19,8 @@ func ParseTxEvents(tx *juno.Tx, eventsParsers map[string]func(tx *juno.Tx, event if err != nil { return err } + + log.Debug().Str("event", event.Type).Msg("handled event") } return nil From 1536990587b6c8c8f685651f484fccd0c87ba69a Mon Sep 17 00:00:00 2001 From: Riccardo Montagnin Date: Fri, 19 Jan 2024 14:29:04 +0100 Subject: [PATCH 03/15] fix: fixed module casting --- x/posts/module.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/x/posts/module.go b/x/posts/module.go index 957e3329..f696233b 100644 --- a/x/posts/module.go +++ b/x/posts/module.go @@ -13,7 +13,7 @@ var ( _ modules.Module = &Module{} _ modules.GenesisModule = &Module{} _ modules.BlockModule = &Module{} - _ modules.MessageModule = &Module{} + _ modules.TransactionModule = &Module{} _ modules.PeriodicOperationsModule = &Module{} ) From 68a779183237fb0377ca4779216ee762b00eb4ba Mon Sep 17 00:00:00 2001 From: Riccardo Montagnin Date: Fri, 19 Jan 2024 14:29:46 +0100 Subject: [PATCH 04/15] feat: parse reports events instead of messages --- x/reports/handle_msg.go | 112 ---------------------------------------- x/reports/handle_tx.go | 96 ++++++++++++++++++++++++++++++++++ x/reports/module.go | 2 +- x/reports/utils.go | 22 ++++++++ 4 files changed, 119 insertions(+), 113 deletions(-) delete mode 100644 x/reports/handle_msg.go create mode 100644 x/reports/handle_tx.go diff --git a/x/reports/handle_msg.go b/x/reports/handle_msg.go deleted file mode 100644 index 67b58a48..00000000 --- a/x/reports/handle_msg.go +++ /dev/null @@ -1,112 +0,0 @@ -package reports - -import ( - "github.com/cosmos/cosmos-sdk/x/authz" - - "github.com/desmos-labs/athena/x/filters" - - reportstypes "github.com/desmos-labs/desmos/v6/x/reports/types" - - "github.com/rs/zerolog/log" - - sdk "github.com/cosmos/cosmos-sdk/types" - juno "github.com/forbole/juno/v5/types" -) - -// HandleMsgExec implements modules.AuthzMessageModule -func (m *Module) HandleMsgExec(index int, _ *authz.MsgExec, _ int, executedMsg sdk.Msg, tx *juno.Tx) error { - return m.HandleMsg(index, executedMsg, tx) -} - -// HandleMsg implements modules.MessageModule -func (m *Module) HandleMsg(index int, msg sdk.Msg, tx *juno.Tx) error { - if len(tx.Logs) == 0 || !filters.ShouldMsgBeParsed(msg) { - return nil - } - - switch desmosMsg := msg.(type) { - case *reportstypes.MsgCreateReport: - return m.handleMsgCreateReport(tx, index, desmosMsg) - - case *reportstypes.MsgDeleteReport: - return m.handleMsgDeleteReport(tx, desmosMsg) - - case *reportstypes.MsgAddReason: - return m.handleMsgAddReason(tx, index, desmosMsg) - - case *reportstypes.MsgSupportStandardReason: - return m.handleMsgSupportStandardReason(tx, index, desmosMsg) - - case *reportstypes.MsgRemoveReason: - return m.handleMsgRemoveReason(tx, desmosMsg) - } - - log.Debug().Str("module", "reports").Str("message", sdk.MsgTypeURL(msg)). - Int64("height", tx.Height).Msg("handled message") - - return nil -} - -// handleMsgCreateReport handles a MsgCreateReport -func (m *Module) handleMsgCreateReport(tx *juno.Tx, index int, msg *reportstypes.MsgCreateReport) error { - event, err := tx.FindEventByType(index, reportstypes.EventTypeCreateReport) - if err != nil { - return err - } - reportIDStr, err := tx.FindAttributeByKey(event, reportstypes.AttributeKeyReportID) - if err != nil { - return err - } - reportID, err := reportstypes.ParseReportID(reportIDStr) - if err != nil { - return err - } - - return m.updateReport(tx.Height, msg.SubspaceID, reportID) -} - -// handleMsgDeleteReport handles a MsgDeleteReport -func (m *Module) handleMsgDeleteReport(tx *juno.Tx, msg *reportstypes.MsgDeleteReport) error { - return m.db.DeleteReport(tx.Height, msg.SubspaceID, msg.ReportID) -} - -// handleMsgAddReason handles a MsgAddReason -func (m *Module) handleMsgAddReason(tx *juno.Tx, index int, msg *reportstypes.MsgAddReason) error { - event, err := tx.FindEventByType(index, reportstypes.EventTypeAddReason) - if err != nil { - return err - } - reasonIDStr, err := tx.FindAttributeByKey(event, reportstypes.AttributeKeyReasonID) - if err != nil { - return err - } - reasonID, err := reportstypes.ParseReasonID(reasonIDStr) - if err != nil { - return err - } - - return m.updateReason(tx.Height, msg.SubspaceID, reasonID) -} - -// handleMsgSupportStandardReason handles a MsgSupportStandardReason -func (m *Module) handleMsgSupportStandardReason(tx *juno.Tx, index int, msg *reportstypes.MsgSupportStandardReason) error { - event, err := tx.FindEventByType(index, reportstypes.EventTypeSupportStandardReason) - if err != nil { - return err - } - reasonIDStr, err := tx.FindAttributeByKey(event, reportstypes.AttributeKeyReasonID) - if err != nil { - return err - } - reasonID, err := reportstypes.ParseReasonID(reasonIDStr) - if err != nil { - return err - } - - return m.updateReason(tx.Height, msg.SubspaceID, reasonID) -} - -// handleMsgRemoveReason handles a MsgRemoveReason -func (m *Module) handleMsgRemoveReason(tx *juno.Tx, msg *reportstypes.MsgRemoveReason) error { - return m.db.DeleteReason(tx.Height, msg.SubspaceID, msg.ReasonID) -} diff --git a/x/reports/handle_tx.go b/x/reports/handle_tx.go new file mode 100644 index 00000000..927552c6 --- /dev/null +++ b/x/reports/handle_tx.go @@ -0,0 +1,96 @@ +package reports + +import ( + abci "github.com/cometbft/cometbft/abci/types" + reportstypes "github.com/desmos-labs/desmos/v6/x/reports/types" + juno "github.com/forbole/juno/v5/types" + + "github.com/desmos-labs/athena/utils" +) + +// HandleTx implements modules.TransactionModule +func (m *Module) HandleTx(tx *juno.Tx) error { + return utils.ParseTxEvents(tx, map[string]func(tx *juno.Tx, event abci.Event) error{ + reportstypes.EventTypeCreateReport: m.parseCreateReportEvent, + reportstypes.EventTypeDeleteReport: m.parseDeleteReportEvent, + reportstypes.EventTypeAddReason: m.parseAddReasonEvent, + reportstypes.EventTypeSupportStandardReason: m.parseSupportStandardReasonEvent, + }) +} + +// ------------------------------------------------------------------------------------------------------------------- + +// parseCreateReportEvent handles a create report event +func (m *Module) parseCreateReportEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := utils.GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + + reportID, err := GetReportIDFromEvent(event) + if err != nil { + return err + } + + return m.updateReport(tx.Height, subspaceID, reportID) +} + +// parseDeleteReportEvent handles a delete report event +func (m *Module) parseDeleteReportEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := utils.GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + + reportID, err := GetReportIDFromEvent(event) + if err != nil { + return err + } + + return m.db.DeleteReport(tx.Height, subspaceID, reportID) +} + +// parseAddReasonEvent handles an add reason event +func (m *Module) parseAddReasonEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := utils.GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + + reasonID, err := GetReasonIDFromEvent(event) + if err != nil { + return err + } + + return m.updateReason(tx.Height, subspaceID, reasonID) +} + +// parseSupportStandardReasonEvent handles a support standard reason event +func (m *Module) parseSupportStandardReasonEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := utils.GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + + reasonID, err := GetReasonIDFromEvent(event) + if err != nil { + return err + } + + return m.updateReason(tx.Height, subspaceID, reasonID) +} + +// parseRemoveReasonEvent handles a remove reason event +func (m *Module) parseRemoveReasonEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := utils.GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + + reasonID, err := GetReasonIDFromEvent(event) + if err != nil { + return err + } + + return m.db.DeleteReason(tx.Height, subspaceID, reasonID) +} diff --git a/x/reports/module.go b/x/reports/module.go index e7925ad8..4eb65d98 100644 --- a/x/reports/module.go +++ b/x/reports/module.go @@ -12,7 +12,7 @@ import ( var ( _ modules.Module = &Module{} _ modules.GenesisModule = &Module{} - _ modules.MessageModule = &Module{} + _ modules.TransactionModule = &Module{} _ modules.PeriodicOperationsModule = &Module{} ) diff --git a/x/reports/utils.go b/x/reports/utils.go index 991eefc4..c49bdae8 100644 --- a/x/reports/utils.go +++ b/x/reports/utils.go @@ -4,6 +4,9 @@ import ( "context" "fmt" + abci "github.com/cometbft/cometbft/abci/types" + "github.com/forbole/juno/v5/types/utils" + "github.com/desmos-labs/athena/types" "github.com/forbole/juno/v5/node/remote" @@ -11,6 +14,25 @@ import ( reportstypes "github.com/desmos-labs/desmos/v6/x/reports/types" ) +// GetReportIDFromEvent returns the report ID from the given event +func GetReportIDFromEvent(event abci.Event) (uint64, error) { + attribute, err := utils.FindAttributeByKey(event, reportstypes.AttributeKeyReportID) + if err != nil { + return 0, err + } + return reportstypes.ParseReportID(attribute.Value) +} + +func GetReasonIDFromEvent(event abci.Event) (uint32, error) { + attribute, err := utils.FindAttributeByKey(event, reportstypes.AttributeKeyReasonID) + if err != nil { + return 0, err + } + return reportstypes.ParseReasonID(attribute.Value) +} + +// ------------------------------------------------------------------------------------------------------------------- + // updateReport updates the stored data for the given report at the specified height func (m *Module) updateReport(height int64, subspaceID uint64, reportID uint64) error { // Get the report From 8eb6a71104da82f504f55fa15e237841a94adbd9 Mon Sep 17 00:00:00 2001 From: Riccardo Montagnin Date: Fri, 19 Jan 2024 14:30:11 +0100 Subject: [PATCH 05/15] docs: added missing comment --- x/reports/utils.go | 1 + 1 file changed, 1 insertion(+) diff --git a/x/reports/utils.go b/x/reports/utils.go index c49bdae8..eec7df9e 100644 --- a/x/reports/utils.go +++ b/x/reports/utils.go @@ -23,6 +23,7 @@ func GetReportIDFromEvent(event abci.Event) (uint64, error) { return reportstypes.ParseReportID(attribute.Value) } +// GetReasonIDFromEvent returns the reason ID from the given event func GetReasonIDFromEvent(event abci.Event) (uint32, error) { attribute, err := utils.FindAttributeByKey(event, reportstypes.AttributeKeyReasonID) if err != nil { From 994fca490155634bcc0d476a795a269986d399f3 Mon Sep 17 00:00:00 2001 From: Riccardo Montagnin Date: Fri, 19 Jan 2024 14:34:12 +0100 Subject: [PATCH 06/15] feat: add missing remove reason event parsing --- x/reports/handle_tx.go | 1 + 1 file changed, 1 insertion(+) diff --git a/x/reports/handle_tx.go b/x/reports/handle_tx.go index 927552c6..62b631a8 100644 --- a/x/reports/handle_tx.go +++ b/x/reports/handle_tx.go @@ -15,6 +15,7 @@ func (m *Module) HandleTx(tx *juno.Tx) error { reportstypes.EventTypeDeleteReport: m.parseDeleteReportEvent, reportstypes.EventTypeAddReason: m.parseAddReasonEvent, reportstypes.EventTypeSupportStandardReason: m.parseSupportStandardReasonEvent, + reportstypes.EventTypeRemoveReason: m.parseRemoveReasonEvent, }) } From 119d8440e34513185a674f4812d171cf9d9c34b4 Mon Sep 17 00:00:00 2001 From: Riccardo Montagnin Date: Fri, 19 Jan 2024 15:00:51 +0100 Subject: [PATCH 07/15] refactor: parse profiles events instead of messages --- x/profiles/handle_msg.go | 121 +------------------------ x/profiles/handle_tx.go | 184 +++++++++++++++++++++++++++++++++++++++ x/profiles/module.go | 1 + x/profiles/utils.go | 31 +++++++ 4 files changed, 217 insertions(+), 120 deletions(-) create mode 100644 x/profiles/handle_tx.go diff --git a/x/profiles/handle_msg.go b/x/profiles/handle_msg.go index e71ba056..36e2f2c5 100644 --- a/x/profiles/handle_msg.go +++ b/x/profiles/handle_msg.go @@ -10,10 +10,6 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" channeltypes "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types" juno "github.com/forbole/juno/v5/types" - - profilestypes "github.com/desmos-labs/desmos/v6/x/profiles/types" - - "github.com/desmos-labs/athena/types" ) // HandleMsgExec implements modules.AuthzMessageModule @@ -22,39 +18,12 @@ func (m *Module) HandleMsgExec(index int, _ *authz.MsgExec, _ int, executedMsg s } // HandleMsg implements modules.MessageModule -func (m *Module) HandleMsg(index int, msg sdk.Msg, tx *juno.Tx) error { +func (m *Module) HandleMsg(_ int, msg sdk.Msg, tx *juno.Tx) error { if len(tx.Logs) == 0 || !filters.ShouldMsgBeParsed(msg) { return nil } switch desmosMsg := msg.(type) { - case *profilestypes.MsgSaveProfile: - return m.handleMsgSaveProfile(tx, desmosMsg) - - case *profilestypes.MsgDeleteProfile: - return m.handleMsgDeleteProfile(tx, desmosMsg) - - case *profilestypes.MsgRequestDTagTransfer: - return m.handleMsgRequestDTagTransfer(tx, index, desmosMsg) - - case *profilestypes.MsgAcceptDTagTransferRequest: - return m.handleMsgAcceptDTagTransfer(tx, desmosMsg) - - case *profilestypes.MsgCancelDTagTransferRequest: - return m.handleDTagTransferRequestDeletion(tx.Height, desmosMsg.Sender, desmosMsg.Receiver) - - case *profilestypes.MsgRefuseDTagTransferRequest: - return m.handleDTagTransferRequestDeletion(tx.Height, desmosMsg.Sender, desmosMsg.Receiver) - - case *profilestypes.MsgLinkChainAccount: - return m.handleMsgChainLink(tx, desmosMsg) - - case *profilestypes.MsgUnlinkChainAccount: - return m.handleMsgUnlinkChainAccount(tx, desmosMsg) - - case *profilestypes.MsgLinkApplication: - return m.handleMsgLinkApplication(tx, desmosMsg) - case *channeltypes.MsgRecvPacket: return m.handlePacket(tx, desmosMsg.Packet) @@ -63,9 +32,6 @@ func (m *Module) HandleMsg(index int, msg sdk.Msg, tx *juno.Tx) error { case *channeltypes.MsgTimeout: return m.handlePacket(tx, desmosMsg.Packet) - - case *profilestypes.MsgUnlinkApplication: - return m.handleMsgUnlinkApplication(tx, desmosMsg) } log.Debug().Str("module", "profiles").Str("message", sdk.MsgTypeURL(msg)). @@ -73,88 +39,3 @@ func (m *Module) HandleMsg(index int, msg sdk.Msg, tx *juno.Tx) error { return nil } - -// ------------------------------------------------------------------------------------------------------------------- - -// handleMsgSaveProfile handles a MsgCreateProfile and properly stores the new profile inside the database -func (m *Module) handleMsgSaveProfile(tx *juno.Tx, msg *profilestypes.MsgSaveProfile) error { - addresses := []string{msg.Creator} - return m.UpdateProfiles(tx.Height, addresses) -} - -// handleMsgDeleteProfile handles a MsgDeleteProfile correctly deleting the account present inside the database -func (m *Module) handleMsgDeleteProfile(tx *juno.Tx, msg *profilestypes.MsgDeleteProfile) error { - return m.db.DeleteProfile(msg.Creator, tx.Height) -} - -// ----------------------------------------------------------------------------------------------------- - -// handleMsgRequestDTagTransfer handles a MsgRequestDTagTransfer storing the request into the database -func (m *Module) handleMsgRequestDTagTransfer(tx *juno.Tx, index int, msg *profilestypes.MsgRequestDTagTransfer) error { - event, err := tx.FindEventByType(index, profilestypes.EventTypeDTagTransferRequest) - if err != nil { - return err - } - - dTagToTrade, err := tx.FindAttributeByKey(event, profilestypes.AttributeKeyDTagToTrade) - if err != nil { - return err - } - - return m.db.SaveDTagTransferRequest(types.NewDTagTransferRequest( - profilestypes.NewDTagTransferRequest(dTagToTrade, msg.Sender, msg.Receiver), - tx.Height, - )) -} - -// handleMsgAcceptDTagTransfer handles a MsgAcceptDTagTransfer effectively transferring the DTag -func (m *Module) handleMsgAcceptDTagTransfer(tx *juno.Tx, msg *profilestypes.MsgAcceptDTagTransferRequest) error { - // Update the involved accounts profiles - addresses := []string{msg.Receiver, msg.Sender} - return m.UpdateProfiles(tx.Height, addresses) -} - -// handleDTagTransferRequestDeletion allows to delete an existing transfer request -func (m *Module) handleDTagTransferRequestDeletion(height int64, sender, receiver string) error { - return m.db.DeleteDTagTransferRequest(types.NewDTagTransferRequest( - profilestypes.NewDTagTransferRequest("", sender, receiver), - height, - )) -} - -// ----------------------------------------------------------------------------------------------------- - -// handleMsgChainLink allows to handle a MsgLinkChainAccount properly -func (m *Module) handleMsgChainLink(tx *juno.Tx, msg *profilestypes.MsgLinkChainAccount) error { - // Save the chain links - err := m.updateUserChainLinks(tx.Height, msg.Signer) - if err != nil { - return err - } - - // Update the default chain links - return m.updateUserDefaultChainLinks(tx.Height, msg.Signer) -} - -// handleMsgUnlinkChainAccount allows to handle a MsgUnlinkChainAccount properly -func (m *Module) handleMsgUnlinkChainAccount(tx *juno.Tx, msg *profilestypes.MsgUnlinkChainAccount) error { - err := m.db.DeleteChainLink(msg.Owner, msg.Target, msg.ChainName, tx.Height) - if err != nil { - return err - } - - // Update the default chain links - return m.updateUserDefaultChainLinks(tx.Height, msg.Owner) -} - -// ----------------------------------------------------------------------------------------------------- - -// handleMsgLinkApplication allows to handle a MsgLinkApplication properly -func (m *Module) handleMsgLinkApplication(tx *juno.Tx, msg *profilestypes.MsgLinkApplication) error { - return m.updateUserApplicationLinks(tx.Height, msg.Sender) -} - -// handleMsgUnlinkApplication allows to handle a MsgUnlinkApplication properly -func (m *Module) handleMsgUnlinkApplication(tx *juno.Tx, msg *profilestypes.MsgUnlinkApplication) error { - return m.db.DeleteApplicationLink(msg.Signer, msg.Application, msg.Username, tx.Height) -} diff --git a/x/profiles/handle_tx.go b/x/profiles/handle_tx.go new file mode 100644 index 00000000..02a01bed --- /dev/null +++ b/x/profiles/handle_tx.go @@ -0,0 +1,184 @@ +package profiles + +import ( + abci "github.com/cometbft/cometbft/abci/types" + "github.com/desmos-labs/athena/types" + "github.com/desmos-labs/athena/utils" + profilestypes "github.com/desmos-labs/desmos/v6/x/profiles/types" + juno "github.com/forbole/juno/v5/types" +) + +// HandleTx implements modules.TransactionModule +func (m *Module) HandleTx(tx *juno.Tx) error { + return utils.ParseTxEvents(tx, map[string]func(tx *juno.Tx, event abci.Event) error{ + profilestypes.EventTypeProfileSaved: m.parseSaveProfileEvent, + profilestypes.EventTypeProfileDeleted: m.parseDeleteProfileEvent, + profilestypes.EventTypeDTagTransferRequest: m.parseRequestDTagTransferEvent, + profilestypes.EventTypeDTagTransferAccept: m.parseAcceptDTagTransferRequestEvent, + profilestypes.EventTypeDTagTransferRefuse: m.parseDeleteDTagTransferRequestEvent, + profilestypes.EventTypeDTagTransferCancel: m.parseDeleteDTagTransferRequestEvent, + profilestypes.EventTypeLinkChainAccount: m.parseLinkChainAccountEvent, + profilestypes.EventTypeUnlinkChainAccount: m.parseUnlinkChainAccountEvent, + profilestypes.EventTypesApplicationLinkCreated: m.parseLinkApplicationEvent, + profilestypes.EventTypeApplicationLinkDeleted: m.parseUnlinkApplicationEvent, + }) +} + +// ------------------------------------------------------------------------------------------------------------------- + +// parseSaveProfileEvent parses the save profile event +func (m *Module) parseSaveProfileEvent(tx *juno.Tx, event abci.Event) error { + creator, err := GetCreatorAddressFromEvent(event) + if err != nil { + return err + } + + return m.UpdateProfiles(tx.Height, []string{creator}) +} + +// parseDeleteProfileEvent parses the delete profile event +func (m *Module) parseDeleteProfileEvent(tx *juno.Tx, event abci.Event) error { + creator, err := GetCreatorAddressFromEvent(event) + if err != nil { + return err + } + + return m.db.DeleteProfile(creator, tx.Height) +} + +// parseRequestDTagTransferEvent parses the request dtag transfer event +func (m *Module) parseRequestDTagTransferEvent(tx *juno.Tx, event abci.Event) error { + sender, err := GetRequestSenderAddressFromEvent(event) + if err != nil { + return err + } + + receiver, err := GetRequestReceiverAddressFromEvent(event) + if err != nil { + return err + } + + dTagToTrade, err := juno.FindAttributeByKey(event, profilestypes.AttributeKeyDTagToTrade) + if err != nil { + return err + } + + return m.db.SaveDTagTransferRequest(types.NewDTagTransferRequest( + profilestypes.NewDTagTransferRequest(dTagToTrade.Value, sender, receiver), + tx.Height, + )) +} + +// parseAcceptDTagTransferRequestEvent parses the accept dtag transfer request event +func (m *Module) parseAcceptDTagTransferRequestEvent(tx *juno.Tx, event abci.Event) error { + sender, err := GetRequestSenderAddressFromEvent(event) + if err != nil { + return err + } + + receiver, err := GetRequestReceiverAddressFromEvent(event) + if err != nil { + return err + } + + return m.UpdateProfiles(tx.Height, []string{sender, receiver}) +} + +// parseDeleteDTagTransferRequestEvent parses the refuse or cancel dtag transfer request events +func (m *Module) parseDeleteDTagTransferRequestEvent(tx *juno.Tx, event abci.Event) error { + sender, err := GetRequestSenderAddressFromEvent(event) + if err != nil { + return err + } + + receiver, err := GetRequestReceiverAddressFromEvent(event) + if err != nil { + return err + } + + return m.db.DeleteDTagTransferRequest(types.NewDTagTransferRequest( + profilestypes.NewDTagTransferRequest("", sender, receiver), + tx.Height, + )) +} + +// parseLinkChainAccountEvent parses the link chain account event +func (m *Module) parseLinkChainAccountEvent(tx *juno.Tx, event abci.Event) error { + ownerAttr, err := juno.FindAttributeByKey(event, profilestypes.AttributeKeyChainLinkOwner) + if err != nil { + return err + } + owner := ownerAttr.Value + + // Save the chain links + err = m.updateUserChainLinks(tx.Height, owner) + if err != nil { + return err + } + + // Update the default chain links + return m.updateUserDefaultChainLinks(tx.Height, owner) +} + +// parseUnlinkChainAccountEvent parses the unlink chain account event +func (m *Module) parseUnlinkChainAccountEvent(tx *juno.Tx, event abci.Event) error { + ownerAttr, err := juno.FindAttributeByKey(event, profilestypes.AttributeKeyChainLinkOwner) + if err != nil { + return err + } + owner := ownerAttr.Value + + targetAttr, err := juno.FindAttributeByKey(event, profilestypes.AttributeKeyChainLinkExternalAddress) + if err != nil { + return err + } + target := targetAttr.Value + + chainNameAttr, err := juno.FindAttributeByKey(event, profilestypes.AttributeKeyChainLinkChainName) + if err != nil { + return err + } + chainName := chainNameAttr.Value + + err = m.db.DeleteChainLink(owner, target, chainName, tx.Height) + if err != nil { + return err + } + + // Update the default chain links + return m.updateUserDefaultChainLinks(tx.Height, owner) +} + +// parseLinkApplicationEvent parses the link application event +func (m *Module) parseLinkApplicationEvent(tx *juno.Tx, event abci.Event) error { + ownerAttr, err := juno.FindAttributeByKey(event, profilestypes.AttributeKeyUser) + if err != nil { + return err + } + owner := ownerAttr.Value + + return m.updateUserApplicationLinks(tx.Height, owner) +} + +// parseUnlinkApplicationEvent parses the unlink application event +func (m *Module) parseUnlinkApplicationEvent(tx *juno.Tx, event abci.Event) error { + ownerAttr, err := juno.FindAttributeByKey(event, profilestypes.AttributeKeyUser) + if err != nil { + return err + } + owner := ownerAttr.Value + + applicationAttr, err := juno.FindAttributeByKey(event, profilestypes.AttributeKeyApplicationName) + if err != nil { + return err + } + application := applicationAttr.Value + + usernameAttr, err := juno.FindAttributeByKey(event, profilestypes.AttributeKeyApplicationUsername) + if err != nil { + return err + } + username := usernameAttr.Value + + return m.db.DeleteApplicationLink(owner, application, username, tx.Height) +} diff --git a/x/profiles/module.go b/x/profiles/module.go index 442e4444..4e109ccc 100644 --- a/x/profiles/module.go +++ b/x/profiles/module.go @@ -15,6 +15,7 @@ var ( _ modules.Module = &Module{} _ modules.PeriodicOperationsModule = &Module{} _ modules.GenesisModule = &Module{} + _ modules.TransactionModule = &Module{} _ modules.MessageModule = &Module{} _ modules.AuthzMessageModule = &Module{} ) diff --git a/x/profiles/utils.go b/x/profiles/utils.go index cce83c61..0beed529 100644 --- a/x/profiles/utils.go +++ b/x/profiles/utils.go @@ -3,6 +3,8 @@ package profiles import ( "context" "fmt" + abci "github.com/cometbft/cometbft/abci/types" + "github.com/forbole/juno/v5/types/utils" "github.com/cosmos/cosmos-sdk/types/query" "github.com/forbole/juno/v5/node/remote" @@ -12,6 +14,35 @@ import ( "github.com/desmos-labs/athena/types" ) +// GetCreatorAddressFromEvent returns the creator address from the given event +func GetCreatorAddressFromEvent(event abci.Event) (string, error) { + creator, err := utils.FindAttributeByKey(event, profilestypes.AttributeKeyProfileCreator) + if err != nil { + return "", err + } + return creator.Value, nil +} + +// GetRequestSenderAddressFromEvent returns the request sender address from the given event +func GetRequestSenderAddressFromEvent(event abci.Event) (string, error) { + creator, err := utils.FindAttributeByKey(event, profilestypes.AttributeKeyRequestSender) + if err != nil { + return "", err + } + return creator.Value, nil +} + +// GetRequestReceiverAddressFromEvent returns the request receiver address from the given event +func GetRequestReceiverAddressFromEvent(event abci.Event) (string, error) { + creator, err := utils.FindAttributeByKey(event, profilestypes.AttributeKeyRequestReceiver) + if err != nil { + return "", err + } + return creator.Value, nil +} + +// -------------------------------------------------------------------------------------------------------------------- + // GetDisplayName returns the name to be displayed for the user having the given address func (m *Module) GetDisplayName(userAddress string) string { profile, err := m.GetUserProfile(userAddress) From 657c821712886795b03a7e74cd6c27c92d16f396 Mon Sep 17 00:00:00 2001 From: Riccardo Montagnin Date: Fri, 19 Jan 2024 15:03:33 +0100 Subject: [PATCH 08/15] chore: run lint --- x/profiles/handle_tx.go | 5 +++-- x/profiles/utils.go | 1 + 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/x/profiles/handle_tx.go b/x/profiles/handle_tx.go index 02a01bed..558c670f 100644 --- a/x/profiles/handle_tx.go +++ b/x/profiles/handle_tx.go @@ -2,10 +2,11 @@ package profiles import ( abci "github.com/cometbft/cometbft/abci/types" - "github.com/desmos-labs/athena/types" - "github.com/desmos-labs/athena/utils" profilestypes "github.com/desmos-labs/desmos/v6/x/profiles/types" juno "github.com/forbole/juno/v5/types" + + "github.com/desmos-labs/athena/types" + "github.com/desmos-labs/athena/utils" ) // HandleTx implements modules.TransactionModule diff --git a/x/profiles/utils.go b/x/profiles/utils.go index 0beed529..dc04192c 100644 --- a/x/profiles/utils.go +++ b/x/profiles/utils.go @@ -3,6 +3,7 @@ package profiles import ( "context" "fmt" + abci "github.com/cometbft/cometbft/abci/types" "github.com/forbole/juno/v5/types/utils" From e50265ad0cd2cb32362b1496ef4d080a887590e8 Mon Sep 17 00:00:00 2001 From: Riccardo Montagnin Date: Fri, 19 Jan 2024 15:04:02 +0100 Subject: [PATCH 09/15] chore: added missing events mapping --- x/posts/handle_tx.go | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/x/posts/handle_tx.go b/x/posts/handle_tx.go index 0cfa40e4..fa1e5434 100644 --- a/x/posts/handle_tx.go +++ b/x/posts/handle_tx.go @@ -12,7 +12,12 @@ import ( // HandleTx handles the transaction events func (m *Module) HandleTx(tx *juno.Tx) error { return utils.ParseTxEvents(tx, map[string]func(tx *juno.Tx, event abci.Event) error{ - poststypes.EventTypeCreatePost: m.parseCreatePostEvent, + poststypes.EventTypeCreatePost: m.parseCreatePostEvent, + poststypes.EventTypeEditPost: m.parseEditPostEvent, + poststypes.EventTypeDeletePost: m.parseDeletePostEvent, + poststypes.EventTypeAddPostAttachment: m.parseAddPostAttachmentEvent, + poststypes.EventTypeRemovePostAttachment: m.parseRemovePostAttachmentEvent, + poststypes.EventTypeAnswerPoll: m.parseAnswerPollEvent, }) } From 36f532a151a00e2bf2e9e38e48c20f742bffb501 Mon Sep 17 00:00:00 2001 From: Riccardo Montagnin Date: Fri, 19 Jan 2024 15:28:26 +0100 Subject: [PATCH 10/15] feat: parse reactions events instead of messages --- x/reactions/handle_msg.go | 104 -------------------------------- x/reactions/handle_tx.go | 123 ++++++++++++++++++++++++++++++++++++++ x/reactions/module.go | 6 +- x/reactions/utils.go | 35 +++++++++++ 4 files changed, 161 insertions(+), 107 deletions(-) delete mode 100644 x/reactions/handle_msg.go create mode 100644 x/reactions/handle_tx.go diff --git a/x/reactions/handle_msg.go b/x/reactions/handle_msg.go deleted file mode 100644 index e7c8e1b8..00000000 --- a/x/reactions/handle_msg.go +++ /dev/null @@ -1,104 +0,0 @@ -package reactions - -import ( - "github.com/cosmos/cosmos-sdk/x/authz" - - "github.com/desmos-labs/athena/x/filters" - - reactionstypes "github.com/desmos-labs/desmos/v6/x/reactions/types" - - "github.com/rs/zerolog/log" - - sdk "github.com/cosmos/cosmos-sdk/types" - juno "github.com/forbole/juno/v5/types" -) - -// HandleMsgExec implements modules.AuthzMessageModule -func (m *Module) HandleMsgExec(index int, _ *authz.MsgExec, _ int, executedMsg sdk.Msg, tx *juno.Tx) error { - return m.HandleMsg(index, executedMsg, tx) -} - -// HandleMsg implements modules.MessageModule -func (m *Module) HandleMsg(index int, msg sdk.Msg, tx *juno.Tx) error { - if len(tx.Logs) == 0 || !filters.ShouldMsgBeParsed(msg) { - return nil - } - - switch desmosMsg := msg.(type) { - case *reactionstypes.MsgAddReaction: - return m.handleMsgAddReaction(tx, index, desmosMsg) - - case *reactionstypes.MsgRemoveReaction: - return m.handleMsgRemoveReaction(tx, desmosMsg) - - case *reactionstypes.MsgAddRegisteredReaction: - return m.handleMsgAddRegisteredReaction(tx, index, desmosMsg) - - case *reactionstypes.MsgEditRegisteredReaction: - return m.handleMsgEditRegisteredReaction(tx, desmosMsg) - - case *reactionstypes.MsgRemoveRegisteredReaction: - return m.handleMsgRemoveRegisteredReaction(tx, desmosMsg) - - case *reactionstypes.MsgSetReactionsParams: - return m.handleMsgSetReactionsParams(tx, desmosMsg) - } - - log.Debug().Str("module", "reactions").Str("message", sdk.MsgTypeURL(msg)). - Int64("height", tx.Height).Msg("handled message") - - return nil -} - -// handleMsgAddReaction handles a MsgAddReaction -func (m *Module) handleMsgAddReaction(tx *juno.Tx, index int, msg *reactionstypes.MsgAddReaction) error { - reactionID, err := m.GetReactionID(tx, index) - if err != nil { - return err - } - - reaction, err := m.GetReaction(tx.Height, msg.SubspaceID, msg.PostID, reactionID) - if err != nil { - return err - } - - return m.db.SaveReaction(reaction) -} - -// handleMsgRemoveReaction handles a MsgRemoveReaction -func (m *Module) handleMsgRemoveReaction(tx *juno.Tx, msg *reactionstypes.MsgRemoveReaction) error { - return m.db.DeleteReaction(tx.Height, msg.SubspaceID, msg.PostID, msg.ReactionID) -} - -// handleMsgAddRegisteredReaction handles a MsgAddRegisteredReaction -func (m *Module) handleMsgAddRegisteredReaction(tx *juno.Tx, index int, msg *reactionstypes.MsgAddRegisteredReaction) error { - event, err := tx.FindEventByType(index, reactionstypes.EventTypeAddRegisteredReaction) - if err != nil { - return err - } - reactionIDStr, err := tx.FindAttributeByKey(event, reactionstypes.AttributeKeyRegisteredReactionID) - if err != nil { - return err - } - reactionID, err := reactionstypes.ParseRegisteredReactionID(reactionIDStr) - if err != nil { - return err - } - - return m.updateRegisteredReaction(tx.Height, msg.SubspaceID, reactionID) -} - -// handleMsgEditRegisteredReaction handles a MsgEditRegisteredReaction -func (m *Module) handleMsgEditRegisteredReaction(tx *juno.Tx, msg *reactionstypes.MsgEditRegisteredReaction) error { - return m.updateRegisteredReaction(tx.Height, msg.SubspaceID, msg.RegisteredReactionID) -} - -// handleMsgRemoveRegisteredReaction handles a MsgRemoveRegisteredReacton -func (m *Module) handleMsgRemoveRegisteredReaction(tx *juno.Tx, msg *reactionstypes.MsgRemoveRegisteredReaction) error { - return m.db.DeleteRegisteredReaction(tx.Height, msg.SubspaceID, msg.RegisteredReactionID) -} - -// handleMsgSetReactionsParams handles a MsgSetReactionsParams -func (m *Module) handleMsgSetReactionsParams(tx *juno.Tx, msg *reactionstypes.MsgSetReactionsParams) error { - return m.updateReactionParams(tx.Height, msg.SubspaceID) -} diff --git a/x/reactions/handle_tx.go b/x/reactions/handle_tx.go new file mode 100644 index 00000000..0a37bb1b --- /dev/null +++ b/x/reactions/handle_tx.go @@ -0,0 +1,123 @@ +package reactions + +import ( + abci "github.com/cometbft/cometbft/abci/types" + reactionstypes "github.com/desmos-labs/desmos/v6/x/reactions/types" + juno "github.com/forbole/juno/v5/types" + + "github.com/desmos-labs/athena/utils" + "github.com/desmos-labs/athena/x/posts" +) + +func (m *Module) HandleTx(tx *juno.Tx) error { + return utils.ParseTxEvents(tx, map[string]func(tx *juno.Tx, event abci.Event) error{ + reactionstypes.EventTypeAddReaction: m.parseAddReactionEvent, + reactionstypes.EventTypeRemoveReaction: m.parseRemoveReactionEvent, + reactionstypes.EventTypeAddRegisteredReaction: m.parseAddRegisteredReactionEvent, + reactionstypes.ActionEditRegisteredReaction: m.parseEditRegisteredReactionEvent, + reactionstypes.EventTypeRemoveRegisteredReaction: m.parseRemoveRegisteredReactionEvent, + reactionstypes.EventTypeSetReactionsParams: m.parseSetReactionsParamsEvent, + }) +} + +// ------------------------------------------------------------------------------------------------------------------- + +// parseAddReactionEvent parses a reaction add event +func (m *Module) parseAddReactionEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := utils.GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + + postID, err := posts.GetPostIDFromEvent(event) + if err != nil { + return err + } + + reactionID, err := GetReactionIDFromEvent(event) + if err != nil { + return err + } + + reaction, err := m.GetReaction(tx.Height, subspaceID, postID, reactionID) + if err != nil { + return err + } + + return m.db.SaveReaction(reaction) +} + +// parseRemoveReactionEvent parses a reaction remove event +func (m *Module) parseRemoveReactionEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := utils.GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + + postID, err := posts.GetPostIDFromEvent(event) + if err != nil { + return err + } + + reactionID, err := GetReactionIDFromEvent(event) + if err != nil { + return err + } + + return m.db.DeleteReaction(tx.Height, subspaceID, postID, reactionID) +} + +// parseAddRegisteredReactionEvent parses a registered reaction add event +func (m *Module) parseAddRegisteredReactionEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := utils.GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + + registeredReactionID, err := GetRegisteredReactionIDFromEvent(event) + if err != nil { + return err + } + + return m.updateRegisteredReaction(tx.Height, subspaceID, registeredReactionID) +} + +// parseEditRegisteredReactionEvent parses a registered reaction edit event +func (m *Module) parseEditRegisteredReactionEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := utils.GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + + registeredReactionID, err := GetRegisteredReactionIDFromEvent(event) + if err != nil { + return err + } + + return m.updateRegisteredReaction(tx.Height, subspaceID, registeredReactionID) +} + +// parseRemoveRegisteredReactionEvent parses a registered reaction remove event +func (m *Module) parseRemoveRegisteredReactionEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := utils.GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + + registeredReactionID, err := GetRegisteredReactionIDFromEvent(event) + if err != nil { + return err + } + + return m.db.DeleteRegisteredReaction(tx.Height, subspaceID, registeredReactionID) +} + +// parseSetReactionsParamsEvent parses a set reactions params event +func (m *Module) parseSetReactionsParamsEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := utils.GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + + return m.updateReactionParams(tx.Height, subspaceID) +} diff --git a/x/reactions/module.go b/x/reactions/module.go index 7d7f8eda..2b263d2f 100644 --- a/x/reactions/module.go +++ b/x/reactions/module.go @@ -10,9 +10,9 @@ import ( ) var ( - _ modules.Module = &Module{} - _ modules.GenesisModule = &Module{} - _ modules.MessageModule = &Module{} + _ modules.Module = &Module{} + _ modules.GenesisModule = &Module{} + _ modules.TransactionModule = &Module{} ) // Module represents the x/fees module handler diff --git a/x/reactions/utils.go b/x/reactions/utils.go index 56532a89..46a4e2b8 100644 --- a/x/reactions/utils.go +++ b/x/reactions/utils.go @@ -3,6 +3,9 @@ package reactions import ( "context" + abci "github.com/cometbft/cometbft/abci/types" + "github.com/forbole/juno/v5/types/utils" + juno "github.com/forbole/juno/v5/types" "github.com/forbole/juno/v5/node/remote" @@ -24,6 +27,38 @@ func (m *Module) GetReactionID(tx *juno.Tx, index int) (uint32, error) { return reactionstypes.ParseReactionID(reactionIDStr) } +// GetReactionIDFromEvent returns the reaction ID from the given event +func GetReactionIDFromEvent(event abci.Event) (uint32, error) { + reactionIDAttr, err := utils.FindAttributeByKey(event, reactionstypes.AttributeKeyReactionID) + if err != nil { + return 0, err + } + + reactionID, err := reactionstypes.ParseReactionID(reactionIDAttr.Value) + if err != nil { + return 0, err + } + + return reactionID, nil +} + +// GetRegisteredReactionIDFromEvent returns the registered reaction ID from the given event +func GetRegisteredReactionIDFromEvent(event abci.Event) (uint32, error) { + registeredReactionIDAttr, err := utils.FindAttributeByKey(event, reactionstypes.AttributeKeyRegisteredReactionID) + if err != nil { + return 0, err + } + + registeredReactionID, err := reactionstypes.ParseRegisteredReactionID(registeredReactionIDAttr.Value) + if err != nil { + return 0, err + } + + return registeredReactionID, nil +} + +// ------------------------------------------------------------------------------------------------------------------- + func (m *Module) GetReaction(height int64, subspaceID uint64, postID uint64, reactionID uint32) (types.Reaction, error) { res, err := m.client.Reaction( remote.GetHeightRequestContext(context.Background(), height), From 997e2cc481a5326c89f5a1460e045008e7a3d075 Mon Sep 17 00:00:00 2001 From: Riccardo Montagnin Date: Fri, 19 Jan 2024 15:28:54 +0100 Subject: [PATCH 11/15] chore: added missing event filtering --- utils/events.go | 24 +++++++++++++++--------- 1 file changed, 15 insertions(+), 9 deletions(-) diff --git a/utils/events.go b/utils/events.go index 5ce5fe05..1a0e10b5 100644 --- a/utils/events.go +++ b/utils/events.go @@ -5,11 +5,26 @@ import ( subspacestypes "github.com/desmos-labs/desmos/v6/x/subspaces/types" juno "github.com/forbole/juno/v5/types" "github.com/rs/zerolog/log" + + "github.com/desmos-labs/athena/x/filters" ) +// GetSubspaceIDFromEvent returns the subspace ID from the given event +func GetSubspaceIDFromEvent(event abci.Event) (uint64, error) { + attribute, err := juno.FindAttributeByKey(event, subspacestypes.AttributeKeySubspaceID) + if err != nil { + return 0, err + } + return subspacestypes.ParseSubspaceID(attribute.Value) +} + // ParseTxEvents parses the given events using the given parsers func ParseTxEvents(tx *juno.Tx, eventsParsers map[string]func(tx *juno.Tx, event abci.Event) error) error { for _, event := range tx.Events { + if !filters.ShouldEventBeParsed(event) { + continue + } + parseEvent, canBeParsed := eventsParsers[event.Type] if !canBeParsed { continue @@ -25,12 +40,3 @@ func ParseTxEvents(tx *juno.Tx, eventsParsers map[string]func(tx *juno.Tx, event return nil } - -// GetSubspaceIDFromEvent returns the subspace ID from the given event -func GetSubspaceIDFromEvent(event abci.Event) (uint64, error) { - attribute, err := juno.FindAttributeByKey(event, subspacestypes.AttributeKeySubspaceID) - if err != nil { - return 0, err - } - return subspacestypes.ParseSubspaceID(attribute.Value) -} From 9c2f5cc2c09b8d9951a9e8bbdf0c15d5273a7c1e Mon Sep 17 00:00:00 2001 From: Riccardo Montagnin Date: Fri, 19 Jan 2024 16:13:00 +0100 Subject: [PATCH 12/15] refactor: improve packages organization --- utils/events/attributes.go | 16 ++++++++++++++++ utils/{ => transactions}/events.go | 12 +----------- x/filters/messages.go | 16 +++++++++++++--- x/posts/handle_tx.go | 18 ++++++++++-------- x/profiles/handle_tx.go | 5 +++-- x/reactions/handle_tx.go | 18 ++++++++++-------- x/reports/handle_tx.go | 15 ++++++++------- 7 files changed, 61 insertions(+), 39 deletions(-) create mode 100644 utils/events/attributes.go rename utils/{ => transactions}/events.go (62%) diff --git a/utils/events/attributes.go b/utils/events/attributes.go new file mode 100644 index 00000000..3cd56ba8 --- /dev/null +++ b/utils/events/attributes.go @@ -0,0 +1,16 @@ +package events + +import ( + abci "github.com/cometbft/cometbft/abci/types" + subspacestypes "github.com/desmos-labs/desmos/v6/x/subspaces/types" + juno "github.com/forbole/juno/v5/types" +) + +// GetSubspaceIDFromEvent returns the subspace ID from the given event +func GetSubspaceIDFromEvent(event abci.Event) (uint64, error) { + attribute, err := juno.FindAttributeByKey(event, subspacestypes.AttributeKeySubspaceID) + if err != nil { + return 0, err + } + return subspacestypes.ParseSubspaceID(attribute.Value) +} diff --git a/utils/events.go b/utils/transactions/events.go similarity index 62% rename from utils/events.go rename to utils/transactions/events.go index 1a0e10b5..400fc097 100644 --- a/utils/events.go +++ b/utils/transactions/events.go @@ -1,23 +1,13 @@ -package utils +package transactions import ( abci "github.com/cometbft/cometbft/abci/types" - subspacestypes "github.com/desmos-labs/desmos/v6/x/subspaces/types" juno "github.com/forbole/juno/v5/types" "github.com/rs/zerolog/log" "github.com/desmos-labs/athena/x/filters" ) -// GetSubspaceIDFromEvent returns the subspace ID from the given event -func GetSubspaceIDFromEvent(event abci.Event) (uint64, error) { - attribute, err := juno.FindAttributeByKey(event, subspacestypes.AttributeKeySubspaceID) - if err != nil { - return 0, err - } - return subspacestypes.ParseSubspaceID(attribute.Value) -} - // ParseTxEvents parses the given events using the given parsers func ParseTxEvents(tx *juno.Tx, eventsParsers map[string]func(tx *juno.Tx, event abci.Event) error) error { for _, event := range tx.Events { diff --git a/x/filters/messages.go b/x/filters/messages.go index 33bdea4d..1e82c171 100644 --- a/x/filters/messages.go +++ b/x/filters/messages.go @@ -4,9 +4,8 @@ import ( abci "github.com/cometbft/cometbft/abci/types" sdk "github.com/cosmos/cosmos-sdk/types" subspacestypes "github.com/desmos-labs/desmos/v6/x/subspaces/types" + "github.com/forbole/juno/v5/types" "github.com/forbole/juno/v5/types/config" - - "github.com/desmos-labs/athena/utils" ) var ( @@ -18,7 +17,18 @@ var ( func ShouldEventBeParsed(event abci.Event) bool { parseCfg() - subspaceID, err := utils.GetSubspaceIDFromEvent(event) + // Search either a 'subspace' or 'subspace_id' attribute + attribute, err := types.FindAttributeByKey(event, "subspace_id") + if err != nil { + attribute, err = types.FindAttributeByKey(event, "subspace") + } + + if err != nil { + return false + } + + // Parse the subspace id + subspaceID, err := subspacestypes.ParseSubspaceID(attribute.Value) if err != nil { return false } diff --git a/x/posts/handle_tx.go b/x/posts/handle_tx.go index fa1e5434..949130a8 100644 --- a/x/posts/handle_tx.go +++ b/x/posts/handle_tx.go @@ -5,13 +5,15 @@ import ( poststypes "github.com/desmos-labs/desmos/v6/x/posts/types" juno "github.com/forbole/juno/v5/types" + "github.com/desmos-labs/athena/utils/events" + "github.com/desmos-labs/athena/utils/transactions" + "github.com/desmos-labs/athena/types" - "github.com/desmos-labs/athena/utils" ) // HandleTx handles the transaction events func (m *Module) HandleTx(tx *juno.Tx) error { - return utils.ParseTxEvents(tx, map[string]func(tx *juno.Tx, event abci.Event) error{ + return transactions.ParseTxEvents(tx, map[string]func(tx *juno.Tx, event abci.Event) error{ poststypes.EventTypeCreatePost: m.parseCreatePostEvent, poststypes.EventTypeEditPost: m.parseEditPostEvent, poststypes.EventTypeDeletePost: m.parseDeletePostEvent, @@ -25,7 +27,7 @@ func (m *Module) HandleTx(tx *juno.Tx) error { // parseCreatePostEvent handles the creation of a new post func (m *Module) parseCreatePostEvent(tx *juno.Tx, event abci.Event) error { - subspaceID, err := utils.GetSubspaceIDFromEvent(event) + subspaceID, err := events.GetSubspaceIDFromEvent(event) if err != nil { return err } @@ -53,7 +55,7 @@ func (m *Module) parseCreatePostEvent(tx *juno.Tx, event abci.Event) error { // parseEditPostEvent handles the edition of an existing post func (m *Module) parseEditPostEvent(tx *juno.Tx, event abci.Event) error { - subspaceID, err := utils.GetSubspaceIDFromEvent(event) + subspaceID, err := events.GetSubspaceIDFromEvent(event) if err != nil { return err } @@ -75,7 +77,7 @@ func (m *Module) parseEditPostEvent(tx *juno.Tx, event abci.Event) error { // parseDeletePostEvent handles the deletion of an existing post func (m *Module) parseDeletePostEvent(tx *juno.Tx, event abci.Event) error { - subspaceID, err := utils.GetSubspaceIDFromEvent(event) + subspaceID, err := events.GetSubspaceIDFromEvent(event) if err != nil { return err } @@ -90,7 +92,7 @@ func (m *Module) parseDeletePostEvent(tx *juno.Tx, event abci.Event) error { // parseAddPostReactionEvent handles the addition of a reaction to an existing post func (m *Module) parseAddPostAttachmentEvent(tx *juno.Tx, event abci.Event) error { - subspaceID, err := utils.GetSubspaceIDFromEvent(event) + subspaceID, err := events.GetSubspaceIDFromEvent(event) if err != nil { return err } @@ -112,7 +114,7 @@ func (m *Module) parseAddPostAttachmentEvent(tx *juno.Tx, event abci.Event) erro // parseRemovePostAttachmentEvent handles the removal of a reaction from an existing post func (m *Module) parseRemovePostAttachmentEvent(tx *juno.Tx, event abci.Event) error { - subspaceID, err := utils.GetSubspaceIDFromEvent(event) + subspaceID, err := events.GetSubspaceIDFromEvent(event) if err != nil { return err } @@ -139,7 +141,7 @@ func (m *Module) parseRemovePostAttachmentEvent(tx *juno.Tx, event abci.Event) e // parseAnswerPollEvent handles the answer to a poll func (m *Module) parseAnswerPollEvent(tx *juno.Tx, event abci.Event) error { - subspaceID, err := utils.GetSubspaceIDFromEvent(event) + subspaceID, err := events.GetSubspaceIDFromEvent(event) if err != nil { return err } diff --git a/x/profiles/handle_tx.go b/x/profiles/handle_tx.go index 558c670f..d380b3f4 100644 --- a/x/profiles/handle_tx.go +++ b/x/profiles/handle_tx.go @@ -5,13 +5,14 @@ import ( profilestypes "github.com/desmos-labs/desmos/v6/x/profiles/types" juno "github.com/forbole/juno/v5/types" + "github.com/desmos-labs/athena/utils/transactions" + "github.com/desmos-labs/athena/types" - "github.com/desmos-labs/athena/utils" ) // HandleTx implements modules.TransactionModule func (m *Module) HandleTx(tx *juno.Tx) error { - return utils.ParseTxEvents(tx, map[string]func(tx *juno.Tx, event abci.Event) error{ + return transactions.ParseTxEvents(tx, map[string]func(tx *juno.Tx, event abci.Event) error{ profilestypes.EventTypeProfileSaved: m.parseSaveProfileEvent, profilestypes.EventTypeProfileDeleted: m.parseDeleteProfileEvent, profilestypes.EventTypeDTagTransferRequest: m.parseRequestDTagTransferEvent, diff --git a/x/reactions/handle_tx.go b/x/reactions/handle_tx.go index 0a37bb1b..bf56fe6c 100644 --- a/x/reactions/handle_tx.go +++ b/x/reactions/handle_tx.go @@ -5,12 +5,14 @@ import ( reactionstypes "github.com/desmos-labs/desmos/v6/x/reactions/types" juno "github.com/forbole/juno/v5/types" - "github.com/desmos-labs/athena/utils" + "github.com/desmos-labs/athena/utils/events" + "github.com/desmos-labs/athena/utils/transactions" + "github.com/desmos-labs/athena/x/posts" ) func (m *Module) HandleTx(tx *juno.Tx) error { - return utils.ParseTxEvents(tx, map[string]func(tx *juno.Tx, event abci.Event) error{ + return transactions.ParseTxEvents(tx, map[string]func(tx *juno.Tx, event abci.Event) error{ reactionstypes.EventTypeAddReaction: m.parseAddReactionEvent, reactionstypes.EventTypeRemoveReaction: m.parseRemoveReactionEvent, reactionstypes.EventTypeAddRegisteredReaction: m.parseAddRegisteredReactionEvent, @@ -24,7 +26,7 @@ func (m *Module) HandleTx(tx *juno.Tx) error { // parseAddReactionEvent parses a reaction add event func (m *Module) parseAddReactionEvent(tx *juno.Tx, event abci.Event) error { - subspaceID, err := utils.GetSubspaceIDFromEvent(event) + subspaceID, err := events.GetSubspaceIDFromEvent(event) if err != nil { return err } @@ -49,7 +51,7 @@ func (m *Module) parseAddReactionEvent(tx *juno.Tx, event abci.Event) error { // parseRemoveReactionEvent parses a reaction remove event func (m *Module) parseRemoveReactionEvent(tx *juno.Tx, event abci.Event) error { - subspaceID, err := utils.GetSubspaceIDFromEvent(event) + subspaceID, err := events.GetSubspaceIDFromEvent(event) if err != nil { return err } @@ -69,7 +71,7 @@ func (m *Module) parseRemoveReactionEvent(tx *juno.Tx, event abci.Event) error { // parseAddRegisteredReactionEvent parses a registered reaction add event func (m *Module) parseAddRegisteredReactionEvent(tx *juno.Tx, event abci.Event) error { - subspaceID, err := utils.GetSubspaceIDFromEvent(event) + subspaceID, err := events.GetSubspaceIDFromEvent(event) if err != nil { return err } @@ -84,7 +86,7 @@ func (m *Module) parseAddRegisteredReactionEvent(tx *juno.Tx, event abci.Event) // parseEditRegisteredReactionEvent parses a registered reaction edit event func (m *Module) parseEditRegisteredReactionEvent(tx *juno.Tx, event abci.Event) error { - subspaceID, err := utils.GetSubspaceIDFromEvent(event) + subspaceID, err := events.GetSubspaceIDFromEvent(event) if err != nil { return err } @@ -99,7 +101,7 @@ func (m *Module) parseEditRegisteredReactionEvent(tx *juno.Tx, event abci.Event) // parseRemoveRegisteredReactionEvent parses a registered reaction remove event func (m *Module) parseRemoveRegisteredReactionEvent(tx *juno.Tx, event abci.Event) error { - subspaceID, err := utils.GetSubspaceIDFromEvent(event) + subspaceID, err := events.GetSubspaceIDFromEvent(event) if err != nil { return err } @@ -114,7 +116,7 @@ func (m *Module) parseRemoveRegisteredReactionEvent(tx *juno.Tx, event abci.Even // parseSetReactionsParamsEvent parses a set reactions params event func (m *Module) parseSetReactionsParamsEvent(tx *juno.Tx, event abci.Event) error { - subspaceID, err := utils.GetSubspaceIDFromEvent(event) + subspaceID, err := events.GetSubspaceIDFromEvent(event) if err != nil { return err } diff --git a/x/reports/handle_tx.go b/x/reports/handle_tx.go index 62b631a8..52b985c2 100644 --- a/x/reports/handle_tx.go +++ b/x/reports/handle_tx.go @@ -5,12 +5,13 @@ import ( reportstypes "github.com/desmos-labs/desmos/v6/x/reports/types" juno "github.com/forbole/juno/v5/types" - "github.com/desmos-labs/athena/utils" + "github.com/desmos-labs/athena/utils/events" + "github.com/desmos-labs/athena/utils/transactions" ) // HandleTx implements modules.TransactionModule func (m *Module) HandleTx(tx *juno.Tx) error { - return utils.ParseTxEvents(tx, map[string]func(tx *juno.Tx, event abci.Event) error{ + return transactions.ParseTxEvents(tx, map[string]func(tx *juno.Tx, event abci.Event) error{ reportstypes.EventTypeCreateReport: m.parseCreateReportEvent, reportstypes.EventTypeDeleteReport: m.parseDeleteReportEvent, reportstypes.EventTypeAddReason: m.parseAddReasonEvent, @@ -23,7 +24,7 @@ func (m *Module) HandleTx(tx *juno.Tx) error { // parseCreateReportEvent handles a create report event func (m *Module) parseCreateReportEvent(tx *juno.Tx, event abci.Event) error { - subspaceID, err := utils.GetSubspaceIDFromEvent(event) + subspaceID, err := events.GetSubspaceIDFromEvent(event) if err != nil { return err } @@ -38,7 +39,7 @@ func (m *Module) parseCreateReportEvent(tx *juno.Tx, event abci.Event) error { // parseDeleteReportEvent handles a delete report event func (m *Module) parseDeleteReportEvent(tx *juno.Tx, event abci.Event) error { - subspaceID, err := utils.GetSubspaceIDFromEvent(event) + subspaceID, err := events.GetSubspaceIDFromEvent(event) if err != nil { return err } @@ -53,7 +54,7 @@ func (m *Module) parseDeleteReportEvent(tx *juno.Tx, event abci.Event) error { // parseAddReasonEvent handles an add reason event func (m *Module) parseAddReasonEvent(tx *juno.Tx, event abci.Event) error { - subspaceID, err := utils.GetSubspaceIDFromEvent(event) + subspaceID, err := events.GetSubspaceIDFromEvent(event) if err != nil { return err } @@ -68,7 +69,7 @@ func (m *Module) parseAddReasonEvent(tx *juno.Tx, event abci.Event) error { // parseSupportStandardReasonEvent handles a support standard reason event func (m *Module) parseSupportStandardReasonEvent(tx *juno.Tx, event abci.Event) error { - subspaceID, err := utils.GetSubspaceIDFromEvent(event) + subspaceID, err := events.GetSubspaceIDFromEvent(event) if err != nil { return err } @@ -83,7 +84,7 @@ func (m *Module) parseSupportStandardReasonEvent(tx *juno.Tx, event abci.Event) // parseRemoveReasonEvent handles a remove reason event func (m *Module) parseRemoveReasonEvent(tx *juno.Tx, event abci.Event) error { - subspaceID, err := utils.GetSubspaceIDFromEvent(event) + subspaceID, err := events.GetSubspaceIDFromEvent(event) if err != nil { return err } From a7b4804f67a28e87a17407bd589a3101a2f4bbe0 Mon Sep 17 00:00:00 2001 From: Riccardo Montagnin Date: Fri, 19 Jan 2024 16:13:09 +0100 Subject: [PATCH 13/15] feat: parse relationships event instead of messages --- x/relationships/handle_msg.go | 90 --------------------------- x/relationships/handle_tx.go | 111 ++++++++++++++++++++++++++++++++++ x/relationships/module.go | 8 +-- x/relationships/utils.go | 84 +++++++++++++++++++++++++ 4 files changed, 199 insertions(+), 94 deletions(-) delete mode 100644 x/relationships/handle_msg.go create mode 100644 x/relationships/handle_tx.go create mode 100644 x/relationships/utils.go diff --git a/x/relationships/handle_msg.go b/x/relationships/handle_msg.go deleted file mode 100644 index c9e845b3..00000000 --- a/x/relationships/handle_msg.go +++ /dev/null @@ -1,90 +0,0 @@ -package relationships - -import ( - "github.com/desmos-labs/athena/x/filters" - - "github.com/cosmos/cosmos-sdk/x/authz" - - relationshipstypes "github.com/desmos-labs/desmos/v6/x/relationships/types" - - "github.com/rs/zerolog/log" - - sdk "github.com/cosmos/cosmos-sdk/types" - juno "github.com/forbole/juno/v5/types" - - "github.com/desmos-labs/athena/types" -) - -// HandleMsgExec implements modules.AuthzMessageModule -func (m *Module) HandleMsgExec(index int, _ *authz.MsgExec, _ int, executedMsg sdk.Msg, tx *juno.Tx) error { - return m.HandleMsg(index, executedMsg, tx) -} - -// HandleMsg implements modules.MessageModule -func (m *Module) HandleMsg(_ int, msg sdk.Msg, tx *juno.Tx) error { - if len(tx.Logs) == 0 || !filters.ShouldMsgBeParsed(msg) { - return nil - } - - switch desmosMsg := msg.(type) { - - case *relationshipstypes.MsgCreateRelationship: - return m.handleMsgCreateRelationship(tx, desmosMsg) - - case *relationshipstypes.MsgDeleteRelationship: - return m.handleMsgDeleteRelationship(tx, desmosMsg) - - case *relationshipstypes.MsgBlockUser: - return m.handleMsgBlockUser(tx, desmosMsg) - - case *relationshipstypes.MsgUnblockUser: - return m.handleMsgUnblockUser(tx, desmosMsg) - - } - - log.Debug().Str("module", "relationships").Str("message", sdk.MsgTypeURL(msg)). - Int64("height", tx.Height).Msg("handled message") - - return nil -} - -// ----------------------------------------------------------------------------------------------------- - -// handleMsgCreateRelationship allows to handle a MsgCreateRelationship properly -func (m *Module) handleMsgCreateRelationship(tx *juno.Tx, msg *relationshipstypes.MsgCreateRelationship) error { - return m.db.SaveRelationship(types.NewRelationship( - relationshipstypes.NewRelationship(msg.Signer, msg.Counterparty, msg.SubspaceID), - tx.Height, - )) -} - -// handleMsgDeleteRelationship allows to handle a MsgDeleteRelationship properly -func (m *Module) handleMsgDeleteRelationship(tx *juno.Tx, msg *relationshipstypes.MsgDeleteRelationship) error { - return m.db.DeleteRelationship(types.NewRelationship( - relationshipstypes.NewRelationship(msg.Signer, msg.Counterparty, msg.SubspaceID), - tx.Height, - )) -} - -// ----------------------------------------------------------------------------------------------------- - -// handleMsgBlockUser allows to handle a MsgBlockUser properly -func (m *Module) handleMsgBlockUser(tx *juno.Tx, msg *relationshipstypes.MsgBlockUser) error { - return m.db.SaveUserBlock(types.NewBlockage( - relationshipstypes.NewUserBlock( - msg.Blocker, - msg.Blocked, - msg.Reason, - msg.SubspaceID, - ), - tx.Height, - )) -} - -// handleMsgUnblockUser allows to handle a MsgUnblockUser properly -func (m *Module) handleMsgUnblockUser(tx *juno.Tx, msg *relationshipstypes.MsgUnblockUser) error { - return m.db.DeleteBlockage(types.NewBlockage( - relationshipstypes.NewUserBlock(msg.Blocker, msg.Blocked, "", msg.SubspaceID), - tx.Height, - )) -} diff --git a/x/relationships/handle_tx.go b/x/relationships/handle_tx.go new file mode 100644 index 00000000..65fb4d7f --- /dev/null +++ b/x/relationships/handle_tx.go @@ -0,0 +1,111 @@ +package relationships + +import ( + abci "github.com/cometbft/cometbft/abci/types" + relationshipstypes "github.com/desmos-labs/desmos/v6/x/relationships/types" + juno "github.com/forbole/juno/v5/types" + + "github.com/desmos-labs/athena/utils/transactions" + + "github.com/desmos-labs/athena/types" +) + +func (m *Module) HandleTx(tx *juno.Tx) error { + return transactions.ParseTxEvents(tx, map[string]func(tx *juno.Tx, event abci.Event) error{ + relationshipstypes.EventTypeRelationshipCreated: m.parseCreateRelationshipEvent, + relationshipstypes.EventTypeRelationshipDeleted: m.parseDeleteRelationshipEvent, + relationshipstypes.EventTypeBlockUser: m.parseBlockUserEvent, + relationshipstypes.EventTypeUnblockUser: m.parseUnblockUserEvent, + }) +} + +// -------------------------------------------------------------------------------------------------------------------- + +// parseCreateRelationshipEvent allows to properly handle a relationship creation event +func (m *Module) parseCreateRelationshipEvent(tx *juno.Tx, event abci.Event) error { + subspace, err := GetSubspaceFromEvent(event) + if err != nil { + return err + } + + creator, err := GetCreatorFromEvent(event) + if err != nil { + return err + } + + counterparty, err := GetCounterpartyFromEvent(event) + if err != nil { + return err + } + + return m.db.SaveRelationship(types.NewRelationship( + relationshipstypes.NewRelationship(creator, counterparty, subspace), + tx.Height, + )) +} + +// parseDeleteRelationshipEvent allows to properly handle a relationship deletion event +func (m *Module) parseDeleteRelationshipEvent(tx *juno.Tx, event abci.Event) error { + subspace, err := GetSubspaceFromEvent(event) + if err != nil { + return err + } + + creator, err := GetCreatorFromEvent(event) + if err != nil { + return err + } + + counterparty, err := GetCounterpartyFromEvent(event) + if err != nil { + return err + } + + return m.db.DeleteRelationship(types.NewRelationship( + relationshipstypes.NewRelationship(creator, counterparty, subspace), + tx.Height, + )) +} + +// parseBlockUserEvent allows to properly handle a user block event +func (m *Module) parseBlockUserEvent(tx *juno.Tx, event abci.Event) error { + subspace, err := GetSubspaceFromEvent(event) + if err != nil { + return err + } + + blocker, err := GetBlockerFromEvent(event) + if err != nil { + return err + } + + blocked, err := GetBlockedFromEvent(event) + if err != nil { + return err + } + + return m.updateUserBlock(tx.Height, subspace, blocker, blocked) +} + +// parseUnblockUserEvent allows to properly handle a user unblock event +func (m *Module) parseUnblockUserEvent(tx *juno.Tx, event abci.Event) error { + subspace, err := GetSubspaceFromEvent(event) + if err != nil { + return err + } + + blocker, err := GetBlockerFromEvent(event) + if err != nil { + return err + } + + blocked, err := GetBlockedFromEvent(event) + if err != nil { + return err + } + + return m.db.DeleteBlockage(types.NewBlockage( + relationshipstypes.NewUserBlock(blocker, blocked, "", subspace), + tx.Height, + )) +} diff --git a/x/relationships/module.go b/x/relationships/module.go index 94c6ae5a..cb6f7e48 100644 --- a/x/relationships/module.go +++ b/x/relationships/module.go @@ -10,12 +10,12 @@ import ( ) var ( - _ modules.Module = &Module{} - _ modules.GenesisModule = &Module{} - _ modules.MessageModule = &Module{} + _ modules.Module = &Module{} + _ modules.GenesisModule = &Module{} + _ modules.TransactionModule = &Module{} ) -// Module represents the x/profiles module handler +// Module represents the x/relationships module handler type Module struct { cdc codec.Codec db Database diff --git a/x/relationships/utils.go b/x/relationships/utils.go new file mode 100644 index 00000000..db109115 --- /dev/null +++ b/x/relationships/utils.go @@ -0,0 +1,84 @@ +package relationships + +import ( + "context" + + abci "github.com/cometbft/cometbft/abci/types" + relationshipstypes "github.com/desmos-labs/desmos/v6/x/relationships/types" + subspacestypes "github.com/desmos-labs/desmos/v6/x/subspaces/types" + "github.com/forbole/juno/v5/types/utils" + + "github.com/desmos-labs/athena/types" +) + +func GetSubspaceFromEvent(event abci.Event) (uint64, error) { + subspaceAttr, err := utils.FindAttributeByKey(event, relationshipstypes.AttributeKeySubspace) + if err != nil { + return 0, err + } + + subspaceID, err := subspacestypes.ParseSubspaceID(subspaceAttr.Value) + if err != nil { + return 0, err + } + + return subspaceID, nil +} + +// GetCreatorFromEvent returns the creator of the relationship from the given event +func GetCreatorFromEvent(event abci.Event) (string, error) { + creatorAttr, err := utils.FindAttributeByKey(event, relationshipstypes.AttributeRelationshipCreator) + if err != nil { + return "", err + } + return creatorAttr.Value, nil +} + +// GetCounterpartyFromEvent returns the counterparty of the relationship from the given event +func GetCounterpartyFromEvent(event abci.Event) (string, error) { + counterpartyAttr, err := utils.FindAttributeByKey(event, relationshipstypes.AttributeRelationshipCounterparty) + if err != nil { + return "", err + } + return counterpartyAttr.Value, nil +} + +// GetBlockerFromEvent returns the blocker of the user block from the given event +func GetBlockerFromEvent(event abci.Event) (string, error) { + blockerAttr, err := utils.FindAttributeByKey(event, relationshipstypes.AttributeKeyUserBlockBlocker) + if err != nil { + return "", err + } + return blockerAttr.Value, nil +} + +// GetBlockedFromEvent returns the blocked of the user block from the given event +func GetBlockedFromEvent(event abci.Event) (string, error) { + blockedAttr, err := utils.FindAttributeByKey(event, relationshipstypes.AttributeKeyUserBlockBlocked) + if err != nil { + return "", err + } + return blockedAttr.Value, nil +} + +// -------------------------------------------------------------------------------------------------------------------- + +func (m *Module) updateUserBlock(height int64, subspaceID uint64, blocker, blocked string) error { + blocks, err := m.client.Blocks(context.Background(), &relationshipstypes.QueryBlocksRequest{ + SubspaceId: subspaceID, + Blocker: blocker, + Blocked: blocked, + }) + if err != nil { + return err + } + + for _, block := range blocks.Blocks { + err = m.db.SaveUserBlock(types.NewBlockage(block, height)) + if err != nil { + return err + } + } + + return nil +} From d8c79f2c36b7f34b758a1373113bc922903db7ab Mon Sep 17 00:00:00 2001 From: Riccardo Montagnin Date: Tue, 23 Jan 2024 08:56:18 +0100 Subject: [PATCH 14/15] refactor: parse subspaces instead of messages --- x/authz/handle_msg.go | 2 +- x/subspaces/handle_msg.go | 221 -------------------------------- x/subspaces/handle_tx.go | 258 ++++++++++++++++++++++++++++++++++++++ x/subspaces/module.go | 6 +- x/subspaces/utils.go | 81 ++++++++++-- 5 files changed, 332 insertions(+), 236 deletions(-) delete mode 100644 x/subspaces/handle_msg.go create mode 100644 x/subspaces/handle_tx.go diff --git a/x/authz/handle_msg.go b/x/authz/handle_msg.go index 29844df4..76096d34 100644 --- a/x/authz/handle_msg.go +++ b/x/authz/handle_msg.go @@ -11,7 +11,7 @@ import ( ) // HandleMsg implements modules.MessageModule -func (m *Module) HandleMsg(index int, msg sdk.Msg, tx *juno.Tx) error { +func (m *Module) HandleMsg(_ int, msg sdk.Msg, tx *juno.Tx) error { if len(tx.Logs) == 0 { return nil } diff --git a/x/subspaces/handle_msg.go b/x/subspaces/handle_msg.go deleted file mode 100644 index 9ed55e5f..00000000 --- a/x/subspaces/handle_msg.go +++ /dev/null @@ -1,221 +0,0 @@ -package subspaces - -import ( - "github.com/cosmos/cosmos-sdk/x/authz" - - "github.com/desmos-labs/athena/x/filters" - - "github.com/rs/zerolog/log" - - sdk "github.com/cosmos/cosmos-sdk/types" - juno "github.com/forbole/juno/v5/types" - - subspacestypes "github.com/desmos-labs/desmos/v6/x/subspaces/types" - - "github.com/desmos-labs/athena/types" -) - -// HandleMsgExec implements modules.AuthzMessageModule -func (m *Module) HandleMsgExec(index int, _ *authz.MsgExec, _ int, executedMsg sdk.Msg, tx *juno.Tx) error { - return m.HandleMsg(index, executedMsg, tx) -} - -// HandleMsg implements modules.MessageModule -func (m *Module) HandleMsg(index int, msg sdk.Msg, tx *juno.Tx) error { - if len(tx.Logs) == 0 || !filters.ShouldMsgBeParsed(msg) { - return nil - } - - switch desmosMsg := msg.(type) { - case *subspacestypes.MsgCreateSubspace: - return m.handleMsgCreateSubspace(tx, index) - - case *subspacestypes.MsgEditSubspace: - return m.handleMsgEditSubspace(tx, desmosMsg) - - case *subspacestypes.MsgDeleteSubspace: - return m.handleMsgDeleteSubspace(tx, desmosMsg) - - case *subspacestypes.MsgCreateSection: - return m.handleMsgCreateSection(tx, index, desmosMsg) - - case *subspacestypes.MsgEditSection: - return m.handleMsgEditSection(tx, desmosMsg) - - case *subspacestypes.MsgMoveSection: - return m.handleMsgMoveSection(tx, desmosMsg) - - case *subspacestypes.MsgDeleteSection: - return m.handleMsgDeleteSection(tx, desmosMsg) - - case *subspacestypes.MsgCreateUserGroup: - return m.handleMsgCreateUserGroup(tx, index, desmosMsg) - - case *subspacestypes.MsgEditUserGroup: - return m.handleMsgEditUserGroup(tx, desmosMsg) - - case *subspacestypes.MsgMoveUserGroup: - return m.handleMsgMoveUserGroup(tx, desmosMsg) - - case *subspacestypes.MsgSetUserGroupPermissions: - return m.handleMsgSetUserGroupPermissions(tx, desmosMsg) - - case *subspacestypes.MsgDeleteUserGroup: - return m.handleMsgDeleteUserGroup(tx, desmosMsg) - - case *subspacestypes.MsgAddUserToUserGroup: - return m.handleMsgAddUserToUserGroup(tx, desmosMsg) - - case *subspacestypes.MsgRemoveUserFromUserGroup: - return m.handleMsgRemoveUserFromUserGroup(tx, desmosMsg) - - case *subspacestypes.MsgSetUserPermissions: - return m.handleMsgSetUserPermissions(tx, desmosMsg) - } - - log.Debug().Str("module", "subspaces").Str("message", sdk.MsgTypeURL(msg)). - Int64("height", tx.Height).Msg("handled message") - - return nil -} - -// ------------------------------------------------------------------------------------------------------------------- - -// handleMsgCreateSubspace handles a MsgCreateSubspace -func (m *Module) handleMsgCreateSubspace(tx *juno.Tx, index int) error { - // Get the subspace id - event, err := tx.FindEventByType(index, subspacestypes.EventTypeCreateSubspace) - if err != nil { - return err - } - subspaceIDStr, err := tx.FindAttributeByKey(event, subspacestypes.AttributeKeySubspaceID) - if err != nil { - return err - } - subspaceID, err := subspacestypes.ParseSubspaceID(subspaceIDStr) - if err != nil { - return err - } - - return m.RefreshSubspaceData(tx.Height, subspaceID) -} - -// handleMsgEditSubspace handles a MsgEditSubspace -func (m *Module) handleMsgEditSubspace(tx *juno.Tx, msg *subspacestypes.MsgEditSubspace) error { - return m.updateSubspace(tx.Height, msg.SubspaceID) -} - -// handleMsgDeleteSubspace handles a MsgDeleteSubspace -func (m *Module) handleMsgDeleteSubspace(tx *juno.Tx, msg *subspacestypes.MsgDeleteSubspace) error { - return m.db.DeleteSubspace(tx.Height, msg.SubspaceID) -} - -// ----------------------------------------------------------------------------------------------------- - -// handleMsgCreateSection handles a MsgCreateSection -func (m *Module) handleMsgCreateSection(tx *juno.Tx, index int, msg *subspacestypes.MsgCreateSection) error { - // Get the subspace id - event, err := tx.FindEventByType(index, subspacestypes.EventTypeCreateSection) - if err != nil { - return err - } - sectionIDStr, err := tx.FindAttributeByKey(event, subspacestypes.AttributeKeySectionID) - if err != nil { - return err - } - sectionID, err := subspacestypes.ParseSectionID(sectionIDStr) - if err != nil { - return err - } - - return m.updateSection(tx.Height, msg.SubspaceID, sectionID) -} - -// handleMsgEditSection handles a MsgEditSection -func (m *Module) handleMsgEditSection(tx *juno.Tx, msg *subspacestypes.MsgEditSection) error { - return m.updateSection(tx.Height, msg.SubspaceID, msg.SectionID) -} - -// handleMsgMoveSection handles a MsgMoveSection -func (m *Module) handleMsgMoveSection(tx *juno.Tx, msg *subspacestypes.MsgMoveSection) error { - return m.updateSection(tx.Height, msg.SubspaceID, msg.SectionID) -} - -// handleMsgDeleteSection handles a MsgDeleteSection -func (m *Module) handleMsgDeleteSection(tx *juno.Tx, msg *subspacestypes.MsgDeleteSection) error { - return m.db.DeleteSection(tx.Height, msg.SubspaceID, msg.SectionID) -} - -// ----------------------------------------------------------------------------------------------------- - -// handleMsgCreateUserGroup handles a MsgCreateUserGroup -func (m *Module) handleMsgCreateUserGroup(tx *juno.Tx, index int, msg *subspacestypes.MsgCreateUserGroup) error { - // Get the group id - event, err := tx.FindEventByType(index, subspacestypes.EventTypeCreateUserGroup) - if err != nil { - return err - } - groupIDStr, err := tx.FindAttributeByKey(event, subspacestypes.AttributeKeyUserGroupID) - if err != nil { - return err - } - groupID, err := subspacestypes.ParseGroupID(groupIDStr) - if err != nil { - return err - } - - // Update the user group - err = m.updateUserGroup(tx.Height, msg.SubspaceID, groupID) - if err != nil { - return err - } - - // Handle initial members - for _, member := range msg.InitialMembers { - err = m.db.AddUserToGroup(types.NewUserGroupMember(msg.SubspaceID, groupID, member, tx.Height)) - if err != nil { - return err - } - } - - return nil -} - -// handleMsgEditUserGroup handles a MsgEditUserGroup -func (m *Module) handleMsgEditUserGroup(tx *juno.Tx, msg *subspacestypes.MsgEditUserGroup) error { - return m.updateUserGroup(tx.Height, msg.SubspaceID, msg.GroupID) -} - -// handleMsgMoveUserGroup handles a MsgMoveUserGroup -func (m *Module) handleMsgMoveUserGroup(tx *juno.Tx, msg *subspacestypes.MsgMoveUserGroup) error { - return m.updateUserGroup(tx.Height, msg.SubspaceID, msg.GroupID) -} - -// handleMsgSetUserGroupPermissions handles a MsgSetUserGroupPermissions properly -func (m *Module) handleMsgSetUserGroupPermissions(tx *juno.Tx, msg *subspacestypes.MsgSetUserGroupPermissions) error { - return m.updateUserGroup(tx.Height, msg.SubspaceID, msg.GroupID) -} - -// handleMsgDeleteUserGroup handles a MsgDeleteUserGroup -func (m *Module) handleMsgDeleteUserGroup(tx *juno.Tx, msg *subspacestypes.MsgDeleteUserGroup) error { - return m.db.DeleteUserGroup(tx.Height, msg.SubspaceID, msg.GroupID) -} - -// ----------------------------------------------------------------------------------------------------- - -// handleMsgAddUserToUserGroup handles a MsgAddUserToUserGroup -func (m *Module) handleMsgAddUserToUserGroup(tx *juno.Tx, msg *subspacestypes.MsgAddUserToUserGroup) error { - return m.db.AddUserToGroup(types.NewUserGroupMember(msg.SubspaceID, msg.GroupID, msg.User, tx.Height)) -} - -// handleMsgRemoveUserFromUserGroup handles a MsgRemoveUserFromUserGroup -func (m *Module) handleMsgRemoveUserFromUserGroup(tx *juno.Tx, msg *subspacestypes.MsgRemoveUserFromUserGroup) error { - return m.db.RemoveUserFromGroup(types.NewUserGroupMember(msg.SubspaceID, msg.GroupID, msg.User, tx.Height)) -} - -// ----------------------------------------------------------------------------------------------------- - -// handleMsgSetUserPermissions handles a MsgSetUserPermissions -func (m *Module) handleMsgSetUserPermissions(tx *juno.Tx, msg *subspacestypes.MsgSetUserPermissions) error { - return m.updateUserPermissions(tx.Height, msg.SubspaceID, msg.SectionID, msg.User) -} diff --git a/x/subspaces/handle_tx.go b/x/subspaces/handle_tx.go new file mode 100644 index 00000000..9e0cdf3d --- /dev/null +++ b/x/subspaces/handle_tx.go @@ -0,0 +1,258 @@ +package subspaces + +import ( + abci "github.com/cometbft/cometbft/abci/types" + subspacestypes "github.com/desmos-labs/desmos/v6/x/subspaces/types" + juno "github.com/forbole/juno/v5/types" + + "github.com/desmos-labs/athena/types" + "github.com/desmos-labs/athena/utils/transactions" +) + +func (m *Module) HandleTx(tx *juno.Tx) error { + return transactions.ParseTxEvents(tx, map[string]func(tx *juno.Tx, event abci.Event) error{ + subspacestypes.EventTypeCreateSubspace: m.handleCreateSubspaceEvent, + subspacestypes.EventTypeEditSubspace: m.handleEditSubspaceEvent, + subspacestypes.EventTypeDeleteSubspace: m.handleDeleteSubspaceEvent, + + subspacestypes.EventTypeCreateSection: m.handleCreateSectionEvent, + subspacestypes.EventTypeEditSection: m.handleEditSectionEvent, + subspacestypes.EventTypeMoveSection: m.handleMoveSectionEvent, + subspacestypes.EventTypeDeleteSection: m.handleDeleteSectionEvent, + + subspacestypes.EventTypeCreateUserGroup: m.handleCreateUserGroupEvent, + subspacestypes.EventTypeEditUserGroup: m.handleEditUserGroupEvent, + subspacestypes.EvenTypeMoveUserGroup: m.handleMoveUserGroupEvent, + subspacestypes.EventTypeSetUserGroupPermissions: m.handleSetUserGroupPermissionsEvent, + subspacestypes.EventTypeDeleteUserGroup: m.handleDeleteUserGroupEvent, + + subspacestypes.EventTypeAddUserToGroup: m.handleAddUserToGroupEvent, + subspacestypes.EventTypeRemoveUserFromGroup: m.handleRemoveUserFromGroupEvent, + + subspacestypes.EventTypeSetUserPermissions: m.handleSetUserPermissionsEvent, + }) +} + +// -------------------------------------------------------------------------------------------------------------------- + +// handleCreateSubspaceEvent handles the creation of a new subspace +func (m *Module) handleCreateSubspaceEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + + return m.RefreshSubspaceData(tx.Height, subspaceID) +} + +// handleEditSubspaceEvent handles the edit of an existing subspace +func (m *Module) handleEditSubspaceEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + + return m.updateSubspace(tx.Height, subspaceID) +} + +// handleDeleteSubspaceEvent handles the deletion of an existing subspace +func (m *Module) handleDeleteSubspaceEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + + return m.db.DeleteSubspace(tx.Height, subspaceID) +} + +// -------------------------------------------------------------------------------------------------------------------- + +// handleCreateSectionEvent handles the creation of a new section +func (m *Module) handleCreateSectionEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + + sectionID, err := GetSectionIDFromEvent(event) + if err != nil { + return err + } + + return m.updateSection(tx.Height, subspaceID, sectionID) +} + +// handleEditSectionEvent handles the edit of an existing section +func (m *Module) handleEditSectionEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + + sectionID, err := GetSectionIDFromEvent(event) + if err != nil { + return err + } + + return m.updateSection(tx.Height, subspaceID, sectionID) +} + +func (m *Module) handleMoveSectionEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + + sectionID, err := GetSectionIDFromEvent(event) + if err != nil { + return err + } + + return m.updateSection(tx.Height, subspaceID, sectionID) +} + +// handleDeleteSectionEvent handles the deletion of an existing section +func (m *Module) handleDeleteSectionEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + + sectionID, err := GetSectionIDFromEvent(event) + if err != nil { + return err + } + + return m.db.DeleteSection(tx.Height, subspaceID, sectionID) +} + +// -------------------------------------------------------------------------------------------------------------------- + +// handleCreateUserGroupEvent handles the creation of a new user group +func (m *Module) handleCreateUserGroupEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + groupID, err := GetUserGroupIDFromEvent(event) + if err != nil { + return err + } + + // Update the user group + return m.updateUserGroup(tx.Height, subspaceID, groupID) +} + +// handleEditUserGroupEvent handles the edit of an existing user group +func (m *Module) handleEditUserGroupEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + groupID, err := GetUserGroupIDFromEvent(event) + if err != nil { + return err + } + + // Update the user group + return m.updateUserGroup(tx.Height, subspaceID, groupID) +} + +// handleMoveUserGroupEvent handles the move of an existing user group +func (m *Module) handleMoveUserGroupEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + groupID, err := GetUserGroupIDFromEvent(event) + if err != nil { + return err + } + + // Update the user group + return m.updateUserGroup(tx.Height, subspaceID, groupID) +} + +// handleSetUserGroupPermissionsEvent handles the setting of permissions for an existing user group +func (m *Module) handleSetUserGroupPermissionsEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + groupID, err := GetUserGroupIDFromEvent(event) + if err != nil { + return err + } + + // Update the user group + return m.updateUserGroup(tx.Height, subspaceID, groupID) +} + +// handleDeleteUserGroupEvent handles the deletion of an existing user group +func (m *Module) handleDeleteUserGroupEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + groupID, err := GetUserGroupIDFromEvent(event) + if err != nil { + return err + } + + // Update the user group + return m.db.DeleteUserGroup(tx.Height, subspaceID, groupID) +} + +// -------------------------------------------------------------------------------------------------------------------- + +// handleAddUserToGroupEvent handles the addition of a user to an existing user group +func (m *Module) handleAddUserToGroupEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + groupID, err := GetUserGroupIDFromEvent(event) + if err != nil { + return err + } + member, err := GetUserFromEvent(event) + if err != nil { + return err + } + + return m.db.AddUserToGroup(types.NewUserGroupMember(subspaceID, groupID, member, tx.Height)) +} + +// handleRemoveUserFromGroupEvent handles the removal of a user from an existing user group +func (m *Module) handleRemoveUserFromGroupEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + groupID, err := GetUserGroupIDFromEvent(event) + if err != nil { + return err + } + member, err := GetUserFromEvent(event) + if err != nil { + return err + } + + return m.db.RemoveUserFromGroup(types.NewUserGroupMember(subspaceID, groupID, member, tx.Height)) +} + +// -------------------------------------------------------------------------------------------------------------------- + +// handleSetUserPermissionsEvent handles the setting of permissions for an existing user +func (m *Module) handleSetUserPermissionsEvent(tx *juno.Tx, event abci.Event) error { + subspaceID, err := GetSubspaceIDFromEvent(event) + if err != nil { + return err + } + user, err := GetUserFromEvent(event) + if err != nil { + return err + } + + return m.updateUserPermissions(tx.Height, subspaceID, user) +} diff --git a/x/subspaces/module.go b/x/subspaces/module.go index 804fd370..a156c249 100644 --- a/x/subspaces/module.go +++ b/x/subspaces/module.go @@ -10,9 +10,9 @@ import ( ) var ( - _ modules.Module = &Module{} - _ modules.GenesisModule = &Module{} - _ modules.MessageModule = &Module{} + _ modules.Module = &Module{} + _ modules.GenesisModule = &Module{} + _ modules.TransactionModule = &Module{} ) // Module represents the x/fees module handler diff --git a/x/subspaces/utils.go b/x/subspaces/utils.go index 80f9aa07..4d73c7c6 100644 --- a/x/subspaces/utils.go +++ b/x/subspaces/utils.go @@ -3,6 +3,9 @@ package subspaces import ( "context" + abci "github.com/cometbft/cometbft/abci/types" + "github.com/forbole/juno/v5/types/utils" + "github.com/forbole/juno/v5/node/remote" subspacestypes "github.com/desmos-labs/desmos/v6/x/subspaces/types" @@ -10,6 +13,44 @@ import ( "github.com/desmos-labs/athena/types" ) +// GetSubspaceIDFromEvent returns the subspace ID from the given event +func GetSubspaceIDFromEvent(event abci.Event) (uint64, error) { + subspaceIDStr, err := utils.FindAttributeByKey(event, subspacestypes.AttributeKeySubspaceID) + if err != nil { + return 0, err + } + return subspacestypes.ParseSubspaceID(subspaceIDStr.Value) +} + +// GetSectionIDFromEvent returns the section ID from the given event +func GetSectionIDFromEvent(event abci.Event) (uint32, error) { + sectionIDStr, err := utils.FindAttributeByKey(event, subspacestypes.AttributeKeySectionID) + if err != nil { + return 0, err + } + return subspacestypes.ParseSectionID(sectionIDStr.Value) +} + +// GetUserGroupIDFromEvent returns the user group ID from the given event +func GetUserGroupIDFromEvent(event abci.Event) (uint32, error) { + groupIDStr, err := utils.FindAttributeByKey(event, subspacestypes.AttributeKeyUserGroupID) + if err != nil { + return 0, err + } + return subspacestypes.ParseGroupID(groupIDStr.Value) +} + +// GetUserFromEvent returns the user from the given event +func GetUserFromEvent(event abci.Event) (string, error) { + userStr, err := utils.FindAttributeByKey(event, subspacestypes.AttributeKeyUser) + if err != nil { + return "", err + } + return userStr.Value, nil +} + +// -------------------------------------------------------------------------------------------------------------------- + // updateSubspace updates the stored data for the given subspace at the specified height func (m *Module) updateSubspace(height int64, subspaceID uint64) error { // Get the subspace @@ -56,23 +97,41 @@ func (m *Module) updateUserGroup(height int64, subspaceID uint64, groupID uint32 } // updateUserPermissions updates the stored permissions for the given user at the specified height -func (m *Module) updateUserPermissions(height int64, subspaceID uint64, sectionID uint32, user string) error { - // Get the permissions - res, err := m.client.UserPermissions( +func (m *Module) updateUserPermissions(height int64, subspaceID uint64, user string) error { + // Get the sections + sectionsRes, err := m.client.Sections( remote.GetHeightRequestContext(context.Background(), height), - &subspacestypes.QueryUserPermissionsRequest{ + &subspacestypes.QuerySectionsRequest{ SubspaceId: subspaceID, - SectionId: sectionID, - User: user, }, ) if err != nil { return err } - // Save the user permissions - return m.db.SaveUserPermission(types.NewUserPermission( - subspacestypes.NewUserPermission(subspaceID, sectionID, user, res.Permissions), - height, - )) + for _, section := range sectionsRes.Sections { + // Get the permissions + res, err := m.client.UserPermissions( + remote.GetHeightRequestContext(context.Background(), height), + &subspacestypes.QueryUserPermissionsRequest{ + SubspaceId: subspaceID, + SectionId: section.ID, + User: user, + }, + ) + if err != nil { + return err + } + + // Save the user permissions + err = m.db.SaveUserPermission(types.NewUserPermission( + subspacestypes.NewUserPermission(subspaceID, section.ID, user, res.Permissions), + height, + )) + if err != nil { + return err + } + } + + return nil } From fbc371bb9d89355c4b376733e8d7a26c70a08467 Mon Sep 17 00:00:00 2001 From: Riccardo Montagnin Date: Tue, 23 Jan 2024 09:06:48 +0100 Subject: [PATCH 15/15] chore: added changeset entry --- ...4d4ce8b2f9fd99eb1424adbf626bd7e5a8c0b2083ba8575ca19.yaml | 6 ++++++ 1 file changed, 6 insertions(+) create mode 100644 .changeset/entries/fc893296400914d4ce8b2f9fd99eb1424adbf626bd7e5a8c0b2083ba8575ca19.yaml diff --git a/.changeset/entries/fc893296400914d4ce8b2f9fd99eb1424adbf626bd7e5a8c0b2083ba8575ca19.yaml b/.changeset/entries/fc893296400914d4ce8b2f9fd99eb1424adbf626bd7e5a8c0b2083ba8575ca19.yaml new file mode 100644 index 00000000..7c7f6344 --- /dev/null +++ b/.changeset/entries/fc893296400914d4ce8b2f9fd99eb1424adbf626bd7e5a8c0b2083ba8575ca19.yaml @@ -0,0 +1,6 @@ +type: feat +module: none +pull_request: 395 +description: Updated the parsing of data to rely on emitted events instead of messages +backward_compatible: true +date: 2024-01-23T08:06:35.693359413Z