community_event.go

package communities

import (
	"crypto/ecdsa"
	"encoding/json"
	"errors"
	"fmt"

	"github.com/golang/protobuf/proto"

	"github.com/status-im/status-go/eth-node/crypto"
	"github.com/status-im/status-go/protocol/protobuf"
)

type CommunityEvent struct {
	CommunityEventClock uint64                             `json:"communityEventClock"`
	Type                protobuf.CommunityEvent_EventType  `json:"type"`
	CommunityConfig     *protobuf.CommunityConfig          `json:"communityConfig,omitempty"`
	TokenPermission     *protobuf.CommunityTokenPermission `json:"tokenPermissions,omitempty"`
	CategoryData        *protobuf.CategoryData             `json:"categoryData,omitempty"`
	ChannelData         *protobuf.ChannelData              `json:"channelData,omitempty"`
	MemberToAction      string                             `json:"memberToAction,omitempty"`
	RequestToJoin       *protobuf.CommunityRequestToJoin   `json:"requestToJoin,omitempty"`
	TokenMetadata       *protobuf.CommunityTokenMetadata   `json:"tokenMetadata,omitempty"`
	Payload             []byte                             `json:"payload"`
	Signature           []byte                             `json:"signature"`
}

func (e *CommunityEvent) ToProtobuf() *protobuf.CommunityEvent {
	var acceptedRequestsToJoin map[string]*protobuf.CommunityRequestToJoin
	var rejectedRequestsToJoin map[string]*protobuf.CommunityRequestToJoin

	switch e.Type {
	case protobuf.CommunityEvent_COMMUNITY_REQUEST_TO_JOIN_ACCEPT:
		acceptedRequestsToJoin = make(map[string]*protobuf.CommunityRequestToJoin)
		acceptedRequestsToJoin[e.MemberToAction] = e.RequestToJoin
	case protobuf.CommunityEvent_COMMUNITY_REQUEST_TO_JOIN_REJECT:
		rejectedRequestsToJoin = make(map[string]*protobuf.CommunityRequestToJoin)
		rejectedRequestsToJoin[e.MemberToAction] = e.RequestToJoin
	}

	return &protobuf.CommunityEvent{
		CommunityEventClock:    e.CommunityEventClock,
		Type:                   e.Type,
		CommunityConfig:        e.CommunityConfig,
		TokenPermission:        e.TokenPermission,
		CategoryData:           e.CategoryData,
		ChannelData:            e.ChannelData,
		MemberToAction:         e.MemberToAction,
		RejectedRequestsToJoin: rejectedRequestsToJoin,
		AcceptedRequestsToJoin: acceptedRequestsToJoin,
		TokenMetadata:          e.TokenMetadata,
	}
}

func communityEventFromProtobuf(msg *protobuf.SignedCommunityEvent) (*CommunityEvent, error) {
	decodedEvent := protobuf.CommunityEvent{}
	err := proto.Unmarshal(msg.Payload, &decodedEvent)
	if err != nil {
		return nil, err
	}

	memberToAction := decodedEvent.MemberToAction
	var requestToJoin *protobuf.CommunityRequestToJoin

	switch decodedEvent.Type {
	case protobuf.CommunityEvent_COMMUNITY_REQUEST_TO_JOIN_ACCEPT:
		for member, request := range decodedEvent.AcceptedRequestsToJoin {
			memberToAction = member
			requestToJoin = request
			break
		}
	case protobuf.CommunityEvent_COMMUNITY_REQUEST_TO_JOIN_REJECT:
		for member, request := range decodedEvent.RejectedRequestsToJoin {
			memberToAction = member
			requestToJoin = request
			break
		}
	}

	return &CommunityEvent{
		CommunityEventClock: decodedEvent.CommunityEventClock,
		Type:                decodedEvent.Type,
		CommunityConfig:     decodedEvent.CommunityConfig,
		TokenPermission:     decodedEvent.TokenPermission,
		CategoryData:        decodedEvent.CategoryData,
		ChannelData:         decodedEvent.ChannelData,
		MemberToAction:      memberToAction,
		RequestToJoin:       requestToJoin,
		TokenMetadata:       decodedEvent.TokenMetadata,
		Payload:             msg.Payload,
		Signature:           msg.Signature,
	}, nil
}

