status-im
/
status-go
mirror of https://github.com/status-im/status-go.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

feat: sync and backup wallet accounts 

Changes applied here introduce:
- improvements to sync wallet accounts among devices (including all account types)
- backing up wallet accounts to and fetch them from waku (an information about received
wallet accounts is sent via `waku.backedup.wallet-account` signal to a client)
This commit is contained in:
Sale Djenic 2023-04-19 16:44:57 +02:00 committed by saledjenic
parent 0eff61c57a
commit f1e3ae5b46
12 changed files with 710 additions and 354 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
protocol/messenger.go
View File

@ -12,6 +12,7 @@ import (
"math/rand"
"os"
"reflect"
"runtime"
"strings"
"sync"
"time"
@ -77,6 +78,8 @@ const (
publicChat chatContext = "public-chat"
privateChat chatContext = "private-chat"
isMobileApp = runtime.GOOS == "android" || runtime.GOOS == "ios"
)
const messageResendMinDelay = 30
@ -2504,23 +2507,20 @@ func (m *Messenger) DeleteAccount(address types.Address) error {
return m.syncWallets(accs, m.dispatchMessage)
}
// syncWallets syncs all wallets with paired devices
func (m *Messenger) syncWallets(accs []*accounts.Account, rawMessageHandler RawMessageHandler) error {
if !m.hasPairedDevices() {
return nil
}
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
clock, chat := m.getLastClockWithRelatedChat()
func (m *Messenger) prepareSyncWalletAccountsMessage(accs []*accounts.Account, clock uint64) *protobuf.SyncWalletAccounts {
accountMessages := make([]*protobuf.SyncWalletAccount, 0)
for _, acc := range accs {
if acc.Chat {
continue
}
// Once mobile app supports seed phrase and private key imported accounts we should remove the following `if` block
if isMobileApp {
if acc.Type != accounts.AccountTypeWatch &&
acc.Type != accounts.AccountTypeGenerated {
continue
}
}
var accountClock uint64
if acc.Clock == 0 {
accountClock = clock
@ -2540,13 +2540,33 @@ func (m *Messenger) syncWallets(accs []*accounts.Account, rawMessageHandler RawM
Color: acc.Color,
Hidden: acc.Hidden,
Removed: acc.Removed,
Emoji: acc.Emoji,
DerivedFrom: acc.DerivedFrom,
KeyUid: acc.KeyUID,
KeypairName: acc.KeypairName,
LastUsedDerivationIndex: acc.LastUsedDerivationIndex,
}
accountMessages = append(accountMessages, syncMessage)
}
message := &protobuf.SyncWalletAccounts{
return &protobuf.SyncWalletAccounts{
Accounts: accountMessages,
}
}
// syncWallets syncs all wallets with paired devices
func (m *Messenger) syncWallets(accs []*accounts.Account, rawMessageHandler RawMessageHandler) error {
if !m.hasPairedDevices() {
return nil
}
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
clock, chat := m.getLastClockWithRelatedChat()
message := m.prepareSyncWalletAccountsMessage(accs, clock)
encodedMessage, err := proto.Marshal(message)
if err != nil {

29
protocol/messenger_backup.go
View File

@ -95,6 +95,11 @@ func (m *Messenger) BackupData(ctx context.Context) (uint64, error) {
return 0, errors[0]
}
syncWalletAccounts, err := m.backupWalletAccounts(clock)
if err != nil {
return 0, err
}
keycardsToBackup, err := m.prepareSyncAllKeycardsMessage(clock)
if err != nil {
return 0, err
@ -119,6 +124,10 @@ func (m *Messenger) BackupData(ctx context.Context) (uint64, error) {
DataNumber: uint32(0),
TotalNumber: uint32(len(settings)),
},
WalletAccountsDetails: &protobuf.FetchingBackedUpDataDetails{
DataNumber: uint32(0),
TotalNumber: uint32(len(syncWalletAccounts.Accounts)),
},
KeycardsDetails: &protobuf.FetchingBackedUpDataDetails{
DataNumber: uint32(0),
TotalNumber: uint32(1),
@ -170,6 +179,17 @@ func (m *Messenger) BackupData(ctx context.Context) (uint64, error) {
}
}
// Update wallet accounts messages encode and dispatch
for i, d := range syncWalletAccounts.Accounts {
pb := backupDetailsOnly()
pb.WalletAccountsDetails.DataNumber = uint32(i + 1)
pb.WalletAccount = d
err = m.encodeAndDispatchBackupMessage(ctx, pb, chat.ID)
if err != nil {
return 0, err
}
}
// Update keycards message encode and dispatch
pb := backupDetailsOnly()
pb.KeycardsDetails.DataNumber = 1
@ -379,3 +399,12 @@ func (m *Messenger) backupProfile(ctx context.Context, clock uint64) ([]*protobu
return backupMessages, nil
}
func (m *Messenger) backupWalletAccounts(clock uint64) (*protobuf.SyncWalletAccounts, error) {
accounts, err := m.settings.GetAccounts()
if err != nil {
return nil, err
}
return m.prepareSyncWalletAccountsMessage(accounts, clock), nil
}

28
protocol/messenger_backup_handler.go
View File

@ -46,6 +46,11 @@ func (m *Messenger) HandleBackup(state *ReceivedMessageState, message protobuf.B
errors = append(errors, err)
}
err = m.handleBackedUpWalletAccount(message.WalletAccount)
if err != nil {
errors = append(errors, err)
}
err = m.handleBackedUpKeycards(message.Keycards)
if err != nil {
errors = append(errors, err)
@ -194,7 +199,28 @@ func (m *Messenger) handleBackedUpKeycards(message *protobuf.SyncAllKeycards) er
Keycards: allKeycards,
}
m.config.messengerSignalsHandler.SendWakuBackedUpSettings(&response)
m.config.messengerSignalsHandler.SendWakuBackedUpKeycards(&response)
}
return nil
}
func (m *Messenger) handleBackedUpWalletAccount(message *protobuf.SyncWalletAccount) error {
if message == nil {
return nil
}
acc, err := m.handleSyncWalletAccount(message)
if err != nil {
return err
}
if m.config.messengerSignalsHandler != nil {
response := wakusync.WakuBackedUpDataResponse{
WalletAccount: acc,
}
m.config.messengerSignalsHandler.SendWakuBackedUpWalletAccount(&response)
}
return nil

56
protocol/messenger_backup_test.go
View File

@ -636,6 +636,62 @@ func (s *MessengerBackupSuite) TestBackupCommunities() {
s.Require().Equal(clock, lastBackup)
}
func (s *MessengerBackupSuite) TestBackupWalletAccounts() {
// Create bob1
bob1 := s.m
walletAccounts := getWalletAccountsForTest()
s.NoError(bob1.settings.SaveAccounts(walletAccounts))
bob1Accs, err := bob1.settings.GetAccounts()
s.Require().NoError(err, "bob1.settings.GetAccounts")
s.Len(bob1Accs, len(walletAccounts), "must have all wallet accounts")
// Create bob2
bob2, err := newMessengerWithKey(s.shh, bob1.identity, s.logger, nil)
s.Require().NoError(err)
_, err = bob2.Start()
s.Require().NoError(err)
// Backup
_, err = bob1.BackupData(context.Background())
s.Require().NoError(err)
// Wait for the message to reach its destination
_, err = WaitOnMessengerResponse(
bob2,
func(r *MessengerResponse) bool {
return r.BackupHandled
},
"no messages",
)
s.Require().NoError(err)
bob2Accs, err := bob2.settings.GetAccounts()
s.Require().NoError(err, "bob2.settings.GetAccounts")
s.Len(bob2Accs, len(walletAccounts), "must have all wallet accounts")
for _, syncedAcc := range bob2Accs {
if syncedAcc.Chat {
continue
}
found := false
for _, sentAcc := range walletAccounts {
if syncedAcc.Address == sentAcc.Address {
// Check account values match the expected values
s.Require().Equal(sentAcc.Address, syncedAcc.Address)
s.Require().Equal(sentAcc.Path, syncedAcc.Path)
s.Require().Equal(sentAcc.KeyUID, syncedAcc.KeyUID)
s.Require().Equal(sentAcc.Name, syncedAcc.Name)
s.Require().Equal(sentAcc.Color, syncedAcc.Color)
s.Require().Equal(sentAcc.Type, syncedAcc.Type)
s.Require().Equal(sentAcc.KeypairName, syncedAcc.KeypairName)
s.Require().Equal(sentAcc.DerivedFrom, syncedAcc.DerivedFrom)
found = true
}
}
s.Require().True(found)
}
}
func (s *MessengerBackupSuite) TestBackupKeycards() {
// Create bob1
bob1 := s.m

1
protocol/messenger_config.go
View File

@ -56,6 +56,7 @@ type MessengerSignalsHandler interface {
SendWakuFetchingBackupProgress(response *wakusync.WakuBackedUpDataResponse)
SendWakuBackedUpProfile(response *wakusync.WakuBackedUpDataResponse)
SendWakuBackedUpSettings(response *wakusync.WakuBackedUpDataResponse)
SendWakuBackedUpWalletAccount(response *wakusync.WakuBackedUpDataResponse)
SendWakuBackedUpKeycards(response *wakusync.WakuBackedUpDataResponse)
}

94
protocol/messenger_handler.go
View File

@ -6,7 +6,6 @@ import (
"database/sql"
"encoding/hex"
"fmt"
"runtime"
"sync"
"time"
@ -37,8 +36,14 @@ const (
requestAddressForTransactionDeclinedMessage = "Request address for transaction declined"
)
var ErrMessageNotAllowed = errors.New("message from a non-contact")
var ErrMessageForWrongChatType = errors.New("message for the wrong chat type")
var (
ErrMessageNotAllowed = errors.New("message from a non-contact")
ErrMessageForWrongChatType = errors.New("message for the wrong chat type")
ErrNotWalletAccount = errors.New("an account is not a wallet account")
ErrWalletAccountNotSupportedForMobileApp = errors.New("handling account is not supported for mobile app")
ErrTryingToStoreOldWalletAccount = errors.New("trying to store an old wallet account")
ErrSomeFieldsMissingForWalletAccount = errors.New("some fields are missing for wallet account")
)
// HandleMembershipUpdate updates a Chat instance according to the membership updates.
// It retrieves chat, if exists, and merges membership updates from the message.
@ -2776,25 +2781,31 @@ func (m *Messenger) updateUnviewedCounts(chat *Chat, mentionedOrReplied bool) {
}
}
func (m *Messenger) HandleSyncWalletAccount(state *ReceivedMessageState, message protobuf.SyncWalletAccounts) error {
dbAccounts, err := m.settings.GetAccounts()
if err != nil {
return err
func (m *Messenger) handleSyncWalletAccount(message *protobuf.SyncWalletAccount) (*accounts.Account, error) {
if message.Chat {
return nil, ErrNotWalletAccount
}
accAddress := types.BytesToAddress(message.Address)
dbAccount, err := m.settings.GetAccountByAddress(accAddress)
if err != nil && err != sql.ErrNoRows {
return nil, err
}
dbAccountMap := make(map[types.Address]*accounts.Account)
for _, acc := range dbAccounts {
dbAccountMap[acc.Address] = acc
// Once mobile app supports seed phrase and private key imported accounts we should remove the following `if` block
if isMobileApp {
accType := accounts.AccountType(message.Type)
if accType != accounts.AccountTypeWatch &&
accType != accounts.AccountTypeGenerated {
return nil, ErrWalletAccountNotSupportedForMobileApp
}
}
var accs []*accounts.Account
for _, message := range message.Accounts {
dbAcc := dbAccountMap[types.BytesToAddress(message.Address)]
if dbAcc != nil && message.Clock <= dbAcc.Clock {
continue
if dbAccount != nil && message.Clock <= dbAccount.Clock {
return nil, ErrTryingToStoreOldWalletAccount
}
var acc *accounts.Account
if dbAcc != nil && message.Removed {
if dbAccount != nil && message.Removed {
acc = &accounts.Account{
Address: types.BytesToAddress(message.Address),
Removed: true,
@ -2812,18 +2823,47 @@ func (m *Messenger) HandleSyncWalletAccount(state *ReceivedMessageState, message
Hidden: message.Hidden,
Name: message.Name,
Clock: message.Clock,
KeyUID: message.KeyUid,
Emoji: message.Emoji,
DerivedFrom: message.DerivedFrom,
KeypairName: message.KeypairName,
LastUsedDerivationIndex: message.LastUsedDerivationIndex,
}
}
if runtime.GOOS != "android" && runtime.GOOS != "ios" {
// For the desktop app we need to ignore accounts with empty `KeypairName` or empty `DerivedFrom` (except if an account
// is not private key imported account or watch only account). Otherwise keypair items will be broken.
// Once mobile app supports seed phrase and private key imported accounts we should remove the following line, not entire if block
if !isMobileApp {
// For the desktop app we need to ignore accounts:
// - with empty `KeypairName` (except if an account is WatchOnly account) or
// - with empty `DerivedFrom` (except if an account is not private key imported account or watch only account)
// Otherwise keypair items will be broken.
if acc.Type != accounts.AccountTypeWatch {
if len(acc.KeypairName) == 0 || acc.Type != accounts.AccountTypeKey && len(acc.DerivedFrom) == 0 {
return nil, ErrSomeFieldsMissingForWalletAccount
}
}
}
}
err = m.settings.SaveAccounts([]*accounts.Account{acc})
if err != nil {
return nil, err
}
return acc, nil
}
func (m *Messenger) HandleSyncWalletAccount(state *ReceivedMessageState, message protobuf.SyncWalletAccounts) error {
var accs []*accounts.Account
for _, accMsg := range message.Accounts {
acc, err := m.handleSyncWalletAccount(accMsg)
if err != nil {
if err == ErrNotWalletAccount ||
err == ErrWalletAccountNotSupportedForMobileApp ||
err == ErrTryingToStoreOldWalletAccount ||
err == ErrSomeFieldsMissingForWalletAccount {
continue
}
}
return err
}
accs = append(accs, acc)
@ -2833,11 +2873,9 @@ func (m *Messenger) HandleSyncWalletAccount(state *ReceivedMessageState, message
return nil
}
err = m.settings.SaveAccounts(accs)
if err != nil {
return err
}
state.Response.Accounts = accs
if isMobileApp {
latestDerivedPath, err := m.settings.GetLatestDerivedPath()
if err != nil {
return err
@ -2849,8 +2887,6 @@ func (m *Messenger) HandleSyncWalletAccount(state *ReceivedMessageState, message
return err
}
if err == nil {
state.Response.Accounts = accs
if state.Response.Settings == nil {
state.Response.Settings = []*settings.SyncSettingField{}
}
@ -2863,7 +2899,7 @@ func (m *Messenger) HandleSyncWalletAccount(state *ReceivedMessageState, message
})
}
return err
return nil
}
func (m *Messenger) HandleSyncContactRequestDecision(state *ReceivedMessageState, message protobuf.SyncContactRequestDecision) error {

201
protocol/messenger_sync_wallets_test.go
View File

@ -65,19 +65,115 @@ func (s *MessengerSyncWalletSuite) newMessenger(shh types.Waku) *Messenger {
return messenger
}
func (s *MessengerSyncWalletSuite) TestSyncWallets() {
func getWalletAccountsForTest() []*accounts.Account {
defaultAccount := &accounts.Account{
Address: types.Address{0x11},
KeyUID: "0000000000000000000000000000000000000000000000000000000000000001",
Wallet: true,
Chat: false,
Path: "m/44'/60'/0'/0/0",
Name: "Default Account",
Color: "blue",
DerivedFrom: "0x0001",
KeypairName: "Profile Keypair",
LastUsedDerivationIndex: 0,
}
generatedFromDefaultAccount1 := &accounts.Account{
Address: types.Address{0x12},
Type: accounts.AccountTypeGenerated,
KeyUID: defaultAccount.KeyUID,
Path: "m/44'/60'/0'/0/1",
Name: "Generated Acc 1",
Color: "blue",
DerivedFrom: defaultAccount.DerivedFrom,
KeypairName: defaultAccount.KeypairName,
LastUsedDerivationIndex: 1,
}
generatedFromDefaultAccount2 := &accounts.Account{
Address: types.Address{0x13},
Type: accounts.AccountTypeGenerated,
KeyUID: defaultAccount.KeyUID,
Path: "m/44'/60'/0'/0/2",
Name: "Generated Acc 2",
Color: "blue",
DerivedFrom: defaultAccount.DerivedFrom,
KeypairName: defaultAccount.KeypairName,
LastUsedDerivationIndex: 2,
}
seedImportedAccount := &accounts.Account{
Address: types.Address{0x14},
Type: accounts.AccountTypeSeed,
KeyUID: "0000000000000000000000000000000000000000000000000000000000000002",
Path: "m/44'/60'/0'/0/0",
Name: "Seed Imported Account",
Color: "green",
DerivedFrom: "0x0002",
KeypairName: "Seed Keypair",
LastUsedDerivationIndex: 0,
}
generatedFromSeedImportedAccount1 := &accounts.Account{
Address: types.Address{0x15},
Type: accounts.AccountTypeSeed,
KeyUID: seedImportedAccount.KeyUID,
Path: "m/44'/60'/0'/0/1",
Name: "Generated Seed Account 1",
Color: "green",
DerivedFrom: seedImportedAccount.DerivedFrom,
KeypairName: seedImportedAccount.KeypairName,
LastUsedDerivationIndex: 1,
}
generatedFromSeedImportedAccount2 := &accounts.Account{
Address: types.Address{0x16},
Type: accounts.AccountTypeSeed,
KeyUID: seedImportedAccount.KeyUID,
Path: "m/44'/60'/0'/0/2",
Name: "Generated Seed Account 2",
Color: "green",
DerivedFrom: seedImportedAccount.DerivedFrom,
KeypairName: seedImportedAccount.KeypairName,
LastUsedDerivationIndex: 2,
}
keyImportedAccount := &accounts.Account{
Address: types.Address{0x17},
Type: accounts.AccountTypeKey,
KeyUID: "0000000000000000000000000000000000000000000000000000000000000003",
Path: "m",
Name: "Key Imported Account",
Color: "blue",
KeypairName: "Private Key Keypair",
}
watchOnlyAccount1 := &accounts.Account{
Address: types.Address{0x18},
Type: accounts.AccountTypeWatch,
Name: "Watch Only Account 1",
Color: "green",
}
watchOnlyAccount2 := &accounts.Account{
Address: types.Address{0x19},
Type: accounts.AccountTypeWatch,
Name: "Watch Only Account 1",
Color: "green",
}
return []*accounts.Account{
defaultAccount,
generatedFromDefaultAccount1,
generatedFromDefaultAccount2,
seedImportedAccount,
generatedFromSeedImportedAccount1,
generatedFromSeedImportedAccount2,
keyImportedAccount,
watchOnlyAccount1,
watchOnlyAccount2,
}
}
func (s *MessengerSyncWalletSuite) TestSyncWallets() {
mainAccount := &accounts.Account{
Address: types.Address{0x01},
Wallet: true,
Wallet: false,
Chat: true,
}
watchOnly1 := &accounts.Account{
Address: types.Address{0x02},
Name: "Alice watch only",
Color: "green",
Type: accounts.AccountTypeWatch,
}
// Create a main account on alice
s.NoError(s.m.settings.SaveAccounts([]*accounts.Account{mainAccount}))
@ -139,28 +235,25 @@ func (s *MessengerSyncWalletSuite) TestSyncWallets() {
err = s.m.EnableInstallation(alicesOtherDevice.installationID)
s.Require().NoError(err)
// Create a watch-only acount on alice
s.NoError(s.m.settings.SaveAccounts([]*accounts.Account{watchOnly1}))
// Store wallet accounts on alice's device
walletAccounts := getWalletAccountsForTest()
expectedTotalNumOfAccounts := len(walletAccounts) + 1 // plus one for the Status profile account
s.NoError(s.m.settings.SaveAccounts(walletAccounts))
acc1, err = s.m.settings.GetAccounts()
s.Require().NoError(err, "alice.settings.GetAccounts")
s.Len(acc1, 2, "Must have 2 accounts")
s.Len(acc1, expectedTotalNumOfAccounts, "Must have all wallet accounts plus one for the Status profile account")
// Trigger's a sync between devices
err = s.m.SyncDevices(context.Background(), "ens-name", "profile-image", nil)
s.Require().NoError(err)
err = tt.RetryWithBackOff(func() error {
_, err := alicesOtherDevice.RetrieveAll()
response, err := alicesOtherDevice.RetrieveAll()
if err != nil {
return err
}
accs, err := alicesOtherDevice.settings.GetAccounts()
if err != nil {
return err
}
if len(accs) != 2 {
if len(response.Accounts) != len(walletAccounts) {
return errors.New("no sync wallet account received")
}
return nil
@ -169,46 +262,47 @@ func (s *MessengerSyncWalletSuite) TestSyncWallets() {
acc2, err = alicesOtherDevice.settings.GetAccounts()
s.Require().NoError(err, "alicesOtherDevice.settings.GetAccounts")
s.Len(acc2, 2, "Must have 2 accounts")
s.Len(acc2, expectedTotalNumOfAccounts, "Must have all wallet accounts plus one for the Status profile account")
for _, syncedAcc := range acc2 {
if syncedAcc.Chat {
continue
}
found := false
for _, acc := range acc2 {
if acc.Address == watchOnly1.Address {
for _, sentAcc := range walletAccounts {
if syncedAcc.Address == sentAcc.Address {
// Check account values match the expected values
s.Require().Equal(watchOnly1.Address, acc.Address)
s.Require().Equal(watchOnly1.Name, acc.Name)
s.Require().Equal(watchOnly1.Color, acc.Color)
s.Require().Equal(watchOnly1.Type, acc.Type)
s.Require().Equal(sentAcc.Address, syncedAcc.Address)
s.Require().Equal(sentAcc.Path, syncedAcc.Path)
s.Require().Equal(sentAcc.KeyUID, syncedAcc.KeyUID)
s.Require().Equal(sentAcc.Name, syncedAcc.Name)
s.Require().Equal(sentAcc.Color, syncedAcc.Color)
s.Require().Equal(sentAcc.Type, syncedAcc.Type)
s.Require().Equal(sentAcc.KeypairName, syncedAcc.KeypairName)
s.Require().Equal(sentAcc.DerivedFrom, syncedAcc.DerivedFrom)
found = true
}
}
s.Require().True(found)
// Updates alice's watch only account attributes
watchOnly2 := &accounts.Account{
Address: types.Address{0x03},
Name: "Alice watch only 2",
Color: "blue",
Type: accounts.AccountTypeWatch,
}
s.Require().NoError(s.m.SaveAccounts([]*accounts.Account{watchOnly2}))
// Updates alice's accounts attributes
for _, acc := range walletAccounts {
acc.Name = acc.Name + "New"
acc.Color = "lightblue"
}
s.Require().NoError(s.m.SaveAccounts(walletAccounts))
// Sync between devices is triggered automatically
// via watch account changes subscription
// Retrieve community link & community
err = tt.RetryWithBackOff(func() error {
_, err := alicesOtherDevice.RetrieveAll()
response, err := alicesOtherDevice.RetrieveAll()
if err != nil {
return err
}
accs, err := alicesOtherDevice.settings.GetAccounts()
if err != nil {
return err
}
if len(accs) != 3 {
if len(response.Accounts) != len(walletAccounts) {
return errors.New("no sync wallet account received")
}
return nil
@ -217,18 +311,27 @@ func (s *MessengerSyncWalletSuite) TestSyncWallets() {
acc2, err = alicesOtherDevice.settings.GetAccounts()
s.Require().NoError(err, "alicesOtherDevice.settings.GetAccounts")
s.Len(acc2, 3, "Must have 2 accounts")
s.Len(acc2, expectedTotalNumOfAccounts, "Must have all wallet accounts plus one for the Status profile account")
found = false
for _, acc := range acc2 {
if acc.Address == watchOnly2.Address {
for _, syncedAcc := range acc2 {
if syncedAcc.Chat {
continue
}
found := false
for _, sentAcc := range walletAccounts {
if syncedAcc.Address == sentAcc.Address {
// Check account values match the expected values
s.Require().Equal(watchOnly2.Address, acc.Address)
s.Require().Equal(watchOnly2.Name, acc.Name)
s.Require().Equal(watchOnly2.Color, acc.Color)
s.Require().Equal(watchOnly2.Type, acc.Type)
s.Require().Equal(sentAcc.Address, syncedAcc.Address)
s.Require().Equal(sentAcc.Path, syncedAcc.Path)
s.Require().Equal(sentAcc.KeyUID, syncedAcc.KeyUID)
s.Require().Equal(sentAcc.Name, syncedAcc.Name)
s.Require().Equal(sentAcc.Color, syncedAcc.Color)
s.Require().Equal(sentAcc.Type, syncedAcc.Type)
s.Require().Equal(sentAcc.KeypairName, syncedAcc.KeypairName)
s.Require().Equal(sentAcc.DerivedFrom, syncedAcc.DerivedFrom)
found = true
}
}
s.Require().True(found)
}
}

425
protocol/protobuf/pairing.pb.go
View File

@ -213,6 +213,8 @@ type Backup struct {
SettingsDetails *FetchingBackedUpDataDetails `protobuf:"bytes,10,opt,name=settingsDetails,proto3" json:"settingsDetails,omitempty"`
Keycards *SyncAllKeycards `protobuf:"bytes,11,opt,name=keycards,proto3" json:"keycards,omitempty"`
KeycardsDetails *FetchingBackedUpDataDetails `protobuf:"bytes,12,opt,name=keycardsDetails,proto3" json:"keycardsDetails,omitempty"`
WalletAccount *SyncWalletAccount `protobuf:"bytes,13,opt,name=walletAccount,proto3" json:"walletAccount,omitempty"`
WalletAccountsDetails *FetchingBackedUpDataDetails `protobuf:"bytes,14,opt,name=walletAccountsDetails,proto3" json:"walletAccountsDetails,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -327,6 +329,20 @@ func (m *Backup) GetKeycardsDetails() *FetchingBackedUpDataDetails {
return nil
}
func (m *Backup) GetWalletAccount() *SyncWalletAccount {
if m != nil {
return m.WalletAccount
}
return nil
}
func (m *Backup) GetWalletAccountsDetails() *FetchingBackedUpDataDetails {
if m != nil {
return m.WalletAccountsDetails
}
return nil
}
type MultiAccount struct {
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
Timestamp int64 `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
@ -1974,6 +1990,11 @@ type SyncWalletAccount struct {
Color string `protobuf:"bytes,10,opt,name=color,proto3" json:"color,omitempty"`
Hidden bool `protobuf:"varint,11,opt,name=hidden,proto3" json:"hidden,omitempty"`
Removed bool `protobuf:"varint,12,opt,name=removed,proto3" json:"removed,omitempty"`
Emoji string `protobuf:"bytes,13,opt,name=emoji,proto3" json:"emoji,omitempty"`
DerivedFrom string `protobuf:"bytes,14,opt,name=derived_from,json=derivedFrom,proto3" json:"derived_from,omitempty"`
KeyUid string `protobuf:"bytes,15,opt,name=key_uid,json=keyUid,proto3" json:"key_uid,omitempty"`
KeypairName string `protobuf:"bytes,16,opt,name=keypair_name,json=keypairName,proto3" json:"keypair_name,omitempty"`
LastUsedDerivationIndex uint64 `protobuf:"varint,17,opt,name=last_used_derivation_index,json=lastUsedDerivationIndex,proto3" json:"last_used_derivation_index,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -2088,6 +2109,41 @@ func (m *SyncWalletAccount) GetRemoved() bool {
return false
}
func (m *SyncWalletAccount) GetEmoji() string {
if m != nil {
return m.Emoji
}
return ""
}
func (m *SyncWalletAccount) GetDerivedFrom() string {
if m != nil {
return m.DerivedFrom
}
return ""
}
func (m *SyncWalletAccount) GetKeyUid() string {
if m != nil {
return m.KeyUid
}
return ""
}
func (m *SyncWalletAccount) GetKeypairName() string {
if m != nil {
return m.KeypairName
}
return ""
}
func (m *SyncWalletAccount) GetLastUsedDerivationIndex() uint64 {
if m != nil {
return m.LastUsedDerivationIndex
}
return 0
}
type SyncWalletAccounts struct {
Accounts []*SyncWalletAccount `protobuf:"bytes,1,rep,name=accounts,proto3" json:"accounts,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
@ -2953,185 +3009,192 @@ func init() {
}
var fileDescriptor_d61ab7221f0b5518 = []byte{
// 2877 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x39, 0x4d, 0x73, 0x1b, 0xc7,
0xb1, 0xc6, 0x07, 0xf1, 0xd1, 0x00, 0x41, 0x70, 0x44, 0x49, 0x10, 0x45, 0x97, 0xa8, 0xb5, 0x5d,
0xd6, 0x7b, 0xe5, 0x47, 0xbd, 0x47, 0x3f, 0xc7, 0x8e, 0x6c, 0x97, 0x03, 0x01, 0x88, 0x45, 0x91,
0x04, 0x99, 0x21, 0x21, 0xc7, 0xae, 0x54, 0x6d, 0x0d, 0x77, 0x47, 0xc4, 0x86, 0x8b, 0x5d, 0x64,
0x67, 0x40, 0x19, 0xbe, 0x25, 0xa7, 0x9c, 0x73, 0x49, 0x8e, 0x3e, 0x27, 0xb7, 0x54, 0xe5, 0x90,
0x5b, 0x8e, 0xb9, 0xe7, 0x98, 0x1c, 0x72, 0x4e, 0xe5, 0x07, 0xe4, 0x98, 0x9a, 0x9e, 0xd9, 0xc5,
0x2e, 0x08, 0x30, 0x54, 0xe5, 0x94, 0x13, 0xa6, 0x7b, 0xbb, 0x7b, 0x7b, 0xfa, 0xbb, 0x17, 0xb0,
0x3a, 0x66, 0x5e, 0xe4, 0x05, 0xe7, 0x3b, 0xe3, 0x28, 0x94, 0x21, 0xa9, 0xe0, 0xcf, 0xd9, 0xe4,
0xe5, 0xe6, 0x2d, 0x31, 0x0d, 0x1c, 0x5b, 0x70, 0x29, 0xbd, 0xe0, 0x5c, 0xe8, 0xc7, 0x9b, 0x16,
0x1b, 0x8f, 0x7d, 0xcf, 0x61, 0xd2, 0x0b, 0x03, 0x7b, 0xc4, 0x25, 0x73, 0x99, 0x64, 0xf6, 0x88,
0x0b, 0xc1, 0xce, 0xb9, 0xa6, 0xb1, 0x18, 0xdc, 0xff, 0x3e, 0x97, 0xce, 0xd0, 0x0b, 0xce, 0x9f,
0x32, 0xe7, 0x82, 0xbb, 0x83, 0x71, 0x97, 0x49, 0xd6, 0xe5, 0x92, 0x79, 0xbe, 0x20, 0x0f, 0xa0,
0x86, 0x4c, 0xc1, 0x64, 0x74, 0xc6, 0xa3, 0x56, 0x6e, 0x3b, 0xf7, 0x68, 0x95, 0x82, 0x42, 0xf5,
0x11, 0x43, 0x1e, 0x42, 0x5d, 0x86, 0x92, 0xf9, 0x31, 0x45, 0x1e, 0x29, 0x6a, 0x88, 0xd3, 0x24,
0xd6, 0x5f, 0x57, 0xa0, 0xa4, 0x64, 0x4f, 0xc6, 0x64, 0x03, 0x56, 0x1c, 0x3f, 0x74, 0x2e, 0x50,
0x50, 0x91, 0x6a, 0x80, 0x34, 0x20, 0xef, 0xb9, 0xc8, 0x59, 0xa5, 0x79, 0xcf, 0x25, 0x9f, 0x41,
0xc5, 0x09, 0x03, 0xc9, 0x1c, 0x29, 0x5a, 0x85, 0xed, 0xc2, 0xa3, 0xda, 0xee, 0x5b, 0x3b, 0xf1,
0x4d, 0x77, 0x4e, 0xa6, 0x81, 0xb3, 0x17, 0x08, 0xc9, 0x7c, 0x1f, 0x2f, 0xd6, 0xd1, 0x94, 0x2f,
0x76, 0x69, 0xc2, 0x44, 0xbe, 0x0b, 0x35, 0x27, 0x1c, 0x8d, 0x26, 0x81, 0x27, 0x3d, 0x2e, 0x5a,
0x45, 0x94, 0x71, 0x37, 0x2b, 0xa3, 0x63, 0x08, 0xa6, 0x34, 0x4d, 0x4b, 0x8e, 0x60, 0x2d, 0x16,
0x63, 0x6c, 0xd0, 0x5a, 0xd9, 0xce, 0x3d, 0xaa, 0xed, 0xbe, 0x33, 0x63, 0xbf, 0xc6, 0x60, 0x74,
0x9e, 0x9b, 0x0c, 0x80, 0xa4, 0xe4, 0xc7, 0x32, 0x4b, 0xaf, 0x23, 0x73, 0x81, 0x00, 0xf2, 0x3e,
0x94, 0xc7, 0x51, 0xf8, 0xd2, 0xf3, 0x79, 0xab, 0x8c, 0xb2, 0xee, 0xcd, 0x64, 0xc5, 0x32, 0x8e,
0x35, 0x01, 0x8d, 0x29, 0xc9, 0x21, 0x34, 0xcc, 0x31, 0xd6, 0xa3, 0xf2, 0x3a, 0x7a, 0xcc, 0x31,
0x93, 0xc7, 0x50, 0x36, 0x11, 0xd7, 0xaa, 0xa2, 0x9c, 0xdb, 0x59, 0x13, 0x9f, 0xe8, 0x87, 0x34,
0xa6, 0x52, 0xc6, 0x8d, 0x43, 0x34, 0x56, 0x00, 0x5e, 0xcb, 0xb8, 0x73, 0xdc, 0xe4, 0x03, 0xa8,
0x5c, 0xf0, 0xa9, 0xc3, 0x22, 0x57, 0xb4, 0x6a, 0xf3, 0x66, 0x50, 0x2a, 0xb4, 0x7d, 0x7f, 0xdf,
0x10, 0xd0, 0x84, 0x54, 0xe9, 0x11, 0x9f, 0x63, 0x3d, 0xea, 0xaf, 0xa5, 0xc7, 0x1c, 0xb7, 0xf5,
0xf7, 0x22, 0xd4, 0x0f, 0x27, 0xbe, 0xf4, 0xda, 0x8e, 0x13, 0x4e, 0x02, 0x49, 0x08, 0x14, 0x03,
0x36, 0xe2, 0x18, 0xe7, 0x55, 0x8a, 0x67, 0xb2, 0x05, 0x55, 0xe9, 0x8d, 0xb8, 0x90, 0x6c, 0x34,
0xc6, 0x68, 0x2f, 0xd0, 0x19, 0x42, 0x3d, 0xf5, 0x5c, 0x1e, 0x48, 0xcf, 0x09, 0x83, 0x56, 0x01,
0xd9, 0x66, 0x08, 0xf2, 0x19, 0x80, 0x13, 0xfa, 0x61, 0x64, 0x0f, 0x99, 0x18, 0x9a, 0x80, 0xde,
0x9e, 0x29, 0x9b, 0x7e, 0xf7, 0x4e, 0x47, 0x11, 0x3e, 0x63, 0x62, 0x48, 0xab, 0x4e, 0x7c, 0x24,
0xf7, 0x54, 0x4e, 0x29, 0x01, 0x9e, 0x8b, 0x01, 0x5d, 0xa0, 0x65, 0x84, 0xf7, 0x5c, 0xf2, 0x6e,
0x62, 0x0d, 0xdb, 0x94, 0x17, 0x0c, 0xcf, 0x2a, 0x6d, 0x18, 0xf4, 0xb1, 0xc6, 0x92, 0xbb, 0x50,
0xbe, 0xe0, 0x53, 0x7b, 0xe2, 0xb9, 0x18, 0x73, 0x55, 0x5a, 0xba, 0xe0, 0xd3, 0x81, 0xe7, 0x92,
0x4f, 0xa0, 0xe4, 0x8d, 0xd8, 0x39, 0x57, 0xf1, 0xa4, 0x34, 0x7b, 0x7b, 0x89, 0x66, 0x7b, 0x78,
0x1f, 0x39, 0xdd, 0x53, 0xc4, 0xd4, 0xf0, 0x90, 0xc7, 0x70, 0xcb, 0x99, 0x08, 0x19, 0x8e, 0xbc,
0x6f, 0x74, 0xa9, 0x42, 0xc5, 0x30, 0xa4, 0xaa, 0x94, 0x64, 0x1e, 0xe1, 0xd5, 0x36, 0x1f, 0x42,
0x35, 0xb9, 0xa3, 0x2a, 0x29, 0x5e, 0xe0, 0xf2, 0xaf, 0x5b, 0xb9, 0xed, 0xc2, 0xa3, 0x02, 0xd5,
0xc0, 0xe6, 0x9f, 0x73, 0xb0, 0x9a, 0x79, 0x5b, 0x5a, 0xf9, 0x5c, 0x46, 0xf9, 0xd8, 0x55, 0xf9,
0x94, 0xab, 0x5a, 0x50, 0x1e, 0xb3, 0xa9, 0x1f, 0x32, 0x17, 0x5d, 0x51, 0xa7, 0x31, 0xa8, 0x5e,
0xf7, 0xca, 0x73, 0xa5, 0xf2, 0x81, 0x32, 0xa2, 0x06, 0xc8, 0x1d, 0x28, 0x0d, 0xb9, 0x77, 0x3e,
0x94, 0xc6, 0xb6, 0x06, 0x22, 0x9b, 0x50, 0x51, 0x09, 0x23, 0xbc, 0x6f, 0x38, 0xda, 0xb4, 0x40,
0x13, 0x98, 0xbc, 0x05, 0xab, 0x11, 0x9e, 0x6c, 0xc9, 0xa2, 0x73, 0x2e, 0xd1, 0xa6, 0x05, 0x5a,
0xd7, 0xc8, 0x53, 0xc4, 0xcd, 0x0a, 0x66, 0x25, 0x55, 0x30, 0xad, 0x3f, 0xe5, 0xe0, 0xd6, 0x41,
0xe8, 0x30, 0xdf, 0x78, 0xe6, 0xd8, 0x28, 0xf7, 0x01, 0x14, 0x2f, 0xf8, 0x54, 0xa0, 0x29, 0x6a,
0xbb, 0x0f, 0x67, 0x5e, 0x58, 0x40, 0xbc, 0xb3, 0xcf, 0xa7, 0x14, 0xc9, 0xc9, 0x13, 0xa8, 0x8f,
0x94, 0x9b, 0x98, 0x76, 0x13, 0x5a, 0xa2, 0xb6, 0x7b, 0x67, 0xb1, 0x13, 0x69, 0x86, 0x56, 0xdd,
0x70, 0xcc, 0x84, 0x78, 0x15, 0x46, 0xae, 0x89, 0xda, 0x04, 0xde, 0xfc, 0x1f, 0x28, 0xec, 0xf3,
0xe9, 0xc2, 0x5c, 0x20, 0x50, 0x54, 0x4d, 0x04, 0x5f, 0x55, 0xa7, 0x78, 0xb6, 0x7e, 0x9f, 0x83,
0xdb, 0x19, 0x45, 0x39, 0x8f, 0x9e, 0x71, 0xdf, 0x0f, 0x55, 0x84, 0x9a, 0xc8, 0xb4, 0x2f, 0x79,
0x24, 0xbc, 0x30, 0x40, 0x61, 0x2b, 0xb4, 0x61, 0xd0, 0x2f, 0x34, 0x56, 0x39, 0x79, 0xcc, 0x39,
0x06, 0xb9, 0x96, 0x5c, 0x52, 0xe0, 0x9e, 0x8b, 0x7d, 0x8c, 0x5f, 0x7a, 0x0e, 0xb7, 0x51, 0x15,
0xad, 0x29, 0x68, 0x54, 0x5f, 0x29, 0x34, 0x23, 0x90, 0xd3, 0x31, 0x47, 0xef, 0x26, 0x04, 0xa7,
0xd3, 0x31, 0x66, 0xaf, 0xf0, 0xce, 0x03, 0x26, 0x27, 0x11, 0x47, 0x2f, 0xd7, 0xe9, 0x0c, 0x61,
0x7d, 0x9b, 0x83, 0xa6, 0x52, 0x3b, 0xdd, 0x99, 0x96, 0x74, 0xbb, 0x77, 0x61, 0xcd, 0x4b, 0x51,
0xd9, 0x49, 0xeb, 0x6b, 0xa4, 0xd1, 0x19, 0x9d, 0x51, 0xa5, 0xc2, 0x15, 0x95, 0x62, 0xc3, 0x16,
0xb3, 0x91, 0x1b, 0x9b, 0x68, 0x05, 0x5b, 0x71, 0x0c, 0x5a, 0x7f, 0xcb, 0xc1, 0xdd, 0x25, 0xcd,
0xf3, 0x86, 0x7d, 0xf9, 0x2d, 0x58, 0x35, 0x1d, 0xc0, 0xc6, 0xd4, 0x35, 0x2a, 0xd5, 0x0d, 0x52,
0xe7, 0xd9, 0x3d, 0xa8, 0xf0, 0x40, 0xd8, 0x29, 0xc5, 0xca, 0x3c, 0x10, 0x68, 0xe3, 0x87, 0x50,
0xf7, 0x99, 0x90, 0xf6, 0x64, 0xec, 0x32, 0xc9, 0x75, 0x1d, 0x2a, 0xd2, 0x9a, 0xc2, 0x0d, 0x34,
0x4a, 0xdd, 0x59, 0x4c, 0x85, 0xe4, 0x23, 0x5b, 0xb2, 0x73, 0xd5, 0x26, 0x0b, 0xea, 0xce, 0x1a,
0x75, 0xca, 0xce, 0x05, 0x79, 0x07, 0x1a, 0xbe, 0x8a, 0x11, 0x3b, 0xf0, 0x9c, 0x0b, 0x7c, 0x89,
0x2e, 0x45, 0xab, 0x88, 0xed, 0x1b, 0xa4, 0xf5, 0xd3, 0x12, 0xdc, 0x5b, 0x3a, 0x29, 0x90, 0xff,
0x85, 0x8d, 0xb4, 0x22, 0x36, 0xf2, 0xfa, 0x53, 0x73, 0x7b, 0x92, 0x52, 0xe8, 0x40, 0x3f, 0xf9,
0x0f, 0x36, 0x85, 0xf2, 0x2d, 0x73, 0x5d, 0xee, 0x62, 0x41, 0xad, 0x50, 0x0d, 0xa8, 0x38, 0x39,
0x53, 0x4e, 0xe6, 0x2e, 0xb6, 0xe0, 0x0a, 0x8d, 0x41, 0x45, 0x3f, 0x9a, 0x28, 0x9d, 0x6a, 0x9a,
0x1e, 0x01, 0x45, 0x1f, 0xf1, 0x51, 0x78, 0xc9, 0x5d, 0x6c, 0x95, 0x15, 0x1a, 0x83, 0x64, 0x1b,
0xea, 0x43, 0x26, 0x6c, 0x14, 0x6b, 0x4f, 0x44, 0x6b, 0x15, 0x1f, 0xc3, 0x90, 0x89, 0xb6, 0x42,
0x0d, 0xb0, 0xc0, 0x5f, 0xf2, 0xc8, 0x7b, 0x19, 0x8f, 0xa2, 0x42, 0x32, 0x39, 0x11, 0xad, 0x06,
0xd6, 0x3b, 0x92, 0x7e, 0x74, 0x82, 0x4f, 0x70, 0xa8, 0x8c, 0x26, 0x42, 0xc6, 0x94, 0x6b, 0x48,
0x59, 0x43, 0x9c, 0x21, 0xf9, 0x14, 0xee, 0x9b, 0x49, 0xcb, 0x8e, 0xf8, 0x4f, 0x26, 0x5c, 0x48,
0xed, 0x45, 0x64, 0xe1, 0xad, 0x26, 0x72, 0xb4, 0x0c, 0x09, 0xd5, 0x14, 0xe8, 0x4c, 0xc5, 0xcf,
0x97, 0xb3, 0xeb, 0x34, 0x58, 0x5f, 0xca, 0xde, 0xc1, 0xcc, 0xf8, 0x0c, 0xb6, 0xe6, 0xd9, 0x95,
0x39, 0x24, 0x37, 0xaf, 0x27, 0xc8, 0x7f, 0x2f, 0xcb, 0x4f, 0x91, 0x42, 0xbf, 0x7f, 0xb9, 0x00,
0xad, 0xc0, 0xad, 0xe5, 0x02, 0xb4, 0x06, 0x0f, 0xa1, 0xee, 0x7a, 0x62, 0xec, 0xb3, 0xa9, 0x8e,
0xaf, 0x0d, 0x74, 0x7d, 0xcd, 0xe0, 0x54, 0x8c, 0x59, 0xaf, 0xae, 0xe6, 0x7b, 0x3c, 0x9e, 0x2c,
0xce, 0xf7, 0x2b, 0x41, 0x9d, 0x5f, 0x10, 0xd4, 0xf3, 0x91, 0x5b, 0xb8, 0x12, 0xb9, 0xd6, 0x53,
0xd8, 0x9c, 0x7f, 0xf1, 0xf1, 0xe4, 0xcc, 0xf7, 0x9c, 0xce, 0x90, 0xdd, 0xb0, 0xd6, 0x58, 0xbf,
0x2b, 0xc0, 0x6a, 0x66, 0x4c, 0xff, 0x97, 0x7c, 0x75, 0x4c, 0xcc, 0x07, 0x50, 0x1b, 0x47, 0xde,
0x25, 0x93, 0xdc, 0xbe, 0xe0, 0x53, 0xd3, 0xbd, 0xc1, 0xa0, 0x54, 0x37, 0xda, 0x56, 0x55, 0x55,
0x38, 0x91, 0x37, 0x56, 0x7a, 0x61, 0x5e, 0xd6, 0x69, 0x1a, 0xa5, 0x9a, 0xf9, 0x8f, 0x43, 0x2f,
0x30, 0x59, 0x59, 0xa1, 0x06, 0x52, 0xad, 0x4e, 0xc7, 0x2a, 0x77, 0xb1, 0x99, 0x57, 0x68, 0x02,
0xcf, 0x92, 0xa6, 0x9c, 0x4e, 0x9a, 0x23, 0x68, 0x1a, 0xef, 0x0a, 0x5b, 0x86, 0xb6, 0x92, 0x63,
0x26, 0xa4, 0x77, 0x96, 0x2d, 0x23, 0x86, 0xfc, 0x34, 0x7c, 0x1e, 0x7a, 0x01, 0x6d, 0x44, 0x19,
0x98, 0x7c, 0x0c, 0x95, 0x78, 0x04, 0x36, 0x23, 0xf7, 0x83, 0x25, 0x82, 0xcc, 0xec, 0x2d, 0x68,
0xc2, 0xa0, 0x3a, 0x18, 0x0f, 0x9c, 0x68, 0x3a, 0x96, 0x49, 0xd2, 0xcf, 0x10, 0xd8, 0xdf, 0xc6,
0xdc, 0x91, 0x6c, 0x96, 0xfa, 0x33, 0x84, 0x6a, 0x5a, 0x86, 0x54, 0x25, 0x30, 0x0e, 0x19, 0x75,
0xb4, 0x5c, 0x63, 0x86, 0xde, 0xe7, 0x53, 0x61, 0xfd, 0xac, 0x00, 0xf7, 0xaf, 0xb9, 0x91, 0xf1,
0x57, 0x2e, 0xf1, 0xd7, 0x9b, 0x00, 0x63, 0x8c, 0x0d, 0x74, 0x97, 0xf6, 0x7f, 0x55, 0x63, 0x94,
0xb7, 0x12, 0xa7, 0x17, 0xd2, 0x4e, 0xbf, 0xa6, 0xb0, 0xde, 0x85, 0xb2, 0x33, 0x64, 0x32, 0x1e,
0x73, 0xab, 0xb4, 0xa4, 0xc0, 0x3d, 0x57, 0xc5, 0x6d, 0xbc, 0x46, 0x4d, 0xd5, 0xd3, 0x92, 0x76,
0x7c, 0x82, 0xdb, 0x43, 0x27, 0xea, 0xf4, 0x2d, 0xeb, 0x97, 0x21, 0x40, 0x2e, 0x80, 0x44, 0xfc,
0x92, 0x33, 0x9f, 0xbb, 0xaa, 0xc8, 0x45, 0x5c, 0x88, 0x64, 0xd0, 0xfd, 0xe4, 0x46, 0x6e, 0xdc,
0xa1, 0x86, 0xbf, 0x1d, 0xb3, 0xf7, 0x02, 0x19, 0x4d, 0xe9, 0x7a, 0x34, 0x8f, 0xdf, 0xec, 0xc2,
0x9d, 0xc5, 0xc4, 0xa4, 0x09, 0x05, 0x65, 0x21, 0x3d, 0x44, 0xa9, 0xa3, 0x52, 0xf7, 0x92, 0xf9,
0x13, 0x6e, 0xa2, 0x5f, 0x03, 0x4f, 0xf2, 0x1f, 0xe5, 0xac, 0x5f, 0xe4, 0xa1, 0x39, 0x9f, 0x81,
0xe4, 0xd3, 0xd4, 0x56, 0x7d, 0x65, 0x40, 0x5c, 0xd2, 0x2b, 0x53, 0x3b, 0xf5, 0xe7, 0x50, 0x37,
0x8e, 0x52, 0x06, 0x15, 0xad, 0xfc, 0xfc, 0xa4, 0xbf, 0x3c, 0xe5, 0x69, 0x6d, 0x9c, 0x9c, 0x05,
0xf9, 0x18, 0xca, 0xf1, 0xa0, 0x59, 0xc0, 0x10, 0xbe, 0x46, 0x8d, 0x78, 0xe6, 0x8c, 0x39, 0xfe,
0x8d, 0xcd, 0xde, 0xfa, 0x10, 0xd6, 0xf0, 0xa9, 0x52, 0xc8, 0xb4, 0xae, 0x9b, 0x95, 0xa2, 0x4f,
0x60, 0x23, 0x66, 0x3c, 0xd4, 0xdf, 0x4e, 0x04, 0xe5, 0xec, 0xa6, 0xdc, 0xdf, 0x83, 0x3b, 0xb8,
0x88, 0x3a, 0xd2, 0xbb, 0xf4, 0xe4, 0xb4, 0xc3, 0x03, 0xc9, 0xa3, 0x6b, 0xf8, 0x9b, 0x50, 0xf0,
0x5c, 0x6d, 0xde, 0x3a, 0x55, 0x47, 0xab, 0xab, 0xcb, 0x69, 0x56, 0x42, 0xdb, 0x71, 0x38, 0xe6,
0xed, 0x4d, 0xa5, 0xf4, 0x74, 0x5e, 0x66, 0xa5, 0x74, 0x3d, 0x31, 0xf2, 0x84, 0x78, 0x0d, 0x31,
0xdf, 0xe6, 0xa0, 0xae, 0xe4, 0x3c, 0x0d, 0xc3, 0x8b, 0x11, 0x8b, 0x2e, 0x96, 0x33, 0x4e, 0x22,
0xdf, 0x98, 0x41, 0x1d, 0x93, 0x61, 0xb5, 0x90, 0x1a, 0x56, 0xef, 0x43, 0x15, 0x1b, 0x8d, 0xad,
0x68, 0x75, 0x22, 0x57, 0x10, 0x31, 0x88, 0xfc, 0xf4, 0xc4, 0xb1, 0x92, 0x9d, 0x38, 0xde, 0x04,
0x70, 0xb9, 0xcf, 0xd5, 0xe4, 0xc6, 0x24, 0x26, 0x72, 0x91, 0x56, 0x0d, 0xa6, 0x2d, 0xad, 0xe7,
0x3a, 0xf8, 0x3b, 0x3e, 0x67, 0xd1, 0x33, 0x4f, 0xc8, 0x30, 0x9a, 0xa6, 0xcb, 0x42, 0x2e, 0x53,
0x16, 0xde, 0x04, 0x70, 0x14, 0xa1, 0x96, 0x95, 0xd7, 0xb2, 0x0c, 0xa6, 0x2d, 0xad, 0x3f, 0xe6,
0x80, 0x28, 0x61, 0xe6, 0x53, 0xca, 0xb1, 0xe7, 0xa8, 0x71, 0x7f, 0xe1, 0x4a, 0x93, 0xda, 0x19,
0xf3, 0x4b, 0x76, 0xc6, 0x02, 0x4e, 0xe4, 0x57, 0x76, 0xc6, 0x22, 0xa2, 0xe3, 0x9d, 0xf1, 0x3e,
0x54, 0xb1, 0x05, 0xe3, 0xd2, 0xa8, 0x67, 0x78, 0x5c, 0x1a, 0x4f, 0x16, 0x2e, 0x8d, 0x25, 0x24,
0x58, 0xb2, 0x34, 0x96, 0xd3, 0x4b, 0xe3, 0x10, 0x6e, 0x5d, 0xbd, 0x89, 0x58, 0xbe, 0x17, 0x7f,
0x04, 0x95, 0xb1, 0x21, 0x32, 0xc9, 0xbe, 0x95, 0xcd, 0xb3, 0xac, 0x24, 0x9a, 0x50, 0x5b, 0xbf,
0xc9, 0xc3, 0xba, 0x22, 0xf8, 0x82, 0xf9, 0x3e, 0x97, 0xd7, 0xcf, 0x1c, 0x2d, 0x28, 0x9b, 0xa2,
0x1a, 0x5b, 0xcd, 0x80, 0xca, 0x3e, 0xaf, 0x50, 0x00, 0x9a, 0xad, 0x42, 0x0d, 0xa4, 0x6c, 0xaf,
0x7c, 0x87, 0x56, 0xab, 0x50, 0x3c, 0x2b, 0x1c, 0xee, 0x48, 0xba, 0xe4, 0xe3, 0x59, 0x49, 0x56,
0xbe, 0x57, 0x73, 0x8c, 0xfe, 0x9c, 0x11, 0x83, 0x8a, 0x7a, 0xcc, 0xe4, 0xd0, 0x8c, 0xcb, 0x78,
0x56, 0xed, 0x2f, 0xe9, 0x3a, 0xb8, 0x6c, 0xd7, 0xd3, 0x6d, 0x28, 0xf6, 0x77, 0x35, 0xe5, 0x6f,
0x75, 0x1f, 0xfc, 0x50, 0x01, 0x88, 0xd4, 0x00, 0x7a, 0xd5, 0x73, 0x5d, 0x1e, 0x98, 0x1e, 0x6a,
0xa0, 0xe5, 0xf3, 0xb3, 0x75, 0xa8, 0x23, 0x2c, 0x63, 0x2c, 0x41, 0x3e, 0x84, 0x8a, 0xa9, 0x79,
0x71, 0xb5, 0xbe, 0x9f, 0xb5, 0x7e, 0x86, 0x9e, 0x26, 0xc4, 0xd6, 0x3f, 0x72, 0x3a, 0xfc, 0x4f,
0xd8, 0x65, 0xd2, 0x43, 0xd2, 0x56, 0xce, 0x65, 0xad, 0xbc, 0xe8, 0xeb, 0xc7, 0x16, 0x54, 0x5f,
0xb2, 0xcb, 0x70, 0x12, 0x79, 0x92, 0x1b, 0xe3, 0xcf, 0x10, 0xd7, 0xe4, 0xe5, 0x43, 0xa8, 0xeb,
0xa9, 0xd0, 0x4e, 0x87, 0x5f, 0x4d, 0xe3, 0xf4, 0xd8, 0xfa, 0xdf, 0xb0, 0xee, 0x0c, 0x99, 0x17,
0xd8, 0x62, 0x18, 0x46, 0x12, 0x3b, 0xb8, 0xfe, 0x08, 0x59, 0xa5, 0x6b, 0xf8, 0xe0, 0x44, 0xe1,
0x55, 0x27, 0x17, 0xaa, 0x86, 0xf0, 0x40, 0x18, 0x9b, 0xab, 0xa3, 0x8a, 0x55, 0x4f, 0xd8, 0x92,
0x0b, 0x69, 0xe6, 0x97, 0x92, 0x27, 0x4e, 0xb9, 0x90, 0xcf, 0x8b, 0x95, 0x62, 0x73, 0xc5, 0xfa,
0x65, 0x0e, 0x6e, 0x2f, 0x1c, 0x82, 0x96, 0xc4, 0xde, 0xfc, 0x48, 0xa0, 0x6d, 0x90, 0x19, 0x09,
0x7a, 0xf0, 0x60, 0xa8, 0x4b, 0x88, 0xcd, 0x22, 0x67, 0xe8, 0x5d, 0x72, 0x5b, 0x4c, 0xc6, 0x63,
0xa5, 0x3b, 0x0f, 0xd8, 0x99, 0x6f, 0x06, 0xe0, 0x0a, 0xdd, 0x32, 0x64, 0x6d, 0x4d, 0x75, 0xa2,
0x89, 0x7a, 0x9a, 0xc6, 0xfa, 0x6d, 0x4e, 0x37, 0x9f, 0x53, 0xb5, 0xc1, 0xa8, 0x9d, 0x88, 0x47,
0x37, 0xdc, 0xb9, 0x3f, 0x85, 0x92, 0x59, 0x82, 0xd4, 0x7b, 0x1a, 0xf3, 0x83, 0x63, 0x4a, 0xe0,
0xce, 0xe9, 0x6c, 0x3d, 0xa2, 0x86, 0xc9, 0x7a, 0x02, 0xb5, 0x14, 0x9a, 0xd4, 0xa0, 0x3c, 0xe8,
0xef, 0xf7, 0x8f, 0xbe, 0xe8, 0x37, 0xdf, 0x50, 0xc0, 0x29, 0x1d, 0x9c, 0x9c, 0xf6, 0xba, 0xcd,
0x1c, 0x59, 0x87, 0xd5, 0x41, 0x1f, 0xc1, 0x2f, 0x8e, 0xe8, 0xe9, 0xb3, 0x2f, 0x9b, 0x79, 0xeb,
0xdb, 0x82, 0x5e, 0x20, 0x5e, 0xa4, 0x16, 0x34, 0x33, 0xd8, 0x2c, 0x51, 0x9e, 0x40, 0xf1, 0x65,
0x14, 0x8e, 0xe2, 0x60, 0x52, 0x67, 0x75, 0x21, 0x19, 0x9a, 0xaa, 0x9f, 0x97, 0xa1, 0x0a, 0x2e,
0x67, 0xa8, 0x62, 0x37, 0x38, 0x8f, 0x87, 0xb7, 0x19, 0x42, 0xb9, 0xc4, 0x8c, 0xbc, 0xba, 0x20,
0x9b, 0xbd, 0x38, 0xc1, 0xb5, 0xf1, 0x8b, 0x53, 0xc4, 0xc5, 0x38, 0x0c, 0x44, 0x9c, 0xd8, 0x09,
0xac, 0xaa, 0x79, 0xc4, 0xc7, 0xbe, 0xa7, 0x99, 0x75, 0xfc, 0x55, 0x0d, 0xa6, 0x2d, 0x09, 0x5f,
0xbc, 0x88, 0x56, 0xd0, 0xb2, 0xff, 0x9f, 0xb5, 0xec, 0x82, 0x5b, 0xef, 0xbc, 0xb8, 0xb2, 0xaa,
0x2e, 0x5c, 0x5f, 0xb5, 0x0f, 0xab, 0xc9, 0x08, 0xf0, 0x43, 0x20, 0x57, 0x39, 0xaf, 0xf8, 0xe2,
0xb8, 0xd7, 0xef, 0xee, 0xf5, 0x3f, 0x6f, 0xe6, 0x48, 0x1d, 0x2a, 0xed, 0x4e, 0xa7, 0x77, 0xac,
0x3c, 0x93, 0x57, 0x50, 0xb7, 0xd7, 0x39, 0xd8, 0xeb, 0xf7, 0xba, 0xcd, 0x82, 0x82, 0x3a, 0xed,
0x7e, 0xa7, 0x77, 0xd0, 0xeb, 0x36, 0x8b, 0xd6, 0x5f, 0x72, 0x7a, 0x36, 0xe8, 0x64, 0xf6, 0xc4,
0x2e, 0x77, 0x3c, 0xb1, 0xfc, 0x03, 0xd4, 0x16, 0x54, 0x8d, 0x3d, 0xf7, 0xe2, 0x48, 0x9b, 0x21,
0xc8, 0x8f, 0x60, 0xcd, 0x35, 0xfc, 0x76, 0x26, 0xf2, 0xde, 0x9f, 0x9f, 0xb2, 0x16, 0xbd, 0x72,
0x27, 0x3e, 0x18, 0xf3, 0x34, 0xdc, 0x0c, 0x6c, 0xbd, 0x07, 0x8d, 0x2c, 0x45, 0xe6, 0xb2, 0x6f,
0x64, 0x2e, 0x9b, 0xb3, 0x7e, 0x9e, 0x87, 0xb5, 0xb9, 0x3f, 0x33, 0x96, 0xf7, 0xab, 0xf9, 0x8d,
0x38, 0x7f, 0x65, 0x23, 0x26, 0xef, 0x01, 0x49, 0x93, 0xd8, 0xe9, 0xd5, 0xa2, 0x99, 0x22, 0xd4,
0xb5, 0x2a, 0xdd, 0x00, 0x8b, 0xaf, 0xd3, 0x00, 0xc9, 0x0f, 0x60, 0x43, 0x84, 0x8e, 0xc7, 0x7c,
0xdb, 0xf7, 0x82, 0x8b, 0xe4, 0x6f, 0xb9, 0xd6, 0x0a, 0x4a, 0x99, 0x5b, 0xd9, 0x4e, 0x90, 0xf2,
0xc0, 0x0b, 0x2e, 0xe2, 0xff, 0x4b, 0x88, 0x98, 0x47, 0x09, 0x4b, 0x00, 0x50, 0xf6, 0xca, 0xcc,
0x9f, 0xe9, 0x59, 0x23, 0x97, 0x9d, 0x35, 0xf6, 0xa1, 0x66, 0xfe, 0xe0, 0x3b, 0x55, 0x0d, 0x31,
0x8f, 0xae, 0xfb, 0xaf, 0xd9, 0x1b, 0xdb, 0xb3, 0xbf, 0x04, 0x0f, 0xcd, 0x3f, 0x82, 0x46, 0xe8,
0x8e, 0x62, 0xa0, 0x69, 0x6e, 0xeb, 0xd7, 0x39, 0x68, 0x28, 0x15, 0x53, 0x6f, 0xfe, 0x0e, 0xd4,
0xa2, 0x04, 0x8a, 0x5b, 0xd3, 0xc6, 0x4c, 0xfe, 0x8c, 0x94, 0xa6, 0x09, 0xc9, 0x2e, 0x6c, 0x88,
0xc9, 0x59, 0xdc, 0xde, 0x9e, 0x8b, 0x30, 0x78, 0x3a, 0x95, 0x3c, 0x6e, 0xfa, 0x0b, 0x9f, 0x91,
0xf7, 0x60, 0x3d, 0x36, 0xdd, 0x8c, 0x41, 0x6f, 0xf4, 0x57, 0x1f, 0x58, 0xbf, 0xca, 0x41, 0x4d,
0x29, 0x6b, 0xfe, 0xef, 0xc1, 0x11, 0x34, 0x09, 0x12, 0x75, 0x5c, 0xd8, 0xeb, 0xee, 0x40, 0xc9,
0x7c, 0x06, 0x33, 0x53, 0x86, 0xf9, 0x0a, 0x96, 0x0a, 0xb3, 0x62, 0x26, 0xcc, 0xb6, 0xa0, 0x3a,
0xdb, 0x02, 0x57, 0x70, 0x30, 0x9e, 0x21, 0x66, 0x19, 0x57, 0x4a, 0x8f, 0x5e, 0x7f, 0x30, 0x03,
0x91, 0x51, 0x4d, 0xcd, 0xe0, 0x61, 0x40, 0x9e, 0x40, 0x89, 0xe1, 0x09, 0x75, 0x6c, 0xec, 0x5a,
0xd9, 0xb8, 0xc8, 0x10, 0xef, 0xe8, 0x1f, 0x6a, 0x38, 0xc8, 0xdb, 0xb0, 0x1a, 0xfa, 0xae, 0x21,
0x19, 0x24, 0x1d, 0x23, 0x8b, 0x24, 0x8f, 0xf1, 0x12, 0x0a, 0x32, 0xab, 0xd6, 0xed, 0x85, 0xaf,
0xa0, 0x31, 0x95, 0xea, 0xa0, 0x25, 0xa3, 0xdd, 0x3a, 0xac, 0xee, 0xf7, 0xbe, 0xec, 0xb4, 0x69,
0xd7, 0x6e, 0x77, 0xbb, 0x98, 0x9c, 0x04, 0x1a, 0xed, 0x4e, 0xe7, 0x68, 0xd0, 0x3f, 0x3d, 0x31,
0xb8, 0x1c, 0xb9, 0x05, 0x6b, 0x31, 0x59, 0xb7, 0x77, 0xd0, 0xd3, 0x25, 0x6b, 0x03, 0x9a, 0x09,
0x21, 0xed, 0x1d, 0x1e, 0xbd, 0xc0, 0xd2, 0x05, 0x50, 0x3a, 0x38, 0xea, 0xec, 0xab, 0xc2, 0xa5,
0xf2, 0x7c, 0xd0, 0x37, 0xd0, 0x0a, 0x59, 0x83, 0xda, 0x60, 0xaf, 0x6b, 0x0f, 0x8e, 0xbb, 0x6d,
0x25, 0xa0, 0x44, 0x9a, 0x50, 0xef, 0xb7, 0x0f, 0x7b, 0x76, 0xe7, 0x59, 0xbb, 0xff, 0x79, 0xaf,
0xdb, 0x2c, 0x5b, 0x5f, 0xe9, 0x06, 0x9a, 0xfa, 0x3f, 0x8f, 0xfc, 0x5f, 0xea, 0xcf, 0x3f, 0x1d,
0x87, 0x4b, 0xae, 0x37, 0xfb, 0xe3, 0x2f, 0x71, 0x4f, 0x3e, 0xed, 0x9e, 0x13, 0x3d, 0x36, 0x5c,
0x49, 0x44, 0x1c, 0x2b, 0xf9, 0xd7, 0x32, 0x1e, 0xf3, 0xd5, 0x79, 0xc1, 0x66, 0xb3, 0xf0, 0x1b,
0xc5, 0xd3, 0xd5, 0xaf, 0x6a, 0x3b, 0x8f, 0x3f, 0x8e, 0xf5, 0x39, 0x2b, 0xe1, 0xe9, 0xfd, 0x7f,
0x06, 0x00, 0x00, 0xff, 0xff, 0x4c, 0x7b, 0xbf, 0x10, 0xc2, 0x1f, 0x00, 0x00,
// 2985 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x19, 0x4d, 0x97, 0x1b, 0x47,
0x31, 0xfa, 0x58, 0x7d, 0x94, 0xb4, 0x5a, 0x6d, 0x7b, 0x6d, 0xcb, 0x6b, 0xe7, 0xd9, 0x9e, 0x24,
0x2f, 0x86, 0x17, 0xd6, 0xe0, 0x10, 0x12, 0xec, 0xe4, 0x05, 0x59, 0x52, 0xe2, 0xf5, 0xda, 0xf2,
0xd2, 0xbb, 0xeb, 0x90, 0xc0, 0x7b, 0xf3, 0xda, 0x33, 0xed, 0x55, 0x67, 0x47, 0x33, 0x62, 0xba,
0xb5, 0x8e, 0x72, 0x02, 0x4e, 0x9c, 0xb9, 0xc0, 0x31, 0x67, 0x8e, 0xbc, 0xc7, 0x81, 0x1b, 0x47,
0xee, 0x1c, 0x81, 0x3f, 0xc0, 0xe3, 0x07, 0x70, 0xe4, 0x75, 0x75, 0xcf, 0x68, 0x46, 0x2b, 0x2d,
0xf6, 0xe3, 0xc4, 0x49, 0x5d, 0x35, 0x55, 0xd5, 0xd5, 0xf5, 0xd1, 0x55, 0xd5, 0x82, 0xf5, 0x09,
0x13, 0xb1, 0x08, 0x8f, 0x77, 0x26, 0x71, 0xa4, 0x22, 0x52, 0xc3, 0x9f, 0x67, 0xd3, 0xe7, 0xdb,
0x17, 0xe4, 0x2c, 0xf4, 0x5c, 0xc9, 0x95, 0x12, 0xe1, 0xb1, 0x34, 0x9f, 0xb7, 0x1d, 0x36, 0x99,
0x04, 0xc2, 0x63, 0x4a, 0x44, 0xa1, 0x3b, 0xe6, 0x8a, 0xf9, 0x4c, 0x31, 0x77, 0xcc, 0xa5, 0x64,
0xc7, 0xdc, 0xd0, 0x38, 0x0c, 0xae, 0x7e, 0xc2, 0x95, 0x37, 0x12, 0xe1, 0xf1, 0x7d, 0xe6, 0x9d,
0x70, 0xff, 0x68, 0xd2, 0x67, 0x8a, 0xf5, 0xb9, 0x62, 0x22, 0x90, 0xe4, 0x3a, 0x34, 0x90, 0x29,
0x9c, 0x8e, 0x9f, 0xf1, 0xb8, 0x53, 0xb8, 0x51, 0xb8, 0xb5, 0x4e, 0x41, 0xa3, 0x86, 0x88, 0x21,
0x37, 0xa1, 0xa9, 0x22, 0xc5, 0x82, 0x84, 0xa2, 0x88, 0x14, 0x0d, 0xc4, 0x19, 0x12, 0xe7, 0x17,
0x55, 0xa8, 0x68, 0xd9, 0xd3, 0x09, 0xd9, 0x82, 0x35, 0x2f, 0x88, 0xbc, 0x13, 0x14, 0x54, 0xa6,
0x06, 0x20, 0x2d, 0x28, 0x0a, 0x1f, 0x39, 0xeb, 0xb4, 0x28, 0x7c, 0xf2, 0x31, 0xd4, 0xbc, 0x28,
0x54, 0xcc, 0x53, 0xb2, 0x53, 0xba, 0x51, 0xba, 0xd5, 0xb8, 0xf3, 0xc6, 0x4e, 0x72, 0xd2, 0x9d,
0x83, 0x59, 0xe8, 0xed, 0x86, 0x52, 0xb1, 0x20, 0xc0, 0x83, 0xf5, 0x0c, 0xe5, 0xd3, 0x3b, 0x34,
0x65, 0x22, 0x3f, 0x84, 0x86, 0x17, 0x8d, 0xc7, 0xd3, 0x50, 0x28, 0xc1, 0x65, 0xa7, 0x8c, 0x32,
0x2e, 0xe7, 0x65, 0xf4, 0x2c, 0xc1, 0x8c, 0x66, 0x69, 0xc9, 0x13, 0xd8, 0x48, 0xc4, 0x58, 0x1b,
0x74, 0xd6, 0x6e, 0x14, 0x6e, 0x35, 0xee, 0xbc, 0x35, 0x67, 0x3f, 0xc7, 0x60, 0x74, 0x91, 0x9b,
0x1c, 0x01, 0xc9, 0xc8, 0x4f, 0x64, 0x56, 0x5e, 0x45, 0xe6, 0x12, 0x01, 0xe4, 0x5d, 0xa8, 0x4e,
0xe2, 0xe8, 0xb9, 0x08, 0x78, 0xa7, 0x8a, 0xb2, 0xae, 0xcc, 0x65, 0x25, 0x32, 0xf6, 0x0d, 0x01,
0x4d, 0x28, 0xc9, 0x63, 0x68, 0xd9, 0x65, 0xa2, 0x47, 0xed, 0x55, 0xf4, 0x58, 0x60, 0x26, 0xb7,
0xa1, 0x6a, 0x23, 0xae, 0x53, 0x47, 0x39, 0x17, 0xf3, 0x26, 0x3e, 0x30, 0x1f, 0x69, 0x42, 0xa5,
0x8d, 0x9b, 0x84, 0x68, 0xa2, 0x00, 0xbc, 0x92, 0x71, 0x17, 0xb8, 0xc9, 0x7b, 0x50, 0x3b, 0xe1,
0x33, 0x8f, 0xc5, 0xbe, 0xec, 0x34, 0x16, 0xcd, 0xa0, 0x55, 0xe8, 0x06, 0xc1, 0x9e, 0x25, 0xa0,
0x29, 0xa9, 0xd6, 0x23, 0x59, 0x27, 0x7a, 0x34, 0x5f, 0x49, 0x8f, 0x05, 0x6e, 0xd2, 0x85, 0xf5,
0x17, 0x2c, 0x08, 0xb8, 0xea, 0x7a, 0x5e, 0x34, 0x0d, 0x55, 0x67, 0x1d, 0xc5, 0x5d, 0xcd, 0x2b,
0xf3, 0x59, 0x96, 0x84, 0xe6, 0x39, 0xc8, 0x4f, 0xe1, 0x62, 0x0e, 0x91, 0x6a, 0xd6, 0x7a, 0x15,
0xcd, 0x96, 0xcb, 0x70, 0xfe, 0x55, 0x86, 0xe6, 0xe3, 0x69, 0xa0, 0x44, 0xb2, 0x1b, 0x81, 0x72,
0xc8, 0xc6, 0x1c, 0xf3, 0xb0, 0x4e, 0x71, 0x4d, 0xae, 0x41, 0x5d, 0x89, 0x31, 0x97, 0x8a, 0x8d,
0x27, 0x98, 0x8d, 0x25, 0x3a, 0x47, 0xe8, 0xaf, 0xc2, 0xe7, 0xa1, 0x12, 0x5e, 0x14, 0x76, 0x4a,
0xc8, 0x36, 0x47, 0x90, 0x8f, 0x01, 0xbc, 0x28, 0x88, 0x62, 0x77, 0xc4, 0xe4, 0xc8, 0x26, 0xdc,
0x8d, 0xb9, 0xca, 0xd9, 0xbd, 0x77, 0x7a, 0x9a, 0xf0, 0x01, 0x93, 0x23, 0x5a, 0xf7, 0x92, 0x25,
0xb9, 0xa2, 0x73, 0x5e, 0x0b, 0x10, 0x3e, 0x26, 0x5c, 0x89, 0x56, 0x11, 0xde, 0xf5, 0xc9, 0xdb,
0xa9, 0xb7, 0x5c, 0x7b, 0xfd, 0x61, 0xfa, 0xd4, 0x69, 0xcb, 0xa2, 0xf7, 0x0d, 0x96, 0x5c, 0x86,
0xea, 0x09, 0x9f, 0xb9, 0x53, 0xe1, 0x63, 0x4e, 0xd4, 0x69, 0xe5, 0x84, 0xcf, 0x8e, 0x84, 0x4f,
0x3e, 0x84, 0x8a, 0x18, 0xb3, 0x63, 0xae, 0xe3, 0x5d, 0x6b, 0xf6, 0xe6, 0x0a, 0xcd, 0x76, 0xf1,
0x3c, 0x6a, 0xb6, 0xab, 0x89, 0xa9, 0xe5, 0x21, 0xb7, 0xe1, 0x82, 0x37, 0x95, 0x2a, 0x1a, 0x8b,
0xaf, 0xcd, 0x55, 0x8a, 0x8a, 0x61, 0xc8, 0xd7, 0x29, 0xc9, 0x7d, 0xc2, 0xa3, 0x6d, 0xdf, 0x84,
0x7a, 0x7a, 0x46, 0x7d, 0xe5, 0x89, 0xd0, 0xe7, 0x5f, 0x75, 0x0a, 0x37, 0x4a, 0xb7, 0x4a, 0xd4,
0x00, 0xdb, 0x7f, 0x2b, 0xc0, 0x7a, 0x6e, 0xb7, 0xac, 0xf2, 0x85, 0x9c, 0xf2, 0x89, 0xab, 0x8a,
0x19, 0x57, 0x75, 0xa0, 0x3a, 0x61, 0xb3, 0x20, 0x62, 0x3e, 0xba, 0xa2, 0x49, 0x13, 0x50, 0x6f,
0xf7, 0x42, 0xf8, 0x4a, 0xfb, 0x40, 0x1b, 0xd1, 0x00, 0xe4, 0x12, 0x54, 0x46, 0x5c, 0x1c, 0x8f,
0x94, 0xb5, 0xad, 0x85, 0xc8, 0x36, 0xd4, 0x74, 0x42, 0x4b, 0xf1, 0x35, 0x47, 0x9b, 0x96, 0x68,
0x0a, 0x93, 0x37, 0x60, 0x3d, 0xc6, 0x95, 0xab, 0x58, 0x7c, 0xcc, 0x15, 0xda, 0xb4, 0x44, 0x9b,
0x06, 0x79, 0x88, 0xb8, 0xf9, 0x85, 0x5e, 0xcb, 0x5c, 0xe8, 0xce, 0x5f, 0x0b, 0x70, 0xe1, 0x51,
0xe4, 0xb1, 0xc0, 0x7a, 0x66, 0xdf, 0x2a, 0xf7, 0x1e, 0x94, 0x4f, 0xf8, 0x4c, 0xa2, 0x29, 0x1a,
0x77, 0x6e, 0xce, 0xbd, 0xb0, 0x84, 0x78, 0x67, 0x8f, 0xcf, 0x28, 0x92, 0x93, 0xbb, 0xd0, 0x1c,
0x6b, 0x37, 0x31, 0x9b, 0x5c, 0x45, 0xcc, 0x88, 0x4b, 0xcb, 0x9d, 0x48, 0x73, 0xb4, 0xfa, 0x84,
0x13, 0x26, 0xe5, 0x8b, 0x28, 0xf6, 0x6d, 0xd4, 0xa6, 0xf0, 0xf6, 0x77, 0xa0, 0xb4, 0xc7, 0x67,
0x4b, 0x73, 0x81, 0x40, 0x59, 0x17, 0x39, 0xdc, 0xaa, 0x49, 0x71, 0xed, 0xfc, 0xa9, 0x00, 0x17,
0x73, 0x8a, 0x72, 0x1e, 0x3f, 0xe0, 0x41, 0x10, 0xe9, 0x08, 0xb5, 0x91, 0xe9, 0x9e, 0xf2, 0x58,
0x8a, 0x28, 0x44, 0x61, 0x6b, 0xb4, 0x65, 0xd1, 0x4f, 0x0d, 0x56, 0x3b, 0x79, 0xc2, 0x39, 0x06,
0xb9, 0x91, 0x5c, 0xd1, 0xe0, 0xae, 0x8f, 0x75, 0x96, 0x9f, 0x0a, 0x8f, 0xbb, 0xa8, 0x8a, 0xd1,
0x14, 0x0c, 0x6a, 0xa8, 0x15, 0x9a, 0x13, 0xa8, 0xd9, 0x84, 0xa3, 0x77, 0x53, 0x82, 0xc3, 0xd9,
0x04, 0xb3, 0x57, 0x8a, 0xe3, 0x90, 0xa9, 0x69, 0xcc, 0xd1, 0xcb, 0x4d, 0x3a, 0x47, 0x38, 0xdf,
0x14, 0xa0, 0xad, 0xd5, 0xce, 0x56, 0xce, 0x15, 0xd5, 0xf8, 0x6d, 0xd8, 0x10, 0x19, 0x2a, 0x37,
0x2d, 0xcd, 0xad, 0x2c, 0x3a, 0xa7, 0x33, 0xaa, 0x54, 0x3a, 0xa3, 0x52, 0x62, 0xd8, 0x72, 0x3e,
0x72, 0x13, 0x13, 0xad, 0x61, 0xab, 0x90, 0x80, 0xce, 0x3f, 0x0b, 0x70, 0x79, 0x45, 0x71, 0x7f,
0xc9, 0xbe, 0xe1, 0x0d, 0x58, 0xb7, 0x15, 0xca, 0xc5, 0xd4, 0xb5, 0x2a, 0x35, 0x2d, 0xd2, 0xe4,
0xd9, 0x15, 0xa8, 0xf1, 0x50, 0xba, 0x19, 0xc5, 0xaa, 0x3c, 0x94, 0x68, 0xe3, 0x9b, 0xd0, 0x0c,
0x98, 0x54, 0xee, 0x74, 0xe2, 0x33, 0xc5, 0xcd, 0x3d, 0x54, 0xa6, 0x0d, 0x8d, 0x3b, 0x32, 0x28,
0x7d, 0x66, 0x39, 0x93, 0x8a, 0x8f, 0x5d, 0xc5, 0x8e, 0x75, 0x19, 0x2f, 0xe9, 0x33, 0x1b, 0xd4,
0x21, 0x3b, 0x96, 0xe4, 0x2d, 0x68, 0x05, 0x3a, 0x46, 0xdc, 0x50, 0x78, 0x27, 0xb8, 0x89, 0xb9,
0x8a, 0xd6, 0x11, 0x3b, 0xb4, 0x48, 0xe7, 0x97, 0x15, 0xb8, 0xb2, 0xb2, 0x93, 0x21, 0xdf, 0x85,
0xad, 0xac, 0x22, 0x2e, 0xf2, 0x06, 0x33, 0x7b, 0x7a, 0x92, 0x51, 0xe8, 0x91, 0xf9, 0xf2, 0x7f,
0x6c, 0x0a, 0xed, 0x5b, 0xe6, 0xfb, 0xdc, 0xc7, 0x0b, 0xb5, 0x46, 0x0d, 0xa0, 0xe3, 0xe4, 0x99,
0x76, 0x32, 0xf7, 0xb1, 0x45, 0xa8, 0xd1, 0x04, 0xd4, 0xf4, 0xe3, 0xa9, 0xd6, 0xa9, 0x61, 0xe8,
0x11, 0xd0, 0xf4, 0x31, 0x1f, 0x47, 0xa7, 0xdc, 0xc7, 0x52, 0x5e, 0xa3, 0x09, 0x48, 0x6e, 0x40,
0x73, 0xc4, 0xa4, 0x8b, 0x62, 0xdd, 0xa9, 0xc4, 0xd2, 0x5c, 0xa3, 0x30, 0x62, 0xb2, 0xab, 0x51,
0x47, 0x78, 0xc1, 0x9f, 0xf2, 0x58, 0x3c, 0x4f, 0x5a, 0x65, 0xa9, 0x98, 0x9a, 0x9a, 0xc2, 0x5b,
0xa2, 0x24, 0xfb, 0xe9, 0x00, 0xbf, 0x60, 0xd3, 0x1b, 0x4f, 0xa5, 0x4a, 0x28, 0x37, 0x90, 0xb2,
0x81, 0x38, 0x4b, 0xf2, 0x11, 0x5c, 0xb5, 0x9d, 0xa0, 0x1b, 0xf3, 0x9f, 0x4f, 0xb9, 0x54, 0xc6,
0x8b, 0xc8, 0xc2, 0x3b, 0x6d, 0xe4, 0xe8, 0x58, 0x12, 0x6a, 0x28, 0xd0, 0x99, 0x9a, 0x9f, 0xaf,
0x66, 0x37, 0x69, 0xb0, 0xb9, 0x92, 0xbd, 0x87, 0x99, 0xf1, 0x31, 0x5c, 0x5b, 0x64, 0xd7, 0xe6,
0x50, 0xdc, 0x6e, 0x4f, 0x90, 0xff, 0x4a, 0x9e, 0x9f, 0x22, 0x85, 0xd9, 0x7f, 0xb5, 0x00, 0xa3,
0xc0, 0x85, 0xd5, 0x02, 0x8c, 0x06, 0x37, 0xa1, 0xe9, 0x0b, 0x39, 0x09, 0xd8, 0xcc, 0xc4, 0xd7,
0x16, 0xba, 0xbe, 0x61, 0x71, 0x3a, 0xc6, 0x9c, 0x17, 0x67, 0xf3, 0x3d, 0x69, 0x4f, 0x96, 0xe7,
0xfb, 0x99, 0xa0, 0x2e, 0x2e, 0x09, 0xea, 0xc5, 0xc8, 0x2d, 0x9d, 0x89, 0x5c, 0xe7, 0x3e, 0x6c,
0x2f, 0x6e, 0xbc, 0x3f, 0x7d, 0x16, 0x08, 0xaf, 0x37, 0x62, 0x2f, 0x79, 0xd7, 0x38, 0x7f, 0x2c,
0xc1, 0x7a, 0x6e, 0x8c, 0xf8, 0xaf, 0x7c, 0x4d, 0x4c, 0xcc, 0xeb, 0xd0, 0x98, 0xc4, 0xe2, 0x94,
0x29, 0xee, 0x9e, 0xf0, 0x99, 0xad, 0xde, 0x60, 0x51, 0xba, 0x1a, 0xdd, 0xd0, 0xb7, 0xaa, 0xf4,
0x62, 0x31, 0xd1, 0x7a, 0x61, 0x5e, 0x36, 0x69, 0x16, 0xa5, 0x8b, 0xf9, 0x97, 0x91, 0x08, 0x6d,
0x56, 0xd6, 0xa8, 0x85, 0x74, 0xa9, 0x33, 0xb1, 0xca, 0x7d, 0x2c, 0xe6, 0x35, 0x9a, 0xc2, 0xf3,
0xa4, 0xa9, 0x66, 0x93, 0xe6, 0x09, 0xb4, 0xad, 0x77, 0xa5, 0xab, 0x22, 0x57, 0xcb, 0xb1, 0x1d,
0xd2, 0x5b, 0xab, 0x86, 0x25, 0x4b, 0x7e, 0x18, 0x3d, 0x8c, 0x44, 0x48, 0x5b, 0x71, 0x0e, 0x26,
0xf7, 0xa0, 0x96, 0xb4, 0xe8, 0x76, 0x24, 0xb8, 0xbe, 0x42, 0x90, 0x9d, 0x0d, 0x24, 0x4d, 0x19,
0x74, 0x05, 0xe3, 0xa1, 0x17, 0xcf, 0x26, 0x2a, 0x4d, 0xfa, 0x39, 0x02, 0xeb, 0xdb, 0x84, 0x7b,
0x8a, 0xcd, 0x53, 0x7f, 0x8e, 0xd0, 0x45, 0xcb, 0x92, 0xea, 0x04, 0xc6, 0x26, 0xa3, 0x89, 0x96,
0x6b, 0xcd, 0xd1, 0x7b, 0x7c, 0x26, 0x9d, 0x5f, 0x95, 0xe0, 0xea, 0x39, 0x27, 0xb2, 0xfe, 0x2a,
0xa4, 0xfe, 0x7a, 0x1d, 0x60, 0x82, 0xb1, 0x81, 0xee, 0x32, 0xfe, 0xaf, 0x1b, 0x8c, 0xf6, 0x56,
0xea, 0xf4, 0x52, 0xd6, 0xe9, 0xe7, 0x5c, 0xac, 0x97, 0xa1, 0xea, 0x8d, 0x98, 0x4a, 0xda, 0xdc,
0x3a, 0xad, 0x68, 0x70, 0xd7, 0xd7, 0x71, 0x9b, 0x8c, 0x79, 0x33, 0xfd, 0xb5, 0x62, 0x1c, 0x9f,
0xe2, 0x76, 0xd1, 0x89, 0x26, 0x7d, 0xab, 0x66, 0x33, 0x04, 0xc8, 0x09, 0x90, 0x98, 0x9f, 0x72,
0x16, 0x70, 0x5f, 0x5f, 0x72, 0x31, 0x97, 0x32, 0x6d, 0x74, 0x3f, 0x7c, 0x29, 0x37, 0xee, 0x50,
0xcb, 0xdf, 0x4d, 0xd8, 0x07, 0xa1, 0x8a, 0x67, 0x74, 0x33, 0x5e, 0xc4, 0x6f, 0xf7, 0xe1, 0xd2,
0x72, 0x62, 0xd2, 0x86, 0x92, 0xb6, 0x90, 0x69, 0xa2, 0xf4, 0x52, 0xab, 0x7b, 0xca, 0x82, 0x29,
0xb7, 0xd1, 0x6f, 0x80, 0xbb, 0xc5, 0x0f, 0x0a, 0xce, 0x6f, 0x8a, 0xd0, 0x5e, 0xcc, 0x40, 0xf2,
0x51, 0x66, 0xea, 0x3f, 0xd3, 0x20, 0xae, 0xa8, 0x95, 0x99, 0x99, 0xff, 0x53, 0x68, 0x5a, 0x47,
0x69, 0x83, 0xca, 0x4e, 0x71, 0xb1, 0xd3, 0x5f, 0x9d, 0xf2, 0xb4, 0x31, 0x49, 0xd7, 0x92, 0xdc,
0x83, 0x6a, 0xd2, 0x68, 0x96, 0x30, 0x84, 0xcf, 0x51, 0x23, 0xe9, 0x39, 0x13, 0x8e, 0xff, 0xe1,
0xe5, 0xc1, 0x79, 0x1f, 0x36, 0xf0, 0xab, 0x56, 0xc8, 0x96, 0xae, 0x97, 0xbb, 0x8a, 0x3e, 0x84,
0xad, 0x84, 0xf1, 0xb1, 0x79, 0xdb, 0x91, 0x94, 0xb3, 0x97, 0xe5, 0xfe, 0x11, 0x5c, 0xc2, 0x41,
0xd9, 0x53, 0xe2, 0x54, 0xa8, 0x59, 0x8f, 0x87, 0x8a, 0xc7, 0xe7, 0xf0, 0xb7, 0xa1, 0x24, 0x7c,
0x63, 0xde, 0x26, 0xd5, 0x4b, 0xa7, 0x6f, 0xae, 0xd3, 0xbc, 0x84, 0xae, 0xe7, 0x71, 0xcc, 0xdb,
0x97, 0x95, 0x32, 0x30, 0x79, 0x99, 0x97, 0xd2, 0x17, 0x72, 0x2c, 0xa4, 0x7c, 0x05, 0x31, 0xdf,
0x14, 0xa0, 0xa9, 0xe5, 0xdc, 0x8f, 0xa2, 0x93, 0x31, 0x8b, 0x4f, 0x56, 0x33, 0x4e, 0xe3, 0xc0,
0x9a, 0x41, 0x2f, 0xd3, 0x66, 0xb5, 0x94, 0x69, 0x56, 0xaf, 0x42, 0x1d, 0x0b, 0x8d, 0xab, 0x69,
0x4d, 0x22, 0xd7, 0x10, 0x71, 0x14, 0x07, 0xd9, 0x8e, 0x63, 0x2d, 0xdf, 0x71, 0xbc, 0x0e, 0xe0,
0xf3, 0x80, 0xeb, 0xce, 0x8d, 0x29, 0x4c, 0xe4, 0x32, 0xad, 0x5b, 0x4c, 0x57, 0x39, 0x0f, 0x4d,
0xf0, 0xf7, 0x02, 0xce, 0xe2, 0x07, 0x42, 0xaa, 0x28, 0x9e, 0x65, 0xaf, 0x85, 0x42, 0xee, 0x5a,
0x78, 0x1d, 0xc0, 0xd3, 0x84, 0x46, 0x56, 0xd1, 0xc8, 0xb2, 0x98, 0xae, 0x72, 0xfe, 0x52, 0x00,
0xa2, 0x85, 0xd9, 0xa7, 0x9e, 0x7d, 0xe1, 0xe9, 0x76, 0x7f, 0xe9, 0x48, 0x93, 0x99, 0x19, 0x8b,
0x2b, 0x66, 0xc6, 0x12, 0x76, 0xe4, 0x67, 0x66, 0xc6, 0x32, 0xa2, 0x93, 0x99, 0xf1, 0x2a, 0xd4,
0xb1, 0x04, 0xe3, 0xd0, 0x68, 0x7a, 0x78, 0x1c, 0x1a, 0x0f, 0x96, 0x0e, 0x8d, 0x15, 0x24, 0x58,
0x31, 0x34, 0x56, 0xb3, 0x43, 0xe3, 0x08, 0x2e, 0x9c, 0x3d, 0x89, 0x5c, 0x3d, 0x17, 0x7f, 0x00,
0xb5, 0x89, 0x25, 0xb2, 0xc9, 0x7e, 0x2d, 0x9f, 0x67, 0x79, 0x49, 0x34, 0xa5, 0x76, 0xfe, 0x51,
0x82, 0xcd, 0x33, 0xef, 0x31, 0x2b, 0x02, 0xa5, 0x03, 0x55, 0x7b, 0xa9, 0x26, 0x56, 0xb3, 0xa0,
0xb6, 0x8f, 0x79, 0x6c, 0x41, 0xb3, 0xd5, 0xa8, 0x85, 0xb4, 0xed, 0xb5, 0xef, 0xd0, 0x6a, 0x35,
0x8a, 0x6b, 0x8d, 0xc3, 0x19, 0xc9, 0x5c, 0xf9, 0xb8, 0xd6, 0x92, 0xb5, 0xef, 0x75, 0x1f, 0x63,
0x9e, 0x33, 0x12, 0x50, 0x53, 0x4f, 0x98, 0x1a, 0xd9, 0x76, 0x19, 0xd7, 0xba, 0xfc, 0xa5, 0x55,
0x07, 0x87, 0xed, 0x66, 0xb6, 0x0c, 0x25, 0xfe, 0xae, 0x67, 0xfc, 0xad, 0xcf, 0x83, 0x0f, 0x15,
0x80, 0x48, 0x03, 0xa0, 0x57, 0x85, 0xef, 0xf3, 0xd0, 0xd6, 0x50, 0x0b, 0x9d, 0xd3, 0x3f, 0x6f,
0xc1, 0x1a, 0x1f, 0x47, 0x5f, 0x0a, 0x6c, 0x9c, 0xeb, 0xd4, 0x00, 0xd8, 0xdf, 0xf1, 0x58, 0x9c,
0x72, 0xdf, 0x7d, 0x1e, 0x47, 0x63, 0x6c, 0x96, 0x75, 0x7f, 0x67, 0x70, 0x9f, 0xc4, 0xd1, 0x38,
0xeb, 0xb9, 0x8d, 0x9c, 0xe7, 0x6e, 0x42, 0xf3, 0x84, 0xcf, 0xf4, 0x68, 0x6c, 0x4a, 0x64, 0xdb,
0xf0, 0x5a, 0x1c, 0x96, 0xc9, 0x7b, 0xb0, 0x6d, 0xba, 0x38, 0xc9, 0x7d, 0x17, 0x85, 0xda, 0x61,
0x14, 0x9f, 0x52, 0x36, 0xd1, 0x43, 0x97, 0xb1, 0xa7, 0x93, 0xdc, 0xef, 0xa7, 0xdf, 0x77, 0xf5,
0x67, 0xe7, 0xb1, 0xc9, 0x89, 0x9c, 0x7b, 0x25, 0x79, 0x1f, 0x6a, 0xf6, 0x96, 0x4e, 0xea, 0xcb,
0xb9, 0xcf, 0x73, 0x29, 0xb1, 0xf3, 0xef, 0x82, 0x49, 0xd8, 0x03, 0x76, 0x9a, 0x56, 0xbd, 0x6c,
0x5c, 0x14, 0xf2, 0x71, 0xb1, 0xec, 0xbd, 0xe6, 0x1a, 0xd4, 0x9f, 0xb3, 0xd3, 0x68, 0x1a, 0x0b,
0xc5, 0x6d, 0xb8, 0xcc, 0x11, 0xe7, 0xdc, 0x24, 0x37, 0xa1, 0x69, 0xfa, 0x58, 0x37, 0x9b, 0x30,
0x0d, 0x83, 0x33, 0x8d, 0xf6, 0xb7, 0x61, 0xd3, 0x1b, 0x31, 0x11, 0xba, 0x72, 0x14, 0xc5, 0x0a,
0x0d, 0x6a, 0x9e, 0x75, 0xeb, 0x74, 0x03, 0x3f, 0x1c, 0x68, 0xbc, 0x36, 0xaa, 0xd4, 0xb7, 0x1e,
0x0f, 0xa5, 0x8d, 0x12, 0xbd, 0xd4, 0x3e, 0x12, 0xd2, 0x55, 0x5c, 0x2a, 0xdb, 0x71, 0x55, 0x84,
0x3c, 0xe4, 0x52, 0x3d, 0x2c, 0xd7, 0xca, 0xed, 0x35, 0xe7, 0xb7, 0x05, 0xb8, 0xb8, 0xb4, 0x6d,
0x5b, 0x91, 0x2d, 0x8b, 0x4d, 0x8c, 0xb1, 0x41, 0xae, 0x89, 0x19, 0xc0, 0xf5, 0x91, 0xb9, 0xf4,
0x5c, 0x16, 0x7b, 0x23, 0x71, 0xca, 0x5d, 0x39, 0x9d, 0x4c, 0xb4, 0xee, 0x3c, 0x64, 0xcf, 0x02,
0xdb, 0xb2, 0xd7, 0xe8, 0x35, 0x4b, 0xd6, 0x35, 0x54, 0x07, 0x86, 0x68, 0x60, 0x68, 0x9c, 0x3f,
0x14, 0x4c, 0xb9, 0x3c, 0xd4, 0x33, 0x97, 0x9e, 0xe2, 0x78, 0xfc, 0x92, 0xaf, 0x04, 0x1f, 0x41,
0xc5, 0x8e, 0x6d, 0x7a, 0x9f, 0xd6, 0x62, 0xab, 0x9b, 0x11, 0xb8, 0x73, 0x38, 0x1f, 0xe8, 0xa8,
0x65, 0x72, 0xee, 0x42, 0x23, 0x83, 0x26, 0x0d, 0xa8, 0x1e, 0x0d, 0xf7, 0x86, 0x4f, 0x3e, 0x1b,
0xb6, 0x5f, 0xd3, 0xc0, 0x21, 0x3d, 0x3a, 0x38, 0x1c, 0xf4, 0xdb, 0x05, 0xb2, 0x09, 0xeb, 0x47,
0x43, 0x04, 0x3f, 0x7b, 0x42, 0x0f, 0x1f, 0x7c, 0xde, 0x2e, 0x3a, 0xdf, 0x94, 0xcc, 0xc8, 0xf3,
0x34, 0x33, 0x52, 0xda, 0x56, 0x6c, 0x85, 0xf2, 0x04, 0xca, 0x98, 0x5e, 0x36, 0x98, 0xf4, 0x5a,
0x1f, 0x48, 0x45, 0xb6, 0x4e, 0x15, 0x55, 0xa4, 0x83, 0xcb, 0x1b, 0xe9, 0xd8, 0x0d, 0x8f, 0x93,
0x76, 0x73, 0x8e, 0xd0, 0x2e, 0xb1, 0x4d, 0xba, 0x29, 0x21, 0x76, 0x92, 0x4f, 0x71, 0x5d, 0x7c,
0x23, 0x8b, 0xb9, 0x9c, 0x44, 0xa1, 0x4c, 0xae, 0xa2, 0x14, 0xd6, 0xf5, 0x27, 0xe6, 0x93, 0x40,
0x18, 0x66, 0x13, 0x7f, 0x75, 0x8b, 0xe9, 0x2a, 0xc2, 0x97, 0x8f, 0xce, 0x35, 0xb4, 0xec, 0xf7,
0xf3, 0x96, 0x5d, 0x72, 0xea, 0x9d, 0xa7, 0x67, 0x86, 0xeb, 0xa5, 0x03, 0xb7, 0xf1, 0x61, 0x3d,
0x6d, 0x5a, 0x7e, 0x02, 0xe4, 0x2c, 0xe7, 0x19, 0x5f, 0xec, 0x0f, 0x86, 0xfd, 0xdd, 0xe1, 0xa7,
0xed, 0x02, 0x69, 0x42, 0xad, 0xdb, 0xeb, 0x0d, 0xf6, 0xb5, 0x67, 0x8a, 0x1a, 0xea, 0x0f, 0x7a,
0x8f, 0x76, 0x87, 0x83, 0x7e, 0xbb, 0xa4, 0xa1, 0x5e, 0x77, 0xd8, 0x1b, 0x3c, 0x1a, 0xf4, 0xdb,
0x65, 0xe7, 0xef, 0x05, 0xd3, 0xcd, 0xf4, 0x72, 0x93, 0x6d, 0x9f, 0x7b, 0x42, 0xae, 0x7e, 0x32,
0xbb, 0x06, 0x75, 0x6b, 0xcf, 0xdd, 0x24, 0xd2, 0xe6, 0x08, 0xf2, 0x33, 0xd8, 0xf0, 0x2d, 0xbf,
0x9b, 0x8b, 0xbc, 0x77, 0x17, 0xfb, 0xc2, 0x65, 0x5b, 0xee, 0x24, 0x0b, 0x6b, 0x9e, 0x96, 0x9f,
0x83, 0x9d, 0x77, 0xa0, 0x95, 0xa7, 0xc8, 0x1d, 0xf6, 0xb5, 0xdc, 0x61, 0x0b, 0xce, 0xaf, 0x8b,
0xb0, 0xb1, 0xf0, 0xf7, 0xd0, 0xea, 0x0a, 0xbb, 0x38, 0xc3, 0x17, 0xcf, 0xcc, 0xf0, 0xe4, 0x1d,
0x20, 0x59, 0x12, 0x37, 0x3b, 0x0c, 0xb5, 0x33, 0x84, 0xe6, 0xae, 0xca, 0x96, 0xec, 0xf2, 0xab,
0x94, 0x6c, 0xf2, 0x63, 0xd8, 0x92, 0x91, 0x27, 0x58, 0xe0, 0x06, 0x22, 0x3c, 0x49, 0xff, 0xe8,
0xec, 0xac, 0xa1, 0x94, 0x85, 0x21, 0xf3, 0x00, 0x29, 0x1f, 0x89, 0xf0, 0x24, 0xf9, 0x07, 0x8a,
0xc8, 0x45, 0x94, 0x74, 0x24, 0x00, 0x65, 0x2f, 0x6c, 0xc7, 0x9c, 0xed, 0x8e, 0x0a, 0xf9, 0xee,
0x68, 0x0f, 0x1a, 0xf6, 0x2f, 0xd3, 0x43, 0x5d, 0xc2, 0x8b, 0xe8, 0xba, 0x6f, 0xcd, 0x77, 0xec,
0xce, 0xff, 0x64, 0x7d, 0x6c, 0xff, 0x63, 0xb5, 0x42, 0x77, 0x34, 0x03, 0xcd, 0x72, 0x3b, 0xbf,
0x2f, 0x40, 0x4b, 0xab, 0x98, 0xd9, 0xf9, 0x07, 0xd0, 0x88, 0x53, 0x28, 0x29, 0x4d, 0x5b, 0x73,
0xf9, 0x73, 0x52, 0x9a, 0x25, 0x24, 0x77, 0x60, 0x4b, 0x4e, 0x9f, 0x25, 0xe5, 0xed, 0xa1, 0x8c,
0xc2, 0xfb, 0x33, 0xc5, 0x93, 0x36, 0x65, 0xe9, 0x37, 0xf2, 0x0e, 0x6c, 0x26, 0xa6, 0x9b, 0x33,
0x98, 0x37, 0x88, 0xb3, 0x1f, 0x9c, 0xdf, 0x15, 0xa0, 0xa1, 0x95, 0xb5, 0xff, 0xa0, 0x61, 0xd3,
0x9c, 0x06, 0x89, 0x5e, 0x2e, 0xad, 0x75, 0x97, 0xa0, 0x62, 0x1f, 0xee, 0x6c, 0x5f, 0x64, 0xdf,
0xed, 0x32, 0x61, 0x56, 0xce, 0x85, 0xd9, 0x35, 0xa8, 0xcf, 0xe7, 0xd6, 0x35, 0x6c, 0xe5, 0xe7,
0x88, 0x79, 0xc6, 0x55, 0xb2, 0xcd, 0xe2, 0x9f, 0x8b, 0xa6, 0x85, 0xb3, 0xaa, 0xe9, 0xa9, 0x21,
0x0a, 0xc9, 0x5d, 0xa8, 0x30, 0x5c, 0xa1, 0x8e, 0xad, 0x3b, 0x4e, 0x3e, 0x2e, 0x72, 0xc4, 0x3b,
0xe6, 0x87, 0x5a, 0x0e, 0xf2, 0x26, 0xac, 0x47, 0x81, 0x6f, 0x49, 0x8e, 0xd2, 0x8a, 0x91, 0x47,
0x92, 0xdb, 0x78, 0x08, 0x0d, 0xd9, 0xe1, 0xf0, 0xe2, 0xd2, 0x2d, 0x68, 0x42, 0xa5, 0x2b, 0x68,
0xc5, 0x6a, 0xb7, 0x09, 0xeb, 0x7b, 0x83, 0xcf, 0x7b, 0x5d, 0xda, 0x77, 0xbb, 0xfd, 0x3e, 0x26,
0x27, 0x81, 0x56, 0xb7, 0xd7, 0x7b, 0x72, 0x34, 0x3c, 0x3c, 0xb0, 0xb8, 0x02, 0xb9, 0x00, 0x1b,
0x09, 0x59, 0x7f, 0xf0, 0x68, 0x60, 0xae, 0xac, 0x2d, 0x68, 0xa7, 0x84, 0x74, 0xf0, 0xf8, 0xc9,
0x53, 0xbc, 0xba, 0x00, 0x2a, 0x8f, 0x9e, 0xf4, 0xf6, 0xf4, 0xc5, 0xa5, 0xf3, 0xfc, 0x68, 0x68,
0xa1, 0x35, 0xb2, 0x01, 0x8d, 0xa3, 0xdd, 0xbe, 0x7b, 0xb4, 0xdf, 0xef, 0x6a, 0x01, 0x15, 0xd2,
0x86, 0xe6, 0xb0, 0xfb, 0x78, 0xe0, 0xf6, 0x1e, 0x74, 0x87, 0x9f, 0x0e, 0xfa, 0xed, 0xaa, 0xf3,
0x85, 0x29, 0xa0, 0x99, 0x7f, 0x48, 0xc9, 0xf7, 0x32, 0x7f, 0xa7, 0x9a, 0x38, 0x5c, 0x71, 0xbc,
0xf9, 0x5f, 0xa9, 0xa9, 0x7b, 0x8a, 0x59, 0xf7, 0x1c, 0x98, 0xb6, 0xe1, 0x4c, 0x22, 0x62, 0x23,
0xcc, 0xbf, 0x52, 0xc9, 0x60, 0xa2, 0xd7, 0x4b, 0x66, 0xb1, 0xa5, 0xaf, 0x2a, 0xf7, 0xd7, 0xbf,
0x68, 0xec, 0xdc, 0xbe, 0x97, 0xe8, 0xf3, 0xac, 0x82, 0xab, 0x77, 0xff, 0x13, 0x00, 0x00, 0xff,
0xff, 0x61, 0x1a, 0x00, 0xa2, 0x14, 0x21, 0x00, 0x00,
}

7
protocol/protobuf/pairing.proto
View File

@ -28,6 +28,8 @@ message Backup {
FetchingBackedUpDataDetails settingsDetails = 10;
SyncAllKeycards keycards = 11;
FetchingBackedUpDataDetails keycardsDetails = 12;
SyncWalletAccount walletAccount = 13;
FetchingBackedUpDataDetails walletAccountsDetails = 14;
}
message MultiAccount {
@ -228,6 +230,11 @@ message SyncWalletAccount {
string color = 10;
bool hidden = 11;
bool removed = 12;
string emoji = 13;
string derived_from = 14;
string key_uid = 15;
string keypair_name = 16;
uint64 last_used_derivation_index = 17;
}
message SyncWalletAccounts {

4
protocol/wakusync/response.go
View File

@ -3,6 +3,7 @@ package wakusync
import (
"encoding/json"
"github.com/status-im/status-go/multiaccounts/accounts"
"github.com/status-im/status-go/multiaccounts/keypairs"
"github.com/status-im/status-go/multiaccounts/settings"
"github.com/status-im/status-go/protocol/protobuf"
@ -13,6 +14,7 @@ type WakuBackedUpDataResponse struct {
Profile *BackedUpProfile
Setting *settings.SyncSettingField
Keycards []*keypairs.KeyPair
WalletAccount *accounts.Account
}
func (sfwr *WakuBackedUpDataResponse) MarshalJSON() ([]byte, error) {
@ -21,10 +23,12 @@ func (sfwr *WakuBackedUpDataResponse) MarshalJSON() ([]byte, error) {
Profile *BackedUpProfile `json:"backedUpProfile,omitempty"`
Setting *settings.SyncSettingField `json:"backedUpSettings,omitempty"`
Keycards []*keypairs.KeyPair `json:"backedUpKeycards,omitempty"`
WalletAccount *accounts.Account `json:"backedUpWalletAccount,omitempty"`
}{
Profile: sfwr.Profile,
Setting: sfwr.Setting,
Keycards: sfwr.Keycards,
WalletAccount: sfwr.WalletAccount,
}
responseItem.FetchingDataProgress = sfwr.FetchingBackedUpDataDetails()

4
services/ext/signal.go
View File

@ -157,6 +157,10 @@ func (m *MessengerSignalsHandler) SendWakuBackedUpSettings(response *wakusync.Wa
signal.SendWakuBackedUpSettings(response)
}
func (m *MessengerSignalsHandler) SendWakuBackedUpWalletAccount(response *wakusync.WakuBackedUpDataResponse) {
signal.SendWakuBackedUpWalletAccount(response)
}
func (m *MessengerSignalsHandler) SendWakuBackedUpKeycards(response *wakusync.WakuBackedUpDataResponse) {
signal.SendWakuBackedUpKeycards(response)
}

7
signal/events_sync_from_waku.go
View File

@ -12,6 +12,9 @@ const (
// EventWakuBackedUpSettings is emitted while applying fetched settings from waku
EventWakuBackedUpSettings = "waku.backedup.settings"
// EventWakuBackedUpWalletAccount is emitted while applying fetched wallet account data from waku
EventWakuBackedUpWalletAccount = "waku.backedup.wallet-account" // #nosec G101
// EventWakuBackedUpKeycards is emitted while applying fetched keycard data from waku
EventWakuBackedUpKeycards = "waku.backedup.keycards"
)
@ -28,6 +31,10 @@ func SendWakuBackedUpSettings(obj json.Marshaler) {
send(EventWakuBackedUpSettings, obj)
}
func SendWakuBackedUpWalletAccount(obj json.Marshaler) {
send(EventWakuBackedUpWalletAccount, obj)
}
func SendWakuBackedUpKeycards(obj json.Marshaler) {
send(EventWakuBackedUpKeycards, obj)
}