feat: mnemonic generation for spark connector

src/app/screens/connectors/ConnectSpark/index.tsx

@@ -6,6 +6,7 @@ import { useNavigate } from "react-router-dom";
 import toast from "~/app/components/Toast";
 import msg from "~/common/lib/msg";
 
+import api from "~/common/lib/api";
 import logo from "/static/assets/icons/albyhub.png";
 
 export default function ConnectSpark() {
@@ -22,10 +23,16 @@ export default function ConnectSpark() {
   async function handleSubmit(event: React.FormEvent<HTMLFormElement>) {
     event.preventDefault();
     setLoading(true);
+
+    const mnemonic = await api.generateMnemonic();
+    const encryptedMnemonic = await api.encryptMnemonic(mnemonic);
+
     const account = {
       name: "Spark",
       config: {},
       connector: getConnectorType(),
+      mnemonic: encryptedMnemonic,
+      useMnemonicForLnurlAuth: true,
     };
 
     try {

src/common/lib/api.ts

@@ -265,6 +265,11 @@ const setMnemonic = (id: string, mnemonic: string | null): Promise<void> =>
     mnemonic,
   });
 
+const encryptMnemonic = (mnemonic: string): Promise<string> =>
+  msg.request("encryptMnemonic", {
+    mnemonic,
+  });
+
 const getSwapInfo = (): Promise<SwapInfoResponse> => msg.request("getSwapInfo");
 const createSwap = (params: CreateSwapParams): Promise<CreateSwapResponse> =>
   msg.request("createSwap", params);
@@ -332,6 +337,7 @@ export default {
   getMnemonic,
   setMnemonic,
   generateMnemonic,
+  encryptMnemonic,
   getSwapInfo,
   createSwap,
   liquid: {

src/extension/background-script/actions/mnemonic/encryptMnemonic.ts

@@ -0,0 +1,20 @@
+import { encryptData } from "~/common/lib/crypto";
+import type { MessageMnemonicEncrypt } from "~/types";
+
+import state from "../../state";
+
+const encryptMnemonic = async (message: MessageMnemonicEncrypt) => {
+  const password = await state.getState().password();
+  if (!password) {
+    return {
+      error: "Password is missing.",
+    };
+  }
+  let mnemonic = message.args.mnemonic;
+  mnemonic = encryptData(mnemonic, password);
+  return {
+    data: mnemonic,
+  };
+};
+
+export default encryptMnemonic;

src/extension/background-script/actions/mnemonic/index.ts

@@ -1,5 +1,6 @@
+import encryptMnemonic from "./encryptMnemonic";
 import generateMnemonic from "./generateMnemonic";
 import getMnemonic from "./getMnemonic";
 import setMnemonic from "./setMnemonic";
 
-export { generateMnemonic, getMnemonic, setMnemonic };
+export { encryptMnemonic, generateMnemonic, getMnemonic, setMnemonic };

src/extension/background-script/connectors/spark.ts

@@ -5,6 +5,8 @@ import type {
   WalletTransfer,
 } from "@buildonspark/spark-sdk/dist/types";
 import { Invoice } from "@getalby/lightning-tools";
+import { decryptData } from "~/common/lib/crypto";
+import state from "~/extension/background-script/state";
 import { Account } from "~/types";
 import Connector, {
   CheckPaymentArgs,
@@ -29,6 +31,8 @@ interface Config {
 
 class SparkConnector implements Connector {
   private _wallet: SparkWallet | undefined;
+  private account: Account;
+  private config: Config;
 
   get supportedMethods() {
     return [
@@ -42,19 +46,27 @@ class SparkConnector implements Connector {
     ];
   }
 
-  constructor(_account: Account, _config: Config) {}
+  constructor(account: Account, config: Config) {
+    this.account = account;
+    this.config = config;
+  }
 
-  async init(mnemonic?: string) {
-    if (!mnemonic) {
+  async init() {
+    if (!this.account.mnemonic) {
       throw new Error("Account has no mnemonic set");
     }
 
     const SparkWallet = await import("@buildonspark/spark-sdk").then(
       (mod) => mod.SparkWallet
     );
+    const password = (await state.getState().password()) as string;
+    const decryptedMnemonic = await decryptData(
+      this.account.mnemonic,
+      password
+    );
 
     const { wallet } = await SparkWallet.initialize({
-      mnemonicOrSeed: mnemonic,
+      mnemonicOrSeed: decryptedMnemonic,
       options: {
         network: "MAINNET",
       },
@@ -257,7 +269,19 @@ class SparkConnector implements Connector {
   }
 
   async signMessage(args: SignMessageArgs): Promise<SignMessageResponse> {
-    throw new Error("Method not implemented.");
+    if (!this._wallet) {
+      throw new Error("Wallet not initialized");
+    }
+    const signature = await this._wallet.signMessageWithIdentityKey(
+      args.message
+    );
+
+    return {
+      data: {
+        message: args.message,
+        signature: signature,
+      },
+    };
   }
 
   connectPeer(args: ConnectPeerArgs): Promise<ConnectPeerResponse> {

src/extension/background-script/router.ts

@@ -66,6 +66,7 @@ const routes = {
   setMnemonic: mnemonic.setMnemonic,
   getMnemonic: mnemonic.getMnemonic,
   generateMnemonic: mnemonic.generateMnemonic,
+  encryptMnemonic: mnemonic.encryptMnemonic,
   getSwapInfo: swaps.info,
   createSwap: swaps.createSwap,
   liquid: {

src/extension/background-script/state.ts

@@ -128,12 +128,7 @@ const state = create<State>((set, get) => ({
       if (!password) throw new Error("Password is not set");
       const config = decryptData(account.config as string, password);
       const connector = new connectors[account.connector](account, config);
-      let mnemonic = "";
-      if (!account.mnemonic) {
-        throw new Error("Mnemonic is not set");
-      }
-      mnemonic = decryptData(account.mnemonic, password);
-      await connector.init(mnemonic);
+      await connector.init();
       return connector;
     })();
     set({ connector: connectorPromise });

src/types.ts

@@ -570,6 +570,13 @@ export interface MessageMnemonicGenerate extends MessageDefault {
   action: "generateMnemonic";
 }
 
+export interface MessageMnemonicEncrypt extends MessageDefault {
+  args: {
+    mnemonic: Account["mnemonic"];
+  };
+  action: "encryptMnemonic";
+}
+
 export interface MessageSignEvent extends MessageDefault {
   args: {
     event: Event;