Merge pull request #840 from rainlanguage/2024-09-09-watchlist-renaming

Renaming watchlist to accounts

crates/settings/src/config.rs

@@ -35,7 +35,7 @@ pub struct Config {
     pub sentry: Option<bool>,
     pub raindex_version: Option<String>,
     #[typeshare(typescript(type = "Record<string, string>"))]
-    pub watchlist: Option<HashMap<String, Arc<String>>>,
+    pub accounts: Option<HashMap<String, Arc<String>>>,
 }
 
 pub type Subgraph = Url;
@@ -171,7 +171,7 @@ impl TryFrom<ConfigSource> for Config {
             })
             .collect::<Result<HashMap<String, Arc<Chart>>, ParseConfigSourceError>>()?;
 
-        let watchlist = item.watchlist.map(|wl| {
+        let accounts = item.accounts.map(|wl| {
             wl.into_iter()
                 .map(|(name, address)| (name, Arc::new(address)))
                 .collect::<HashMap<String, Arc<String>>>()
@@ -190,7 +190,7 @@ impl TryFrom<ConfigSource> for Config {
             charts,
             deployments,
             sentry: item.sentry,
-            watchlist,
+            accounts,
         };
 
         Ok(config)
@@ -282,7 +282,7 @@ mod tests {
         let charts = HashMap::new();
         let deployments = HashMap::new();
         let sentry = Some(true);
-        let watchlist = Some(HashMap::from([(
+        let accounts = Some(HashMap::from([(
             "name-one".to_string(),
             "address-one".to_string(),
         )]));
@@ -301,7 +301,7 @@ mod tests {
             charts,
             deployments,
             sentry,
-            watchlist,
+            accounts,
         };
 
         let config_result = Config::try_from(config_string);
@@ -361,11 +361,11 @@ mod tests {
         // Verify raindex_version
         assert_eq!(config.raindex_version, Some("0x123".to_string()));
 
-        // Verify watchlist
-        assert!(config.watchlist.is_some());
-        let watchlist = config.watchlist.as_ref().unwrap();
-        assert_eq!(watchlist.len(), 1);
-        let (name, address) = watchlist.iter().next().unwrap();
+        // Verify accounts
+        assert!(config.accounts.is_some());
+        let accounts = config.accounts.as_ref().unwrap();
+        assert_eq!(accounts.len(), 1);
+        let (name, address) = accounts.iter().next().unwrap();
         assert_eq!(name, "name-one");
         assert_eq!(address.as_str(), "address-one");
     }

crates/settings/src/config_source.rs

@@ -39,7 +39,7 @@ pub struct ConfigSource {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub raindex_version: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub watchlist: Option<HashMap<String, String>>,
+    pub accounts: Option<HashMap<String, String>>,
 }
 
 #[typeshare]
@@ -375,7 +375,7 @@ deployments:
         
 sentry: true
 
-watchlist:
+accounts:
     name-one: address-one
     name-two: address-two"#,
             mocked_chain_id_server.url("/json")
@@ -483,9 +483,9 @@ watchlist:
 
         assert_eq!(config.raindex_version, Some("123".to_string()));
 
-        let watchlist = config.watchlist.unwrap();
-        assert_eq!(watchlist.get("name-one").unwrap(), "address-one");
-        assert_eq!(watchlist.get("name-two").unwrap(), "address-two");
+        let accounts = config.accounts.unwrap();
+        assert_eq!(accounts.get("name-one").unwrap(), "address-one");
+        assert_eq!(accounts.get("name-two").unwrap(), "address-two");
     }
 
     #[tokio::test]

crates/settings/src/merge.rs

@@ -37,8 +37,8 @@ pub enum MergeError {
     #[error("There is already a remote networks definition called {0}")]
     RemoteNetworksCollision(String),
 
-    #[error("There is already a watchlist called {0}")]
-    WatchlistCollision(String),
+    #[error("There is already a accounts called {0}")]
+    AccountsCollision(String),
 }
 
 impl ConfigSource {
@@ -150,18 +150,18 @@ impl ConfigSource {
             (Some(_), Some(_)) => Err(MergeError::DeploymentCollision("sentry".into())),
         }?;
 
-        // Watchlist
-        match (&mut self.watchlist, other.watchlist) {
-            (Some(watchlist), Some(other_watchlist)) => {
-                for (key, value) in other_watchlist {
-                    if watchlist.contains_key(&key) {
-                        return Err(MergeError::WatchlistCollision(key));
+        // Accounts
+        match (&mut self.accounts, other.accounts) {
+            (Some(accounts), Some(other_accounts)) => {
+                for (key, value) in other_accounts {
+                    if accounts.contains_key(&key) {
+                        return Err(MergeError::AccountsCollision(key));
                     }
-                    watchlist.insert(key, value);
+                    accounts.insert(key, value);
                 }
             }
-            (None, Some(other_watchlist)) => {
-                self.watchlist = Some(other_watchlist);
+            (None, Some(other_accounts)) => {
+                self.accounts = Some(other_accounts);
             }
             _ => {}
         }
@@ -270,18 +270,18 @@ impl Config {
             (Some(_), Some(_)) => Err(MergeError::DeploymentCollision("sentry".into())),
         }?;
 
-        // Watchlist
-        match (&mut self.watchlist, other.watchlist) {
-            (Some(watchlist), Some(other_watchlist)) => {
-                for (key, value) in other_watchlist {
-                    if watchlist.contains_key(&key) {
-                        return Err(MergeError::WatchlistCollision(key));
+        // Accounts
+        match (&mut self.accounts, other.accounts) {
+            (Some(accounts), Some(other_accounts)) => {
+                for (key, value) in other_accounts {
+                    if accounts.contains_key(&key) {
+                        return Err(MergeError::AccountsCollision(key));
                     }
-                    watchlist.insert(key, value);
+                    accounts.insert(key, value);
                 }
             }
-            (None, Some(other_watchlist)) => {
-                self.watchlist = Some(other_watchlist);
+            (None, Some(other_accounts)) => {
+                self.accounts = Some(other_accounts);
             }
             _ => {}
         }
@@ -312,7 +312,7 @@ mod tests {
             networks: HashMap::new(),
             deployments: HashMap::new(),
             sentry: None,
-            watchlist: None,
+            accounts: None,
         };
 
         let other = ConfigSource {
@@ -329,7 +329,7 @@ mod tests {
             networks: HashMap::new(),
             deployments: HashMap::new(),
             sentry: None,
-            watchlist: None,
+            accounts: None,
         };
 
         assert_eq!(config.merge(other), Ok(()));
@@ -351,7 +351,7 @@ mod tests {
             networks: HashMap::new(),
             deployments: HashMap::new(),
             sentry: None,
-            watchlist: None,
+            accounts: None,
         };
 
         let mut other = ConfigSource {
@@ -368,7 +368,7 @@ mod tests {
             networks: HashMap::new(),
             deployments: HashMap::new(),
             sentry: None,
-            watchlist: None,
+            accounts: None,
         };
 
         // Add a collision to cause an unsuccessful merge
@@ -404,7 +404,7 @@ mod tests {
             networks: HashMap::new(),
             deployments: HashMap::new(),
             sentry: None,
-            watchlist: None,
+            accounts: None,
         };
 
         let mut other = ConfigSource {
@@ -421,7 +421,7 @@ mod tests {
             networks: HashMap::new(),
             deployments: HashMap::new(),
             sentry: None,
-            watchlist: None,
+            accounts: None,
         };
 
         other.metaboards.insert(

crates/settings/src/scenario.rs

@@ -213,7 +213,7 @@ mod tests {
             charts: HashMap::new(), // Assuming no charts for simplification
             deployments: HashMap::new(),
             sentry: None,
-            watchlist: None, // Assuming no watchlist for simplification
+            accounts: None, // Assuming no accounts for simplification
         };
 
         // Perform the conversion

tauri-app/src/lib/components/ListViewOrderbookSelector.svelte

@@ -2,7 +2,7 @@
   import { isEmpty } from 'lodash';
   import DropdownActiveNetwork from './DropdownActiveNetwork.svelte';
   import DropdownActiveOrderbook from './DropdownActiveOrderbook.svelte';
-  import DropdownOrderListWatchlist from './dropdown/DropdownOrderListWatchlist.svelte';
+  import DropdownOrderListAccounts from './dropdown/DropdownOrderListAccounts.svelte';
   import DropdownOrderStatus from './dropdown/DropdownOrderStatus.svelte';
   import { settings } from '$lib/stores/settings';
   import { Alert } from 'flowbite-svelte';
@@ -15,7 +15,7 @@
     >
   {:else}
     <DropdownOrderStatus />
-    <DropdownOrderListWatchlist />
+    <DropdownOrderListAccounts />
     <DropdownActiveNetwork />
     <DropdownActiveOrderbook />
   {/if}

tauri-app/src/lib/components/dropdown/DropdownOrderListAccounts.svelte

@@ -0,0 +1,14 @@
+<script lang="ts">
+  import { accounts, activeAccountsItems } from '$lib/stores/settings';
+  import DropdownCheckbox from './DropdownCheckbox.svelte';
+
+  $: options = $accounts;
+</script>
+
+<DropdownCheckbox
+  {options}
+  bind:value={$activeAccountsItems}
+  label="Accounts"
+  allLabel="All accounts"
+  emptyMessage="No accounts added"
+/>

tauri-app/src/lib/components/dropdown/DropdownOrderListWatchlist.test.ts → tauri-app/src/lib/components/dropdown/DropdownOrderListAccounts.test.ts

@@ -1,31 +1,31 @@
 import { render, fireEvent, screen, waitFor } from '@testing-library/svelte';
 import { get, writable } from 'svelte/store';
-import DropdownOrderListWatchlist from './DropdownOrderListWatchlist.svelte';
-import { activeWatchlistItems } from '$lib/stores/settings';
+import DropdownOrderListAccounts from './DropdownOrderListAccounts.svelte';
+import { activeAccountsItems } from '$lib/stores/settings';
 import { expect, test, vi } from 'vitest';
 
 vi.mock('$lib/stores/settings', async (importOriginal) => {
   const { mockSettingsStore } = await import('$lib/mocks/settings');
   return {
     ...((await importOriginal()) as object),
     settings: mockSettingsStore,
-    watchlist: writable({
+    accounts: writable({
       address1: 'Label 1',
       address2: 'Label 2',
       address3: 'Label 3',
     }),
-    activeWatchlist: writable({}),
-    activeWatchlistItems: writable({}),
+    activeAccounts: writable({}),
+    activeAccountItems: writable({}),
   };
 });
 
 test('renders correctly', () => {
-  render(DropdownOrderListWatchlist);
-  expect(screen.getByText('Watchlist')).toBeInTheDocument();
+  render(DropdownOrderListAccounts);
+  expect(screen.getByText('Accounts')).toBeInTheDocument();
 });
 
 test('displays the correct number of options', async () => {
-  render(DropdownOrderListWatchlist);
+  render(DropdownOrderListAccounts);
 
   await fireEvent.click(screen.getByTestId('dropdown-checkbox-button'));
 
@@ -35,45 +35,43 @@ test('displays the correct number of options', async () => {
   });
 });
 
-test('updates active watchlist when an option is selected', async () => {
-  render(DropdownOrderListWatchlist);
+test('updates active accounts when an option is selected', async () => {
+  render(DropdownOrderListAccounts);
 
   await fireEvent.click(screen.getByTestId('dropdown-checkbox-button'));
   await fireEvent.click(screen.getByText('Label 1'));
 
   await waitFor(() => {
-    expect(get(activeWatchlistItems)).toEqual({ address1: 'Label 1' });
+    expect(get(activeAccountsItems)).toEqual({ address1: 'Label 1' });
   });
 });
 
-test('selects all items when "All addresses" is clicked', async () => {
-  render(DropdownOrderListWatchlist);
+test('selects all items when "All accounts" is clicked', async () => {
+  render(DropdownOrderListAccounts);
 
   await fireEvent.click(screen.getByTestId('dropdown-checkbox-button'));
-  await fireEvent.click(screen.getByText('All addresses'));
+  await fireEvent.click(screen.getByText('All accounts'));
 
   await waitFor(() => {
-    expect(get(activeWatchlistItems)).toEqual({
+    expect(get(activeAccountsItems)).toEqual({
       address1: 'Label 1',
       address2: 'Label 2',
       address3: 'Label 3',
     });
   });
 });
 
-test('displays "No watchlist added" when watchlist is empty', async () => {
+test('displays "No accounts added" when accounts list is empty', async () => {
   vi.doUnmock('$lib/stores/settings');
   vi.resetModules();
 
-  const { default: DropdownOrderListWatchlist } = await import(
-    './DropdownOrderListWatchlist.svelte'
-  );
+  const { default: DropdownOrderListAccounts } = await import('./DropdownOrderListAccounts.svelte');
 
-  render(DropdownOrderListWatchlist);
+  render(DropdownOrderListAccounts);
 
   await fireEvent.click(screen.getByTestId('dropdown-checkbox-button'));
 
   await waitFor(() => {
-    expect(screen.getByText('No watchlist added')).toBeInTheDocument();
+    expect(screen.getByText('No accounts added')).toBeInTheDocument();
   });
 });

tauri-app/src/lib/components/tables/OrdersListTable.svelte

@@ -21,15 +21,15 @@
   import { subgraphUrl } from '$lib/stores/settings';
   import { formatTimestampSecondsAsLocal } from '$lib/utils/time';
   import { handleOrderRemoveModal } from '$lib/services/modal';
-  import { activeWatchlist, activeOrderStatus } from '$lib/stores/settings';
+  import { activeAccounts, activeOrderStatus } from '$lib/stores/settings';
   import { get } from 'svelte/store';
 
   $: query = createInfiniteQuery({
-    queryKey: [QKEY_ORDERS, $activeWatchlist, $activeOrderStatus],
+    queryKey: [QKEY_ORDERS, $activeAccounts, $activeOrderStatus],
     queryFn: ({ pageParam }) => {
       return ordersList(
         $subgraphUrl,
-        Object.values(get(activeWatchlist)),
+        Object.values(get(activeAccounts)),
         $activeOrderStatus,
         pageParam,
       );