diff --git a/examples/vite-core/src/App.tsx b/examples/vite-core/src/App.tsx
index b3f2062..19ead68 100644
--- a/examples/vite-core/src/App.tsx
+++ b/examples/vite-core/src/App.tsx
@@ -73,6 +73,7 @@ const App = () => {
       </header>
       <main>
         <WalletStatus open={open} checkIsOpen={checkIsOpen} balance={balance} />
+        <MnemonicManager />
         <JoinFederation open={open} checkIsOpen={checkIsOpen} />
         <GenerateLightningInvoice />
         <RedeemEcash />
@@ -522,4 +523,200 @@ const SendOnchain = () => {
   )
 }
 
+const MnemonicManager = () => {
+  const [mnemonicState, setMnemonicState] = useState<string>('')
+  const [inputMnemonic, setInputMnemonic] = useState<string>('')
+  const [activeAction, setActiveAction] = useState<
+    'get' | 'set' | 'generate' | null
+  >(null)
+  const [isLoading, setIsLoading] = useState(false)
+  const [message, setMessage] = useState<{
+    text: string
+    type: 'success' | 'error'
+  }>()
+  const [showMnemonic, setShowMnemonic] = useState(false)
+
+  const clearMessage = () => setMessage(undefined)
+
+  // Helper function to extract user-friendly error messages
+  const extractErrorMessage = (error: any): string => {
+    let errorMsg = 'Operation failed'
+
+    if (error instanceof Error) {
+      errorMsg = error.message
+    } else if (typeof error === 'object' && error !== null) {
+      // Handle RPC error objects
+      const rpcError = error as any
+      if (rpcError.error) {
+        errorMsg = rpcError.error
+      } else if (rpcError.message) {
+        errorMsg = rpcError.message
+      }
+    }
+
+    return errorMsg
+  }
+
+  const handleAction = async (action: 'get' | 'set' | 'generate') => {
+    if (activeAction === action) {
+      setActiveAction(null)
+      return
+    }
+    setActiveAction(action)
+    clearMessage()
+
+    if (action === 'get') {
+      await handleGetMnemonic()
+    } else if (action === 'generate') {
+      await handleGenerateMnemonic()
+    }
+  }
+
+  const handleGenerateMnemonic = async () => {
+    setIsLoading(true)
+    try {
+      const newMnemonic = await director.generateMnemonic()
+      setMnemonicState(newMnemonic.join(' '))
+      setMessage({ text: 'New mnemonic generated!', type: 'success' })
+      setShowMnemonic(true)
+    } catch (error) {
+      console.error('Error generating mnemonic:', error)
+      const errorMsg = extractErrorMessage(error)
+      setMessage({ text: errorMsg, type: 'error' })
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  const handleGetMnemonic = async () => {
+    setIsLoading(true)
+    try {
+      const mnemonic = await director.getMnemonic()
+      if (mnemonic && mnemonic.length > 0) {
+        setMnemonicState(mnemonic.join(' '))
+        setMessage({ text: 'Mnemonic retrieved!', type: 'success' })
+        setShowMnemonic(true)
+      } else {
+        setMessage({ text: 'No mnemonic found', type: 'error' })
+      }
+    } catch (error) {
+      console.error('Error getting mnemonic:', error)
+      const errorMsg = extractErrorMessage(error)
+      setMessage({ text: errorMsg, type: 'error' })
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  const handleSetMnemonic = async (e: React.FormEvent) => {
+    e.preventDefault()
+    if (!inputMnemonic.trim()) return
+
+    setIsLoading(true)
+    try {
+      const words = inputMnemonic.trim().split(/\s+/)
+      await director.setMnemonic(words)
+      setMessage({ text: 'Mnemonic set successfully!', type: 'success' })
+      setInputMnemonic('')
+      setMnemonicState(words.join(' '))
+      setActiveAction(null)
+    } catch (error) {
+      console.error('Error setting mnemonic:', error)
+      const errorMsg = extractErrorMessage(error)
+      setMessage({ text: errorMsg, type: 'error' })
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  const copyToClipboard = async () => {
+    try {
+      await navigator.clipboard.writeText(mnemonicState)
+      setMessage({ text: 'Copied to clipboard!', type: 'success' })
+    } catch (error) {
+      setMessage({ text: 'Failed to copy', type: 'error' })
+    }
+  }
+
+  return (
+    <div className="section mnemonic-section">
+      <h3>🔑 Mnemonic Manager</h3>
+
+      <div className="mnemonic-buttons">
+        <button
+          onClick={() => handleAction('get')}
+          disabled={isLoading}
+          className={`btn ${activeAction === 'get' ? 'active' : ''}`}
+        >
+          Get
+        </button>
+        <button
+          onClick={() => handleAction('set')}
+          disabled={isLoading}
+          className={`btn ${activeAction === 'set' ? 'active' : ''}`}
+        >
+          Set
+        </button>
+        <button
+          onClick={() => handleAction('generate')}
+          disabled={isLoading}
+          className={`btn ${activeAction === 'generate' ? 'active' : ''}`}
+        >
+          Generate
+        </button>
+      </div>
+
+      {activeAction === 'set' && (
+        <form onSubmit={handleSetMnemonic} className="mnemonic-form">
+          <textarea
+            placeholder="Enter 12 or 24 words separated by spaces"
+            value={inputMnemonic}
+            onChange={(e) => setInputMnemonic(e.target.value)}
+            rows={2}
+            className="mnemonic-input"
+          />
+          <button
+            type="submit"
+            disabled={isLoading || !inputMnemonic.trim()}
+            className="btn btn-primary"
+          >
+            {isLoading ? 'Setting...' : 'Set Mnemonic'}
+          </button>
+        </form>
+      )}
+
+      {mnemonicState && (
+        <div className="mnemonic-display">
+          <div className="mnemonic-output">
+            <span className={showMnemonic ? '' : 'blurred'}>
+              {mnemonicState}
+            </span>
+            <div className="mnemonic-actions">
+              <button
+                onClick={() => setShowMnemonic(!showMnemonic)}
+                className="btn btn-small"
+                title={showMnemonic ? 'Hide mnemonic' : 'Show mnemonic'}
+              >
+                {showMnemonic ? '👁️' : '👁️‍🗨️'}
+              </button>
+              <button
+                onClick={copyToClipboard}
+                className="btn btn-small"
+                disabled={!showMnemonic}
+                title="Copy to clipboard"
+              >
+                📋
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
+
+      {message && (
+        <div className={`message ${message.type}`}>{message.text}</div>
+      )}
+    </div>
+  )
+}
+
 export default App
diff --git a/flake.nix b/flake.nix
index 7e10285..6118f45 100644
--- a/flake.nix
+++ b/flake.nix
@@ -6,7 +6,7 @@
       url = "github:fedimint/fedimint/v0.8.1";
     };
     fedimint-wasm = {
-      url = "github:fedimint/fedimint?rev=ba238118bf5b204bc73c1113b6cadd62bca4e66c";
+      url = "github:fedimint/fedimint?rev=a88f7f6ceb988ee964bf06900183c3c16f7f4c38";
     };
   };
   outputs =
diff --git a/packages/core/src/FedimintWallet.ts b/packages/core/src/FedimintWallet.ts
index c3c9ecf..26a9a41 100644
--- a/packages/core/src/FedimintWallet.ts
+++ b/packages/core/src/FedimintWallet.ts
@@ -8,7 +8,7 @@ import {
   WalletService,
 } from './services'
 
-const DEFAULT_CLIENT_NAME = 'fm-default' as const
+const DEFAULT_CLIENT_NAME = 'dd5135b2-c228-41b7-a4f9-3b6e7afe3088' as const
 
 export class FedimintWallet {
   public balance: BalanceService
@@ -68,14 +68,16 @@ export class FedimintWallet {
   async open(clientName: string = DEFAULT_CLIENT_NAME) {
     // TODO: Determine if this should be safe or throw
     if (this._isOpen) throw new Error('The FedimintWallet is already open.')
-    const { success } = await this._client.sendSingleMessage<{
-      success: boolean
-    }>('open', { clientName })
-    if (success) {
-      this._isOpen = !!success
+
+    try {
+      await this._client.openClient(clientName)
+      this._isOpen = true
       this._resolveOpen()
+      return true
+    } catch (e) {
+      this._client.logger.error('Error opening client', e)
+      return false
     }
-    return success
   }
 
   async joinFederation(
@@ -88,15 +90,10 @@ export class FedimintWallet {
         'The FedimintWallet is already open. You can only call `joinFederation` on closed clients.',
       )
     try {
-      const response = await this._client.sendSingleMessage<{
-        success: boolean
-      }>('join', { inviteCode, clientName })
-      if (response.success) {
-        this._isOpen = true
-        this._resolveOpen()
-      }
-
-      return response.success
+      await this._client.joinFederation(inviteCode, clientName)
+      this._isOpen = true
+      this._resolveOpen()
+      return true
     } catch (e) {
       this._client.logger.error('Error joining federation', e)
       return false
diff --git a/packages/core/src/WalletDirector.ts b/packages/core/src/WalletDirector.ts
index 95387a5..7ecd568 100644
--- a/packages/core/src/WalletDirector.ts
+++ b/packages/core/src/WalletDirector.ts
@@ -1,7 +1,12 @@
 import { TransportClient } from './transport'
 import { type LogLevel } from './utils/logger'
 import { FederationConfig, JSONValue } from './types'
-import { Transport } from '@fedimint/types'
+import {
+  Transport,
+  ParsedInviteCode,
+  ParsedBolt11Invoice,
+  PreviewFederation,
+} from '@fedimint/types'
 import { FedimintWallet } from './FedimintWallet'
 
 export class WalletDirector {
@@ -40,15 +45,6 @@ export class WalletDirector {
     return new FedimintWallet(this._client)
   }
 
-  async previewFederation(inviteCode: string) {
-    await this._client.initialize()
-    const response = this._client.sendSingleMessage<{
-      config: FederationConfig
-      federation_id: string
-    }>('previewFederation', { inviteCode })
-    return response
-  }
-
   /**
    * Sets the log level for the library.
    * @param level The desired log level ('DEBUG', 'INFO', 'WARN', 'ERROR', 'NONE').
@@ -65,26 +61,21 @@ export class WalletDirector {
    * The response includes the federation_id and url.
    *
    * @param {string} inviteCode - The invite code to be parsed.
-   * @returns {Promise<{ federation_id: string, url: string}>}
+   * @returns {Promise<ParsedInviteCode>}
    *          A promise that resolves to an object containing:
-   *          - `federation_id`: The id of the feder.
+   *          - `federation_id`: The id of the federation.
    *          - `url`: One of the apipoints to connect to the federation
    *
    * @throws {Error} If the TransportClient encounters an issue during the parsing process.
    *
    * @example
    * const inviteCode = "example-invite-code";
-   * const parsedCode = await wallet.parseInviteCode(inviteCode);
+   * const parsedCode = await walletDirector.parseInviteCode(inviteCode);
    * console.log(parsedCode.federation_id, parsedCode.url);
    */
-  async parseInviteCode(inviteCode: string) {
+  async parseInviteCode(inviteCode: string): Promise<ParsedInviteCode> {
     await this._client.initialize()
-    const response = await this._client.sendSingleMessage<{
-      type: string
-      data: JSONValue
-      requestId: number
-    }>('parseInviteCode', { inviteCode })
-    return response
+    return this._client.parseInviteCode(inviteCode)
   }
 
   /**
@@ -94,9 +85,9 @@ export class WalletDirector {
    * The response includes details such as the amount, expiry, and memo.
    *
    * @param {string} invoiceStr - The BOLT11 invoice string to be parsed.
-   * @returns {Promise<{ amount: string, expiry: number, memo: string }>}
+   * @returns {Promise<ParsedBolt11Invoice>}
    *          A promise that resolves to an object containing:
-   *          - `amount`: The amount specified in the invoice.
+   *          - `amount`: The amount specified in the invoice (in satoshis).
    *          - `expiry`: The expiry time of the invoice in seconds.
    *          - `memo`: A description or memo attached to the invoice.
    *
@@ -104,16 +95,44 @@ export class WalletDirector {
    *
    * @example
    * const invoiceStr = "lnbc1...";
-   * const parsedInvoice = await wallet.parseBolt11Invoice(invoiceStr);
+   * const parsedInvoice = await walletDirector.parseBolt11Invoice(invoiceStr);
    * console.log(parsedInvoice.amount, parsedInvoice.expiry, parsedInvoice.memo);
    */
-  async parseBolt11Invoice(invoiceStr: string) {
+  async parseBolt11Invoice(invoiceStr: string): Promise<ParsedBolt11Invoice> {
     await this._client.initialize()
-    const response = await this._client.sendSingleMessage<{
-      type: string
-      data: JSONValue
-      requestId: number
-    }>('parseBolt11Invoice', { invoiceStr })
-    return response
+    return this._client.parseBolt11Invoice(invoiceStr)
+  }
+
+  /**
+   * Previews the configuration of a federation using the provided invite code.
+   *
+   * Retrieves and returns the federation configuration
+   * associated with the given invite code.
+   *
+   * @param inviteCode - The invite code used to identify the federation to preview.
+   * @returns {Promise<PreviewFederation>} A promise that resolves to a `PreviewFederation` object containing the federation's
+   * configuration and ID.
+   * @example
+   * const inviteCode = "example-invite-code";
+   * const federationPreview = await walletDirector.previewFederation(inviteCode);
+   * console.log(federationPreview.config, federationPreview.federation_id);
+   */
+  async previewFederation(inviteCode: string): Promise<PreviewFederation> {
+    return await this._client.previewFederation(inviteCode)
+  }
+
+  async generateMnemonic(): Promise<string[]> {
+    const result = await this._client.generateMnemonic()
+    return result.mnemonic
+  }
+
+  async getMnemonic(): Promise<string[]> {
+    const result = await this._client.getMnemonic()
+    return result.mnemonic
+  }
+
+  async setMnemonic(words: string[]): Promise<boolean> {
+    const result = await this._client.setMnemonic(words)
+    return result.success
   }
 }
diff --git a/packages/core/src/transport/TransportClient.ts b/packages/core/src/transport/TransportClient.ts
index e1c70ee..ff58d3a 100644
--- a/packages/core/src/transport/TransportClient.ts
+++ b/packages/core/src/transport/TransportClient.ts
@@ -10,6 +10,9 @@ import type {
   Transport,
   TransportMessage,
   TransportMessageType,
+  ParsedInviteCode,
+  ParsedBolt11Invoice,
+  PreviewFederation,
 } from '@fedimint/types'
 
 /**
@@ -40,7 +43,7 @@ export class TransportClient {
   // Idempotent setup - Loads the wasm module
   initialize() {
     if (this.initPromise) return this.initPromise
-    this.initPromise = this.sendSingleMessage('init')
+    this.initPromise = this.sendUnifiedRpcRequest({ type: 'init' })
     return this.initPromise
   }
 
@@ -58,6 +61,48 @@ export class TransportClient {
     if (type === 'log') {
       this.handleLogMessage(message)
     }
+
+    if (type === 'rpcResponse') {
+      // Handle native RPC response format
+      const rpcResponse = (message as any).response
+      const callback =
+        requestId !== undefined
+          ? this.requestCallbacks.get(requestId)
+          : undefined
+
+      this.logger.debug(
+        'TransportClient - rpcResponse received',
+        requestId,
+        rpcResponse,
+      )
+
+      if (callback && rpcResponse) {
+        // Check if the response has the expected structure
+        if (rpcResponse.kind) {
+          // Convert RPC response kind to transport format
+          const transportData = this.mapRpcResponseToTransport(rpcResponse.kind)
+          callback(transportData)
+        } else {
+          // Response might be in a different format, let's handle it
+          this.logger.debug(
+            'TransportClient - unexpected response format',
+            rpcResponse,
+          )
+
+          // Try to handle the response directly
+          if (rpcResponse.error) {
+            callback({ error: rpcResponse.error })
+          } else if (rpcResponse.data !== undefined) {
+            callback({ data: rpcResponse.data })
+          } else {
+            // If it's a successful response without explicit data/error structure
+            callback({ data: rpcResponse })
+          }
+        }
+      }
+      return
+    }
+
     const streamCallback =
       requestId !== undefined ? this.requestCallbacks.get(requestId) : undefined
     // TODO: Handle errors... maybe have another callbacks list for errors?
@@ -73,45 +118,28 @@ export class TransportClient {
     }
   }
 
+  /**
+   * Maps RPC response kinds to transport message format
+   */
+  private mapRpcResponseToTransport(kind: any) {
+    switch (kind.type) {
+      case 'data':
+        return { data: kind.data }
+      case 'error':
+        return { error: kind.error }
+      case 'aborted':
+        return { aborted: true }
+      case 'end':
+        return { end: true }
+      default:
+        return { error: 'Unknown response type' }
+    }
+  }
+
   // TODO: Handle errors... maybe have another callbacks list for errors?
   // TODO: Handle timeouts
   // TODO: Handle multiple errors
 
-  sendSingleMessage<
-    Response extends JSONValue = JSONValue,
-    Payload extends JSONValue = JSONValue,
-  >(type: TransportMessageType, payload?: Payload) {
-    return new Promise<Response>((resolve, reject) => {
-      const requestId = ++this.requestCounter
-      this.logger.debug(
-        'TransportClient - sendSingleMessage',
-        requestId,
-        type,
-        payload,
-      )
-      this.requestCallbacks.set(
-        requestId,
-        (response: StreamResult<Response>) => {
-          this.requestCallbacks.delete(requestId)
-          this.logger.debug(
-            'TransportClient - sendSingleMessage - response',
-            requestId,
-            response,
-          )
-          if (response.data) resolve(response.data)
-          else if (response.error) reject(response.error)
-          else
-            this.logger.warn(
-              'TransportClient - sendSingleMessage - malformed response',
-              requestId,
-              response,
-            )
-        },
-      )
-      this.transport.postMessage({ type, payload, requestId })
-    })
-  }
-
   /**
    * @summary Initiates an RPC stream with the specified module and method.
    *
@@ -171,12 +199,17 @@ export class TransportClient {
       }
     })
 
+    const rpcRequest = {
+      type: 'client_rpc',
+      module: module,
+      method: method,
+      payload: body,
+    }
+
     // Initiate the inner RPC stream setup asynchronously
     this._rpcStreamInner(
       requestId,
-      module,
-      method,
-      body,
+      rpcRequest,
       onSuccess,
       onError,
       onEnd,
@@ -188,14 +221,9 @@ export class TransportClient {
     return unsubscribe
   }
 
-  private async _rpcStreamInner<
-    Response extends JSONValue = JSONValue,
-    Body extends JSONValue = JSONValue,
-  >(
+  private async _rpcStreamInner<Response extends JSONValue = JSONValue>(
     requestId: number,
-    module: ModuleKind,
-    method: string,
-    body: Body,
+    rpcRequest: any,
     onSuccess: (res: Response) => void,
     onError: (res: StreamError['error']) => void,
     onEnd: () => void = () => {},
@@ -212,16 +240,23 @@ export class TransportClient {
         onEnd()
       }
     })
+
+    // Send the unified RPC request with specific type
     this.transport.postMessage({
-      type: 'rpc',
-      payload: { module, method, body },
+      type: rpcRequest.type as TransportMessageType,
+      payload: rpcRequest,
       requestId,
     })
 
     unsubscribePromise.then(() => {
+      // Use the new RPC cancel method
       this.transport.postMessage({
-        type: 'unsubscribe',
-        requestId,
+        type: 'cancel_rpc' as TransportMessageType,
+        payload: {
+          type: 'cancel_rpc',
+          cancel_request_id: requestId,
+        },
+        requestId: ++this.requestCounter,
       })
       this.requestCallbacks.delete(requestId)
     })
@@ -232,13 +267,148 @@ export class TransportClient {
     Error extends string = string,
   >(module: ModuleKind, method: string, body: JSONValue) {
     this.logger.debug('TransportClient - rpcSingle', module, method, body)
-    return new Promise<Response>((resolve, reject) => {
-      this.rpcStream<Response>(module, method, body, resolve, reject)
+    const rpcRequest = {
+      type: 'client_rpc',
+      module: module,
+      method: method,
+      payload: body,
+    }
+    return this.sendUnifiedRpcRequest<Response>(rpcRequest)
+  }
+
+  // New RPC methods for the updated architecture - using existing transport infrastructure
+
+  /**
+   * Send a direct RPC request
+   */
+  async sendUnifiedRpcRequest<T = JSONValue>(kind: any): Promise<T> {
+    const requestId = ++this.requestCounter
+
+    // Debug: Log what we're sending
+    this.logger.debug(
+      'TransportClient - sendUnifiedRpcRequest',
+      requestId,
+      kind,
+    )
+
+    return new Promise<T>((resolve, reject) => {
+      this.requestCallbacks.set(requestId, (response: any) => {
+        this.requestCallbacks.delete(requestId)
+
+        if (response.error) {
+          reject(new Error(response.error))
+        } else if (response.data !== undefined) {
+          resolve(response.data)
+        } else {
+          reject(new Error('Invalid response format'))
+        }
+      })
+
+      // Use the specific RPC type directly
+      this.transport.postMessage({
+        type: kind.type as TransportMessageType,
+        payload: kind,
+        requestId,
+      })
+    })
+  }
+
+  /**
+   * Set mnemonic words for the wallet
+   */
+  async setMnemonic(words: string[]): Promise<{ success: boolean }> {
+    return this.sendUnifiedRpcRequest({
+      type: 'set_mnemonic',
+      words,
+    })
+  }
+
+  /**
+   * Generate a new mnemonic
+   */
+  async generateMnemonic(): Promise<{ mnemonic: string[] }> {
+    return this.sendUnifiedRpcRequest({
+      type: 'generate_mnemonic',
+    })
+  }
+
+  /**
+   * Get the current mnemonic
+   */
+  async getMnemonic(): Promise<{ mnemonic: string[] }> {
+    return this.sendUnifiedRpcRequest({
+      type: 'get_mnemonic',
+    })
+  }
+
+  /**
+   * Join a federation
+   */
+  async joinFederation(
+    inviteCode: string,
+    clientName: string,
+    forceRecover: boolean = false,
+  ): Promise<void> {
+    await this.sendUnifiedRpcRequest({
+      type: 'join_federation',
+      invite_code: inviteCode,
+      force_recover: forceRecover,
+      client_name: clientName,
+    })
+  }
+
+  /**
+   * Open a client
+   */
+  async openClient(clientName: string): Promise<void> {
+    await this.sendUnifiedRpcRequest({
+      type: 'open_client',
+      client_name: clientName,
+    })
+  }
+
+  /**
+   * Close a client
+   */
+  async closeClient(clientName: string): Promise<void> {
+    await this.sendUnifiedRpcRequest({
+      type: 'close_client',
+      client_name: clientName,
+    })
+  }
+
+  /**
+   * Parse an invite code
+   */
+  async parseInviteCode(inviteCode: string): Promise<ParsedInviteCode> {
+    return this.sendUnifiedRpcRequest({
+      type: 'parse_invite_code',
+      invite_code: inviteCode,
+    })
+  }
+
+  /**
+   * Parse a Bolt11 invoice
+   */
+  async parseBolt11Invoice(invoice: string): Promise<ParsedBolt11Invoice> {
+    return this.sendUnifiedRpcRequest({
+      type: 'parse_bolt11_invoice',
+      invoice,
+    })
+  }
+
+  /**
+   * Preview federation information
+   */
+  async previewFederation(inviteCode: string): Promise<PreviewFederation> {
+    return this.sendUnifiedRpcRequest({
+      type: 'preview_federation',
+      invite_code: inviteCode,
     })
   }
 
   async cleanup() {
-    await this.sendSingleMessage('cleanup')
+    await this.sendUnifiedRpcRequest({ type: 'cleanup' })
     this.requestCounter = 0
     this.initPromise = undefined
     this.requestCallbacks.clear()
diff --git a/packages/transport-web/src/worker.js b/packages/transport-web/src/worker.js
index df59142..7d9d990 100644
--- a/packages/transport-web/src/worker.js
+++ b/packages/transport-web/src/worker.js
@@ -1,19 +1,13 @@
-// Web Worker for fedimint-client-wasm to run in the browser
+// Web Worker for fedimint-client-wasm to run in the browser using new RPC architecture
 
 // HACK: Fixes vitest browser runner
 // TODO: remove once https://github.com/vitest-dev/vitest/pull/6569 lands in a release
 globalThis.__vitest_browser_runner__ = { wrapDynamicImport: (foo) => foo() }
 
-// dynamically imported Constructor for WasmClient
-let WasmClient = null
-// client instance
-let client = null
+// RpcHandler instance
+let rpcHandler = null
 
-const streamCancelMap = new Map()
-
-const handleFree = (requestId) => {
-  streamCancelMap.delete(requestId)
-}
+// TODO: needs proper logging.
 
 console.log('Worker - init')
 
@@ -33,135 +27,93 @@ self.onmessage = async (event) => {
 
   try {
     if (type === 'init') {
-      WasmClient = (await import('@fedimint/fedimint-client-wasm-bundler'))
-        .WasmClient
-      self.postMessage({ type: 'initialized', data: {}, requestId })
-    } else if (type === 'open') {
-      const { clientName } = payload
-      client = (await WasmClient.open(clientName)) || null
-      self.postMessage({
-        type: 'open',
-        data: { success: !!client },
-        requestId,
+      let RpcHandler = (await import('@fedimint/fedimint-client-wasm-bundler'))
+        .RpcHandler
+
+      const root = await navigator.storage.getDirectory()
+      const dbFileHandle = await root.getFileHandle('fedimint.db', {
+        create: true,
       })
-    } else if (type === 'join') {
-      const { inviteCode, clientName: joinClientName } = payload
-      try {
-        client = await WasmClient.join_federation(joinClientName, inviteCode)
-        self.postMessage({
-          type: 'join',
-          data: { success: !!client },
-          requestId,
-        })
-      } catch (e) {
-        self.postMessage({ type: 'error', error: e.message, requestId })
-      }
-    } else if (type === 'previewFederation') {
-      const { inviteCode } = payload
-      try {
-        client = await WasmClient.preview_federation(inviteCode)
-        const parsed = JSON.parse(client)
-        self.postMessage({
-          type: 'previewFederation',
-          data: {
-            success: !!client,
-            config: parsed.config,
-            federation_id: parsed.federation_id,
-          },
-          requestId,
-        })
-      } catch (e) {
-        self.postMessage({ type: 'error', error: e.message, requestId })
-      }
-    } else if (type === 'rpc') {
-      const { module, method, body } = payload
-      console.log('RPC received', module, method, body)
-      if (!client) {
+      const dbSyncHandle = await dbFileHandle.createSyncAccessHandle()
+
+      rpcHandler = new RpcHandler(dbSyncHandle)
+
+      self.postMessage({ type: 'initialized', data: {}, requestId })
+    } else if (
+      type === 'set_mnemonic' ||
+      type === 'generate_mnemonic' ||
+      type === 'get_mnemonic' ||
+      type === 'join_federation' ||
+      type === 'open_client' ||
+      type === 'close_client' ||
+      type === 'client_rpc' ||
+      type === 'parse_invite_code' ||
+      type === 'parse_bolt11_invoice' ||
+      type === 'preview_federation' ||
+      type === 'cancel_rpc'
+    ) {
+      if (!rpcHandler) {
         self.postMessage({
           type: 'error',
-          error: 'WasmClient not initialized',
+          error: 'RpcHandler not initialized',
           requestId,
         })
         return
       }
-      const rpcHandle = await client.rpc(
-        module,
-        method,
-        JSON.stringify(body),
-        (res) => {
-          console.log('RPC response', requestId, res)
-          const data = JSON.parse(res)
-          self.postMessage({ type: 'rpcResponse', requestId, ...data })
 
-          if (data.end !== undefined) {
-            // Handle stream ending
-            const handle = streamCancelMap.get(requestId)
-            handle?.free()
-          }
-        },
-      )
-      streamCancelMap.set(requestId, rpcHandle)
-    } else if (type === 'unsubscribe') {
-      const rpcHandle = streamCancelMap.get(requestId)
-      if (rpcHandle) {
-        rpcHandle.cancel()
-        rpcHandle.free()
-        streamCancelMap.delete(requestId)
+      const rpcRequest = JSON.stringify({
+        request_id: requestId,
+        ...payload,
+      })
+
+      // Debug: Log the final RPC request
+      console.log('RPC request being sent:', rpcRequest)
+
+      // Create a callback function to handle RPC responses
+      const callback = (responseStr) => {
+        try {
+          const response = JSON.parse(responseStr)
+
+          // Debug: Log the raw response to see the structure
+          console.log(
+            'Raw RPC response received:',
+            JSON.stringify(response, null, 2),
+          )
+
+          self.postMessage({
+            type: 'rpcResponse',
+            requestId: response.request_id,
+            response: response,
+          })
+        } catch (error) {
+          self.postMessage({
+            type: 'error',
+            error: `Failed to parse RPC response: ${error.message}`,
+            requestId,
+          })
+        }
       }
+      // Call the RPC handler
+      rpcHandler.rpc(rpcRequest, callback)
     } else if (type === 'cleanup') {
+      // TODO: proper cleanup.
       console.log('cleanup message received')
-      client?.free()
+      rpcHandler = null
       self.postMessage({
         type: 'cleanup',
         data: {},
         requestId,
       })
       close()
-    } else if (type === 'parseInviteCode') {
-      const { inviteCode } = payload
-      try {
-        const res = WasmClient.parse_invite_code(inviteCode)
-        const parsedRes = JSON.parse(res)
-        self.postMessage({
-          type: 'parseInviteCode',
-          data: parsedRes,
-          requestId,
-        })
-      } catch (error) {
-        self.postMessage({
-          type: 'error',
-          error: `Failed to parse invite code: ${error.message}`,
-          requestId,
-        })
-      }
-    } else if (type === 'parseBolt11Invoice') {
-      const { invoiceStr } = payload
-      try {
-        const res = WasmClient.parse_bolt11_invoice(invoiceStr)
-        const parsedRes = JSON.parse(res)
-        self.postMessage({
-          type: 'parseBolt11Invoice',
-          data: parsedRes,
-          requestId,
-        })
-      } catch (error) {
-        self.postMessage({
-          type: 'error',
-          error: `Failed to parse invoice: ${error.message}`,
-          requestId,
-        })
-      }
     } else {
       self.postMessage({
         type: 'error',
-        error: 'Unknown message type',
+        error: `Unknown message type: ${type}`,
         requestId,
       })
     }
   } catch (e) {
     console.error('ERROR', e)
-    self.postMessage({ type: 'error', error: e, requestId })
+    self.postMessage({ type: 'error', error: e.message || e, requestId })
   }
 }
-
-// self.postMessage({ type: 'init', data: {} })
diff --git a/packages/types/src/common.ts b/packages/types/src/common.ts
new file mode 100644
index 0000000..c61fc32
--- /dev/null
+++ b/packages/types/src/common.ts
@@ -0,0 +1,7 @@
+export type JSONValue =
+  | string
+  | number
+  | boolean
+  | null
+  | { [key: string]: JSONValue }
+  | JSONValue[]
diff --git a/packages/types/src/index.ts b/packages/types/src/index.ts
index e0e9454..6308b2b 100644
--- a/packages/types/src/index.ts
+++ b/packages/types/src/index.ts
@@ -1,24 +1,22 @@
-export type JSONValue =
-  | string
-  | number
-  | boolean
-  | null
-  | { [key: string]: JSONValue }
-  | JSONValue[]
+import type { JSONValue } from './common'
 
 export const TRANSPORT_MESSAGE_TYPES = [
   'init',
   'initialized',
-  'rpc',
+  'set_mnemonic',
+  'generate_mnemonic',
+  'get_mnemonic',
+  'join_federation',
+  'open_client',
+  'close_client',
+  'client_rpc',
+  'parse_invite_code',
+  'parse_bolt11_invoice',
+  'preview_federation',
+  'cancel_rpc',
   'log',
-  'open',
-  'join',
   'error',
-  'unsubscribe',
   'cleanup',
-  'parseInviteCode',
-  'parseBolt11Invoice',
-  'previewFederation',
 ] as const
 
 export type TransportMessageType = (typeof TRANSPORT_MESSAGE_TYPES)[number]
@@ -58,3 +56,6 @@ export type TransportLogger = {
   warn(message: string, ...args: any[]): void
   error(message: string, ...args: any[]): void
 }
+
+export * from './rpc'
+export * from './common'
diff --git a/packages/types/src/rpc.ts b/packages/types/src/rpc.ts
new file mode 100644
index 0000000..ab09372
--- /dev/null
+++ b/packages/types/src/rpc.ts
@@ -0,0 +1,111 @@
+import type { JSONValue } from './common'
+
+export type RpcRequestFull = {
+  request_id: number
+} & RpcRequest
+
+export type RpcRequest =
+  | {
+      type: 'set_mnemonic'
+      words: string[]
+    }
+  | {
+      type: 'generate_mnemonic'
+    }
+  | {
+      type: 'get_mnemonic'
+    }
+  | {
+      type: 'join_federation'
+      invite_code: string
+      client_name: string
+      force_recover: boolean
+    }
+  | {
+      type: 'open_client'
+      client_name: string
+    }
+  | {
+      type: 'close_client'
+      client_name: string
+    }
+  | {
+      type: 'client_rpc'
+      client_name: string
+      module: string
+      method: string
+      payload: JSONValue
+    }
+  | {
+      type: 'parse_invite_code'
+      invite_code: string
+    }
+  | {
+      type: 'parse_bolt11_invoice'
+      invoice: string
+    }
+  | {
+      type: 'preview_federation'
+      invite_code: string
+    }
+  | {
+      type: 'cancel_rpc'
+      cancel_request_id: number
+    }
+
+export type RpcResponse = {
+  request_id: number
+  kind: RpcResponseKind
+}
+
+export type RpcResponseKind =
+  | {
+      type: 'data'
+      data: JSONValue
+    }
+  | {
+      type: 'error'
+      error: string
+    }
+  | {
+      type: 'aborted'
+    }
+  | {
+      type: 'end'
+    }
+
+const validRpcRequestTypes = [
+  'set_mnemonic',
+  'generate_mnemonic',
+  'get_mnemonic',
+  'join_federation',
+  'open_client',
+  'close_client',
+  'client_rpc',
+  'parse_invite_code',
+  'parse_bolt11_invoice',
+  'preview_federation',
+  'cancel_rpc',
+] as const
+
+export type RpcRequestType = RpcRequest['type']
+
+export function isValidRpcRequestType(type: string): type is RpcRequestType {
+  return validRpcRequestTypes.includes(type as RpcRequestType)
+}
+
+export interface ParsedInviteCode extends Record<string, JSONValue> {
+  federation_id: string
+  url: string
+}
+
+export interface PreviewFederation extends Record<string, JSONValue> {
+  config: string
+  federation_id: string
+}
+
+export interface ParsedBolt11Invoice extends Record<string, JSONValue> {
+  amount: number // in satoshis
+  expiry: number
+  memo: string
+}