feat(gui): Migrate to Tauri events

- Replace Electron IPC with Tauri invoke() for API calls
- Implement TauriSwapProgressEvent for state management
- Remove IpcInvokeButton, replace with PromiseInvokeButton
- Update models: new tauriModel.ts, refactor rpcModel.ts
- Simplify SwapSlice state, remove processRunning flag
- Refactor SwapStatePage to use TauriSwapProgressEvent
- Update HistoryRow and HistoryRowActions for new data structures
- Remove unused Electron-specific components (e.g., RpcStatusAlert)
- Update dependencies: React 18, Material-UI v4 to v5
- Implement typeshare for Rust/TypeScript type synchronization
- Add BobStateName enum for more precise swap state tracking
- Refactor utility functions for Tauri compatibility
- Remove JSONStream and other Electron-specific dependencies

src-gui/src/renderer/rpc.ts

@@ -1,31 +1,89 @@
-import { invoke } from "@tauri-apps/api/core";
-import { store } from "./store/storeRenderer";
+import { invoke as invokeUnsafe } from "@tauri-apps/api/core";
+import { listen } from "@tauri-apps/api/event";
+import {
+  BalanceArgs,
+  BalanceResponse,
+  BuyXmrArgs,
+  BuyXmrResponse,
+  GetSwapInfoResponse,
+  ResumeSwapArgs,
+  ResumeSwapResponse,
+  SuspendCurrentSwapResponse,
+  TauriSwapProgressEventWrapper,
+  WithdrawBtcArgs,
+  WithdrawBtcResponse,
+} from "models/tauriModel";
 import { rpcSetBalance, rpcSetSwapInfo } from "store/features/rpcSlice";
+import { swapTauriEventReceived } from "store/features/swapSlice";
+import { store } from "./store/storeRenderer";
+import { Provider } from "models/apiModel";
+import { providerToConcatenatedMultiAddr } from "utils/multiAddrUtils";
+
+listen<TauriSwapProgressEventWrapper>("swap-progress-update", (event) => {
+  console.log("Received swap progress event", event.payload);
+  store.dispatch(swapTauriEventReceived(event.payload));
+});
+
+async function invoke<ARGS, RESPONSE>(
+  command: string,
+  args: ARGS,
+): Promise<RESPONSE> {
+  return invokeUnsafe(command, {
+    args: args as Record<string, unknown>,
+  }) as Promise<RESPONSE>;
+}
+
+async function invokeNoArgs<RESPONSE>(command: string): Promise<RESPONSE> {
+  return invokeUnsafe(command, {}) as Promise<RESPONSE>;
+}
 
 export async function checkBitcoinBalance() {
-  const response = (await invoke("get_balance")) as {
-    balance: number;
-  };
+  const response = await invoke<BalanceArgs, BalanceResponse>("get_balance", {
+    force_refresh: true,
+  });
 
   store.dispatch(rpcSetBalance(response.balance));
 }
 
 export async function getRawSwapInfos() {
-  const response = await invoke("get_swap_infos_all");
+  const response =
+    await invokeNoArgs<GetSwapInfoResponse[]>("get_swap_infos_all");
 
-  (response as any[]).forEach((info) => store.dispatch(rpcSetSwapInfo(info)));
+  response.forEach((swapInfo) => {
+    store.dispatch(rpcSetSwapInfo(swapInfo));
+  });
 }
 
 export async function withdrawBtc(address: string): Promise<string> {
-  const response = (await invoke("withdraw_btc", {
-    args: {
+  const response = await invoke<WithdrawBtcArgs, WithdrawBtcResponse>(
+    "withdraw_btc",
+    {
       address,
       amount: null,
     },
-  })) as {
-    txid: string;
-    amount: number;
-  };
+  );
 
   return response.txid;
 }
+
+export async function buyXmr(
+  seller: Provider,
+  bitcoin_change_address: string,
+  monero_receive_address: string,
+) {
+  await invoke<BuyXmrArgs, BuyXmrResponse>("buy_xmr", {
+    seller: providerToConcatenatedMultiAddr(seller),
+    bitcoin_change_address,
+    monero_receive_address,
+  });
+}
+
+export async function resumeSwap(swapId: string) {
+  await invoke<ResumeSwapArgs, ResumeSwapResponse>("resume_swap", {
+    swap_id: swapId,
+  });
+}
+
+export async function suspendCurrentSwap() {
+  await invokeNoArgs<SuspendCurrentSwapResponse>("suspend_current_swap");
+}