Set account head when creating a new wallet (#291)

Author: danield9tqh

main/api/accounts/handleCreateAccount.ts

@@ -1,13 +1,19 @@
-import { AccountFormat } from "@ironfish/sdk";
+import { AccountFormat, CreateAccountRequest } from "@ironfish/sdk";
 
 import { manager } from "../manager";
 
-export async function handleCreateAccount({ name }: { name: string }) {
+export async function handleCreateAccount({
+  name,
+  createdAt,
+  head,
+}: CreateAccountRequest) {
   const ironfish = await manager.getIronfish();
   const rpcClient = await ironfish.rpcClient();
 
   const createResponse = await rpcClient.wallet.createAccount({
     name,
+    createdAt,
+    head,
   });
 
   const exportResponse = await rpcClient.wallet.exportAccount({

main/api/accounts/index.ts

@@ -39,11 +39,21 @@ export const accountRouter = t.router({
     .input(
       z.object({
         name: z.string(),
+        createdAt: z.number().optional(),
+        head: z
+          .object({
+            sequence: z.number(),
+            hash: z.string(),
+          })
+          .optional(),
       }),
     )
     .mutation(async (opts) => {
       return handleCreateAccount(opts.input);
     }),
+  getExternalChainHead: t.procedure.query(async () =>
+    manager.getExternalChainHead(),
+  ),
   importAccount: t.procedure
     .input(handleImportAccountInputs)
     .mutation(async (opts) => {

main/api/accounts/utils/getExternalChainHead.ts

@@ -0,0 +1,114 @@
+import { GENESIS_BLOCK_SEQUENCE } from "@ironfish/sdk";
+import axios from "axios";
+
+const MAINNET_API_URL = `https://api.ironfish.network`;
+const TESTNET_API_URL = `https://testnet.api.ironfish.network`;
+const CONFIRMATION_BLOCKS = 20;
+
+type Block = { sequence: number; hash: string };
+
+// Try to get a head sequence to use for new account createdAt fields if the chain is not yet synced
+export async function getExternalChainHead(
+  networkId: number,
+): Promise<Block | undefined> {
+  const fromAPI = await getChainHeadWithConfirmation(networkId).catch(
+    () => undefined,
+  );
+
+  return fromAPI || getDefaultHead(networkId);
+}
+
+async function getChainHeadWithConfirmation(
+  networkId: number,
+): Promise<Block | undefined> {
+  const headFromAPI = await getChainHeadFromAPI(networkId).catch(
+    () => undefined,
+  );
+  if (!headFromAPI) {
+    return undefined;
+  }
+
+  const sequence = Math.max(
+    GENESIS_BLOCK_SEQUENCE,
+    headFromAPI.sequence - CONFIRMATION_BLOCKS,
+  );
+  return getBlockFromAPI(networkId, sequence).catch(() => undefined);
+}
+
+// Local block sequences in case network is unreachable
+function getDefaultHead(networkId: number): Block | undefined {
+  switch (networkId) {
+    case 0:
+      return {
+        sequence: 740000,
+        hash: "00000419de21cb51eeea7b002c89e630f0b326525e99a6595b4c87442fd7bfa5",
+      };
+    case 1:
+      return {
+        sequence: 806900,
+        hash: "0000000000016a6993058e7459fff9f1413f14c09483612d511e5e86894803b7",
+      };
+    default:
+      return undefined;
+  }
+}
+
+async function getChainHeadFromAPI(networkId: number): Promise<Block> {
+  const apiURL = getAPIUrl(networkId);
+  if (!apiURL) {
+    throw new Error(
+      `Manifest url for the snapshots are not available for network ID ${networkId}`,
+    );
+  }
+
+  const headBlock = (
+    await axios.get<{ sequence: number; hash: string }>(
+      `${apiURL}/blocks/head`,
+      {
+        timeout: 5000,
+      },
+    )
+  ).data;
+
+  return {
+    sequence: headBlock.sequence,
+    hash: headBlock.hash,
+  };
+}
+
+async function getBlockFromAPI(
+  networkId: number,
+  sequence: number,
+): Promise<Block | undefined> {
+  const apiURL = getAPIUrl(networkId);
+  if (!apiURL) {
+    throw new Error(
+      `Manifest url for the snapshots are not available for network ID ${networkId}`,
+    );
+  }
+
+  const head = (
+    await axios.get<{ sequence: number; hash: string }>(
+      `${apiURL}/blocks/find?sequence=${sequence}&with_transactions=false`,
+      {
+        timeout: 5000,
+      },
+    )
+  ).data;
+
+  return {
+    sequence: head.sequence,
+    hash: head.hash,
+  };
+}
+
+const getAPIUrl = (networkId: number): string | null => {
+  switch (networkId) {
+    case 0:
+      return TESTNET_API_URL;
+    case 1:
+      return MAINNET_API_URL;
+    default:
+      return null;
+  }
+};

main/api/manager.ts

@@ -1,5 +1,6 @@
 import { RpcClient } from "@ironfish/sdk";
 
+import { getExternalChainHead } from "./accounts/utils/getExternalChainHead";
 import { Ironfish } from "./ironfish/Ironfish";
 import { userSettingsStore } from "../stores/userSettingsStore";
 
@@ -11,6 +12,7 @@ export type InitialState =
 
 export class Manager {
   private _ironfish: Ironfish | null = null;
+  private _externalChainHead?: { sequence: number; hash: string };
 
   async getIronfish(): Promise<Ironfish> {
     if (this._ironfish) return this._ironfish;
@@ -23,6 +25,13 @@ export class Manager {
     return this._ironfish;
   }
 
+  async getExternalChainHead(): Promise<
+    { sequence: number; hash: string } | undefined
+  > {
+    const networkId = await userSettingsStore.getSetting("networkId");
+    return getExternalChainHead(networkId);
+  }
+
   async shouldDownloadSnapshot(): Promise<boolean> {
     const ironfish = await this.getIronfish();
     const rpcClient = await ironfish.rpcClient();

package-lock.json

@@ -22,7 +22,7 @@
   },
   "license": "MPL-2.0",
   "dependencies": {
-    "@ironfish/sdk": "2.8.1",
+    "@ironfish/sdk": "2.9.0",
     "@ironfish/rust-nodejs": "2.7.0",
     "@ledgerhq/errors": "6.19.1",
     "@ledgerhq/hw-transport-node-hid": "6.29.5",