diff --git a/VERSION b/VERSION index 244fb7efb..4402320d1 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -0.133.0 +0.133.1 \ No newline at end of file diff --git a/appdatabase/migrations/bindata.go b/appdatabase/migrations/bindata.go index a4979835b..7dd32ea96 100644 --- a/appdatabase/migrations/bindata.go +++ b/appdatabase/migrations/bindata.go @@ -47,6 +47,7 @@ // 1674232431_add_balance_history.up.sql (698B) // 1676368933_keypairs_to_keycards.up.sql (639B) // 1676951398_add_currency_format_cache.up.sql (291B) +// 1676968196_keycards_add_clock_column.up.sql (73B) // doc.go (74B) package migrations @@ -131,7 +132,7 @@ func _1640111208_dummyUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1640111208_dummy.up.sql", size: 258, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1640111208_dummy.up.sql", size: 258, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x3e, 0xf0, 0xae, 0x20, 0x6e, 0x75, 0xd1, 0x36, 0x14, 0xf2, 0x40, 0xe5, 0xd6, 0x7a, 0xc4, 0xa5, 0x72, 0xaa, 0xb5, 0x4d, 0x71, 0x97, 0xb8, 0xe8, 0x95, 0x22, 0x95, 0xa2, 0xac, 0xaf, 0x48, 0x58}} return a, nil } @@ -151,7 +152,7 @@ func _1642666031_add_removed_clock_to_bookmarksUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1642666031_add_removed_clock_to_bookmarks.up.sql", size: 117, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1642666031_add_removed_clock_to_bookmarks.up.sql", size: 117, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x84, 0x4e, 0x38, 0x99, 0x7a, 0xc, 0x90, 0x13, 0xec, 0xfe, 0x2f, 0x55, 0xff, 0xb7, 0xb6, 0xaa, 0x96, 0xc6, 0x92, 0x79, 0xcc, 0xee, 0x4e, 0x99, 0x53, 0xfe, 0x1c, 0xbb, 0x32, 0x2, 0xa4, 0x27}} return a, nil } @@ -171,7 +172,7 @@ func _1643644541_gif_api_key_settingUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1643644541_gif_api_key_setting.up.sql", size: 108, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1643644541_gif_api_key_setting.up.sql", size: 108, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x1b, 0x94, 0x28, 0xfb, 0x66, 0xd1, 0x7c, 0xb8, 0x89, 0xe2, 0xb4, 0x71, 0x65, 0x24, 0x57, 0x22, 0x95, 0x38, 0x97, 0x3, 0x9b, 0xc6, 0xa4, 0x41, 0x7b, 0xba, 0xf7, 0xdb, 0x70, 0xf7, 0x20, 0x3a}} return a, nil } @@ -191,7 +192,7 @@ func _1644188994_recent_stickersUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1644188994_recent_stickers.up.sql", size: 79, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1644188994_recent_stickers.up.sql", size: 79, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x1e, 0xad, 0xaa, 0x30, 0xbf, 0x4, 0x7, 0xf8, 0xc3, 0x3, 0xb8, 0x97, 0x23, 0x2b, 0xbd, 0x1c, 0x60, 0x69, 0xb0, 0x42, 0x5e, 0x6b, 0xd, 0xa7, 0xa3, 0x6b, 0x2e, 0xdc, 0x70, 0x13, 0x72, 0x7}} return a, nil } @@ -211,7 +212,7 @@ func _1646659233_add_address_to_dapp_permisssionUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1646659233_add_address_to_dapp_permisssion.up.sql", size: 700, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1646659233_add_address_to_dapp_permisssion.up.sql", size: 700, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xed, 0xb0, 0x35, 0xcc, 0x2e, 0x16, 0xe6, 0x15, 0x86, 0x2c, 0x37, 0x80, 0xae, 0xa3, 0xc5, 0x31, 0x78, 0x5, 0x9d, 0xcd, 0x7b, 0xeb, 0x5f, 0xf2, 0xb3, 0x74, 0x72, 0xdf, 0xcf, 0x88, 0xb, 0x40}} return a, nil } @@ -231,7 +232,7 @@ func _1646841105_add_emoji_accountUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1646841105_add_emoji_account.up.sql", size: 96, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1646841105_add_emoji_account.up.sql", size: 96, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xe6, 0x77, 0x29, 0x95, 0x18, 0x64, 0x82, 0x63, 0xe7, 0xaf, 0x6c, 0xa9, 0x15, 0x7d, 0x46, 0xa6, 0xbc, 0xdf, 0xa7, 0xd, 0x2b, 0xd2, 0x2d, 0x97, 0x4d, 0xa, 0x6b, 0xd, 0x6e, 0x90, 0x42, 0x5c}} return a, nil } @@ -251,7 +252,7 @@ func _1647278782_display_nameUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1647278782_display_name.up.sql", size: 110, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1647278782_display_name.up.sql", size: 110, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xf4, 0xa1, 0x1f, 0x3e, 0x61, 0x65, 0x8d, 0xff, 0xee, 0xde, 0xc5, 0x91, 0xd9, 0x5c, 0xb5, 0xe2, 0xf0, 0xb7, 0xe7, 0x5c, 0x5c, 0x16, 0x25, 0x89, 0xee, 0x78, 0x12, 0xea, 0x3e, 0x48, 0x41, 0xa6}} return a, nil } @@ -271,7 +272,7 @@ func _1647862838_reset_last_backupUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1647862838_reset_last_backup.up.sql", size: 37, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1647862838_reset_last_backup.up.sql", size: 37, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x21, 0xe3, 0xd5, 0xf6, 0x5f, 0xfe, 0x65, 0xfa, 0x1d, 0x88, 0xf8, 0x5f, 0x24, 0x71, 0x34, 0x68, 0x96, 0x2a, 0x60, 0x87, 0x15, 0x82, 0x4d, 0x8a, 0x59, 0x3d, 0x1f, 0xd8, 0x56, 0xd4, 0xfb, 0xda}} return a, nil } @@ -291,7 +292,7 @@ func _1647871652_add_settings_sync_clock_tableUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1647871652_add_settings_sync_clock_table.up.sql", size: 1044, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1647871652_add_settings_sync_clock_table.up.sql", size: 1044, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xd8, 0x58, 0xec, 0x85, 0x90, 0xfa, 0x30, 0x98, 0x98, 0x9a, 0xa6, 0xa8, 0x96, 0x2b, 0x38, 0x93, 0xf3, 0xae, 0x46, 0x74, 0xa4, 0x41, 0x62, 0x9b, 0x2, 0x86, 0xbf, 0xe5, 0x2a, 0xce, 0xe2, 0xc0}} return a, nil } @@ -311,7 +312,7 @@ func _1647880168_add_torrent_configUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1647880168_add_torrent_config.up.sql", size: 211, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1647880168_add_torrent_config.up.sql", size: 211, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x1, 0x92, 0x22, 0x37, 0x96, 0xf3, 0xb5, 0x5b, 0x27, 0xd0, 0x7d, 0x43, 0x5, 0x4e, 0x9d, 0xe2, 0x49, 0xbe, 0x86, 0x31, 0xa1, 0x89, 0xff, 0xd6, 0x51, 0xe0, 0x9c, 0xb, 0xda, 0xfc, 0xf2, 0x93}} return a, nil } @@ -331,7 +332,7 @@ func _1647882837_add_communities_settings_tableUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1647882837_add_communities_settings_table.up.sql", size: 206, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1647882837_add_communities_settings_table.up.sql", size: 206, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xbd, 0x87, 0x78, 0x99, 0xd9, 0x5d, 0xbd, 0xf7, 0x57, 0x9c, 0xca, 0x97, 0xbd, 0xb3, 0xe9, 0xb5, 0x89, 0x31, 0x3f, 0xf6, 0x5c, 0x13, 0xb, 0xc3, 0x54, 0x93, 0x18, 0x40, 0x7, 0x82, 0xfe, 0x7e}} return a, nil } @@ -351,7 +352,7 @@ func _1647956635_add_waku_messages_tableUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1647956635_add_waku_messages_table.up.sql", size: 266, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1647956635_add_waku_messages_table.up.sql", size: 266, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xd1, 0xe, 0xe1, 0xdc, 0xda, 0x2e, 0x89, 0x8d, 0xdc, 0x2a, 0x1c, 0x13, 0xa1, 0xfc, 0xfe, 0xf, 0xb2, 0xb9, 0x85, 0xc8, 0x45, 0xd6, 0xd1, 0x7, 0x5c, 0xa3, 0x8, 0x47, 0x44, 0x6d, 0x96, 0xe0}} return a, nil } @@ -371,7 +372,7 @@ func _1648554928_network_testUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1648554928_network_test.up.sql", size: 132, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1648554928_network_test.up.sql", size: 132, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x9a, 0xc5, 0x7f, 0x87, 0xf3, 0x2c, 0xf7, 0xbb, 0xd3, 0x3a, 0x4e, 0x76, 0x88, 0xca, 0xaf, 0x73, 0xce, 0x8f, 0xa1, 0xf6, 0x3d, 0x4d, 0xed, 0x6f, 0x49, 0xf2, 0xfe, 0x56, 0x2a, 0x60, 0x68, 0xca}} return a, nil } @@ -391,7 +392,7 @@ func _1649174829_add_visitble_tokenUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1649174829_add_visitble_token.up.sql", size: 84, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1649174829_add_visitble_token.up.sql", size: 84, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xa3, 0x22, 0xc0, 0x2b, 0x3f, 0x4f, 0x3d, 0x5e, 0x4c, 0x68, 0x7c, 0xd0, 0x15, 0x36, 0x9f, 0xec, 0xa1, 0x2a, 0x7b, 0xb4, 0xe3, 0xc6, 0xc9, 0xb4, 0x81, 0x50, 0x4a, 0x11, 0x3b, 0x35, 0x7, 0xcf}} return a, nil } @@ -411,7 +412,7 @@ func _1649882262_add_derived_from_accountsUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1649882262_add_derived_from_accounts.up.sql", size: 110, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1649882262_add_derived_from_accounts.up.sql", size: 110, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x11, 0xb9, 0x44, 0x4d, 0x85, 0x8d, 0x7f, 0xb4, 0xae, 0x4f, 0x5c, 0x66, 0x64, 0xb6, 0xe2, 0xe, 0x3d, 0xad, 0x9d, 0x8, 0x4f, 0xab, 0x6e, 0xa8, 0x7d, 0x76, 0x3, 0xad, 0x96, 0x1, 0xee, 0x5c}} return a, nil } @@ -431,7 +432,7 @@ func _1650612625_add_community_message_archive_hashes_tableUpSql() (*asset, erro return nil, err } - info := bindataFileInfo{name: "1650612625_add_community_message_archive_hashes_table.up.sql", size: 130, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1650612625_add_community_message_archive_hashes_table.up.sql", size: 130, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x48, 0x31, 0xb3, 0x75, 0x23, 0xe2, 0x45, 0xe, 0x47, 0x1b, 0x35, 0xa5, 0x6e, 0x83, 0x4e, 0x64, 0x7d, 0xd7, 0xa2, 0xda, 0xe9, 0x53, 0xf1, 0x16, 0x86, 0x2c, 0x57, 0xad, 0xfa, 0xca, 0x39, 0xde}} return a, nil } @@ -451,7 +452,7 @@ func _1650616788_add_communities_archives_info_tableUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1650616788_add_communities_archives_info_table.up.sql", size: 208, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1650616788_add_communities_archives_info_table.up.sql", size: 208, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xd1, 0x4f, 0x80, 0x45, 0xb9, 0xd9, 0x15, 0xe2, 0x78, 0xd0, 0xcb, 0x71, 0xc1, 0x1b, 0xb7, 0x1b, 0x1b, 0x97, 0xfe, 0x47, 0x53, 0x3c, 0x62, 0xbc, 0xdd, 0x3a, 0x94, 0x1a, 0xc, 0x48, 0x76, 0xe}} return a, nil } @@ -471,7 +472,7 @@ func _1652715604_add_clock_accountsUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1652715604_add_clock_accounts.up.sql", size: 62, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1652715604_add_clock_accounts.up.sql", size: 62, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xb6, 0xd9, 0x8d, 0x73, 0xc9, 0xef, 0xfa, 0xb1, 0x4b, 0xa5, 0xf3, 0x5, 0x19, 0x26, 0x46, 0xf8, 0x47, 0x93, 0xdb, 0xac, 0x2, 0xef, 0xf9, 0x71, 0x56, 0x83, 0xe6, 0x2d, 0xb0, 0xd7, 0x83, 0x5c}} return a, nil } @@ -491,7 +492,7 @@ func _1653037334_add_notifications_settings_tableUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1653037334_add_notifications_settings_table.up.sql", size: 1276, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1653037334_add_notifications_settings_table.up.sql", size: 1276, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x4b, 0xc4, 0x65, 0xac, 0xa, 0xf2, 0xef, 0xb6, 0x39, 0x3c, 0xc5, 0xb1, 0xb2, 0x9c, 0x86, 0x58, 0xe0, 0x38, 0xcb, 0x57, 0x3c, 0x76, 0x73, 0x87, 0x79, 0x4e, 0xf6, 0xed, 0xb0, 0x8e, 0x9e, 0xa}} return a, nil } @@ -511,7 +512,7 @@ func _1654702119_add_mutual_contact_settingsUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1654702119_add_mutual_contact_settings.up.sql", size: 78, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1654702119_add_mutual_contact_settings.up.sql", size: 78, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x26, 0x66, 0x67, 0x50, 0xfe, 0xd7, 0xe3, 0x29, 0x8b, 0xff, 0x9d, 0x5a, 0x87, 0xa7, 0x99, 0x6e, 0xd6, 0xcd, 0x2e, 0xbb, 0x17, 0xdf, 0x7f, 0xf7, 0xa3, 0xfa, 0x32, 0x7c, 0x2d, 0x92, 0xc8, 0x74}} return a, nil } @@ -531,7 +532,7 @@ func _1655375270_add_clock_field_to_communities_settings_tableUpSql() (*asset, e return nil, err } - info := bindataFileInfo{name: "1655375270_add_clock_field_to_communities_settings_table.up.sql", size: 74, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1655375270_add_clock_field_to_communities_settings_table.up.sql", size: 74, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x19, 0xc5, 0xc0, 0xf9, 0x84, 0x53, 0xdf, 0x83, 0xcf, 0xb6, 0x40, 0x6d, 0xf5, 0xdc, 0x77, 0x37, 0xb7, 0xe3, 0xa, 0x75, 0xe7, 0x6, 0x11, 0xca, 0x2b, 0x51, 0x92, 0xdd, 0x7d, 0xdb, 0xc3, 0xf5}} return a, nil } @@ -551,7 +552,7 @@ func _1655385721_drop_networks_configUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1655385721_drop_networks_config.up.sql", size: 27, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1655385721_drop_networks_config.up.sql", size: 27, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xfc, 0xa7, 0x20, 0xbb, 0x67, 0x21, 0xe, 0xc6, 0xc8, 0x21, 0x74, 0xe0, 0xce, 0xc8, 0xe2, 0x2, 0xb4, 0xea, 0xf0, 0xe5, 0xc4, 0x4d, 0xdd, 0xd4, 0x52, 0x31, 0xa9, 0x3d, 0xcd, 0xd8, 0x9b, 0xab}} return a, nil } @@ -571,7 +572,7 @@ func _1655385724_networks_chaincolor_shortnameUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1655385724_networks_chainColor_shortName.up.sql", size: 220, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1655385724_networks_chainColor_shortName.up.sql", size: 220, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xd9, 0xe7, 0x84, 0xbb, 0x5f, 0xd2, 0x2c, 0x42, 0x88, 0x62, 0x52, 0xb6, 0x58, 0x31, 0xac, 0xc, 0x96, 0x2b, 0x1b, 0xe5, 0x4e, 0x9a, 0x3a, 0xf6, 0xf6, 0xfc, 0xa9, 0x1a, 0x35, 0x62, 0x28, 0x88}} return a, nil } @@ -591,7 +592,7 @@ func _1655456688_add_deleted_at_field_to_bookmarks_tableUpSql() (*asset, error) return nil, err } - info := bindataFileInfo{name: "1655456688_add_deleted_at_field_to_bookmarks_table.up.sql", size: 69, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1655456688_add_deleted_at_field_to_bookmarks_table.up.sql", size: 69, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xe7, 0x9a, 0xbd, 0x9a, 0xc9, 0xf, 0xdf, 0x90, 0x0, 0x5d, 0xea, 0x6e, 0x7d, 0x51, 0x95, 0xcd, 0x90, 0xd3, 0x1a, 0x36, 0x6c, 0xf4, 0xbd, 0xa7, 0x6b, 0xbf, 0xe5, 0xdb, 0xa3, 0x88, 0xe3, 0x50}} return a, nil } @@ -611,7 +612,7 @@ func _1655462032_create_bookmarks_deleted_at_indexUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1655462032_create_bookmarks_deleted_at_index.up.sql", size: 81, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1655462032_create_bookmarks_deleted_at_index.up.sql", size: 81, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xf, 0x8e, 0x20, 0x6b, 0x14, 0x9e, 0xcd, 0x97, 0xd3, 0xfe, 0x62, 0x3, 0x26, 0x59, 0x1, 0x6c, 0x99, 0xef, 0x6d, 0x21, 0xd4, 0xb5, 0xa3, 0xf4, 0x39, 0x40, 0x54, 0x6, 0xd, 0x60, 0x13, 0x38}} return a, nil } @@ -631,7 +632,7 @@ func _1657617291_add_multi_transactions_tableUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1657617291_add_multi_transactions_table.up.sql", size: 412, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1657617291_add_multi_transactions_table.up.sql", size: 412, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x86, 0xb0, 0x4e, 0x8c, 0x4, 0x82, 0xb4, 0x43, 0xaa, 0xd0, 0x16, 0xdd, 0xcb, 0x88, 0x81, 0xac, 0x4, 0x34, 0x1a, 0x8f, 0x2e, 0xc5, 0x69, 0xb, 0xf0, 0x17, 0xf7, 0xe3, 0x9, 0xe, 0x54, 0xe0}} return a, nil } @@ -651,7 +652,7 @@ func _1660134042_add_social_links_settings_tableUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1660134042_add_social_links_settings_table.up.sql", size: 334, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1660134042_add_social_links_settings_table.up.sql", size: 334, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x84, 0x73, 0xb6, 0xe7, 0x3f, 0xaa, 0x39, 0x9a, 0x56, 0x56, 0x31, 0xf1, 0x8e, 0x26, 0x23, 0x1, 0xe4, 0xfa, 0x98, 0xfe, 0x78, 0x87, 0x20, 0xcb, 0x52, 0xf4, 0x38, 0x7f, 0xc4, 0x1c, 0x4, 0x22}} return a, nil } @@ -671,7 +672,7 @@ func _1660134060_settings_bioUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1660134060_settings_bio.up.sql", size: 91, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1660134060_settings_bio.up.sql", size: 91, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x46, 0x25, 0xa0, 0xa6, 0x47, 0xff, 0xbc, 0x2a, 0x0, 0xff, 0x59, 0x4b, 0xb0, 0xc9, 0x4e, 0x15, 0xe4, 0xd9, 0xda, 0xeb, 0xfe, 0x55, 0x98, 0xc3, 0x9d, 0x96, 0xe7, 0xf, 0xd1, 0x5c, 0x93, 0x73}} return a, nil } @@ -691,7 +692,7 @@ func _1660134070_add_wakuv2_storeUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1660134070_add_wakuv2_store.up.sql", size: 269, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1660134070_add_wakuv2_store.up.sql", size: 269, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x1d, 0xe6, 0xc3, 0x9, 0xef, 0xdc, 0xae, 0x49, 0x30, 0x78, 0x54, 0xd6, 0xdb, 0xbf, 0xc0, 0x8e, 0x25, 0x8f, 0xfc, 0x67, 0x80, 0x39, 0x37, 0xd4, 0x86, 0xc1, 0x85, 0xc8, 0x99, 0xc4, 0x59, 0xd4}} return a, nil } @@ -711,7 +712,7 @@ func _1660134072_waku2_store_messagesUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1660134072_waku2_store_messages.up.sql", size: 497, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "1660134072_waku2_store_messages.up.sql", size: 497, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x3e, 0xeb, 0xb4, 0xa0, 0xa1, 0x2b, 0xcb, 0x4c, 0x3c, 0xc6, 0xd0, 0xe8, 0x96, 0xe3, 0x96, 0xf1, 0x4f, 0x1f, 0xe0, 0xe7, 0x1f, 0x85, 0xa3, 0xe, 0xf7, 0x52, 0x56, 0x63, 0x2b, 0xb0, 0x87, 0x7b}} return a, nil } @@ -731,7 +732,7 @@ func _1662365868_add_key_uid_accountsUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1662365868_add_key_uid_accounts.up.sql", size: 68, mode: os.FileMode(0644), modTime: time.Unix(1663587122, 0)} + info := bindataFileInfo{name: "1662365868_add_key_uid_accounts.up.sql", size: 68, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xc6, 0xd8, 0x2f, 0x2f, 0x3b, 0xa8, 0xbd, 0x6d, 0xf6, 0x87, 0x7e, 0xd2, 0xf1, 0xa2, 0xf7, 0x81, 0x6a, 0x23, 0x10, 0xbc, 0xbf, 0x5b, 0xe7, 0x2b, 0x9c, 0xa9, 0x8a, 0x18, 0xbb, 0xd0, 0x86, 0x91}} return a, nil } @@ -751,7 +752,7 @@ func _1662447680_add_keypairs_tableUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1662447680_add_keypairs_table.up.sql", size: 218, mode: os.FileMode(0644), modTime: time.Unix(1663587122, 0)} + info := bindataFileInfo{name: "1662447680_add_keypairs_table.up.sql", size: 218, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xdc, 0x25, 0xa9, 0xc7, 0x63, 0x27, 0x97, 0x35, 0x5f, 0x6b, 0xab, 0x26, 0xcb, 0xf9, 0xbd, 0x5e, 0xac, 0x3, 0xa0, 0x5e, 0xb9, 0x71, 0xa3, 0x1f, 0xb3, 0x4f, 0x7f, 0x79, 0x28, 0x48, 0xbe, 0xc}} return a, nil } @@ -771,7 +772,7 @@ func _1662460056_move_favourites_to_saved_addressesUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1662460056_move_favourites_to_saved_addresses.up.sql", size: 233, mode: os.FileMode(0644), modTime: time.Unix(1663587122, 0)} + info := bindataFileInfo{name: "1662460056_move_favourites_to_saved_addresses.up.sql", size: 233, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x10, 0xa2, 0x8c, 0xa3, 0xec, 0xad, 0xdf, 0xc3, 0x48, 0x5, 0x9b, 0x50, 0x25, 0x59, 0xae, 0x7d, 0xee, 0x58, 0xd2, 0x41, 0x27, 0xf2, 0x22, 0x2e, 0x9a, 0xb9, 0x4a, 0xcc, 0x38, 0x6e, 0x3a, 0xb2}} return a, nil } @@ -791,7 +792,7 @@ func _1662738097_add_base_fee_transactionUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1662738097_add_base_fee_transaction.up.sql", size: 112, mode: os.FileMode(0644), modTime: time.Unix(1663587122, 0)} + info := bindataFileInfo{name: "1662738097_add_base_fee_transaction.up.sql", size: 112, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x6b, 0xfb, 0x10, 0xae, 0xfc, 0x77, 0x70, 0x98, 0x6f, 0xec, 0xaa, 0xcd, 0x7, 0xc7, 0x74, 0x23, 0xc, 0xd5, 0x1e, 0x82, 0xdd, 0xfe, 0xff, 0x3b, 0xd2, 0x49, 0x10, 0x5b, 0x30, 0xc, 0x2d, 0xb0}} return a, nil } @@ -811,7 +812,7 @@ func _1662972194_add_keypairs_tableUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1662972194_add_keypairs_table.up.sql", size: 345, mode: os.FileMode(0644), modTime: time.Unix(1663587122, 0)} + info := bindataFileInfo{name: "1662972194_add_keypairs_table.up.sql", size: 345, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xab, 0x76, 0xf2, 0x86, 0xe1, 0x7e, 0xe9, 0x47, 0x32, 0x48, 0xd5, 0x6b, 0xe5, 0xd, 0xab, 0xb7, 0xf1, 0xd4, 0xf1, 0xad, 0x38, 0xa6, 0x11, 0xe7, 0xce, 0x5c, 0x11, 0x11, 0xf, 0x47, 0xb2, 0x4}} return a, nil } @@ -831,7 +832,7 @@ func _1664392661_add_third_party_id_to_waku_messagesUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1664392661_add_third_party_id_to_waku_messages.up.sql", size: 70, mode: os.FileMode(0644), modTime: time.Unix(1664889752, 0)} + info := bindataFileInfo{name: "1664392661_add_third_party_id_to_waku_messages.up.sql", size: 70, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xfd, 0x67, 0x66, 0x9e, 0x66, 0x74, 0xce, 0x1c, 0xb, 0x1b, 0x9d, 0xd5, 0xfc, 0x65, 0xe, 0x83, 0x90, 0x4c, 0x61, 0x4e, 0x6b, 0xe7, 0x86, 0xbe, 0x36, 0x4f, 0x91, 0x36, 0x4, 0x47, 0x7b, 0x82}} return a, nil } @@ -851,7 +852,7 @@ func _1664783660_add_sync_info_to_saved_addressesUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1664783660_add_sync_info_to_saved_addresses.up.sql", size: 388, mode: os.FileMode(0644), modTime: time.Unix(1666188919, 0)} + info := bindataFileInfo{name: "1664783660_add_sync_info_to_saved_addresses.up.sql", size: 388, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x67, 0x7c, 0x3a, 0x95, 0x4e, 0x55, 0xb2, 0xbd, 0xb4, 0x18, 0x93, 0xc1, 0xcf, 0x9f, 0x12, 0xbb, 0x49, 0x8a, 0x2a, 0x6a, 0x2a, 0x7f, 0xad, 0x44, 0xc3, 0xf, 0x3a, 0x79, 0x18, 0xb9, 0x4c, 0x64}} return a, nil } @@ -871,7 +872,7 @@ func _1668109917_wakunodesUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1668109917_wakunodes.up.sql", size: 99, mode: os.FileMode(0644), modTime: time.Unix(1669399895, 0)} + info := bindataFileInfo{name: "1668109917_wakunodes.up.sql", size: 99, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x29, 0xaa, 0x9e, 0x2, 0x66, 0x85, 0x69, 0xa8, 0xd9, 0xe2, 0x4b, 0x8d, 0x2a, 0x9c, 0xdf, 0xd2, 0xef, 0x64, 0x58, 0xe3, 0xa6, 0xe7, 0xc1, 0xd1, 0xc8, 0x9c, 0xc0, 0x2c, 0x1, 0xa8, 0x7b, 0x81}} return a, nil } @@ -891,7 +892,7 @@ func _1670249678_display_name_to_settings_sync_clock_tableUpSql() (*asset, error return nil, err } - info := bindataFileInfo{name: "1670249678_display_name_to_settings_sync_clock_table.up.sql", size: 83, mode: os.FileMode(0644), modTime: time.Unix(1673032882, 0)} + info := bindataFileInfo{name: "1670249678_display_name_to_settings_sync_clock_table.up.sql", size: 83, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x39, 0x18, 0xdc, 0xc4, 0x1f, 0x79, 0x22, 0x16, 0x4d, 0xdf, 0x6c, 0x66, 0xd5, 0xa4, 0x88, 0x5d, 0x5, 0x37, 0xa7, 0x41, 0x5, 0x50, 0xae, 0x12, 0xfa, 0x7e, 0x89, 0x24, 0x5c, 0xae, 0x30, 0xfc}} return a, nil } @@ -911,7 +912,7 @@ func _1670836810_add_imported_flag_to_community_archive_hashesUpSql() (*asset, e return nil, err } - info := bindataFileInfo{name: "1670836810_add_imported_flag_to_community_archive_hashes.up.sql", size: 144, mode: os.FileMode(0644), modTime: time.Unix(1673009770, 0)} + info := bindataFileInfo{name: "1670836810_add_imported_flag_to_community_archive_hashes.up.sql", size: 144, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x6f, 0xf, 0xf0, 0xbd, 0xfe, 0x63, 0x25, 0x8f, 0x5e, 0x46, 0x4b, 0x45, 0x31, 0x8b, 0x3e, 0xd8, 0x6b, 0x5d, 0x9d, 0x6d, 0x10, 0x9a, 0x87, 0x4b, 0x18, 0xc6, 0x39, 0x81, 0x6e, 0xe4, 0x75, 0xfb}} return a, nil } @@ -931,7 +932,7 @@ func _1671438731_add_magnetlink_uri_to_communities_archive_infoUpSql() (*asset, return nil, err } - info := bindataFileInfo{name: "1671438731_add_magnetlink_uri_to_communities_archive_info.up.sql", size: 86, mode: os.FileMode(0644), modTime: time.Unix(1673032882, 0)} + info := bindataFileInfo{name: "1671438731_add_magnetlink_uri_to_communities_archive_info.up.sql", size: 86, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xda, 0x8b, 0x4b, 0xd6, 0xd8, 0xe2, 0x3d, 0xf7, 0x6b, 0xcd, 0x1e, 0x70, 0x9, 0x2e, 0x35, 0x4, 0x61, 0xc3, 0xb5, 0x9d, 0xc5, 0x27, 0x21, 0xa, 0x5a, 0xd6, 0x3e, 0xa6, 0x24, 0xa2, 0x12, 0xdf}} return a, nil } @@ -951,7 +952,7 @@ func _1672933930_switcher_cardUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1672933930_switcher_card.up.sql", size: 162, mode: os.FileMode(0644), modTime: time.Unix(1673032882, 0)} + info := bindataFileInfo{name: "1672933930_switcher_card.up.sql", size: 162, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x39, 0xba, 0xdc, 0xbb, 0x40, 0x4, 0xf2, 0x10, 0xdf, 0xb4, 0xd2, 0x80, 0x8a, 0x74, 0x4d, 0xf6, 0xbc, 0x50, 0x7, 0xd, 0x22, 0x7f, 0xc4, 0xaf, 0xaa, 0xde, 0xdc, 0x71, 0xe9, 0x42, 0x98, 0x36}} return a, nil } @@ -971,7 +972,7 @@ func _1674056187_add_price_cacheUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1674056187_add_price_cache.up.sql", size: 255, mode: os.FileMode(0644), modTime: time.Unix(1674168257, 0)} + info := bindataFileInfo{name: "1674056187_add_price_cache.up.sql", size: 255, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xb7, 0x79, 0x6a, 0x9b, 0x28, 0xd1, 0x22, 0xf0, 0x84, 0x76, 0x40, 0x39, 0x49, 0x15, 0x5d, 0xaa, 0xfd, 0x11, 0xff, 0x13, 0x27, 0x42, 0x12, 0xfa, 0x82, 0xe6, 0x7a, 0xf0, 0x5e, 0x1f, 0xe3, 0xba}} return a, nil } @@ -991,7 +992,7 @@ func _1674136690_ens_usernamesUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1674136690_ens_usernames.up.sql", size: 98, mode: os.FileMode(0644), modTime: time.Unix(1674213541, 0)} + info := bindataFileInfo{name: "1674136690_ens_usernames.up.sql", size: 98, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x81, 0x7a, 0xf3, 0xa8, 0x88, 0x99, 0xd6, 0x9c, 0x69, 0x48, 0x3c, 0x10, 0xda, 0x72, 0xdc, 0x14, 0xd, 0x6e, 0x8c, 0x82, 0x92, 0x2d, 0x2c, 0xee, 0x4c, 0x70, 0xa4, 0xdc, 0x5c, 0x5, 0x2, 0xc3}} return a, nil } @@ -1011,7 +1012,7 @@ func _1674232431_add_balance_historyUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1674232431_add_balance_history.up.sql", size: 698, mode: os.FileMode(0644), modTime: time.Unix(1674751271, 0)} + info := bindataFileInfo{name: "1674232431_add_balance_history.up.sql", size: 698, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xf7, 0xb5, 0x18, 0xca, 0x4a, 0x93, 0xbb, 0x6f, 0xa4, 0xee, 0xe4, 0x3e, 0xff, 0x6a, 0x4b, 0xe2, 0xe1, 0x61, 0x28, 0xee, 0xc5, 0x26, 0x57, 0x61, 0x5e, 0x6d, 0x44, 0x1e, 0x85, 0x43, 0x70, 0xa2}} return a, nil } @@ -1031,7 +1032,7 @@ func _1676368933_keypairs_to_keycardsUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1676368933_keypairs_to_keycards.up.sql", size: 639, mode: os.FileMode(0644), modTime: time.Unix(1676643817, 0)} + info := bindataFileInfo{name: "1676368933_keypairs_to_keycards.up.sql", size: 639, mode: os.FileMode(0644), modTime: time.Unix(1676888614, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x81, 0x93, 0x27, 0x2, 0xf0, 0x37, 0x81, 0x65, 0xa4, 0xb3, 0x5b, 0x60, 0x36, 0x95, 0xfc, 0x81, 0xf0, 0x3b, 0x7c, 0xc3, 0x2c, 0x85, 0xbd, 0x38, 0x46, 0xa4, 0x95, 0x4a, 0x6, 0x3e, 0x74, 0xd5}} return a, nil } @@ -1051,11 +1052,31 @@ func _1676951398_add_currency_format_cacheUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1676951398_add_currency_format_cache.up.sql", size: 291, mode: os.FileMode(0644), modTime: time.Unix(1676643817, 0)} + info := bindataFileInfo{name: "1676951398_add_currency_format_cache.up.sql", size: 291, mode: os.FileMode(0644), modTime: time.Unix(1676888614, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xf9, 0xa3, 0x76, 0x35, 0xca, 0xf, 0xe8, 0xdf, 0xd9, 0x61, 0xf9, 0xed, 0xfc, 0x6d, 0xf5, 0xe, 0x11, 0x88, 0xbd, 0x14, 0x92, 0xc6, 0x57, 0x53, 0xe, 0xcd, 0x52, 0xf4, 0xa9, 0xb1, 0xdd, 0xfd}} return a, nil } +var __1676968196_keycards_add_clock_columnUpSql = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x04\xc0\xb1\x0a\x80\x20\x10\x06\xe0\x57\xf9\x1f\xa1\xbd\xe9\x4a\x83\xe0\x3a\x21\xce\x59\x44\x9d\x14\x8a\xb4\xa1\xb7\xef\x23\x56\x7b\x42\x69\x61\x8b\x5a\xbe\x14\x9f\xdc\x41\xc6\x60\x75\xec\x0f\x41\x8b\x7d\x84\xf7\xce\x71\x94\x90\xda\x95\x2a\x76\x51\x88\x53\x88\x67\x86\xb1\x1b\x79\x56\x4c\xf3\x1f\x00\x00\xff\xff\xdf\xc5\x21\x50\x49\x00\x00\x00") + +func _1676968196_keycards_add_clock_columnUpSqlBytes() ([]byte, error) { + return bindataRead( + __1676968196_keycards_add_clock_columnUpSql, + "1676968196_keycards_add_clock_column.up.sql", + ) +} + +func _1676968196_keycards_add_clock_columnUpSql() (*asset, error) { + bytes, err := _1676968196_keycards_add_clock_columnUpSqlBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "1676968196_keycards_add_clock_column.up.sql", size: 73, mode: os.FileMode(0644), modTime: time.Unix(1677485977, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x4c, 0xf, 0x1c, 0x28, 0x41, 0x57, 0x57, 0x6c, 0xe, 0x75, 0x6b, 0x75, 0x12, 0x0, 0x18, 0x1e, 0x88, 0x1e, 0x45, 0xe0, 0x32, 0xb9, 0xd4, 0xd9, 0x2e, 0xc8, 0xb, 0x80, 0x6, 0x51, 0x3d, 0x28}} + return a, nil +} + var _docGo = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x2c\xc9\xb1\x0d\xc4\x20\x0c\x05\xd0\x9e\x29\xfe\x02\xd8\xfd\x6d\xe3\x4b\xac\x2f\x44\x82\x09\x78\x7f\xa5\x49\xfd\xa6\x1d\xdd\xe8\xd8\xcf\x55\x8a\x2a\xe3\x47\x1f\xbe\x2c\x1d\x8c\xfa\x6f\xe3\xb4\x34\xd4\xd9\x89\xbb\x71\x59\xb6\x18\x1b\x35\x20\xa2\x9f\x0a\x03\xa2\xe5\x0d\x00\x00\xff\xff\x60\xcd\x06\xbe\x4a\x00\x00\x00") func docGoBytes() ([]byte, error) { @@ -1071,7 +1092,7 @@ func docGo() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "doc.go", size: 74, mode: os.FileMode(0644), modTime: time.Unix(1662753054, 0)} + info := bindataFileInfo{name: "doc.go", size: 74, mode: os.FileMode(0644), modTime: time.Unix(1676634063, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xde, 0x7c, 0x28, 0xcd, 0x47, 0xf2, 0xfa, 0x7c, 0x51, 0x2d, 0xd8, 0x38, 0xb, 0xb0, 0x34, 0x9d, 0x4c, 0x62, 0xa, 0x9e, 0x28, 0xc3, 0x31, 0x23, 0xd9, 0xbb, 0x89, 0x9f, 0xa0, 0x89, 0x1f, 0xe8}} return a, nil } @@ -1261,6 +1282,8 @@ var _bindata = map[string]func() (*asset, error){ "1676951398_add_currency_format_cache.up.sql": _1676951398_add_currency_format_cacheUpSql, + "1676968196_keycards_add_clock_column.up.sql": _1676968196_keycards_add_clock_columnUpSql, + "doc.go": docGo, } @@ -1352,6 +1375,7 @@ var _bintree = &bintree{nil, map[string]*bintree{ "1674232431_add_balance_history.up.sql": &bintree{_1674232431_add_balance_historyUpSql, map[string]*bintree{}}, "1676368933_keypairs_to_keycards.up.sql": &bintree{_1676368933_keypairs_to_keycardsUpSql, map[string]*bintree{}}, "1676951398_add_currency_format_cache.up.sql": &bintree{_1676951398_add_currency_format_cacheUpSql, map[string]*bintree{}}, + "1676968196_keycards_add_clock_column.up.sql": &bintree{_1676968196_keycards_add_clock_columnUpSql, map[string]*bintree{}}, "doc.go": &bintree{docGo, map[string]*bintree{}}, }} diff --git a/appdatabase/migrations/sql/1676968196_keycards_add_clock_column.up.sql b/appdatabase/migrations/sql/1676968196_keycards_add_clock_column.up.sql new file mode 100644 index 000000000..e0c02af1e --- /dev/null +++ b/appdatabase/migrations/sql/1676968196_keycards_add_clock_column.up.sql @@ -0,0 +1 @@ +ALTER TABLE keycards ADD COLUMN last_update_clock INT NOT NULL DEFAULT 0; \ No newline at end of file diff --git a/multiaccounts/keypairs/database.go b/multiaccounts/keypairs/database.go index c246b5d06..65bdbacca 100644 --- a/multiaccounts/keypairs/database.go +++ b/multiaccounts/keypairs/database.go @@ -2,18 +2,24 @@ package keypairs import ( "database/sql" + "errors" "fmt" "strings" "github.com/status-im/status-go/eth-node/types" ) +const ( + dbTransactionIsNil = "database transaction is nil" +) + type KeyPair struct { KeycardUID string `json:"keycard-uid"` KeycardName string `json:"keycard-name"` KeycardLocked bool `json:"keycard-locked"` AccountsAddresses []types.Address `json:"accounts-addresses"` KeyUID string `json:"key-uid"` + LastUpdateClock uint64 } type KeyPairs struct { @@ -40,7 +46,8 @@ func (kp *KeyPairs) processResult(rows *sql.Rows, groupByKeycard bool) ([]*KeyPa for rows.Next() { keyPair := &KeyPair{} addr := types.Address{} - err := rows.Scan(&keyPair.KeycardUID, &keyPair.KeycardName, &keyPair.KeycardLocked, &addr, &keyPair.KeyUID) + err := rows.Scan(&keyPair.KeycardUID, &keyPair.KeycardName, &keyPair.KeycardLocked, &addr, &keyPair.KeyUID, + &keyPair.LastUpdateClock) if err != nil { return nil, err } @@ -80,7 +87,8 @@ func (kp *KeyPairs) getAllRows(groupByKeycard bool) ([]*KeyPair, error) { k.keycard_name, k.keycard_locked, ka.account_address, - k.key_uid + k.key_uid, + k.last_update_clock FROM keycards AS k LEFT JOIN @@ -113,7 +121,8 @@ func (kp *KeyPairs) GetMigratedKeyPairByKeyUID(keyUID string) ([]*KeyPair, error k.keycard_name, k.keycard_locked, ka.account_address, - k.key_uid + k.key_uid, + k.last_update_clock FROM keycards AS k LEFT JOIN @@ -133,87 +142,44 @@ func (kp *KeyPairs) GetMigratedKeyPairByKeyUID(keyUID string) ([]*KeyPair, error return kp.processResult(rows, false) } -func (kp *KeyPairs) AddMigratedKeyPairOrAddAccountsIfKeyPairIsAdded(keyPair KeyPair) (err error) { - var ( - tx *sql.Tx - insertKcAcc *sql.Stmt - ) +func (kp *KeyPairs) startTransactionAndCheckIfNeedToProceed(kcUID string, clock uint64) (tx *sql.Tx, proceed bool, err error) { tx, err = kp.db.Begin() if err != nil { - return + return nil, false, err } - defer func() { - if err == nil { - err = tx.Commit() - return - } - _ = tx.Rollback() - }() - - var tmpKeyUID string - err = tx.QueryRow(`SELECT keycard_uid FROM keycards WHERE keycard_uid = ?`, keyPair.KeycardUID).Scan(&tmpKeyUID) + var dbLastUpdateClock uint64 + err = tx.QueryRow(`SELECT last_update_clock FROM keycards WHERE keycard_uid = ?`, kcUID).Scan(&dbLastUpdateClock) if err != nil { - if err == sql.ErrNoRows { - insertKc, err := tx.Prepare(` - INSERT INTO - keycards - ( - keycard_uid, - keycard_name, - keycard_locked, - key_uid - ) - VALUES - (?, ?, ?, ?); - `) - - if err != nil { - return err - } - - defer insertKc.Close() - - _, err = insertKc.Exec(keyPair.KeycardUID, keyPair.KeycardName, keyPair.KeycardLocked, keyPair.KeyUID) - if err != nil { - return err - } - - } else { - return err - } + return tx, false, err } - insertKcAcc, err = tx.Prepare(` - INSERT INTO - keycards_accounts - ( - keycard_uid, - account_address - ) - VALUES - (?, ?); - `) - - if err != nil { - return err - } - defer insertKcAcc.Close() - - for i := range keyPair.AccountsAddresses { - addr := keyPair.AccountsAddresses[i] - - _, err = insertKcAcc.Exec(keyPair.KeycardUID, addr) - if err != nil { - return err - } - } - return nil + return tx, dbLastUpdateClock <= clock, nil } -func (kp *KeyPairs) getAccountsForKeycard(kcUID string) ([]types.Address, error) { - var accountAddresses []types.Address +func (kp *KeyPairs) setLastUpdateClock(tx *sql.Tx, kcUID string, clock uint64) (err error) { + if tx == nil { + return errors.New(dbTransactionIsNil) + } - rows, err := kp.db.Query(`SELECT account_address FROM keycards_accounts WHERE keycard_uid = ?`, kcUID) + _, err = tx.Exec(` + UPDATE + keycards + SET + last_update_clock = ? + WHERE + keycard_uid = ?`, + clock, kcUID) + + return err +} + +func (kp *KeyPairs) getAccountsForKeycard(tx *sql.Tx, kcUID string) ([]types.Address, error) { + var accountAddresses []types.Address + if tx == nil { + return accountAddresses, errors.New(dbTransactionIsNil) + } + + rows, err := tx.Query(`SELECT account_address FROM keycards_accounts WHERE keycard_uid = ?`, kcUID) if err != nil { return nil, err } @@ -231,89 +197,45 @@ func (kp *KeyPairs) getAccountsForKeycard(kcUID string) ([]types.Address, error) return accountAddresses, nil } -func (kp *KeyPairs) RemoveMigratedAccountsForKeycard(kcUID string, accountAddresses []types.Address) (err error) { - dbAccountAddresses, err := kp.getAccountsForKeycard(kcUID) - if err != nil { - return err - } - deleteKeycard := true - for _, dbAddr := range dbAccountAddresses { - found := false - for _, addr := range accountAddresses { - if dbAddr == addr { - found = true - } - } - if !found { - deleteKeycard = false - } +func (kp *KeyPairs) addAccounts(tx *sql.Tx, kcUID string, accountsAddresses []types.Address) (err error) { + if tx == nil { + return errors.New(dbTransactionIsNil) } - if deleteKeycard { - return kp.DeleteKeycard(kcUID) - } - - inVector := strings.Repeat(",?", len(accountAddresses)-1) - query := ` - DELETE - FROM + insertKcAcc, err := tx.Prepare(` + INSERT INTO keycards_accounts - WHERE - keycard_uid = ? - AND - account_address IN (?` + inVector + `) - ` - delete, err := kp.db.Prepare(query) - if err != nil { - return err - } - - args := make([]interface{}, len(accountAddresses)+1) - args[0] = kcUID - for i, addr := range accountAddresses { - args[i+1] = addr - } - - defer delete.Close() - - _, err = delete.Exec(args...) - - return err -} - -func (kp *KeyPairs) execUpdateQuery(kcUID string, field string, value interface{}) (err error) { - sql := fmt.Sprintf(`UPDATE keycards SET %s = ? WHERE keycard_uid = ?`, field) // nolint: gosec - - update, err := kp.db.Prepare(sql) + ( + keycard_uid, + account_address + ) + VALUES + (?, ?); + `) if err != nil { return err } - defer update.Close() + defer insertKcAcc.Close() - _, err = update.Exec(value, kcUID) + for i := range accountsAddresses { + addr := accountsAddresses[i] - return err + _, err = insertKcAcc.Exec(kcUID, addr) + if err != nil { + return err + } + } + + return nil } -func (kp *KeyPairs) KeycardLocked(kcUID string) (err error) { - return kp.execUpdateQuery(kcUID, "keycard_locked", true) -} +func (kp *KeyPairs) deleteKeycard(tx *sql.Tx, kcUID string) (err error) { + if tx == nil { + return errors.New(dbTransactionIsNil) + } -func (kp *KeyPairs) KeycardUnlocked(kcUID string) (err error) { - return kp.execUpdateQuery(kcUID, "keycard_locked", false) -} - -func (kp *KeyPairs) UpdateKeycardUID(oldKcUID string, newKcUID string) (err error) { - return kp.execUpdateQuery(oldKcUID, "keycard_uid", newKcUID) -} - -func (kp *KeyPairs) SetKeycardName(kcUID string, kpName string) (err error) { - return kp.execUpdateQuery(kcUID, "keycard_name", kpName) -} - -func (kp *KeyPairs) DeleteKeycard(kcUID string) (err error) { - delete, err := kp.db.Prepare(` + delete, err := tx.Prepare(` DELETE FROM keycards @@ -330,6 +252,191 @@ func (kp *KeyPairs) DeleteKeycard(kcUID string) (err error) { return err } +func (kp *KeyPairs) AddMigratedKeyPairOrAddAccountsIfKeyPairIsAdded(keyPair KeyPair) (added bool, err error) { + tx, proceed, err := kp.startTransactionAndCheckIfNeedToProceed(keyPair.KeycardUID, keyPair.LastUpdateClock) + defer func() { + if err == nil { + err = tx.Commit() + return + } + _ = tx.Rollback() + }() + + if err != nil { + if err == sql.ErrNoRows { + _, err = tx.Exec(` + INSERT INTO + keycards + ( + keycard_uid, + keycard_name, + keycard_locked, + key_uid, + last_update_clock + ) + VALUES + (?, ?, ?, ?, ?);`, + keyPair.KeycardUID, keyPair.KeycardName, keyPair.KeycardLocked, keyPair.KeyUID, keyPair.LastUpdateClock) + + if err != nil { + return false, err + } + + err = kp.addAccounts(tx, keyPair.KeycardUID, keyPair.AccountsAddresses) + return err == nil, err + } + + return false, err + } + + if proceed { + err = kp.setLastUpdateClock(tx, keyPair.KeycardUID, keyPair.LastUpdateClock) + if err != nil { + return false, err + } + + err = kp.addAccounts(tx, keyPair.KeycardUID, keyPair.AccountsAddresses) + return err == nil, err + } + + return false, nil +} + +func (kp *KeyPairs) RemoveMigratedAccountsForKeycard(kcUID string, accountAddresses []types.Address, + clock uint64) (removed bool, err error) { + tx, proceed, err := kp.startTransactionAndCheckIfNeedToProceed(kcUID, clock) + defer func() { + if err == nil { + err = tx.Commit() + return + } + _ = tx.Rollback() + }() + + if err != nil { + return false, err + } + + if proceed { + err = kp.setLastUpdateClock(tx, kcUID, clock) + if err != nil { + return false, err + } + + dbAccountAddresses, err := kp.getAccountsForKeycard(tx, kcUID) + if err != nil { + return false, err + } + deleteKeycard := true + for _, dbAddr := range dbAccountAddresses { + found := false + for _, addr := range accountAddresses { + if dbAddr == addr { + found = true + } + } + if !found { + deleteKeycard = false + } + } + + if deleteKeycard { + err = kp.deleteKeycard(tx, kcUID) + return err == nil, err + } + + inVector := strings.Repeat(",?", len(accountAddresses)-1) + query := ` + DELETE + FROM + keycards_accounts + WHERE + keycard_uid = ? + AND + account_address IN (?` + inVector + `) + ` + delete, err := tx.Prepare(query) + if err != nil { + return false, err + } + + args := make([]interface{}, len(accountAddresses)+1) + args[0] = kcUID + for i, addr := range accountAddresses { + args[i+1] = addr + } + + defer delete.Close() + + _, err = delete.Exec(args...) + + return true, err + } + + return false, nil +} + +func (kp *KeyPairs) execUpdateQuery(kcUID string, clock uint64, field string, value interface{}) (updated bool, err error) { + tx, proceed, err := kp.startTransactionAndCheckIfNeedToProceed(kcUID, clock) + defer func() { + if err == nil { + err = tx.Commit() + return + } + _ = tx.Rollback() + }() + + if err != nil { + return false, err + } + + if proceed { + sql := fmt.Sprintf(`UPDATE keycards SET %s = ?, last_update_clock = ? WHERE keycard_uid = ?`, field) // nolint: gosec + _, err = tx.Exec(sql, value, clock, kcUID) + return err == nil, err + } + + return false, nil +} + +func (kp *KeyPairs) KeycardLocked(kcUID string, clock uint64) (updated bool, err error) { + return kp.execUpdateQuery(kcUID, clock, "keycard_locked", true) +} + +func (kp *KeyPairs) KeycardUnlocked(kcUID string, clock uint64) (updated bool, err error) { + return kp.execUpdateQuery(kcUID, clock, "keycard_locked", false) +} + +func (kp *KeyPairs) UpdateKeycardUID(oldKcUID string, newKcUID string, clock uint64) (updated bool, err error) { + return kp.execUpdateQuery(oldKcUID, clock, "keycard_uid", newKcUID) +} + +func (kp *KeyPairs) SetKeycardName(kcUID string, kpName string, clock uint64) (updated bool, err error) { + return kp.execUpdateQuery(kcUID, clock, "keycard_name", kpName) +} + +func (kp *KeyPairs) DeleteKeycard(kcUID string, clock uint64) (deleted bool, err error) { + tx, proceed, err := kp.startTransactionAndCheckIfNeedToProceed(kcUID, clock) + defer func() { + if err == nil { + err = tx.Commit() + return + } + _ = tx.Rollback() + }() + + if err != nil { + return false, err + } + + if proceed { + err = kp.deleteKeycard(tx, kcUID) + return err == nil, err + } + + return false, nil +} + func (kp *KeyPairs) DeleteKeypair(keyUID string) (err error) { delete, err := kp.db.Prepare(` DELETE @@ -342,8 +449,6 @@ func (kp *KeyPairs) DeleteKeypair(keyUID string) (err error) { return err } defer delete.Close() - _, err = delete.Exec(keyUID) - return err } diff --git a/multiaccounts/keypairs/database_test.go b/multiaccounts/keypairs/database_test.go index 3cf862f3a..d6e83352a 100644 --- a/multiaccounts/keypairs/database_test.go +++ b/multiaccounts/keypairs/database_test.go @@ -34,6 +34,7 @@ func TestKeypairs(t *testing.T) { KeycardLocked: false, AccountsAddresses: []types.Address{{0x01}, {0x02}, {0x03}, {0x04}}, KeyUID: "0000000000000000000000000000000000000000000000000000000000000001", + LastUpdateClock: 100, } keyPair2 := KeyPair{ KeycardUID: "00000000000000000000000000000002", @@ -41,6 +42,7 @@ func TestKeypairs(t *testing.T) { KeycardLocked: false, AccountsAddresses: []types.Address{{0x01}, {0x02}}, KeyUID: "0000000000000000000000000000000000000000000000000000000000000002", + LastUpdateClock: 200, } keyPair3 := KeyPair{ KeycardUID: "00000000000000000000000000000003", @@ -48,6 +50,7 @@ func TestKeypairs(t *testing.T) { KeycardLocked: false, AccountsAddresses: []types.Address{{0x01}, {0x02}}, KeyUID: "0000000000000000000000000000000000000000000000000000000000000002", + LastUpdateClock: 300, } keyPair4 := KeyPair{ KeycardUID: "00000000000000000000000000000004", @@ -55,22 +58,38 @@ func TestKeypairs(t *testing.T) { KeycardLocked: false, AccountsAddresses: []types.Address{{0x01}, {0x02}, {0x03}}, KeyUID: "0000000000000000000000000000000000000000000000000000000000000004", + LastUpdateClock: 400, } // Test adding key pairs - err := db.AddMigratedKeyPairOrAddAccountsIfKeyPairIsAdded(keyPair1) + result, err := db.AddMigratedKeyPairOrAddAccountsIfKeyPairIsAdded(keyPair1) require.NoError(t, err) - err = db.AddMigratedKeyPairOrAddAccountsIfKeyPairIsAdded(keyPair2) + require.Equal(t, true, result) + result, err = db.AddMigratedKeyPairOrAddAccountsIfKeyPairIsAdded(keyPair2) require.NoError(t, err) - err = db.AddMigratedKeyPairOrAddAccountsIfKeyPairIsAdded(keyPair3) + require.Equal(t, true, result) + result, err = db.AddMigratedKeyPairOrAddAccountsIfKeyPairIsAdded(keyPair3) require.NoError(t, err) - err = db.AddMigratedKeyPairOrAddAccountsIfKeyPairIsAdded(KeyPair{ + require.Equal(t, true, result) + // this should be added + result, err = db.AddMigratedKeyPairOrAddAccountsIfKeyPairIsAdded(KeyPair{ KeycardUID: keyPair3.KeycardUID, AccountsAddresses: []types.Address{{0x03}}, + LastUpdateClock: keyPair3.LastUpdateClock + 1, }) require.NoError(t, err) - err = db.AddMigratedKeyPairOrAddAccountsIfKeyPairIsAdded(keyPair4) + require.Equal(t, true, result) + // this should not be added as it has clock value less than last updated clock value + result, err = db.AddMigratedKeyPairOrAddAccountsIfKeyPairIsAdded(KeyPair{ + KeycardUID: keyPair3.KeycardUID, + AccountsAddresses: []types.Address{{0x04}}, + LastUpdateClock: keyPair3.LastUpdateClock, + }) require.NoError(t, err) + require.Equal(t, false, result) + result, err = db.AddMigratedKeyPairOrAddAccountsIfKeyPairIsAdded(keyPair4) + require.NoError(t, err) + require.Equal(t, true, result) // Test reading migrated key pairs rows, err := db.GetAllMigratedKeyPairs() @@ -103,6 +122,7 @@ func TestKeypairs(t *testing.T) { require.Equal(t, keyPair1.KeycardName, rows[0].KeycardName) require.Equal(t, keyPair1.KeycardLocked, rows[0].KeycardLocked) require.Equal(t, len(keyPair1.AccountsAddresses), len(rows[0].AccountsAddresses)) + require.Equal(t, keyPair1.LastUpdateClock, rows[0].LastUpdateClock) rows, err = db.GetAllKnownKeycards() require.NoError(t, err) @@ -113,27 +133,32 @@ func TestKeypairs(t *testing.T) { require.Equal(t, keyPair1.KeycardName, kp.KeycardName) require.Equal(t, keyPair1.KeycardLocked, kp.KeycardLocked) require.Equal(t, len(keyPair1.AccountsAddresses), len(kp.AccountsAddresses)) + require.Equal(t, keyPair1.LastUpdateClock, kp.LastUpdateClock) } else if kp.KeycardUID == keyPair2.KeycardUID { require.Equal(t, keyPair2.KeycardUID, kp.KeycardUID) require.Equal(t, keyPair2.KeycardName, kp.KeycardName) require.Equal(t, keyPair2.KeycardLocked, kp.KeycardLocked) require.Equal(t, len(keyPair2.AccountsAddresses), len(kp.AccountsAddresses)) + require.Equal(t, keyPair2.LastUpdateClock, kp.LastUpdateClock) } else if kp.KeycardUID == keyPair3.KeycardUID { require.Equal(t, keyPair3.KeycardUID, kp.KeycardUID) require.Equal(t, keyPair3.KeycardName, kp.KeycardName) require.Equal(t, keyPair3.KeycardLocked, kp.KeycardLocked) require.Equal(t, len(keyPair3.AccountsAddresses)+1, len(kp.AccountsAddresses)) // Add 1, cause one account is additionally added. + require.Equal(t, keyPair3.LastUpdateClock+1, kp.LastUpdateClock) } else { require.Equal(t, keyPair4.KeycardUID, kp.KeycardUID) require.Equal(t, keyPair4.KeycardName, kp.KeycardName) require.Equal(t, keyPair4.KeycardLocked, kp.KeycardLocked) require.Equal(t, len(keyPair4.AccountsAddresses), len(kp.AccountsAddresses)) + require.Equal(t, keyPair4.LastUpdateClock, kp.LastUpdateClock) } } // Test seting a new keycard name - err = db.SetKeycardName(keyPair1.KeycardUID, "Card101") + result, err = db.SetKeycardName(keyPair1.KeycardUID, "Card101", 1000) require.NoError(t, err) + require.Equal(t, true, result) rows, err = db.GetAllMigratedKeyPairs() require.NoError(t, err) newKeycardName := "" @@ -144,9 +169,24 @@ func TestKeypairs(t *testing.T) { } require.Equal(t, "Card101", newKeycardName) - // Test locking a keycard - err = db.KeycardLocked(keyPair1.KeycardUID) + // Test seting a new keycard name with an old clock value + result, err = db.SetKeycardName(keyPair1.KeycardUID, "Card102", 999) // clock is less than the last one require.NoError(t, err) + require.Equal(t, false, result) + rows, err = db.GetAllMigratedKeyPairs() + require.NoError(t, err) + newKeycardName = "" + for _, kp := range rows { + if kp.KeyUID == keyPair1.KeyUID { + newKeycardName = kp.KeycardName + } + } + require.Equal(t, "Card101", newKeycardName) + + // Test locking a keycard + result, err = db.KeycardLocked(keyPair1.KeycardUID, 1001) + require.NoError(t, err) + require.Equal(t, true, result) rows, err = db.GetAllMigratedKeyPairs() require.NoError(t, err) locked := false @@ -161,17 +201,19 @@ func TestKeypairs(t *testing.T) { const numOfAccountsToRemove = 2 require.Greater(t, len(keyPair1.AccountsAddresses), numOfAccountsToRemove) accountsToRemove := keyPair1.AccountsAddresses[:numOfAccountsToRemove] - err = db.RemoveMigratedAccountsForKeycard(keyPair1.KeycardUID, accountsToRemove) + result, err = db.RemoveMigratedAccountsForKeycard(keyPair1.KeycardUID, accountsToRemove, 1002) require.NoError(t, err) + require.Equal(t, true, result) rows, err = db.GetMigratedKeyPairByKeyUID(keyPair1.KeyUID) require.NoError(t, err) require.Equal(t, 1, len(rows)) require.Equal(t, len(keyPair1.AccountsAddresses)-numOfAccountsToRemove, len(rows[0].AccountsAddresses)) // Test deleting accounts one by one, with the last deleted account keycard should be delete as well - for _, addr := range keyPair4.AccountsAddresses { - err = db.RemoveMigratedAccountsForKeycard(keyPair4.KeycardUID, []types.Address{addr}) + for i, addr := range keyPair4.AccountsAddresses { + result, err = db.RemoveMigratedAccountsForKeycard(keyPair4.KeycardUID, []types.Address{addr}, 1003+uint64(i)) require.NoError(t, err) + require.Equal(t, true, result) } rows, err = db.GetAllMigratedKeyPairs() require.NoError(t, err) @@ -185,12 +227,14 @@ func TestKeypairs(t *testing.T) { require.Equal(t, true, deletedKeyPair4) // Test update keycard uid - err = db.UpdateKeycardUID(keyPair1.KeycardUID, keycardUID) + result, err = db.UpdateKeycardUID(keyPair1.KeycardUID, keycardUID, 1100) require.NoError(t, err) + require.Equal(t, true, result) // Test unlocking a locked keycard - err = db.KeycardUnlocked(keycardUID) + result, err = db.KeycardUnlocked(keycardUID, 1101) require.NoError(t, err) + require.Equal(t, true, result) rows, err = db.GetAllMigratedKeyPairs() require.NoError(t, err) locked = true @@ -202,8 +246,9 @@ func TestKeypairs(t *testing.T) { require.Equal(t, false, locked) // Test detleting a keycard - err = db.DeleteKeycard(keycardUID) + result, err = db.DeleteKeycard(keycardUID, 1102) require.NoError(t, err) + require.Equal(t, true, result) rows, err = db.GetAllMigratedKeyPairs() require.NoError(t, err) require.Equal(t, 1, len(rows)) diff --git a/services/accounts/accounts.go b/services/accounts/accounts.go index bd2b50333..2a6f70970 100644 --- a/services/accounts/accounts.go +++ b/services/accounts/accounts.go @@ -5,6 +5,7 @@ import ( "errors" "fmt" "strings" + "time" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/event" @@ -443,22 +444,23 @@ func (api *API) VerifyPassword(password string) bool { func (api *API) AddMigratedKeyPairOrAddAccountsIfKeyPairIsAdded(ctx context.Context, kcUID string, kpName string, keyUID string, accountAddresses []string, password string) error { kp := keypairs.KeyPair{ - KeycardUID: kcUID, - KeycardName: kpName, - KeycardLocked: false, - KeyUID: keyUID, + KeycardUID: kcUID, + KeycardName: kpName, + KeycardLocked: false, + KeyUID: keyUID, + LastUpdateClock: uint64(time.Now().Unix()), } for _, addr := range accountAddresses { kp.AccountsAddresses = append(kp.AccountsAddresses, types.Address(common.HexToAddress(addr))) } - err := api.db.AddMigratedKeyPairOrAddAccountsIfKeyPairIsAdded(kp) + added, err := api.db.AddMigratedKeyPairOrAddAccountsIfKeyPairIsAdded(kp) if err != nil { return err } // Once we migrate a keypair, corresponding keystore files need to be deleted. - if len(password) > 0 { + if added && len(password) > 0 { for _, addr := range kp.AccountsAddresses { err = api.manager.DeleteAccount(addr, password) if err != nil { @@ -475,7 +477,9 @@ func (api *API) RemoveMigratedAccountsForKeycard(ctx context.Context, kcUID stri addresses = append(addresses, types.Address(common.HexToAddress(addr))) } - return api.db.RemoveMigratedAccountsForKeycard(kcUID, addresses) + clock := uint64(time.Now().Unix()) + _, err := api.db.RemoveMigratedAccountsForKeycard(kcUID, addresses, clock) + return err } func (api *API) GetAllKnownKeycards(ctx context.Context) ([]*keypairs.KeyPair, error) { @@ -491,19 +495,27 @@ func (api *API) GetMigratedKeyPairByKeyUID(ctx context.Context, keyUID string) ( } func (api *API) SetKeycardName(ctx context.Context, kcUID string, kpName string) error { - return api.db.SetKeycardName(kcUID, kpName) + clock := uint64(time.Now().Unix()) + _, err := api.db.SetKeycardName(kcUID, kpName, clock) + return err } func (api *API) KeycardLocked(ctx context.Context, kcUID string) error { - return api.db.KeycardLocked(kcUID) + clock := uint64(time.Now().Unix()) + _, err := api.db.KeycardLocked(kcUID, clock) + return err } func (api *API) KeycardUnlocked(ctx context.Context, kcUID string) error { - return api.db.KeycardUnlocked(kcUID) + clock := uint64(time.Now().Unix()) + _, err := api.db.KeycardUnlocked(kcUID, clock) + return err } func (api *API) DeleteKeycard(ctx context.Context, kcUID string) error { - return api.db.DeleteKeycard(kcUID) + clock := uint64(time.Now().Unix()) + _, err := api.db.DeleteKeycard(kcUID, clock) + return err } func (api *API) DeleteKeypair(ctx context.Context, keyUID string) error { @@ -511,5 +523,7 @@ func (api *API) DeleteKeypair(ctx context.Context, keyUID string) error { } func (api *API) UpdateKeycardUID(ctx context.Context, oldKcUID string, newKcUID string) error { - return api.db.UpdateKeycardUID(oldKcUID, newKcUID) + clock := uint64(time.Now().Unix()) + _, err := api.db.UpdateKeycardUID(oldKcUID, newKcUID, clock) + return err }