Adds Create Account flow; Snapshot Download updates

main/api/accounts/handleCreateAccount.ts

@@ -0,0 +1,30 @@
+import { AccountFormat } from "@ironfish/sdk";
+
+import { manager } from "../manager";
+
+export async function handleCreateAccount({ name }: { name: string }) {
+  const ironfish = await manager.getIronfish();
+  const rpcClient = await ironfish.rpcClient();
+
+  const createResponse = await rpcClient.wallet.createAccount({
+    name,
+  });
+
+  const exportResponse = await rpcClient.wallet.exportAccount({
+    account: createResponse.content.name,
+    viewOnly: false,
+    format: AccountFormat.Mnemonic,
+  });
+
+  const mnemonic = exportResponse.content.account?.toString();
+
+  if (!mnemonic) {
+    throw new Error("Failed to get mnemonic phrase");
+  }
+
+  return {
+    name: createResponse.content.name,
+    publicAddress: createResponse.content.publicAddress,
+    mnemonic,
+  };
+}

main/api/accounts/handleExportAccount.ts

@@ -0,0 +1,29 @@
+import { AccountFormat } from "@ironfish/sdk";
+import * as z from "zod";
+
+import { manager } from "../manager";
+
+export const handleExportAccountInputs = z.object({
+  name: z.string(),
+  format: z.custom<`${AccountFormat}`>((format) => {
+    return typeof format === "string" && format in AccountFormat;
+  }),
+  viewOnly: z.boolean().optional(),
+});
+
+export async function handleExportAccount({
+  name,
+  format,
+  viewOnly = false,
+}: z.infer<typeof handleExportAccountInputs>) {
+  const ironfish = await manager.getIronfish();
+  const rpcClient = await ironfish.rpcClient();
+
+  const exportResponse = await rpcClient.wallet.exportAccount({
+    account: name,
+    format: AccountFormat[format],
+    viewOnly,
+  });
+
+  return exportResponse.content;
+}

main/api/accounts/handleRenameAccount.ts

@@ -0,0 +1,23 @@
+import * as z from "zod";
+
+import { manager } from "../manager";
+
+export const handleRenameAccountInputs = z.object({
+  account: z.string(),
+  newName: z.string(),
+});
+
+export async function handleRenameAccount({
+  account,
+  newName,
+}: z.infer<typeof handleRenameAccountInputs>) {
+  const ironfish = await manager.getIronfish();
+  const rpcClient = await ironfish.rpcClient();
+
+  const renameResponse = await rpcClient.wallet.renameAccount({
+    account,
+    newName,
+  });
+
+  return renameResponse.content;
+}

main/api/accounts/index.ts

@@ -1,7 +1,16 @@
 import { z } from "zod";
 
+import { handleCreateAccount } from "./handleCreateAccount";
+import {
+  handleExportAccount,
+  handleExportAccountInputs,
+} from "./handleExportAccount";
 import { handleGetAccount } from "./handleGetAccount";
 import { handleGetAccounts } from "./handleGetAccounts";
+import {
+  handleRenameAccountInputs,
+  handleRenameAccount,
+} from "./handleRenameAccount";
 import { manager } from "../manager";
 import { t } from "../trpc";
 
@@ -16,6 +25,25 @@ export const accountRouter = t.router({
       return handleGetAccount(opts.input);
     }),
   getAccounts: t.procedure.query(handleGetAccounts),
