package protocol import ( "context" "crypto/ecdsa" "encoding/json" "errors" "sync" "time" "github.com/google/uuid" "github.com/stretchr/testify/suite" "go.uber.org/zap" gethcommon "github.com/ethereum/go-ethereum/common" hexutil "github.com/ethereum/go-ethereum/common/hexutil" "github.com/status-im/status-go/account" "github.com/status-im/status-go/account/generator" "github.com/status-im/status-go/appdatabase" "github.com/status-im/status-go/common/dbsetup" "github.com/status-im/status-go/eth-node/crypto" "github.com/status-im/status-go/eth-node/types" "github.com/status-im/status-go/multiaccounts" "github.com/status-im/status-go/multiaccounts/accounts" "github.com/status-im/status-go/multiaccounts/settings" "github.com/status-im/status-go/params" "github.com/status-im/status-go/protocol/common" "github.com/status-im/status-go/protocol/communities" "github.com/status-im/status-go/protocol/protobuf" "github.com/status-im/status-go/protocol/requests" "github.com/status-im/status-go/services/communitytokens" walletToken "github.com/status-im/status-go/services/wallet/token" "github.com/status-im/status-go/t/helpers" "github.com/status-im/status-go/transactions" "github.com/status-im/status-go/walletdatabase" ) type AccountManagerMock struct { AccountsMap map[string]string } func (m *AccountManagerMock) GetVerifiedWalletAccount(db *accounts.Database, address, password string) (*account.SelectedExtKey, error) { return &account.SelectedExtKey{ Address: types.HexToAddress(address), }, nil } func (m *AccountManagerMock) CanRecover(rpcParams account.RecoverParams, revealedAddress types.Address) (bool, error) { return true, nil } func (m *AccountManagerMock) Sign(rpcParams account.SignParams, verifiedAccount *account.SelectedExtKey) (result types.HexBytes, err error) { return types.HexBytes{}, nil } func (m *AccountManagerMock) DeleteAccount(address types.Address) error { return nil } type TokenManagerMock struct { Balances *map[uint64]map[gethcommon.Address]map[gethcommon.Address]*hexutil.Big } func (m *TokenManagerMock) GetAllChainIDs() ([]uint64, error) { chainIDs := make([]uint64, 0, len(*m.Balances)) for key := range *m.Balances { chainIDs = append(chainIDs, key) } return chainIDs, nil } func (m *TokenManagerMock) GetBalancesByChain(ctx context.Context, accounts, tokenAddresses []gethcommon.Address, chainIDs []uint64) (map[uint64]map[gethcommon.Address]map[gethcommon.Address]*hexutil.Big, error) { time.Sleep(100 * time.Millisecond) // simulate response time return *m.Balances, nil } func (m *TokenManagerMock) FindOrCreateTokenByAddress(ctx context.Context, chainID uint64, address gethcommon.Address) *walletToken.Token { time.Sleep(100 * time.Millisecond) // simulate response time return nil } type CollectiblesServiceMock struct { Collectibles map[uint64]map[string]*communitytokens.CollectibleContractData Assets map[uint64]map[string]*communitytokens.AssetContractData Signers map[string]string } func (c *CollectiblesServiceMock) SetSignerPubkeyForCommunity(communityID []byte, signerPubKey string) { if c.Signers == nil { c.Signers = make(map[string]string) } c.Signers[types.EncodeHex(communityID)] = signerPubKey } func (c *CollectiblesServiceMock) SetSignerPubKey(ctx context.Context, chainID uint64, contractAddress string, txArgs transactions.SendTxArgs, password string, newSignerPubKey string) (string, error) { return "", nil } func (c *CollectiblesServiceMock) GetCollectibleContractData(chainID uint64, contractAddress string) (*communitytokens.CollectibleContractData, error) { collectibleContractData, dataExists := c.Collectibles[chainID][contractAddress] if dataExists { return collectibleContractData, nil } return nil, nil } func (c *CollectiblesServiceMock) GetAssetContractData(chainID uint64, contractAddress string) (*communitytokens.AssetContractData, error) { assetsContractData, dataExists := c.Assets[chainID][contractAddress] if dataExists { return assetsContractData, nil } return nil, nil } func (c *CollectiblesServiceMock) SetMockCollectibleContractData(chainID uint64, contractAddress string, collectible *communitytokens.CollectibleContractData) { if c.Collectibles == nil { c.Collectibles = make(map[uint64]map[string]*communitytokens.CollectibleContractData) } c.Collectibles[chainID] = make(map[string]*communitytokens.CollectibleContractData) c.Collectibles[chainID][contractAddress] = collectible } func (c *CollectiblesServiceMock) SafeGetSignerPubKey(ctx context.Context, chainID uint64, communityID string) (string, error) { if c.Signers == nil { c.Signers = make(map[string]string) } return c.Signers[communityID], nil } func (c *CollectiblesServiceMock) SetMockAssetContractData(chainID uint64, contractAddress string, assetData *communitytokens.AssetContractData) { if c.Assets == nil { c.Assets = make(map[uint64]map[string]*communitytokens.AssetContractData) } c.Assets[chainID] = make(map[string]*communitytokens.AssetContractData) c.Assets[chainID][contractAddress] = assetData } func (c *CollectiblesServiceMock) DeploymentSignatureDigest(chainID uint64, addressFrom string, communityID string) ([]byte, error) { return gethcommon.Hex2Bytes("ccbb375343347491706cf4b43796f7b96ccc89c9e191a8b78679daeba1684ec7"), nil } func newMessenger(s *suite.Suite, shh types.Waku, logger *zap.Logger, password string, walletAddresses []string, mockedBalances *map[uint64]map[gethcommon.Address]map[gethcommon.Address]*hexutil.Big, collectiblesService communitytokens.ServiceInterface) *Messenger { accountsManagerMock := &AccountManagerMock{} accountsManagerMock.AccountsMap = make(map[string]string) for _, walletAddress := range walletAddresses { accountsManagerMock.AccountsMap[walletAddress] = types.EncodeHex(crypto.Keccak256([]byte(password))) } tokenManagerMock := &TokenManagerMock{ Balances: mockedBalances, } privateKey, err := crypto.GenerateKey() s.Require().NoError(err) messenger, err := newCommunitiesTestMessenger(shh, privateKey, logger, accountsManagerMock, tokenManagerMock, collectiblesService) s.Require().NoError(err) currentDistributorObj, ok := messenger.communitiesKeyDistributor.(*CommunitiesKeyDistributorImpl) s.Require().True(ok) messenger.communitiesKeyDistributor = &TestCommunitiesKeyDistributor{ CommunitiesKeyDistributorImpl: *currentDistributorObj, subscriptions: map[chan *CommunityAndKeyActions]bool{}, mutex: sync.RWMutex{}, } // add wallet account with keypair for _, walletAddress := range walletAddresses { kp := accounts.GetProfileKeypairForTest(false, true, false) kp.Accounts[0].Address = types.HexToAddress(walletAddress) err := messenger.settings.SaveOrUpdateKeypair(kp) s.Require().NoError(err) } walletAccounts, err := messenger.settings.GetActiveAccounts() s.Require().NoError(err) s.Require().Len(walletAccounts, len(walletAddresses)) for i := range walletAddresses { s.Require().Equal(walletAccounts[i].Type, accounts.AccountTypeGenerated) } return messenger } func newCommunitiesTestMessenger(shh types.Waku, privateKey *ecdsa.PrivateKey, logger *zap.Logger, accountsManager account.Manager, tokenManager communities.TokenManager, collectiblesService communitytokens.ServiceInterface) (*Messenger, error) { madb, err := multiaccounts.InitializeDB(dbsetup.InMemoryPath) if err != nil { return nil, err } acc := generator.NewAccount(privateKey, nil) iai := acc.ToIdentifiedAccountInfo("") walletDb, err := helpers.SetupTestMemorySQLDB(walletdatabase.DbInitializer{}) if err != nil { return nil, err } appDb, err := helpers.SetupTestMemorySQLDB(appdatabase.DbInitializer{}) if err != nil { return nil, err } options := []Option{ WithCustomLogger(logger), WithDatabase(appDb), WithWalletDatabase(walletDb), WithMultiAccounts(madb), WithAccount(iai.ToMultiAccount()), WithDatasync(), WithResendParams(3, 3), WithTokenManager(tokenManager), } if collectiblesService != nil { options = append(options, WithCommunityTokensService(collectiblesService)) } m, err := NewMessenger( "Test", privateKey, &testNode{shh: shh}, uuid.New().String(), nil, accountsManager, options..., ) if err != nil { return nil, err } err = m.Init() if err != nil { return nil, err } config := params.NodeConfig{ NetworkID: 10, DataDir: "test", } networks := json.RawMessage("{}") setting := settings.Settings{ Address: types.HexToAddress("0x1122334455667788990011223344556677889900"), AnonMetricsShouldSend: false, CurrentNetwork: "mainnet_rpc", DappsAddress: types.HexToAddress("0x1122334455667788990011223344556677889900"), InstallationID: "d3efcff6-cffa-560e-a547-21d3858cbc51", KeyUID: "0x1122334455667788990011223344556677889900", Name: "Test", Networks: &networks, LatestDerivedPath: 0, PhotoPath: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADIAAAAyCAIAAACRXR/mAAAAjklEQVR4nOzXwQmFMBAAUZXUYh32ZB32ZB02sxYQQSZGsod55/91WFgSS0RM+SyjA56ZRZhFmEWYRRT6h+M6G16zrxv6fdJpmUWYRbxsYr13dKfanpN0WmYRZhGzXz6AWYRZRIfbaX26fT9Jk07LLMIsosPt9I/dTDotswizCG+nhFmEWYRZhFnEHQAA///z1CFkYamgfQAAAABJRU5ErkJggg==", PreviewPrivacy: false, PublicKey: "0x04112233445566778899001122334455667788990011223344556677889900112233445566778899001122334455667788990011223344556677889900", SigningPhrase: "yurt joey vibe", SendPushNotifications: true, ProfilePicturesVisibility: 1, DefaultSyncPeriod: 777600, UseMailservers: true, LinkPreviewRequestEnabled: true, SendStatusUpdates: true, WalletRootAddress: types.HexToAddress("0x1122334455667788990011223344556677889900")} _ = m.settings.CreateSettings(setting, config) return m, nil } func createCommunity(s *suite.Suite, owner *Messenger) (*communities.Community, *Chat) { return createCommunityConfigurable(s, owner, protobuf.CommunityPermissions_AUTO_ACCEPT) } func createOnRequestCommunity(s *suite.Suite, owner *Messenger) (*communities.Community, *Chat) { return createCommunityConfigurable(s, owner, protobuf.CommunityPermissions_MANUAL_ACCEPT) } func createCommunityConfigurable(s *suite.Suite, owner *Messenger, permission protobuf.CommunityPermissions_Access) (*communities.Community, *Chat) { description := &requests.CreateCommunity{ Membership: protobuf.CommunityPermissions_AUTO_ACCEPT, Name: "status", Color: "#ffffff", Description: "status community description", } // Create an community chat response, err := owner.CreateCommunity(description, true) s.Require().NoError(err) s.Require().NotNil(response) s.Require().Len(response.Communities(), 1) community := response.Communities()[0] s.Require().True(community.Joined()) s.Require().True(community.IsControlNode()) s.Require().Len(response.CommunitiesSettings(), 1) communitySettings := response.CommunitiesSettings()[0] s.Require().Equal(communitySettings.CommunityID, community.IDString()) s.Require().Equal(communitySettings.HistoryArchiveSupportEnabled, false) orgChat := &protobuf.CommunityChat{ Permissions: &protobuf.CommunityPermissions{ Access: protobuf.CommunityPermissions_AUTO_ACCEPT, }, Identity: &protobuf.ChatIdentity{ DisplayName: "status-core", Emoji: "😎", Description: "status-core community chat", }, } response, err = owner.CreateCommunityChat(community.ID(), orgChat) s.Require().NoError(err) s.Require().NotNil(response) s.Require().Len(response.Chats(), 1) return community, response.Chats()[0] } func advertiseCommunityTo(s *suite.Suite, community *communities.Community, owner *Messenger, user *Messenger) { // Create wrapped (Signed) community data. wrappedCommunity, err := community.ToProtocolMessageBytes() s.Require().NoError(err) // Unwrap signer (Admin) data at user side. signer, description, err := communities.UnwrapCommunityDescriptionMessage(wrappedCommunity) s.Require().NoError(err) // Handle community data state at receiver side messageState := user.buildMessageState() messageState.CurrentMessageState = &CurrentMessageState{} messageState.CurrentMessageState.PublicKey = &user.identity.PublicKey err = user.handleCommunityDescription(messageState, signer, description, wrappedCommunity, nil) s.Require().NoError(err) } func joinCommunity(s *suite.Suite, community *communities.Community, owner *Messenger, user *Messenger, request *requests.RequestToJoinCommunity, password string) { if password != "" { signingParams, err := user.GenerateJoiningCommunityRequestsForSigning(common.PubkeyToHex(&user.identity.PublicKey), community.ID(), request.AddressesToReveal) s.Require().NoError(err) for i := range signingParams { signingParams[i].Password = password } signatures, err := user.SignData(signingParams) s.Require().NoError(err) updateAddresses := len(request.AddressesToReveal) == 0 if updateAddresses { request.AddressesToReveal = make([]string, len(signingParams)) } for i := range signingParams { request.AddressesToReveal[i] = signingParams[i].Address request.Signatures = append(request.Signatures, types.FromHex(signatures[i])) } if updateAddresses { request.AirdropAddress = request.AddressesToReveal[0] } } response, err := user.RequestToJoinCommunity(request) s.Require().NoError(err) s.Require().NotNil(response) s.Require().Len(response.RequestsToJoinCommunity, 1) s.Require().Len(response.ActivityCenterNotifications(), 1) notification := response.ActivityCenterNotifications()[0] s.Require().NotNil(notification) s.Require().Equal(notification.Type, ActivityCenterNotificationTypeCommunityRequest) s.Require().Equal(notification.MembershipStatus, ActivityCenterMembershipStatusPending) // Retrieve and accept join request _, err = WaitOnMessengerResponse(owner, func(r *MessengerResponse) bool { return len(r.Communities()) > 0 && r.Communities()[0].HasMember(&user.identity.PublicKey) }, "user not accepted") s.Require().NoError(err) // Retrieve join request response _, err = WaitOnMessengerResponse(user, func(r *MessengerResponse) bool { return len(r.Communities()) > 0 && r.Communities()[0].HasMember(&user.identity.PublicKey) }, "user not accepted") s.Require().NoError(err) } func requestToJoinCommunity(s *suite.Suite, controlNode *Messenger, user *Messenger, request *requests.RequestToJoinCommunity) types.HexBytes { response, err := user.RequestToJoinCommunity(request) s.Require().NoError(err) s.Require().NotNil(response) s.Require().Len(response.RequestsToJoinCommunity, 1) requestToJoin := response.RequestsToJoinCommunity[0] s.Require().Equal(requestToJoin.PublicKey, common.PubkeyToHex(&user.identity.PublicKey)) _, err = WaitOnMessengerResponse( controlNode, func(r *MessengerResponse) bool { if len(r.RequestsToJoinCommunity) == 0 { return false } for _, resultRequest := range r.RequestsToJoinCommunity { if resultRequest.PublicKey == common.PubkeyToHex(&user.identity.PublicKey) { return true } } return false }, "control node did not receive community request to join", ) s.Require().NoError(err) return requestToJoin.ID } func joinOnRequestCommunity(s *suite.Suite, community *communities.Community, controlNode *Messenger, user *Messenger, request *requests.RequestToJoinCommunity) { // Request to join the community requestToJoinID := requestToJoinCommunity(s, controlNode, user, request) // accept join request acceptRequestToJoin := &requests.AcceptRequestToJoinCommunity{ID: requestToJoinID} response, err := controlNode.AcceptRequestToJoinCommunity(acceptRequestToJoin) s.Require().NoError(err) s.Require().NotNil(response) updatedCommunity := response.Communities()[0] s.Require().NotNil(updatedCommunity) s.Require().True(updatedCommunity.HasMember(&user.identity.PublicKey)) // receive request to join response _, err = WaitOnMessengerResponse( user, func(r *MessengerResponse) bool { return len(r.Communities()) > 0 && r.Communities()[0].HasMember(&user.identity.PublicKey) }, "user did not receive request to join response", ) s.Require().NoError(err) userCommunity, err := user.GetCommunityByID(community.ID()) s.Require().NoError(err) s.Require().True(userCommunity.HasMember(&user.identity.PublicKey)) _, err = WaitOnMessengerResponse( controlNode, func(r *MessengerResponse) bool { return len(r.Communities()) > 0 && r.Communities()[0].HasMember(&user.identity.PublicKey) }, "control node did not receive request to join response", ) s.Require().NoError(err) } func sendChatMessage(s *suite.Suite, sender *Messenger, chatID string, text string) *common.Message { msg := &common.Message{ ChatMessage: &protobuf.ChatMessage{ ChatId: chatID, ContentType: protobuf.ChatMessage_TEXT_PLAIN, Text: text, }, } _, err := sender.SendChatMessage(context.Background(), msg) s.Require().NoError(err) return msg } func grantPermission(s *suite.Suite, community *communities.Community, controlNode *Messenger, target *Messenger, role protobuf.CommunityMember_Roles) { responseAddRole, err := controlNode.AddRoleToMember(&requests.AddRoleToMember{ CommunityID: community.ID(), User: common.PubkeyToHexBytes(target.IdentityPublicKey()), Role: role, }) s.Require().NoError(err) s.Require().NoError(checkRolePermissionInResponse(responseAddRole, target.IdentityPublicKey(), role)) response, err := WaitOnMessengerResponse(target, func(response *MessengerResponse) bool { if len(response.Communities()) == 0 { return false } err := checkRolePermissionInResponse(response, target.IdentityPublicKey(), role) return err == nil }, "community description changed message not received") s.Require().NoError(err) s.Require().NoError(checkRolePermissionInResponse(response, target.IdentityPublicKey(), role)) } func checkRolePermissionInResponse(response *MessengerResponse, member *ecdsa.PublicKey, role protobuf.CommunityMember_Roles) error { if len(response.Communities()) == 0 { return errors.New("Response does not contain communities") } rCommunities := response.Communities() switch role { case protobuf.CommunityMember_ROLE_OWNER: if !rCommunities[0].IsMemberOwner(member) { return errors.New("Member without owner role") } case protobuf.CommunityMember_ROLE_ADMIN: if !rCommunities[0].IsMemberAdmin(member) { return errors.New("Member without admin role") } case protobuf.CommunityMember_ROLE_TOKEN_MASTER: if !rCommunities[0].IsMemberTokenMaster(member) { return errors.New("Member without token master role") } default: return errors.New("Can't check unknonw member role") } return nil } func checkMemberJoinedToTheCommunity(response *MessengerResponse, member *ecdsa.PublicKey) error { if len(response.Communities()) == 0 { return errors.New("No communities in the response") } if !response.Communities()[0].HasMember(member) { return errors.New("Member was not added to the community") } return nil } func waitOnCommunitiesEvent(user *Messenger, condition func(*communities.Subscription) bool) <-chan error { errCh := make(chan error, 1) go func() { defer close(errCh) for { select { case sub, more := <-user.communitiesManager.Subscribe(): if !more { errCh <- errors.New("channel closed when waiting for communities event") return } if condition(sub) { return } case <-time.After(500 * time.Millisecond): errCh <- errors.New("timed out when waiting for communities event") return } } }() return errCh }