package settings import ( "context" "database/sql" "encoding/json" "fmt" "sync" "time" "github.com/ethereum/go-ethereum/log" "github.com/status-im/status-go/common/dbsetup" "github.com/status-im/status-go/eth-node/types" "github.com/status-im/status-go/multiaccounts/errors" "github.com/status-im/status-go/nodecfg" "github.com/status-im/status-go/params" "github.com/status-im/status-go/sqlite" ) type Notifier func(SettingField, interface{}) var ( // dbInstances holds a map of singleton instances of Database dbInstances map[string]*Database // mutex guards the instantiation of the dbInstances values, to prevent any concurrent instantiations mutex sync.Mutex ) // Database sql wrapper for operations with browser objects. type Database struct { db *sql.DB SyncQueue chan SyncSettingField changesSubscriptions []chan *SyncSettingField notifier Notifier } // MakeNewDB ensures that a singleton instance of Database is returned per sqlite db file func MakeNewDB(db *sql.DB) (*Database, error) { filename, err := dbsetup.GetDBFilename(db) if err != nil { return nil, err } d := &Database{ db: db, SyncQueue: make(chan SyncSettingField, 100), } // An empty filename means that the sqlite database is held in memory // In this case we don't want to restrict the instantiation if filename == "" { return d, nil } // Lock to protect the map from concurrent access mutex.Lock() defer mutex.Unlock() // init dbInstances if it hasn't been already if dbInstances == nil { dbInstances = map[string]*Database{} } // If we haven't seen this database file before make an instance if _, ok := dbInstances[filename]; !ok { dbInstances[filename] = d } // Check if the current dbInstance is closed, if closed assign new Database if err := dbInstances[filename].db.Ping(); err != nil { dbInstances[filename] = d } return dbInstances[filename], nil } func (db *Database) GetDB() *sql.DB { return db.db } func (db *Database) GetSyncQueue() chan SyncSettingField { return db.SyncQueue } func (db *Database) GetChangesSubscriptions() []chan *SyncSettingField { return db.changesSubscriptions } func (db *Database) GetNotifier() Notifier { return db.notifier } func (db *Database) SetSettingsNotifier(n Notifier) { db.notifier = n } // TODO remove photoPath from settings func (db *Database) CreateSettings(s Settings, n params.NodeConfig) error { tx, err := db.db.BeginTx(context.Background(), &sql.TxOptions{}) if err != nil { return err } defer func() { if err == nil { err = tx.Commit() return } // don't shadow original error _ = tx.Rollback() }() _, err = tx.Exec(` INSERT INTO settings ( address, currency, current_network, dapps_address, device_name, preferred_name, display_name, bio, eip1581_address, installation_id, key_uid, keycard_instance_uid, keycard_paired_on, keycard_pairing, latest_derived_path, mnemonic, name, networks, photo_path, preview_privacy, public_key, signing_phrase, wallet_root_address, synthetic_id, current_user_status, profile_pictures_show_to, profile_pictures_visibility, url_unfurling_mode, omit_transfers_history_scan, mnemonic_was_not_shown, wallet_token_preferences_group_by_community, wallet_collectible_preferences_group_by_collection, wallet_collectible_preferences_group_by_community, test_networks_enabled ) VALUES ( ?,?,?,?,?,?,?,?,?,?,?,?,?,?, ?,?,?,?,?,?,?,?,?,'id',?,?,?,?,?,?,?,?,?,?)`, s.Address, s.Currency, s.CurrentNetwork, s.DappsAddress, s.DeviceName, s.PreferredName, s.DisplayName, s.Bio, s.EIP1581Address, s.InstallationID, s.KeyUID, s.KeycardInstanceUID, s.KeycardPairedOn, s.KeycardPairing, s.LatestDerivedPath, s.Mnemonic, s.Name, s.Networks, s.PhotoPath, s.PreviewPrivacy, s.PublicKey, s.SigningPhrase, s.WalletRootAddress, s.CurrentUserStatus, s.ProfilePicturesShowTo, s.ProfilePicturesVisibility, s.URLUnfurlingMode, s.OmitTransfersHistoryScan, s.MnemonicWasNotShown, s.TokenGroupByCommunity, s.CollectibleGroupByCollection, s.CollectibleGroupByCommunity, s.TestNetworksEnabled, ) if err != nil { return err } if s.DisplayName != "" { now := time.Now().Unix() query := db.buildUpdateSyncClockQueryForField(DisplayName) _, err := tx.Exec(query, uint64(now), uint64(now)) if err != nil { return err } } return nodecfg.SaveConfigWithTx(tx, &n) } func (db *Database) getSettingFieldFromReactName(reactName string) (SettingField, error) { for _, s := range SettingFieldRegister { if s.GetReactName() == reactName { return s, nil } } return SettingField{}, errors.ErrInvalidConfig } func (db *Database) makeSelectRow(setting SettingField) *sql.Row { query := "SELECT %s FROM settings WHERE synthetic_id = 'id'" query = fmt.Sprintf(query, setting.GetDBName()) return db.db.QueryRow(query) } func (db *Database) makeSelectString(setting SettingField) (string, error) { var result sql.NullString err := db.makeSelectRow(setting).Scan(&result) if err == sql.ErrNoRows { return "", nil } if result.Valid { return result.String, nil } return "", err } func (db *Database) saveSetting(setting SettingField, value interface{}) error { query := "UPDATE settings SET %s = ? WHERE synthetic_id = 'id'" query = fmt.Sprintf(query, setting.GetDBName()) update, err := db.db.Prepare(query) if err != nil { return err } _, err = update.Exec(value) if err != nil { return err } if db.notifier != nil { db.notifier(setting, value) } return nil } func (db *Database) parseSaveAndSyncSetting(sf SettingField, value interface{}) (err error) { if sf.ValueCastHandler() != nil { value, err = sf.ValueCastHandler()(value) if err != nil { return err } } if sf.ValueHandler() != nil { value, err = sf.ValueHandler()(value) if err != nil { return err } } // TODO(samyoul) this is ugly as hell need a more elegant solution if NodeConfig.GetReactName() == sf.GetReactName() { if err = nodecfg.SaveNodeConfig(db.db, value.(*params.NodeConfig)); err != nil { return err } value = nil } err = db.saveSetting(sf, value) if err != nil { return err } if sf.GetDBName() == DBColumnMnemonic { mnemonicRemoved := value == nil || value.(string) == "" err = db.saveSetting(MnemonicRemoved, mnemonicRemoved) if err != nil { return err } sf = MnemonicRemoved value = mnemonicRemoved } if sf.CanSync(FromInterface) { db.SyncQueue <- SyncSettingField{sf, value} } db.postChangesToSubscribers(&SyncSettingField{sf, value}) return nil } // SaveSetting stores data from any non-sync source // If the field requires syncing the field data is pushed on to the SyncQueue func (db *Database) SaveSetting(setting string, value interface{}) error { sf, err := db.getSettingFieldFromReactName(setting) if err != nil { return err } return db.parseSaveAndSyncSetting(sf, value) } // SaveSettingField is identical in functionality to SaveSetting, except the setting parameter is a SettingField and // doesn't require any SettingFieldRegister lookup. // This func is useful if you already know the SettingField to save func (db *Database) SaveSettingField(sf SettingField, value interface{}) error { return db.parseSaveAndSyncSetting(sf, value) } func (db *Database) DeleteMnemonic() error { return db.saveSetting(Mnemonic, nil) } // SaveSyncSetting stores setting data from a sync protobuf source, note it does not call SettingField.ValueHandler() // nor does this function attempt to write to the Database.SyncQueue, // yet it still writes to Database.changesSubscriptions. func (db *Database) SaveSyncSetting(setting SettingField, value interface{}, clock uint64) error { ls, err := db.GetSettingLastSynced(setting) if err != nil { return err } if clock <= ls { return errors.ErrNewClockOlderThanCurrent } err = db.SetSettingLastSynced(setting, clock) if err != nil { return err } err = db.saveSetting(setting, value) if err != nil { return err } db.postChangesToSubscribers(&SyncSettingField{setting, value}) return nil } func (db *Database) GetSettingLastSynced(setting SettingField) (result uint64, err error) { query := "SELECT %s FROM settings_sync_clock WHERE synthetic_id = 'id'" query = fmt.Sprintf(query, setting.GetDBName()) err = db.db.QueryRow(query).Scan(&result) if err != nil { return 0, err } return result, nil } func (db *Database) buildUpdateSyncClockQueryForField(setting SettingField) string { query := "UPDATE settings_sync_clock SET %s = ? WHERE synthetic_id = 'id' AND %s < ?" return fmt.Sprintf(query, setting.GetDBName(), setting.GetDBName()) } func (db *Database) SetSettingLastSynced(setting SettingField, clock uint64) error { query := db.buildUpdateSyncClockQueryForField(setting) _, err := db.db.Exec(query, clock, clock) return err } func (db *Database) GetSettings() (Settings, error) { var s Settings err := db.db.QueryRow(` SELECT address, anon_metrics_should_send, chaos_mode, currency, current_network, custom_bootnodes, custom_bootnodes_enabled, dapps_address, display_name, bio, eip1581_address, fleet, hide_home_tooltip, installation_id, key_uid, keycard_instance_uid, keycard_paired_on, keycard_pairing, last_updated, latest_derived_path, link_preview_request_enabled, link_previews_enabled_sites, log_level, mnemonic, mnemonic_removed, name, networks, notifications_enabled, push_notifications_server_enabled, push_notifications_from_contacts_only, remote_push_notifications_enabled, send_push_notifications, push_notifications_block_mentions, photo_path, pinned_mailservers, preferred_name, preview_privacy, public_key, remember_syncing_choice, signing_phrase, stickers_packs_installed, stickers_packs_pending, stickers_recent_stickers, syncing_on_mobile_network, default_sync_period, use_mailservers, messages_from_contacts_only, usernames, appearance, profile_pictures_show_to, profile_pictures_visibility, wallet_root_address, wallet_set_up_passed, wallet_visible_tokens, waku_bloom_filter_mode, webview_allow_permission_requests, current_user_status, send_status_updates, gif_recents, gif_favorites, opensea_enabled, last_backup, backup_enabled, telemetry_server_url, auto_message_enabled, gif_api_key, test_networks_enabled, mutual_contact_enabled, profile_migration_needed, is_goerli_enabled, wallet_token_preferences_group_by_community, url_unfurling_mode, omit_transfers_history_scan, mnemonic_was_not_shown, wallet_show_community_asset_when_sending_tokens, wallet_display_assets_below_balance, wallet_display_assets_below_balance_threshold, wallet_collectible_preferences_group_by_collection, wallet_collectible_preferences_group_by_community, peer_syncing_enabled FROM settings WHERE synthetic_id = 'id'`).Scan( &s.Address, &s.AnonMetricsShouldSend, &s.ChaosMode, &s.Currency, &s.CurrentNetwork, &s.CustomBootnodes, &s.CustomBootnodesEnabled, &s.DappsAddress, &s.DisplayName, &s.Bio, &s.EIP1581Address, &s.Fleet, &s.HideHomeTooltip, &s.InstallationID, &s.KeyUID, &s.KeycardInstanceUID, &s.KeycardPairedOn, &s.KeycardPairing, &s.LastUpdated, &s.LatestDerivedPath, &s.LinkPreviewRequestEnabled, &s.LinkPreviewsEnabledSites, &s.LogLevel, &s.Mnemonic, &s.MnemonicRemoved, &s.Name, &s.Networks, &s.NotificationsEnabled, &s.PushNotificationsServerEnabled, &s.PushNotificationsFromContactsOnly, &s.RemotePushNotificationsEnabled, &s.SendPushNotifications, &s.PushNotificationsBlockMentions, &s.PhotoPath, &s.PinnedMailserver, &s.PreferredName, &s.PreviewPrivacy, &s.PublicKey, &s.RememberSyncingChoice, &s.SigningPhrase, &s.StickerPacksInstalled, &s.StickerPacksPending, &s.StickersRecentStickers, &s.SyncingOnMobileNetwork, &s.DefaultSyncPeriod, &s.UseMailservers, &s.MessagesFromContactsOnly, &s.Usernames, &s.Appearance, &s.ProfilePicturesShowTo, &s.ProfilePicturesVisibility, &s.WalletRootAddress, &s.WalletSetUpPassed, &s.WalletVisibleTokens, &s.WakuBloomFilterMode, &s.WebViewAllowPermissionRequests, &sqlite.JSONBlob{Data: &s.CurrentUserStatus}, &s.SendStatusUpdates, &sqlite.JSONBlob{Data: &s.GifRecents}, &sqlite.JSONBlob{Data: &s.GifFavorites}, &s.OpenseaEnabled, &s.LastBackup, &s.BackupEnabled, &s.TelemetryServerURL, &s.AutoMessageEnabled, &s.GifAPIKey, &s.TestNetworksEnabled, &s.MutualContactEnabled, &s.ProfileMigrationNeeded, &s.IsGoerliEnabled, &s.TokenGroupByCommunity, &s.URLUnfurlingMode, &s.OmitTransfersHistoryScan, &s.MnemonicWasNotShown, &s.ShowCommunityAssetWhenSendingTokens, &s.DisplayAssetsBelowBalance, &s.DisplayAssetsBelowBalanceThreshold, &s.CollectibleGroupByCollection, &s.CollectibleGroupByCommunity, &s.PeerSyncingEnabled, ) return s, err } // We should remove this and realated things once mobile team starts usign `settings_notifications` package func (db *Database) GetNotificationsEnabled() (result bool, err error) { err = db.makeSelectRow(NotificationsEnabled).Scan(&result) if err == sql.ErrNoRows { return result, nil } return result, err } func (db *Database) GetProfilePicturesVisibility() (result int, err error) { err = db.makeSelectRow(ProfilePicturesVisibility).Scan(&result) if err == sql.ErrNoRows { return result, nil } return result, err } func (db *Database) GetPublicKey() (string, error) { return db.makeSelectString(PublicKey) } func (db *Database) GetFleet() (string, error) { return db.makeSelectString(Fleet) } func (db *Database) GetDappsAddress() (rst types.Address, err error) { err = db.makeSelectRow(DappsAddress).Scan(&rst) if err == sql.ErrNoRows { return rst, nil } return } func (db *Database) GetPinnedMailservers() (rst map[string]string, err error) { rst = make(map[string]string) var pinnedMailservers string err = db.db.QueryRow("SELECT COALESCE(pinned_mailservers, '') FROM settings WHERE synthetic_id = 'id'").Scan(&pinnedMailservers) if err == sql.ErrNoRows || pinnedMailservers == "" { return rst, nil } err = json.Unmarshal([]byte(pinnedMailservers), &rst) if err != nil { return nil, err } return } func (db *Database) CanUseMailservers() (result bool, err error) { err = db.makeSelectRow(UseMailservers).Scan(&result) if err == sql.ErrNoRows { return result, nil } return result, err } func (db *Database) CanSyncOnMobileNetwork() (result bool, err error) { err = db.makeSelectRow(SyncingOnMobileNetwork).Scan(&result) if err == sql.ErrNoRows { return result, nil } return result, err } func (db *Database) GetDefaultSyncPeriod() (result uint32, err error) { err = db.makeSelectRow(DefaultSyncPeriod).Scan(&result) if err == sql.ErrNoRows { return result, nil } return result, err } func (db *Database) GetMessagesFromContactsOnly() (result bool, err error) { err = db.makeSelectRow(MessagesFromContactsOnly).Scan(&result) if err == sql.ErrNoRows { return result, nil } return result, err } func (db *Database) GetProfilePicturesShowTo() (result int64, err error) { err = db.makeSelectRow(ProfilePicturesShowTo).Scan(&result) if err == sql.ErrNoRows { return result, nil } return result, err } func (db *Database) GetLatestDerivedPath() (result uint, err error) { err = db.makeSelectRow(LatestDerivedPath).Scan(&result) return } func (db *Database) GetCurrentStatus(status interface{}) error { err := db.makeSelectRow(CurrentUserStatus).Scan(&sqlite.JSONBlob{Data: &status}) if err == sql.ErrNoRows { return nil } return err } func (db *Database) ShouldBroadcastUserStatus() (result bool, err error) { err = db.makeSelectRow(SendStatusUpdates).Scan(&result) // If the `send_status_updates` value is nil the sql.ErrNoRows will be returned // because this feature is opt out, `true` should be returned in the case where no value is found if err == sql.ErrNoRows { return true, nil } return result, err } func (db *Database) BackupEnabled() (result bool, err error) { err = db.makeSelectRow(BackupEnabled).Scan(&result) if err == sql.ErrNoRows { return true, nil } return result, err } func (db *Database) AutoMessageEnabled() (result bool, err error) { err = db.makeSelectRow(AutoMessageEnabled).Scan(&result) if err == sql.ErrNoRows { return true, nil } return result, err } func (db *Database) LastBackup() (result uint64, err error) { err = db.makeSelectRow(LastBackup).Scan(&result) if err == sql.ErrNoRows { return 0, nil } return result, err } func (db *Database) SetLastBackup(time uint64) error { return db.SaveSettingField(LastBackup, time) } func (db *Database) SetBackupFetched(fetched bool) error { return db.SaveSettingField(BackupFetched, fetched) } func (db *Database) BackupFetched() (result bool, err error) { err = db.makeSelectRow(BackupFetched).Scan(&result) if err == sql.ErrNoRows { return true, nil } return result, err } func (db *Database) ENSName() (string, error) { return db.makeSelectString(PreferredName) } func (db *Database) DeviceName() (string, error) { return db.makeSelectString(DeviceName) } func (db *Database) DisplayName() (string, error) { return db.makeSelectString(DisplayName) } func (db *Database) Bio() (string, error) { return db.makeSelectString(Bio) } func (db *Database) Mnemonic() (string, error) { return db.makeSelectString(Mnemonic) } func (db *Database) MnemonicRemoved() (result bool, err error) { err = db.makeSelectRow(MnemonicRemoved).Scan(&result) if err == sql.ErrNoRows { return result, nil } return result, err } func (db *Database) GetMnemonicWasNotShown() (result bool, err error) { err = db.makeSelectRow(MnemonicWasNotShown).Scan(&result) if err == sql.ErrNoRows { return result, nil } return result, err } func (db *Database) GifAPIKey() (string, error) { return db.makeSelectString(GifAPIKey) } func (db *Database) MutualContactEnabled() (result bool, err error) { err = db.makeSelectRow(MutualContactEnabled).Scan(&result) return result, err } func (db *Database) GifRecents() (recents json.RawMessage, err error) { err = db.makeSelectRow(GifRecents).Scan(&sqlite.JSONBlob{Data: &recents}) if err == sql.ErrNoRows { return nil, err } return recents, nil } func (db *Database) GifFavorites() (favorites json.RawMessage, err error) { err = db.makeSelectRow(GifFavourites).Scan(&sqlite.JSONBlob{Data: &favorites}) if err == sql.ErrNoRows { return nil, err } return favorites, nil } func (db *Database) GetPreferredUsername() (string, error) { return db.makeSelectString(PreferredName) } func (db *Database) GetCurrency() (string, error) { return db.makeSelectString(Currency) } func (db *Database) GetInstalledStickerPacks() (rst *json.RawMessage, err error) { err = db.makeSelectRow(StickersPacksInstalled).Scan(&rst) return } func (db *Database) GetPendingStickerPacks() (rst *json.RawMessage, err error) { err = db.makeSelectRow(StickersPacksPending).Scan(&rst) return } func (db *Database) GetRecentStickers() (rst *json.RawMessage, err error) { err = db.makeSelectRow(StickersRecentStickers).Scan(&rst) return } func (db *Database) SetPinnedMailservers(mailservers map[string]string) error { return db.SaveSettingField(PinnedMailservers, mailservers) } func (db *Database) SetUseMailservers(value bool) error { return db.SaveSettingField(UseMailservers, value) } func (db *Database) GetWalletRootAddress() (rst types.Address, err error) { err = db.makeSelectRow(WalletRootAddress).Scan(&rst) if err == sql.ErrNoRows { return rst, nil } return } func (db *Database) GetEIP1581Address() (rst types.Address, err error) { err = db.makeSelectRow(EIP1581Address).Scan(&rst) if err == sql.ErrNoRows { return rst, nil } return } func (db *Database) GetMasterAddress() (rst types.Address, err error) { err = db.makeSelectRow(MasterAddress).Scan(&rst) if err == sql.ErrNoRows { return rst, nil } return } func (db *Database) GetTestNetworksEnabled() (result bool, err error) { err = db.makeSelectRow(TestNetworksEnabled).Scan(&result) if err == sql.ErrNoRows { return result, nil } return result, err } func (db *Database) GetIsGoerliEnabled() (result bool, err error) { err = db.makeSelectRow(IsGoerliEnabled).Scan(&result) if err == sql.ErrNoRows { return result, nil } return result, err } func (db *Database) SetPeerSyncingEnabled(value bool) error { return db.SaveSettingField(PeerSyncingEnabled, value) } func (db *Database) GetPeerSyncingEnabled() (result bool, err error) { err = db.makeSelectRow(PeerSyncingEnabled).Scan(&result) if err == sql.ErrNoRows { return result, nil } return result, err } func (db *Database) GetTokenGroupByCommunity() (result bool, err error) { err = db.makeSelectRow(TokenGroupByCommunity).Scan(&result) if err == sql.ErrNoRows { return result, nil } return result, err } func (db *Database) SetTokenGroupByCommunity(value bool) error { return db.SaveSettingField(TokenGroupByCommunity, value) } func (db *Database) GetCollectibleGroupByCollection() (result bool, err error) { err = db.makeSelectRow(CollectibleGroupByCollection).Scan(&result) if err == sql.ErrNoRows { return result, nil } return result, err } func (db *Database) SetCollectibleGroupByCollection(value bool) error { return db.SaveSettingField(CollectibleGroupByCollection, value) } func (db *Database) GetCollectibleGroupByCommunity() (result bool, err error) { err = db.makeSelectRow(CollectibleGroupByCommunity).Scan(&result) if err == sql.ErrNoRows { return result, nil } return result, err } func (db *Database) SetCollectibleGroupByCommunity(value bool) error { return db.SaveSettingField(CollectibleGroupByCommunity, value) } func (db *Database) GetTelemetryServerURL() (string, error) { return db.makeSelectString(TelemetryServerURL) } func (db *Database) ProfileMigrationNeeded() (result bool, err error) { err = db.makeSelectRow(ProfileMigrationNeeded).Scan(&result) return result, err } func (db *Database) URLUnfurlingMode() (result int64, err error) { err = db.makeSelectRow(URLUnfurlingMode).Scan(&result) if err == sql.ErrNoRows { return result, nil } return result, err } func (db *Database) SubscribeToChanges() chan *SyncSettingField { s := make(chan *SyncSettingField, 100) db.changesSubscriptions = append(db.changesSubscriptions, s) return s } func (db *Database) postChangesToSubscribers(change *SyncSettingField) { // Publish on channels, drop if buffer is full for _, s := range db.changesSubscriptions { select { case s <- change: default: log.Warn("settings changes subscription channel full, dropping message") } } } func (db *Database) MnemonicWasShown() error { return db.SaveSettingField(MnemonicWasNotShown, false) }