Merge branch 'main' into 2024-11-01-sidebar-scroll

crates/subgraph/Cargo.toml

@@ -19,6 +19,7 @@ alloy = { workspace = true, features = ["rand"] }
 rain_orderbook_bindings = { workspace = true }
 chrono = { workspace = true }
 cynic-introspection = "3.7.3"
+futures = "0.3.17"
 tsify = { version = "0.4.5", default-features = false, features = ["js", "wasm-bindgen"] }
 wasm-bindgen = { version = "0.2.92" }
 js-sys = { version = "0.3.69" }

crates/subgraph/src/lib.rs

@@ -1,4 +1,5 @@
 mod cynic_client;
+mod multi_orderbook_client;
 mod orderbook_client;
 mod pagination;
 pub mod types;
@@ -10,5 +11,6 @@ pub mod vol;
 #[cynic::schema("orderbook")]
 pub mod schema {}
 
+pub use multi_orderbook_client::{MultiOrderbookSubgraphClient, MultiSubgraphArgs};
 pub use orderbook_client::{OrderbookSubgraphClient, OrderbookSubgraphClientError};
 pub use pagination::{PageQueryClient, PaginationArgs};

crates/subgraph/src/multi_orderbook_client.rs

@@ -0,0 +1,67 @@
+use futures::future::join_all;
+use reqwest::Url;
+use serde::Deserialize;
+
+use crate::{
+    types::common::{OrderWithSubgraphName, OrdersListFilterArgs},
+    OrderbookSubgraphClient, OrderbookSubgraphClientError, PaginationArgs,
+};
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct MultiSubgraphArgs {
+    url: Url,
+    name: String,
+}
+
+pub struct MultiOrderbookSubgraphClient {
+    subgraphs: Vec<MultiSubgraphArgs>,
+}
+impl MultiOrderbookSubgraphClient {
+    pub fn new(subgraphs: Vec<MultiSubgraphArgs>) -> Self {
+        Self { subgraphs }
+    }
+
+    fn get_orderbook_subgraph_client(&self, url: Url) -> OrderbookSubgraphClient {
+        OrderbookSubgraphClient::new(url)
+    }
+
+    pub async fn orders_list(
+        &self,
+        filter_args: OrdersListFilterArgs,
+        pagination_args: PaginationArgs,
+    ) -> Result<Vec<OrderWithSubgraphName>, OrderbookSubgraphClientError> {
+        let futures = self.subgraphs.iter().map(|subgraph| {
+            let url = subgraph.url.clone();
+            let filter_args = filter_args.clone();
+            let pagination_args = pagination_args.clone();
+            async move {
+                let client = self.get_orderbook_subgraph_client(url);
+                let orders = client.orders_list(filter_args, pagination_args).await?;
+                let wrapped_orders: Vec<OrderWithSubgraphName> = orders
+                    .into_iter()
+                    .map(|order| OrderWithSubgraphName {
+                        order,
+                        subgraph_name: subgraph.name.clone(),
+                    })
+                    .collect();
+                Ok::<_, OrderbookSubgraphClientError>(wrapped_orders)
+            }
+        });
+
+        let results = join_all(futures).await;
+
+        let mut all_orders: Vec<OrderWithSubgraphName> = results
+            .into_iter()
+            .filter_map(Result::ok)
+            .flatten()
+            .collect();
+
+        all_orders.sort_by(|a, b| {
+            let a_timestamp = a.order.timestamp_added.0.parse::<i64>().unwrap_or(0);
+            let b_timestamp = b.order.timestamp_added.0.parse::<i64>().unwrap_or(0);
+            b_timestamp.cmp(&a_timestamp)
+        });
+
+        Ok(all_orders)
+    }
+}

crates/subgraph/src/types/common.rs

@@ -94,6 +94,14 @@ pub struct Order {
     pub trades: Vec<OrderStructPartialTrade>,
 }
 
