feat(wallet-daemon): track authored templates and show on UI (tari-project#1333)

Description
---
When a transaction is finalized and contains a template that belongs to
any of our account, I add it to a new SQLite table in wallet daemon
mapped by account's key index.
Additionally a new wallet daemon frontend page in order to see what are
the authored templates.


![image](https://github.com/user-attachments/assets/014e9d0d-013a-4bb9-9ef5-5f092176ab96)

![image](https://github.com/user-attachments/assets/653c0df1-a521-4449-b05e-ae8ae8e04fe2)


Motivation and Context
---
It was hard sometimes to see what templates we authored/created with an
account.

How Has This Been Tested?
---
1. Start a fresh swarm
2. Create an account in wallet daemon
3. Publish a template
4. Check new template on templates page

What process can a PR reviewer use to test or verify this change?
---


Breaking Changes
---

- [ ] None
- [x] Requires data directory to be deleted
- [ ] Other - Please specify

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

- **New Features**
- Introduced a dedicated "Templates" section in the wallet application,
allowing users to view their authored templates.
- Enhanced the API to support secure, paginated template listings and
integrated it with a background service for timely updates.
- Updated the user interface with a new menu item, secured route, and
breadcrumb entry for easy navigation to the Templates section.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

---------

Co-authored-by: Stan Bondi <sdbondi@users.noreply.github.com>

Author: ksrichard

applications/tari_dan_wallet_daemon/src/handlers/templates.rs

@@ -2,7 +2,13 @@
 //   SPDX-License-Identifier: BSD-3-Clause
 
 use tari_dan_wallet_sdk::{apis::jwt::JrpcPermission, network::WalletNetworkInterface};
-use tari_wallet_daemon_client::types::{TemplatesGetRequest, TemplatesGetResponse};
+use tari_wallet_daemon_client::types::{
+    AuthoredTemplate,
+    TemplatesGetRequest,
+    TemplatesGetResponse,
+    TemplatesListAuthoredRequest,
+    TemplatesListAuthoredResponse,
+};
 
 use crate::handlers::HandlerContext;
 
@@ -21,3 +27,22 @@ pub async fn handle_get(
 
     Ok(TemplatesGetResponse { template_definition })
 }
+
+pub async fn handle_list_owned(
+    context: &HandlerContext,
+    token: Option<String>,
+    req: TemplatesListAuthoredRequest,
+) -> Result<TemplatesListAuthoredResponse, anyhow::Error> {
+    let sdk = context.wallet_sdk().clone();
+    sdk.jwt_api().check_auth(token, &[JrpcPermission::TemplatesRead])?;
+
+    let (templates, total_templates) =
+        context
+            .wallet_sdk()
+            .template_api()
+            .list_authored_templates(req.key_index, req.page, req.page_size)?;
+    Ok(TemplatesListAuthoredResponse {
+        templates: templates.iter().map(AuthoredTemplate::from).collect(),
+        total_templates,
+    })
+}

applications/tari_dan_wallet_daemon/src/jrpc_server.rs

@@ -177,7 +177,11 @@ async fn handler(
             "list" => call_handler(context, value, token, substates::handle_list).await,
             _ => Ok(value.method_not_found(&value.method)),
         },
-        Some(("templates", "get")) => call_handler(context, value, token, templates::handle_get).await,
+        Some(("templates", method)) => match method {
+            "get" => call_handler(context, value, token, templates::handle_get).await,
+            "list_authored" => call_handler(context, value, token, templates::handle_list_owned).await,
+            _ => Ok(value.method_not_found(&value.method)),
+        },
         Some(("nfts", method)) => match method {
             "mint_account_nft" => call_handler(context, value, token, nfts::handle_mint_account_nft).await,
             "get" => call_handler(context, value, token, nfts::handle_get_nft).await,

applications/tari_dan_wallet_daemon/src/services/mod.rs

@@ -12,6 +12,8 @@ mod webauthn;
 pub use webauthn::*;
 
 mod session_store;
+mod template_monitor;
+
 // -------------------------------- Spawn -------------------------------- //
 use anyhow::anyhow;
 use futures::{future, future::BoxFuture, FutureExt};
@@ -23,7 +25,10 @@ use tokio::{sync::oneshot, task::JoinHandle};
 use transaction_service::TransactionService;
 pub use transaction_service::TransactionServiceHandle;
 
-use crate::{notify::Notify, services::account_monitor::AccountMonitor};
+use crate::{
+    notify::Notify,
+    services::{account_monitor::AccountMonitor, template_monitor::TemplateMonitor},
+};
 
 type Reply<T> = oneshot::Sender<T>;
 
@@ -40,13 +45,20 @@ where
     let (transaction_service, transaction_service_handle) =
         TransactionService::new(notify.clone(), wallet_sdk.clone(), shutdown_signal.clone());
     let transaction_service_join_handle = tokio::spawn(transaction_service.run());
+    let template_monitor = TemplateMonitor::new(notify.clone(), wallet_sdk.clone(), shutdown_signal.clone());
+    let template_monitor_join_handle = tokio::spawn(template_monitor.run());
     let (account_monitor, account_monitor_handle) = AccountMonitor::new(notify, wallet_sdk, shutdown_signal);
     let account_monitor_join_handle = tokio::spawn(account_monitor.run());
 
     Services {
         account_monitor_handle,
         transaction_service_handle,
-        services_fut: try_select_any([transaction_service_join_handle, account_monitor_join_handle]).boxed(),
+        services_fut: try_select_any([
+            transaction_service_join_handle,
+            account_monitor_join_handle,
+            template_monitor_join_handle,
+        ])
+        .boxed(),
     }
 }
 

applications/tari_dan_wallet_daemon/src/services/template_monitor.rs

@@ -0,0 +1,102 @@
+// Copyright 2025 The Tari Project
+// SPDX-License-Identifier: BSD-3-Clause
+
+use log::error;
+use tari_common_types::types::PublicKey;
+use tari_dan_common_types::optional::IsNotFoundError;
+use tari_dan_wallet_sdk::{
+    apis::key_manager,
+    models::TransactionStatus,
+    network::WalletNetworkInterface,
+    storage::WalletStore,
+    DanWalletSdk,
+};
+use tari_engine_types::commit_result::TransactionResult;
+use tari_shutdown::ShutdownSignal;
+
+use crate::{notify::Notify, services::WalletEvent};
+
+const LOG_TARGET: &str = "tari::dan::wallet_daemon::template_monitor";
+
+pub struct TemplateMonitor<TStore, TNetworkInterface> {
+    notify: Notify<WalletEvent>,
+    wallet_sdk: DanWalletSdk<TStore, TNetworkInterface>,
+    shutdown_signal: ShutdownSignal,
+}
+
+impl<TStore, TNetworkInterface> TemplateMonitor<TStore, TNetworkInterface>
+where
+    TStore: WalletStore,
+    TNetworkInterface: WalletNetworkInterface,
+    TNetworkInterface::Error: IsNotFoundError,
+{
+    pub fn new(
+        notify: Notify<WalletEvent>,
+        wallet_sdk: DanWalletSdk<TStore, TNetworkInterface>,
+        shutdown_signal: ShutdownSignal,
+    ) -> Self {
+        Self {
+            notify,
+            wallet_sdk,
+            shutdown_signal,
+        }
+    }
+
+    async fn handle_wallet_event(&self, event: WalletEvent) -> anyhow::Result<()> {
+        if let WalletEvent::TransactionFinalized(event) = event {
+            if matches!(event.status, TransactionStatus::Accepted) {
+                if let TransactionResult::Accept(diff) = event.finalize.result {
+                    let templates_iter = diff.up_iter().filter_map(|(id, value)| {
+                        if let Some(template_address) = id.as_template() {
+                            if let Some(template) = value.clone().into_substate_value().as_template() {
+                                if let Some(key_index) = self.get_key_index_for_public_key(&template.author) {
+                                    return Some((key_index, template_address));
+                                }
+                            }
+                        }
+                        None
+                    });
+                    for (key_index, template_addr) in templates_iter {
+                        if let Err(error) = self
+                            .wallet_sdk
+                            .template_api()
+                            .add_authored_template(key_index, template_addr.as_hash())
+                            .await
+                        {
+                            error!(target: LOG_TARGET, "Error saving template to authored ({template_addr:?}): {}", error);
+                        }
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn get_key_index_for_public_key(&self, author_public_key: &PublicKey) -> Option<u64> {
+        if let Ok((key_index, _)) = self
+            .wallet_sdk
+            .key_manager_api()
+            .get_key_for_public_key(key_manager::TRANSACTION_BRANCH, author_public_key)
+        {
+            return Some(key_index);
+        }
+        None
+    }
+
+    pub async fn run(mut self) -> anyhow::Result<()> {
+        let mut events_subscription = self.notify.subscribe();
+        loop {
+            tokio::select! {
+                _ = self.shutdown_signal.wait() => {
+                    break Ok(());
+                }
+
+                Ok(event) = events_subscription.recv() => {
+                    if let Err(error) = self.handle_wallet_event(event).await {
+                        error!(target: LOG_TARGET, "Error handling event: {}", error);
+                    }
+                }
+            }
+        }
+    }
+}

applications/tari_dan_wallet_web_ui/package-lock.json

@@ -39,6 +39,7 @@ import { useEffect } from "react";
 import { useAuthMethod } from "./api/hooks/useAuth";
 import AccessToken from "./routes/AccessToken/AccessToken";
 import { jwtDecode } from "jwt-decode";
+import Templates from "./routes/Templates/Templates";
 
 export const breadcrumbRoutes = [
   {
@@ -101,6 +102,11 @@ export const breadcrumbRoutes = [
     path: "/settings",
     dynamic: false,
   },
+  {
+    label: "Templates",
+    path: "/templates",
+    dynamic: false,
+  },
 ];
 
 const isTokenExpired = (token: any) => {
@@ -229,6 +235,10 @@ function App() {
             path="settings"
             element={<GuardedRoute isAuthenticated={isAuthenticated} redirect="/settings" component={SettingsPage} />}
           />
+          <Route
+            path="templates"
+            element={<GuardedRoute isAuthenticated={isAuthenticated} redirect="/templates" component={Templates} />}
+          />
           <Route path="*" element={<ErrorPage />} />
         </Route>
       </Routes>

applications/tari_dan_wallet_web_ui/src/App.tsx

@@ -20,7 +20,7 @@
 //  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 //  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-import {useState} from "react";
+import { useState } from "react";
 import IconButton from "@mui/material/IconButton";
 import ContentCopyIcon from "@mui/icons-material/ContentCopy";
 import Tooltip from "@mui/material/Tooltip";
@@ -29,11 +29,11 @@ interface CopyProps {
   copy: string;
   floatright?: boolean;
   title?: string;
-  iconWidth?: string,
-  iconHeight?: string,
+  iconWidth?: string;
+  iconHeight?: string;
 }
 
-const CopyToClipboard = ({ copy, floatright, title, iconWidth="16px", iconHeight="16px" }: CopyProps) => {
+const CopyToClipboard = ({ copy, floatright, title, iconWidth = "16px", iconHeight = "16px" }: CopyProps) => {
   const [tooltip, setTooltip] = useState<string | null>(null);
   const handleClick = async (copyThis: string) => {
     try {

applications/tari_dan_wallet_web_ui/src/Components/CopyToClipboard.tsx

@@ -24,25 +24,13 @@ import { NavLink } from "react-router-dom";
 import ListItemButton from "@mui/material/ListItemButton";
 import ListItemIcon from "@mui/material/ListItemIcon";
 import ListItemText from "@mui/material/ListItemText";
-import {
-  IoHomeOutline,
-  IoHome,
-  IoBarChartOutline,
-  IoBarChart,
-  IoKeyOutline,
-  IoKey,
-  IoWalletOutline,
-  IoWallet,
-  IoTicketOutline,
-  IoTicket,
-  IoSettingsOutline,
-  IoSettings,
-} from "react-icons/io5";
+import { IoHome, IoHomeOutline, IoSettings, IoSettingsOutline } from "react-icons/io5";
 import Tooltip from "@mui/material/Tooltip";
 import Fade from "@mui/material/Fade";
 import ThemeSwitcher from "./ThemeSwitcher";
 import Box from "@mui/material/Box";
 import { useTheme } from "@mui/material/styles";
+import { LuLayoutTemplate } from "react-icons/lu";
 
 function MainListItems() {
   const theme = useTheme();
@@ -89,6 +77,12 @@ function MainListItems() {
     //   activeIcon: <IoTicket style={activeIconStyle} />,
     //   link: 'access-tokens',
     // },
+    {
+      title: "Templates",
+      icon: <LuLayoutTemplate style={iconStyle} />,
+      activeIcon: <LuLayoutTemplate style={activeIconStyle} />,
+      link: "templates",
+    },
     {
       title: "Settings",
       icon: <IoSettingsOutline style={iconStyle} />,

applications/tari_dan_wallet_web_ui/src/Components/MenuItems.tsx

@@ -1,18 +1,18 @@
 // Copyright 2025 The Tari Project
 // SPDX-License-Identifier: BSD-3-Clause
 
-import {useQuery} from "@tanstack/react-query";
-import {authGetMethod} from "../../utils/json_rpc";
-import {ApiError} from "../helpers/types";
+import { useQuery } from "@tanstack/react-query";
+import { authGetMethod } from "../../utils/json_rpc";
+import { ApiError } from "../helpers/types";
 
 export const useAuthMethod = () => {
-    return useQuery({
-        queryKey: ["auth_method"],
-        queryFn: () => {
-            return authGetMethod();
-        },
-        onError: (error: ApiError) => {
-            error;
-        },
-    });
-};
+  return useQuery({
+    queryKey: ["auth_method"],
+    queryFn: () => {
+      return authGetMethod();
+    },
+    onError: (error: ApiError) => {
+      error;
+    },
+  });
+};

applications/tari_dan_wallet_web_ui/src/api/hooks/useAuth.tsx

@@ -0,0 +1,23 @@
+// Copyright 2025 The Tari Project
+// SPDX-License-Identifier: BSD-3-Clause
+
+import { useQuery } from "@tanstack/react-query";
+import { ApiError } from "../helpers/types";
+import { templatesListAuthored } from "../../utils/json_rpc";
+import { TemplatesListAuthoredRequest } from "@tari-project/typescript-bindings";
+
+export const useListTemplatesAuthored = (request: TemplatesListAuthoredRequest) => {
+  return useQuery({
+    queryKey: ["templates_list_authored", request],
+    queryFn: () => {
+      return templatesListAuthored(request);
+    },
+    onError: (error: ApiError) => {
+      error;
+    },
+    refetchInterval: false,
+    notifyOnChangeProps: ["data", "error"],
+    retryOnMount: false,
+    retry: false,
+  });
+};