github.com/status-im/status-go@v1.1.0/protocol/messenger_sync_keycard_change_test.go (about)

     1  package protocol
     2  
     3  import (
     4  	"context"
     5  	"crypto/ecdsa"
     6  	"testing"
     7  
     8  	"github.com/stretchr/testify/suite"
     9  	"go.uber.org/zap"
    10  
    11  	gethbridge "github.com/status-im/status-go/eth-node/bridge/geth"
    12  	"github.com/status-im/status-go/eth-node/crypto"
    13  	"github.com/status-im/status-go/eth-node/types"
    14  	"github.com/status-im/status-go/multiaccounts/accounts"
    15  	"github.com/status-im/status-go/protocol/encryption/multidevice"
    16  	"github.com/status-im/status-go/protocol/tt"
    17  	"github.com/status-im/status-go/waku"
    18  )
    19  
    20  func TestMessengerSyncKeycardChangeSuite(t *testing.T) {
    21  	suite.Run(t, new(MessengerSyncKeycardChangeSuite))
    22  }
    23  
    24  type MessengerSyncKeycardChangeSuite struct {
    25  	suite.Suite
    26  	main       *Messenger // main instance of Messenger paired with `other`
    27  	other      *Messenger
    28  	privateKey *ecdsa.PrivateKey // private key for the main instance of Messenger
    29  
    30  	// If one wants to send messages between different instances of Messenger,
    31  	// a single Waku service should be shared.
    32  	shh types.Waku
    33  
    34  	logger *zap.Logger
    35  }
    36  
    37  func (s *MessengerSyncKeycardChangeSuite) SetupTest() {
    38  	s.logger = tt.MustCreateTestLogger()
    39  
    40  	config := waku.DefaultConfig
    41  	config.MinimumAcceptedPoW = 0
    42  	shh := waku.New(&config, s.logger)
    43  	s.shh = gethbridge.NewGethWakuWrapper(shh)
    44  	s.Require().NoError(shh.Start())
    45  
    46  	s.main = s.newMessenger(s.shh)
    47  	s.privateKey = s.main.identity
    48  
    49  	var err error
    50  	// Create new device and add main account to
    51  	s.other, err = newMessengerWithKey(s.shh, s.main.identity, s.logger, nil)
    52  	s.Require().NoError(err)
    53  
    54  	// Pair devices (main and other)
    55  	imOther := &multidevice.InstallationMetadata{
    56  		Name:       "other-device",
    57  		DeviceType: "other-device-type",
    58  	}
    59  	err = s.other.SetInstallationMetadata(s.other.installationID, imOther)
    60  	s.Require().NoError(err)
    61  	response, err := s.other.SendPairInstallation(context.Background(), nil)
    62  	s.Require().NoError(err)
    63  	s.Require().NotNil(response)
    64  
    65  	// Wait for the message to reach its destination
    66  	_, err = WaitOnMessengerResponse(
    67  		s.main,
    68  		func(r *MessengerResponse) bool { return len(r.Installations()) > 0 },
    69  		"installation not received",
    70  	)
    71  	s.Require().NoError(err)
    72  
    73  	err = s.main.EnableInstallation(s.other.installationID)
    74  	s.Require().NoError(err)
    75  
    76  	// Pre-condition - both sides have to know about keypairs migrated to a keycards
    77  	kp1 := accounts.GetProfileKeypairForTest(true, true, true)
    78  	kp2 := accounts.GetSeedImportedKeypair1ForTest()
    79  	// kp3 := accounts.GetSeedImportedKeypair2ForTest()
    80  	kp1.Clock = 1
    81  	kp2.Clock = 1
    82  	// kp3.Clock = 1
    83  
    84  	err = s.main.settings.SaveOrUpdateKeypair(kp1)
    85  	s.Require().NoError(err)
    86  	err = s.main.settings.SaveOrUpdateKeypair(kp2)
    87  	s.Require().NoError(err)
    88  	// err = s.main.settings.SaveOrUpdateKeypair(kp3)
    89  	// s.Require().NoError(err)
    90  	dbKeypairs, err := s.main.settings.GetActiveKeypairs()
    91  	s.Require().NoError(err)
    92  	s.Require().Equal(2, len(dbKeypairs))
    93  
    94  	kp1.Clock = 0
    95  	kp2.Clock = 0
    96  	// kp3.Clock = 0
    97  
    98  	err = s.other.settings.SaveOrUpdateKeypair(kp1)
    99  	s.Require().NoError(err)
   100  	err = s.other.settings.SaveOrUpdateKeypair(kp2)
   101  	s.Require().NoError(err)
   102  	// err = s.other.settings.SaveOrUpdateKeypair(kp3)
   103  	// s.Require().NoError(err)
   104  	dbKeypairs, err = s.other.settings.GetActiveKeypairs()
   105  	s.Require().NoError(err)
   106  	s.Require().Equal(2, len(dbKeypairs))
   107  }
   108  
   109  func (s *MessengerSyncKeycardChangeSuite) TearDownTest() {
   110  	TearDownMessenger(&s.Suite, s.other)
   111  	TearDownMessenger(&s.Suite, s.main)
   112  }
   113  
   114  func (s *MessengerSyncKeycardChangeSuite) newMessenger(shh types.Waku) *Messenger {
   115  	privateKey, err := crypto.GenerateKey()
   116  	s.Require().NoError(err)
   117  
   118  	messenger, err := newMessengerWithKey(s.shh, privateKey, s.logger, nil)
   119  	s.Require().NoError(err)
   120  
   121  	return messenger
   122  }
   123  
   124  func (s *MessengerSyncKeycardChangeSuite) TestAddingNewKeycards() {
   125  	dbOnReceiver := s.other.settings
   126  
   127  	// Add key cards on sender
   128  	keycard1 := accounts.GetProfileKeycardForTest()
   129  
   130  	keycard2 := accounts.GetKeycardForSeedImportedKeypair1ForTest()
   131  
   132  	err := s.main.SaveOrUpdateKeycard(context.Background(), keycard1)
   133  	s.Require().NoError(err)
   134  	err = s.main.SaveOrUpdateKeycard(context.Background(), keycard2)
   135  	s.Require().NoError(err)
   136  
   137  	// Wait for the response
   138  	_, err = WaitOnMessengerResponse(
   139  		s.other,
   140  		func(r *MessengerResponse) bool {
   141  			return len(r.Keypairs) == 2
   142  		},
   143  		"expected to receive keycard activities",
   144  	)
   145  	s.Require().NoError(err)
   146  
   147  	senderKeycards, err := s.main.settings.GetAllKnownKeycards()
   148  	s.Require().NoError(err)
   149  	s.Require().Equal(2, len(senderKeycards))
   150  	s.Require().True(accounts.Contains(senderKeycards, keycard1, accounts.SameKeycards))
   151  	s.Require().True(accounts.Contains(senderKeycards, keycard2, accounts.SameKeycards))
   152  
   153  	syncedKeycards, err := dbOnReceiver.GetAllKnownKeycards()
   154  	s.Require().NoError(err)
   155  	s.Require().Equal(2, len(syncedKeycards))
   156  	s.Require().True(accounts.Contains(syncedKeycards, keycard1, accounts.SameKeycards))
   157  	s.Require().True(accounts.Contains(syncedKeycards, keycard2, accounts.SameKeycards))
   158  }
   159  
   160  func (s *MessengerSyncKeycardChangeSuite) TestAddingAccountsToKeycard() {
   161  	senderDb := s.main.settings
   162  	dbOnReceiver := s.other.settings
   163  
   164  	keycard1 := accounts.GetProfileKeycardForTest()
   165  
   166  	keycard2 := accounts.GetKeycardForSeedImportedKeypair1ForTest()
   167  
   168  	// Add keycard on sender
   169  	err := senderDb.SaveOrUpdateKeycard(*keycard1, 0, false)
   170  	s.Require().NoError(err)
   171  
   172  	// Add the same keycard on receiver
   173  	err = dbOnReceiver.SaveOrUpdateKeycard(*keycard1, 0, false)
   174  	s.Require().NoError(err)
   175  
   176  	// Add additional accounts to sender
   177  	err = s.main.SaveOrUpdateKeycard(context.Background(), keycard2)
   178  	s.Require().NoError(err)
   179  
   180  	// Wait for the response
   181  	_, err = WaitOnMessengerResponse(
   182  		s.other,
   183  		func(r *MessengerResponse) bool {
   184  			return len(r.Keypairs) == 1
   185  		},
   186  		"expected to receive keycard activities",
   187  	)
   188  	s.Require().NoError(err)
   189  
   190  	senderKeycards, err := senderDb.GetAllKnownKeycards()
   191  	s.Require().NoError(err)
   192  	s.Require().Equal(2, len(senderKeycards))
   193  	s.Require().True(contains(senderKeycards, keycard1, accounts.SameKeycards))
   194  	s.Require().True(contains(senderKeycards, keycard2, accounts.SameKeycards))
   195  
   196  	syncedKeycards, err := dbOnReceiver.GetAllKnownKeycards()
   197  	s.Require().NoError(err)
   198  	s.Require().Equal(2, len(syncedKeycards))
   199  	s.Require().True(contains(syncedKeycards, keycard1, accounts.SameKeycards))
   200  	s.Require().True(contains(syncedKeycards, keycard2, accounts.SameKeycards))
   201  }
   202  
   203  func (s *MessengerSyncKeycardChangeSuite) TestRemovingAccountsFromKeycard() {
   204  	senderDb := s.main.settings
   205  	dbOnReceiver := s.other.settings
   206  
   207  	keycard1 := accounts.GetProfileKeycardForTest()
   208  
   209  	// Add keycard on sender
   210  	err := senderDb.SaveOrUpdateKeycard(*keycard1, 0, false)
   211  	s.Require().NoError(err)
   212  
   213  	// Add the same keycard on receiver
   214  	err = dbOnReceiver.SaveOrUpdateKeycard(*keycard1, 0, false)
   215  	s.Require().NoError(err)
   216  
   217  	// Prepare expected keycard for comparison
   218  	updatedKeycard1 := accounts.GetProfileKeycardForTest()
   219  	updatedKeycard1.AccountsAddresses = updatedKeycard1.AccountsAddresses[2:]
   220  
   221  	// Remove accounts from sender
   222  	err = s.main.DeleteKeycardAccounts(context.Background(), keycard1.KeycardUID, keycard1.AccountsAddresses[:2])
   223  	s.Require().NoError(err)
   224  
   225  	// Wait for the response
   226  	_, err = WaitOnMessengerResponse(
   227  		s.other,
   228  		func(r *MessengerResponse) bool {
   229  			return len(r.Keypairs) == 1
   230  		},
   231  		"expected to receive keycard activities",
   232  	)
   233  	s.Require().NoError(err)
   234  
   235  	senderKeycards, err := senderDb.GetAllKnownKeycards()
   236  	s.Require().NoError(err)
   237  	s.Require().Equal(1, len(senderKeycards))
   238  	s.Require().True(contains(senderKeycards, updatedKeycard1, accounts.SameKeycards))
   239  
   240  	syncedKeycards, err := dbOnReceiver.GetAllKnownKeycards()
   241  	s.Require().NoError(err)
   242  	s.Require().Equal(1, len(syncedKeycards))
   243  	s.Require().True(contains(syncedKeycards, updatedKeycard1, accounts.SameKeycards))
   244  }
   245  
   246  func (s *MessengerSyncKeycardChangeSuite) TestRemovingAllAccountsForKeyUID() {
   247  	senderDb := s.main.settings
   248  	dbOnReceiver := s.other.settings
   249  
   250  	keycard1 := accounts.GetProfileKeycardForTest()
   251  
   252  	// Add keycard on sender
   253  	err := senderDb.SaveOrUpdateKeycard(*keycard1, 0, false)
   254  	s.Require().NoError(err)
   255  
   256  	// Add the same keycard on receiver
   257  	err = dbOnReceiver.SaveOrUpdateKeycard(*keycard1, 0, false)
   258  	s.Require().NoError(err)
   259  
   260  	// Remove all accounts from sender for KeyUID
   261  	err = s.main.DeleteAllKeycardsWithKeyUID(context.Background(), keycard1.KeyUID)
   262  	s.Require().NoError(err)
   263  
   264  	// Wait for the response
   265  	_, err = WaitOnMessengerResponse(
   266  		s.other,
   267  		func(r *MessengerResponse) bool {
   268  			return len(r.Keypairs) == 1
   269  		},
   270  		"expected to receive keycard activities",
   271  	)
   272  	s.Require().NoError(err)
   273  
   274  	senderKeycards, err := senderDb.GetKeycardsWithSameKeyUID(keycard1.KeyUID)
   275  	s.Require().NoError(err)
   276  	s.Require().Equal(0, len(senderKeycards))
   277  
   278  	syncedKeycards, err := dbOnReceiver.GetKeycardsWithSameKeyUID(keycard1.KeyUID)
   279  	s.Require().NoError(err)
   280  	s.Require().Equal(0, len(syncedKeycards))
   281  }
   282  
   283  func (s *MessengerSyncKeycardChangeSuite) TestDeleteKeycard() {
   284  	senderDb := s.main.settings
   285  	dbOnReceiver := s.other.settings
   286  
   287  	keycard1 := accounts.GetProfileKeycardForTest()
   288  
   289  	// Add keycard on sender
   290  	err := senderDb.SaveOrUpdateKeycard(*keycard1, 0, false)
   291  	s.Require().NoError(err)
   292  
   293  	// Add the same keycard on receiver
   294  	err = dbOnReceiver.SaveOrUpdateKeycard(*keycard1, 0, false)
   295  	s.Require().NoError(err)
   296  
   297  	// Remove keycard from sender
   298  	err = s.main.DeleteKeycard(context.Background(), keycard1.KeycardUID)
   299  	s.Require().NoError(err)
   300  
   301  	// Wait for the response
   302  	_, err = WaitOnMessengerResponse(
   303  		s.other,
   304  		func(r *MessengerResponse) bool {
   305  			return len(r.Keypairs) == 1
   306  		},
   307  		"expected to receive keycard activities",
   308  	)
   309  	s.Require().NoError(err)
   310  
   311  	senderKeycard, err := senderDb.GetKeycardByKeycardUID(keycard1.KeycardUID)
   312  	s.Require().Error(err)
   313  	s.Require().True(err == accounts.ErrNoKeycardForPassedKeycardUID)
   314  	s.Require().Nil(senderKeycard)
   315  
   316  	syncedKeycard, err := dbOnReceiver.GetKeycardByKeycardUID(keycard1.KeycardUID)
   317  	s.Require().Error(err)
   318  	s.Require().True(err == accounts.ErrNoKeycardForPassedKeycardUID)
   319  	s.Require().Nil(syncedKeycard)
   320  }
   321  
   322  func (s *MessengerSyncKeycardChangeSuite) TestSettingKeycardName() {
   323  	senderDb := s.main.settings
   324  	dbOnReceiver := s.other.settings
   325  
   326  	keycard1 := accounts.GetProfileKeycardForTest()
   327  
   328  	// Add keycard on sender
   329  	err := senderDb.SaveOrUpdateKeycard(*keycard1, 0, false)
   330  	s.Require().NoError(err)
   331  
   332  	// Add the same keycard on receiver
   333  	err = dbOnReceiver.SaveOrUpdateKeycard(*keycard1, 0, false)
   334  	s.Require().NoError(err)
   335  
   336  	// Prepare expected keycard for comparison
   337  	updatedKeycard1 := accounts.GetProfileKeycardForTest()
   338  	updatedKeycard1.KeycardName = "New Keycard Name"
   339  
   340  	// Set new keycard name to sender
   341  	err = s.main.SetKeycardName(context.Background(), updatedKeycard1.KeycardUID, updatedKeycard1.KeycardName)
   342  	s.Require().NoError(err)
   343  
   344  	// Wait for the response
   345  	_, err = WaitOnMessengerResponse(
   346  		s.other,
   347  		func(r *MessengerResponse) bool {
   348  			return len(r.Keypairs) == 1
   349  		},
   350  		"expected to receive keycard activities",
   351  	)
   352  	s.Require().NoError(err)
   353  
   354  	senderKeycard, err := senderDb.GetKeycardByKeycardUID(updatedKeycard1.KeycardUID)
   355  	s.Require().NoError(err)
   356  	s.Require().True(accounts.SameKeycards(updatedKeycard1, senderKeycard))
   357  
   358  	syncedKeycard, err := dbOnReceiver.GetKeycardByKeycardUID(updatedKeycard1.KeycardUID)
   359  	s.Require().NoError(err)
   360  	s.Require().True(accounts.SameKeycards(updatedKeycard1, syncedKeycard))
   361  }
   362  
   363  func (s *MessengerSyncKeycardChangeSuite) TestSettingKeycardLocked() {
   364  	senderDb := s.main.settings
   365  	dbOnReceiver := s.other.settings
   366  
   367  	keycard1 := accounts.GetProfileKeycardForTest()
   368  
   369  	// Add keycard on sender
   370  	err := senderDb.SaveOrUpdateKeycard(*keycard1, 0, false)
   371  	s.Require().NoError(err)
   372  
   373  	// Add the same keycard on receiver
   374  	err = dbOnReceiver.SaveOrUpdateKeycard(*keycard1, 0, false)
   375  	s.Require().NoError(err)
   376  
   377  	// Prepare expected keycard for comparison
   378  	updatedKeycard1 := accounts.GetProfileKeycardForTest()
   379  	updatedKeycard1.KeycardLocked = true
   380  
   381  	err = s.main.KeycardLocked(context.Background(), updatedKeycard1.KeycardUID)
   382  	s.Require().NoError(err)
   383  
   384  	// Wait for the response
   385  	_, err = WaitOnMessengerResponse(
   386  		s.other,
   387  		func(r *MessengerResponse) bool {
   388  			return len(r.Keypairs) == 1
   389  		},
   390  		"expected to receive keycard activities",
   391  	)
   392  	s.Require().NoError(err)
   393  
   394  	senderKeycard, err := senderDb.GetKeycardByKeycardUID(updatedKeycard1.KeycardUID)
   395  	s.Require().NoError(err)
   396  	s.Require().True(accounts.SameKeycards(updatedKeycard1, senderKeycard))
   397  
   398  	syncedKeycard, err := dbOnReceiver.GetKeycardByKeycardUID(updatedKeycard1.KeycardUID)
   399  	s.Require().NoError(err)
   400  	s.Require().True(accounts.SameKeycards(updatedKeycard1, syncedKeycard))
   401  }
   402  
   403  func (s *MessengerSyncKeycardChangeSuite) TestSettingKeycardUnlocked() {
   404  	senderDb := s.main.settings
   405  	dbOnReceiver := s.other.settings
   406  
   407  	keycard1 := accounts.GetProfileKeycardForTest()
   408  	keycard1.KeycardLocked = true
   409  
   410  	// Add keycard on sender
   411  	err := senderDb.SaveOrUpdateKeycard(*keycard1, 0, false)
   412  	s.Require().NoError(err)
   413  
   414  	// Add the same keycard on receiver
   415  	err = dbOnReceiver.SaveOrUpdateKeycard(*keycard1, 0, false)
   416  	s.Require().NoError(err)
   417  
   418  	// Prepare expected keycard for comparison
   419  	updatedKeycard1 := accounts.GetProfileKeycardForTest()
   420  	updatedKeycard1.KeycardLocked = false
   421  
   422  	err = s.main.KeycardUnlocked(context.Background(), updatedKeycard1.KeycardUID)
   423  	s.Require().NoError(err)
   424  
   425  	// Wait for the response
   426  	_, err = WaitOnMessengerResponse(
   427  		s.other,
   428  		func(r *MessengerResponse) bool {
   429  			return len(r.Keypairs) == 1
   430  		},
   431  		"expected to receive keycard activities",
   432  	)
   433  	s.Require().NoError(err)
   434  
   435  	senderKeycard, err := senderDb.GetKeycardByKeycardUID(updatedKeycard1.KeycardUID)
   436  	s.Require().NoError(err)
   437  	s.Require().True(accounts.SameKeycards(updatedKeycard1, senderKeycard))
   438  
   439  	syncedKeycard, err := dbOnReceiver.GetKeycardByKeycardUID(updatedKeycard1.KeycardUID)
   440  	s.Require().NoError(err)
   441  	s.Require().True(accounts.SameKeycards(updatedKeycard1, syncedKeycard))
   442  }
   443  
   444  func (s *MessengerSyncKeycardChangeSuite) TestUpdatingKeycardUid() {
   445  	senderDb := s.main.settings
   446  	dbOnReceiver := s.other.settings
   447  
   448  	keycard1 := accounts.GetProfileKeycardForTest()
   449  
   450  	// Add keycard on sender
   451  	err := senderDb.SaveOrUpdateKeycard(*keycard1, 0, false)
   452  	s.Require().NoError(err)
   453  
   454  	// Add the same keycard on receiver
   455  	err = dbOnReceiver.SaveOrUpdateKeycard(*keycard1, 0, false)
   456  	s.Require().NoError(err)
   457  
   458  	// Prepare expected keycard for comparison
   459  	updatedKeycard1 := accounts.GetProfileKeycardForTest()
   460  	updatedKeycard1.KeycardUID = "00000000000000000000000000000000"
   461  
   462  	// Update keycard uid on sender
   463  	err = s.main.UpdateKeycardUID(context.Background(), keycard1.KeycardUID, updatedKeycard1.KeycardUID)
   464  	s.Require().NoError(err)
   465  
   466  	// Wait for the response
   467  	_, err = WaitOnMessengerResponse(
   468  		s.other,
   469  		func(r *MessengerResponse) bool {
   470  			return len(r.Keypairs) == 1
   471  		},
   472  		"expected to receive keycard activities",
   473  	)
   474  	s.Require().NoError(err)
   475  
   476  	senderKeycard, err := senderDb.GetKeycardByKeycardUID(updatedKeycard1.KeycardUID)
   477  	s.Require().NoError(err)
   478  	s.Require().True(accounts.SameKeycards(updatedKeycard1, senderKeycard))
   479  
   480  	syncedKeycard, err := dbOnReceiver.GetKeycardByKeycardUID(updatedKeycard1.KeycardUID)
   481  	s.Require().NoError(err)
   482  	s.Require().True(accounts.SameKeycards(updatedKeycard1, syncedKeycard))
   483  }