+#[derive(Debug, Serialize, Clone)]
+#[typeshare]
+#[serde(rename_all = "camelCase")]
+pub struct OrderWithSubgraphName {
+    pub order: Order,
+    pub subgraph_name: String,
+}
+
 #[derive(cynic::QueryFragment, Debug, Serialize, Clone)]
 #[cynic(graphql_type = "Order")]
 #[serde(rename_all = "camelCase")]

package.json

@@ -1,7 +1,7 @@
 {
     "name": "@rainlanguage/orderbook",
     "description": "Provides RainLanguage Orderbook rust crates' functionalities in typescript through wasm bindgen",
-    "version": "0.0.1-alpha.4",
+    "version": "0.0.1-alpha.5",
     "author": "Rain Language",
     "license": "CAL-1.0",
     "repository": {

tauri-app/src-tauri/src/commands/order.rs

@@ -8,22 +8,20 @@ use rain_orderbook_common::{
     types::FlattenError, types::OrderDetailExtended, types::OrderFlattened,
 };
 use rain_orderbook_subgraph_client::{types::common::*, PaginationArgs};
+use rain_orderbook_subgraph_client::{MultiOrderbookSubgraphClient, MultiSubgraphArgs};
 use std::fs;
 use std::path::PathBuf;
 use tauri::AppHandle;
 
 #[tauri::command]
 pub async fn orders_list(
-    subgraph_args: SubgraphArgs,
+    multi_subgraph_args: Vec<MultiSubgraphArgs>,
     filter_args: OrdersListFilterArgs,
     pagination_args: PaginationArgs,
-) -> CommandResult<Vec<Order>> {
-    let orders = subgraph_args
-        .to_subgraph_client()
-        .await?
-        .orders_list(filter_args, pagination_args)
-        .await?;
-    Ok(orders)
+) -> CommandResult<Vec<OrderWithSubgraphName>> {
+    let client = MultiOrderbookSubgraphClient::new(multi_subgraph_args);
+    let all_orders = client.orders_list(filter_args, pagination_args).await?;
+    Ok(all_orders)
 }
 
 #[tauri::command]

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

@@ -1,14 +1,15 @@
 <script lang="ts">
   import { isEmpty } from 'lodash';
-  import DropdownActiveNetwork from './DropdownActiveNetwork.svelte';
-  import DropdownActiveOrderbook from './DropdownActiveOrderbook.svelte';
   import DropdownOrderListAccounts from './dropdown/DropdownOrderListAccounts.svelte';
   import DropdownOrderStatus from './dropdown/DropdownOrderStatus.svelte';
   import CheckboxZeroBalanceVault from './checkbox/CheckboxZeroBalanceVault.svelte';
   import { settings } from '$lib/stores/settings';
   import { Alert } from 'flowbite-svelte';
   import { page } from '$app/stores';
   import InputOrderHash from './input/InputOrderHash.svelte';
+  import DropdownActiveSubgraphs from './dropdown/DropdownActiveSubgraphs.svelte';
+  import DropdownActiveNetwork from './DropdownActiveNetwork.svelte';
+  import DropdownActiveOrderbook from './DropdownActiveOrderbook.svelte';
 
   $: currentRoute = $page.url.pathname;
   $: isVaultsPage = currentRoute.startsWith('/vaults');
@@ -31,7 +32,14 @@
     {/if}
 
     <DropdownOrderListAccounts />
-    <DropdownActiveNetwork />
-    <DropdownActiveOrderbook />
+
+    {#if isOrdersPage}
+      <DropdownActiveSubgraphs />
+    {/if}
+
+    {#if isVaultsPage}
+      <DropdownActiveNetwork />
+      <DropdownActiveOrderbook />
+    {/if}
   {/if}
 </div>

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

@@ -0,0 +1,42 @@
+<script lang="ts">
+  import DropdownCheckbox from './DropdownCheckbox.svelte';
+  import { settings, activeSubgraphs } from '$lib/stores/settings';
+
+  $: dropdownOptions = Object.keys($settings?.subgraphs ?? {}).reduce(
+    (acc, key) => ({
+      ...acc,
+      [key]: key,
+    }),
+    {},
+  );
+
+  function handleStatusChange(event: CustomEvent<Record<string, string>>) {
+    let items = Object.keys(event.detail);
+    activeSubgraphs.set(
+      Object.values(items).reduce(
+        (acc, key) => ({ ...acc, [key]: ($settings?.subgraphs ?? {})[key] }),
+        {} as Record<string, string>,
+      ),
+    );
+  }
+
+  $: value =
+    Object.keys($activeSubgraphs).length === 0
+      ? {}
+      : Object.keys($activeSubgraphs).reduce(
+          (acc, key) => ({
+            ...acc,
+            [key]: key,
+          }),
+          {},
+        );
+</script>
+
+<DropdownCheckbox
+  options={dropdownOptions}
+  on:change={handleStatusChange}
+  label="Networks"
+  showAllLabel={false}
+  onlyTitle={true}
+  {value}
+/>

tauri-app/src/lib/components/dropdown/DropdownActiveSubgraphs.test.ts

@@ -0,0 +1,75 @@
+import { render, fireEvent, screen, waitFor } from '@testing-library/svelte';
+import { get, writable } from 'svelte/store';
+import { activeSubgraphs, settings } from '$lib/stores/settings';
+import { beforeEach, expect, test, vi, describe } from 'vitest';
+import DropdownActiveSubgraphs from './DropdownActiveSubgraphs.svelte';
+
+vi.mock('$lib/stores/settings', async (importOriginal) => {
+  const { mockConfigSource } = await import('$lib/mocks/settings');
+  return {
+    ...((await importOriginal()) as object),
+    settings: writable({
+      ...mockConfigSource,
+      subgraphs: {
+        mainnet: 'mainnet',
+        testnet: 'testnet',
+        local: 'local',
+      },
+    }),
+    activeSubgraphs: writable({}),
+  };
+});
+
+describe('DropdownActiveSubgraphs', () => {
+  beforeEach(() => {
+    settings.set({
+      ...get(settings),
+      subgraphs: {
+        mainnet: 'mainnet',
+        testnet: 'testnet',
+        local: 'local',
+      },
+    });
+    activeSubgraphs.set({});
+  });
+
+  test('renders correctly', () => {
+    render(DropdownActiveSubgraphs);
+    expect(screen.getByText('Networks')).toBeInTheDocument();
+  });
+
+  test('displays the correct number of options', async () => {
+    render(DropdownActiveSubgraphs);
+
+    await fireEvent.click(screen.getByTestId('dropdown-checkbox-button'));
+
+    await waitFor(() => {
+      const options = screen.getAllByTestId('dropdown-checkbox-option');
+      expect(options).toHaveLength(3);
+    });
+  });
+
+  test('updates active subgraphs when an option is selected', async () => {
+    render(DropdownActiveSubgraphs);
+
+    await fireEvent.click(screen.getByTestId('dropdown-checkbox-button'));
+    await fireEvent.click(screen.getByText('mainnet'));
+    await waitFor(() => {
+      expect(get(activeSubgraphs)).toEqual({ mainnet: 'mainnet' });
+    });
+
+    await fireEvent.click(screen.getByText('testnet'));
+    await waitFor(() => {
+      expect(get(activeSubgraphs)).toEqual({ mainnet: 'mainnet', testnet: 'testnet' });
+    });
+
+    await fireEvent.click(screen.getByText('local'));
+    await waitFor(() => {
+      expect(get(activeSubgraphs)).toEqual({
+        mainnet: 'mainnet',
+        testnet: 'testnet',
+        local: 'local',
+      });
+    });
+  });
+});

tauri-app/src/lib/components/input/InputOrderHash.svelte

@@ -11,7 +11,7 @@
   }
 </script>
 
-<div class="flex">
+<div class="flex items-center gap-x-2">
   <Label>Order Hash</Label>
   <div class="w-32">
     <input