+  createAccount: t.procedure
+    .input(
+      z.object({
+        name: z.string(),
+      }),
+    )
+    .mutation(async (opts) => {
+      return handleCreateAccount(opts.input);
+    }),
+  exportAccount: t.procedure
+    .input(handleExportAccountInputs)
+    .query(async (opts) => {
+      return handleExportAccount(opts.input);
+    }),
+  renameAccount: t.procedure
+    .input(handleRenameAccountInputs)
+    .mutation(async (opts) => {
+      return handleRenameAccount(opts.input);
+    }),
   isValidPublicAddress: t.procedure
     .input(
       z.object({

main/api/ironfish/Ironfish.ts

@@ -1,6 +1,7 @@
 import { BoxKeyPair } from "@ironfish/rust-nodejs";
 import {
   ALL_API_NAMESPACES,
+  FullNode,
   IronfishSdk,
   NodeUtils,
   RpcClient,
@@ -9,10 +10,10 @@ import {
 } from "@ironfish/sdk";
 import { v4 as uuid } from "uuid";
 
+import { logger } from "./logger";
 import packageJson from "../../../package.json";
 import { SnapshotManager } from "../snapshot/snapshotManager";
 import { SplitPromise, splitPromise } from "../utils";
-import { logger } from "./logger";
 
 function getPrivateIdentity(sdk: IronfishSdk) {
   const networkIdentity = sdk.internal.get("networkIdentity");
@@ -30,6 +31,7 @@ export class Ironfish {
 
   private rpcClientPromise: SplitPromise<RpcClient> = splitPromise();
   private sdkPromise: SplitPromise<IronfishSdk> = splitPromise();
+  private fullNodePromise: SplitPromise<FullNode> = splitPromise();
   private _started: boolean = false;
   private _initialized: boolean = false;
   private _dataDir: string;
@@ -46,19 +48,25 @@ export class Ironfish {
     return this.sdkPromise.promise;
   }
 
+  fullNode(): Promise<FullNode> {
+    return this.fullNodePromise.promise;
+  }
+
   async downloadSnapshot(): Promise<void> {
     if (this._started) {
       throw new Error("Cannot download snapshot after node has started");
     }
 
     const sdk = await this.sdk();
-    await this.snapshotManager.run(sdk);
+    const node = await this.fullNode();
+    await this.snapshotManager.run(sdk, node);
   }
 
   async init() {
     if (this._initialized) {
       return;
     }
+
     this._initialized = true;
 
     console.log("Initializing IronFish SDK...");
@@ -69,22 +77,6 @@ export class Ironfish {
       pkg: getPackageFrom(packageJson),
     });
 
-    this.sdkPromise.resolve(sdk);
-  }
-
-  async start() {
-    if (this._started) {
-      return;
-    }
-    this._started = true;
-
-    if (this.snapshotManager.started) {
-      await this.snapshotManager.result();
-    }
-
-    console.log("Starting IronFish Node...");
-
-    const sdk = await this.sdk();
     const node = await sdk.node({
       privateIdentity: getPrivateIdentity(sdk),
       autoSeed: true,
@@ -104,13 +96,26 @@ export class Ironfish {
       await node.internal.save();
     }
 
-    await node.start();
-
     const rpcClient = new RpcMemoryClient(
       node.logger,
       node.rpc.getRouter(ALL_API_NAMESPACES),
     );
 
+    this.sdkPromise.resolve(sdk);
+    this.fullNodePromise.resolve(node);
     this.rpcClientPromise.resolve(rpcClient);
   }
+
+  async start() {
+    if (this._started) {
+      return;
+    }
+
+    console.log("Starting FullNode...");
+
+    this._started = true;
+
+    const node = await this.fullNode();
+    await node.start();
+  }
 }

main/api/ironfish/index.ts

@@ -19,6 +19,6 @@ export const ironfishRouter = t.router({
   }),
   startNode: t.procedure.mutation(async () => {
     const ironfish = await manager.getIronfish();
-    ironfish.start();
+    await ironfish.start();
   }),
 });

main/api/manager.ts

@@ -6,7 +6,7 @@ import {
 } from "./user-settings/userSettings";
 
 export type InitialState =
-  | "create-account"
+  | "onboarding"
   | "snapshot-download-prompt"
   | "start-node";
 
@@ -36,15 +36,24 @@ export class Manager {
     if (this._initialState) return this._initialState;
 
     const ironfish = await this.getIronfish();
-    const sdk = await ironfish.sdk();
+    const rpcClient = await ironfish.rpcClient();
 
-    if (sdk.internal.get("isFirstRun")) {
-      this._initialState = "snapshot-download-prompt";
-    } else {
-      this._initialState = "start-node";
+    const accountsResponse = await rpcClient.wallet.getAccounts();
+
+    if (accountsResponse.content.accounts.length === 0) {
+      return "onboarding";
+    }
+
+    const statusResponse = await rpcClient.node.getStatus();
+    const headTimestamp = statusResponse.content.blockchain.headTimestamp;
+    const hoursSinceLastBlock = (Date.now() - headTimestamp) / 1000 / 60 / 60;
+
+    // If the last block was more than 2 weeks ago, prompt the user to download a snapshot
+    if (hoursSinceLastBlock > 24 * 7 * 2) {
+      return "snapshot-download-prompt";
     }
 
-    return this._initialState;
+    return "start-node";
   }
 }
 

main/api/snapshot/snapshotManager.ts

@@ -1,6 +1,6 @@
 import fsAsync from "fs/promises";
 
-import { Event, IronfishSdk, Meter, NodeUtils } from "@ironfish/sdk";
+import { Event, FullNode, IronfishSdk, Meter } from "@ironfish/sdk";
 import log from "electron-log";
 
 import {
@@ -16,15 +16,15 @@ export class SnapshotManager {
   snapshotPromise: SplitPromise<void> = splitPromise();
   started = false;
 
-  async run(sdk: IronfishSdk): Promise<void> {
+  async run(sdk: IronfishSdk, node: FullNode): Promise<void> {
     if (this.started) {
       return;
     }
 
     this.started = true;
 
     try {
-      await this._run(sdk);
+      await this._run(sdk, node);
       this.snapshotPromise.resolve();
     } catch (e) {
       this.snapshotPromise.reject(e);
@@ -35,9 +35,7 @@ export class SnapshotManager {
     return this.snapshotPromise.promise;
   }
 
-  async _run(sdk: IronfishSdk): Promise<void> {
-    const node = await sdk.node();
-    await NodeUtils.waitForOpen(node);
+  async _run(sdk: IronfishSdk, node: FullNode): Promise<void> {
     const nodeChainDBVersion = await node.chain.blockchainDb.getVersion();
     await node.closeDB();
 
@@ -112,5 +110,6 @@ export class SnapshotManager {
 
     await downloadedSnapshot.replaceDatabase();
     await fsAsync.rm(downloadedSnapshot.file);
+    await node.openDB();
   }
 }

package.json

@@ -70,8 +70,9 @@
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "react-hook-form": "^7.47.0",
+    "react-icons": "^4.11.0",
     "type-fest": "^4.6.0",
-    "typescript": "^4.9.5",
+    "typescript": "^5.2.2",
     "usehooks-ts": "^2.9.1",
     "zod": "^3.22.3"
   },