func (e *CommunityEvent) RecoverSigner() (*ecdsa.PublicKey, error) {
	if e.Signature == nil || len(e.Signature) == 0 {
		return nil, errors.New("missing signature")
	}

	signer, err := crypto.SigToPub(
		crypto.Keccak256(e.Payload),
		e.Signature,
	)
	if err != nil {
		return nil, errors.New("failed to recover signer")
	}

	return signer, nil
}

func (e *CommunityEvent) Sign(pk *ecdsa.PrivateKey) error {
	sig, err := crypto.Sign(crypto.Keccak256(e.Payload), pk)
	if err != nil {
		return err
	}

	e.Signature = sig
	return nil
}

func (e *CommunityEvent) Validate() error {
	switch e.Type {
	case protobuf.CommunityEvent_COMMUNITY_EDIT:
		if e.CommunityConfig == nil || e.CommunityConfig.Identity == nil ||
			e.CommunityConfig.Permissions == nil || e.CommunityConfig.AdminSettings == nil {
			return errors.New("invalid config change admin event")
		}

	case protobuf.CommunityEvent_COMMUNITY_MEMBER_TOKEN_PERMISSION_CHANGE:
		if e.TokenPermission == nil || len(e.TokenPermission.Id) == 0 {
			return errors.New("invalid token permission change event")
		}

	case protobuf.CommunityEvent_COMMUNITY_MEMBER_TOKEN_PERMISSION_DELETE:
		if e.TokenPermission == nil || len(e.TokenPermission.Id) == 0 {
			return errors.New("invalid token permission delete event")
		}

	case protobuf.CommunityEvent_COMMUNITY_CATEGORY_CREATE:
		if e.CategoryData == nil || len(e.CategoryData.CategoryId) == 0 {
			return errors.New("invalid community category create event")
		}

	case protobuf.CommunityEvent_COMMUNITY_CATEGORY_DELETE:
		if e.CategoryData == nil || len(e.CategoryData.CategoryId) == 0 {
			return errors.New("invalid community category delete event")
		}

	case protobuf.CommunityEvent_COMMUNITY_CATEGORY_EDIT:
		if e.CategoryData == nil || len(e.CategoryData.CategoryId) == 0 {
			return errors.New("invalid community category edit event")
		}

	case protobuf.CommunityEvent_COMMUNITY_CHANNEL_CREATE:
		if e.ChannelData == nil || len(e.ChannelData.ChannelId) == 0 ||
			e.ChannelData.Channel == nil {
			return errors.New("invalid community channel create event")
		}

	case protobuf.CommunityEvent_COMMUNITY_CHANNEL_DELETE:
		if e.ChannelData == nil || len(e.ChannelData.ChannelId) == 0 {
			return errors.New("invalid community channel delete event")
		}

	case protobuf.CommunityEvent_COMMUNITY_CHANNEL_EDIT:
		if e.ChannelData == nil || len(e.ChannelData.ChannelId) == 0 ||
			e.ChannelData.Channel == nil {
			return errors.New("invalid community channel edit event")
		}

	case protobuf.CommunityEvent_COMMUNITY_CHANNEL_REORDER:
		if e.ChannelData == nil || len(e.ChannelData.ChannelId) == 0 {
			return errors.New("invalid community channel reorder event")
		}

	case protobuf.CommunityEvent_COMMUNITY_CATEGORY_REORDER:
		if e.CategoryData == nil || len(e.CategoryData.CategoryId) == 0 {
			return errors.New("invalid community category reorder event")
		}

	case protobuf.CommunityEvent_COMMUNITY_REQUEST_TO_JOIN_ACCEPT, protobuf.CommunityEvent_COMMUNITY_REQUEST_TO_JOIN_REJECT:
		if len(e.MemberToAction) == 0 || e.RequestToJoin == nil {
			return errors.New("invalid community request to join event")
		}

	case protobuf.CommunityEvent_COMMUNITY_MEMBER_KICK:
		if len(e.MemberToAction) == 0 {
			return errors.New("invalid community member kick event")
		}

	case protobuf.CommunityEvent_COMMUNITY_MEMBER_BAN:
		if len(e.MemberToAction) == 0 {
			return errors.New("invalid community member ban event")
		}

	case protobuf.CommunityEvent_COMMUNITY_MEMBER_UNBAN:
		if len(e.MemberToAction) == 0 {
			return errors.New("invalid community member unban event")
		}

	case protobuf.CommunityEvent_COMMUNITY_TOKEN_ADD:
		if e.TokenMetadata == nil || len(e.TokenMetadata.ContractAddresses) == 0 {
			return errors.New("invalid add community token event")
		}
	case protobuf.CommunityEvent_COMMUNITY_DELETE_BANNED_MEMBER_MESSAGES:
		if len(e.MemberToAction) == 0 {
			return errors.New("invalid delete all community member messages event")
		}
	}
	return nil
}

