Pass in account head to wallet/createAccount (#5619)

Author: danield9tqh

ironfish/src/rpc/routes/wallet/create.test.ts

@@ -21,7 +21,7 @@ describe('Route wallet/create', () => {
   it('should create an account', async () => {
     await routeTest.node.wallet.createAccount('existingAccount', { setDefault: true })
     const createdAtHead = {
-      hash: routeTest.node.chain.head.hash,
+      hash: Buffer.alloc(32, 0),
       sequence: routeTest.node.chain.head.sequence,
     }
 

ironfish/src/rpc/routes/wallet/createAccount.test.ts

@@ -5,6 +5,7 @@
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
+import { blake3 } from '@napi-rs/blake-hash'
 import { v4 as uuid } from 'uuid'
 import { createRouteTest } from '../../../testUtilities/routeTest'
 import { RPC_ERROR_CODES } from '../../adapters'
@@ -20,7 +21,7 @@ describe('Route wallet/createAccount', () => {
   it('should create an account', async () => {
     await routeTest.node.wallet.createAccount('existingAccount', { setDefault: true })
     const createdAtHead = {
-      hash: routeTest.node.chain.head.hash,
+      hash: Buffer.alloc(32, 0),
       sequence: routeTest.node.chain.head.sequence,
     }
 
@@ -118,6 +119,9 @@ describe('Route wallet/createAccount', () => {
         sequence: 10,
       },
     })
+
+    const head = await account?.getHead()
+    expect(head).toBeNull()
   })
 
   it('should set account createdAt to null', async () => {
@@ -142,4 +146,37 @@ describe('Route wallet/createAccount', () => {
       createdAt: null,
     })
   })
+
+  it('should set account head if passed', async () => {
+    const name = uuid()
+
+    const response = await routeTest.client.wallet.createAccount({
+      name,
+      createdAt: null,
+      head: {
+        hash: blake3('test').toString('hex'),
+        sequence: 10,
+      },
+    })
+
+    expect(response.status).toBe(200)
+    expect(response.content).toMatchObject({
+      name: name,
+      publicAddress: expect.any(String),
+      isDefaultAccount: true,
+    })
+
+    const account = routeTest.node.wallet.getAccountByName(name)
+    expect(account).toMatchObject({
+      name: name,
+      publicAddress: response.content.publicAddress,
+      createdAt: null,
+    })
+
+    const head = await account?.getHead()
+    expect(head).toMatchObject({
+      hash: blake3('test'),
+      sequence: 10,
+    })
+  })
 })

ironfish/src/rpc/routes/wallet/createAccount.ts

@@ -22,6 +22,10 @@ export type CreateAccountRequest = {
   name: string
   default?: boolean
   createdAt?: number | null
+  head?: {
+    hash: string
+    sequence: number
+  }
 }
 
 export type CreateAccountResponse = {
@@ -35,6 +39,13 @@ export const CreateAccountRequestSchema: yup.ObjectSchema<CreateAccountRequest>
     name: yup.string().defined(),
     default: yup.boolean().optional(),
     createdAt: yup.number().optional().nullable(),
+    head: yup
+      .object({
+        hash: yup.string().defined(),
+        sequence: yup.number().defined(),
+      })
+      .optional()
+      .default(undefined),
   })
   .defined()
 
@@ -52,17 +63,17 @@ routes.register<typeof CreateAccountRequestSchema, CreateAccountResponse>(
   async (request, context): Promise<void> => {
     AssertHasRpcContext(request, context, 'wallet')
 
-    const createdAt =
-      typeof request.data.createdAt === 'number'
-        ? {
-            hash: Buffer.alloc(32, 0),
-            sequence: request.data.createdAt,
-          }
-        : request.data.createdAt
+    const head = request.data.head && {
+      hash: Buffer.from(request.data.head.hash, 'hex'),
+      sequence: request.data.head.sequence,
+    }
 
     let account
     try {
-      account = await context.wallet.createAccount(request.data.name, { createdAt })
+      account = await context.wallet.createAccount(request.data.name, {
+        createdAt: request.data.createdAt,
+        head,
+      })
     } catch (e) {
       if (e instanceof DuplicateAccountNameError) {
         throw new RpcValidationError(e.message, 400, RPC_ERROR_CODES.DUPLICATE_ACCOUNT_NAME)

ironfish/src/testUtilities/fixtures/account.ts

@@ -11,7 +11,7 @@ import { FixtureGenerate, useFixture } from './fixture'
 export function useAccountFixture(
   wallet: Wallet,
   generate: FixtureGenerate<SpendingAccount> | string = 'test',
-  options?: { createdAt?: HeadValue | null; setDefault?: boolean },
+  options?: Parameters<Wallet['createAccount']>[1],
 ): Promise<SpendingAccount> {
   if (typeof generate === 'string') {
     const name = generate
@@ -61,7 +61,7 @@ export async function useAccountAndAddFundsFixture(
   wallet: Wallet,
   chain: Blockchain,
   generate: FixtureGenerate<SpendingAccount> | string = 'test',
-  options?: { createdAt?: HeadValue | null; setDefault?: boolean },
+  options?: Parameters<Wallet['createAccount']>[1],
 ): Promise<SpendingAccount> {
   const account = await useAccountFixture(wallet, generate, options)
   const block = await useMinerBlockFixture(chain, undefined, account)

ironfish/src/wallet/wallet.ts

@@ -1355,7 +1355,7 @@ export class Wallet {
 
   async createAccount(
     name: string,
-    options: { createdAt?: HeadValue | null; setDefault?: boolean } = {
+    options: { setDefault?: boolean; createdAt?: number | null; head?: HeadValue | null } = {
       setDefault: false,
     },
   ): Promise<Account> {
@@ -1369,15 +1369,12 @@ export class Wallet {
 
     const key = generateKey()
 
-    let createdAt: HeadValue | null = null
-    if (options.createdAt !== undefined) {
-      createdAt = options.createdAt
-    } else if (this.nodeClient) {
-      try {
-        createdAt = await this.getChainHead()
-      } catch {
-        this.logger.warn('Failed to fetch chain head from node client')
-      }
+    const createdAt = await this.createdAtWithDefault(options.createdAt)
+    let accountHead: HeadValue | null
+    if (options.head === undefined) {
+      accountHead = createdAt && (await this.accountHeadAtSequence(createdAt.sequence))
+    } else {
+      accountHead = options.head
     }
 
     const account = new Account({
@@ -1413,7 +1410,7 @@ export class Wallet {
         await this.walletDb.setAccount(account, tx)
       }
 
-      await account.updateHead(createdAt, tx)
+      await account.updateHead(accountHead, tx)
     })
 
     this.accountById.set(account.id, account)
@@ -1425,6 +1422,52 @@ export class Wallet {
     return account
   }
 
+  /*
+   * Use createdAt if provided, otherwise use the current chain head
+   */
+  private async createdAtWithDefault(createdAt?: number | null): Promise<HeadValue | null> {
+    if (createdAt === null) {
+      return null
+    }
+
+    if (createdAt === undefined) {
+      try {
+        const sequence = (await this.getChainHead()).sequence
+        return {
+          sequence,
+          hash: Buffer.alloc(32, 0),
+        }
+      } catch {
+        this.logger.warn('Failed to fetch chain head from node client')
+        return null
+      }
+    }
+
+    return {
+      sequence: createdAt,
+      hash: Buffer.alloc(32, 0),
+    }
+  }
+
+  /*
+   * Try to get the block hash from the chain with createdAt sequence
+   * Otherwise, return null
+   */
+  private async accountHeadAtSequence(sequence: number): Promise<HeadValue | null> {
+    try {
+      const previousBlock = await this.chainGetBlock({ sequence })
+      return previousBlock
+        ? {
+            hash: Buffer.from(previousBlock.block.hash, 'hex'),
+            sequence: previousBlock.block.sequence,
+          }
+        : null
+    } catch {
+      this.logger.warn(`Failed to fetch block ${sequence} from node client`)
+      return null
+    }
+  }
+
   async skipRescan(account: Account, tx?: IDatabaseTransaction): Promise<void> {
     const { hash, sequence } = await this.getChainHead()
     await account.updateHead({ hash, sequence }, tx)
@@ -1544,20 +1587,10 @@ export class Wallet {
         }
       }
 
-      if (createdAt !== null) {
-        const previousBlock = await this.chainGetBlock({ sequence: createdAt.sequence - 1 })
+      const accountHead =
+        createdAt && (await this.accountHeadAtSequence(createdAt.sequence - 1))
 
-        const head = previousBlock
-          ? {
-              hash: Buffer.from(previousBlock.block.hash, 'hex'),
-              sequence: previousBlock.block.sequence,
-            }
-          : null
-
-        await account.updateHead(head, tx)
-      } else {
-        await account.updateHead(null, tx)
-      }
+      await account.updateHead(accountHead, tx)
     })
 
     this.accountById.set(account.id, account)