// EventTypeID constructs a unique identifier for an event and its associated target.
func (e *CommunityEvent) EventTypeID() string {
	switch e.Type {
	case protobuf.CommunityEvent_COMMUNITY_EDIT:
		return fmt.Sprintf("%d", e.Type)

	case protobuf.CommunityEvent_COMMUNITY_MEMBER_TOKEN_PERMISSION_CHANGE,
		protobuf.CommunityEvent_COMMUNITY_MEMBER_TOKEN_PERMISSION_DELETE:
		return fmt.Sprintf("%d-%s", e.Type, e.TokenPermission.Id)

	case protobuf.CommunityEvent_COMMUNITY_CATEGORY_CREATE,
		protobuf.CommunityEvent_COMMUNITY_CATEGORY_DELETE,
		protobuf.CommunityEvent_COMMUNITY_CATEGORY_EDIT,
		protobuf.CommunityEvent_COMMUNITY_CATEGORY_REORDER:
		return fmt.Sprintf("%d-%s", e.Type, e.CategoryData.CategoryId)

	case protobuf.CommunityEvent_COMMUNITY_CHANNEL_CREATE,
		protobuf.CommunityEvent_COMMUNITY_CHANNEL_DELETE,
		protobuf.CommunityEvent_COMMUNITY_CHANNEL_EDIT,
		protobuf.CommunityEvent_COMMUNITY_CHANNEL_REORDER:
		return fmt.Sprintf("%d-%s", e.Type, e.ChannelData.ChannelId)

	case protobuf.CommunityEvent_COMMUNITY_REQUEST_TO_JOIN_ACCEPT,
		protobuf.CommunityEvent_COMMUNITY_REQUEST_TO_JOIN_REJECT,
		protobuf.CommunityEvent_COMMUNITY_MEMBER_KICK,
		protobuf.CommunityEvent_COMMUNITY_MEMBER_BAN,
		protobuf.CommunityEvent_COMMUNITY_MEMBER_UNBAN,
		protobuf.CommunityEvent_COMMUNITY_DELETE_BANNED_MEMBER_MESSAGES:
		return fmt.Sprintf("%d-%s", e.Type, e.MemberToAction)

	case protobuf.CommunityEvent_COMMUNITY_TOKEN_ADD:
		return fmt.Sprintf("%d-%s", e.Type, e.TokenMetadata.Name)
	}

	return ""
}

func communityEventsToJSONEncodedBytes(communityEvents []CommunityEvent) ([]byte, error) {
	return json.Marshal(communityEvents)
}

func communityEventsFromJSONEncodedBytes(jsonEncodedRawEvents []byte) ([]CommunityEvent, error) {
	var events []CommunityEvent
	err := json.Unmarshal(jsonEncodedRawEvents, &events)
	if err != nil {
		return nil, err
	}

	return events, nil
}