feat(1280): Implementation of allow passing key to fresh created account (#1531)

Signed-off-by: matevszm <mateusz.marcinkowski@blockydevs.com>

Author: matevszm

src/__tests__/mocks/fixtures.ts

@@ -19,6 +19,10 @@ export const ED25519_HEX_PUBLIC_KEY =
   '99813fcbebfebca118fd96c08d15973ac60713bf3c129aebae6be2d626117336';
 export const ED25519_HEX_PUBLIC_KEY_WITH_0X = `0x${ED25519_HEX_PUBLIC_KEY}`;
 export const ECDSA_EVM_ADDRESS = '0x48dfcb856aab92c0152c1de06b3263e3be3bde2c';
+export const ACCOUNT_ID_EVM_ADDRESS_9999 =
+  '0x000000000000000000000000000000000000270f';
+export const ACCOUNT_ID_EVM_ADDRESS_8888 =
+  '0x00000000000000000000000000000000000022b8';
 export const MOCK_PUBLIC_KEY =
   '0000000000000000000000000000000000000000000000000000000000000000';
 

src/core/services/account/__tests__/unit/account-transaction-service.test.ts

@@ -12,7 +12,6 @@ import { ECDSA_HEX_PUBLIC_KEY } from '@/__tests__/mocks/fixtures';
 import { makeLogger } from '@/__tests__/mocks/mocks';
 import { ValidationError } from '@/core/errors';
 import { AccountServiceImpl } from '@/core/services/account/account-transaction-service';
-import { KeyAlgorithm } from '@/core/shared/constants';
 
 import {
   createMockAccountCreateTransaction,
@@ -59,11 +58,10 @@ describe('AccountServiceImpl', () => {
   });
 
   describe('createAccount', () => {
-    it('should create account with ECDSA key type', () => {
+    it('should create account with provided public key', () => {
       const params = {
         balanceRaw: 100_000_000n,
         publicKey: ECDSA_HEX_PUBLIC_KEY,
-        keyType: KeyAlgorithm.ECDSA,
       };
 
       const result = accountService.createAccount(params);
@@ -73,43 +71,13 @@ describe('AccountServiceImpl', () => {
       expect(mockTransaction.setInitialBalance).toHaveBeenCalledWith(
         mockHbarInstance,
       );
-      expect(mockTransaction.setECDSAKeyWithAlias).toHaveBeenCalledWith(
-        mockPublicKeyInstance,
-      );
-      expect(mockTransaction.setKeyWithoutAlias).not.toHaveBeenCalled();
-      expect(result.transaction).toBe(mockTransaction);
-      expect(result.publicKey).toBe(ECDSA_HEX_PUBLIC_KEY);
-    });
-
-    it('should create account with ED25519 key type', () => {
-      const params = {
-        balanceRaw: 50_000_000n,
-        publicKey: ECDSA_HEX_PUBLIC_KEY,
-        keyType: KeyAlgorithm.ED25519,
-      };
-
-      const result = accountService.createAccount(params);
-
       expect(mockTransaction.setKeyWithoutAlias).toHaveBeenCalledWith(
         mockPublicKeyInstance,
       );
-      expect(mockTransaction.setECDSAKeyWithAlias).not.toHaveBeenCalled();
       expect(result.transaction).toBe(mockTransaction);
       expect(result.publicKey).toBe(ECDSA_HEX_PUBLIC_KEY);
     });
 
-    it('should default to ECDSA when keyType is not specified', () => {
-      const params = {
-        balanceRaw: 100_000_000n,
-        publicKey: ECDSA_HEX_PUBLIC_KEY,
-      };
-
-      accountService.createAccount(params);
-
-      expect(mockTransaction.setECDSAKeyWithAlias).toHaveBeenCalled();
-      expect(mockTransaction.setKeyWithoutAlias).not.toHaveBeenCalled();
-    });
-
     it('should set max auto associations when specified', () => {
       const params = {
         balanceRaw: 100_000_000n,

src/core/services/account/account-transaction-service.interface.ts

@@ -1,5 +1,3 @@
-import type { KeyAlgorithm } from '@/core/shared/constants';
-
 /**
  * Interface for Account-related operations
  * All account services must implement this interface
@@ -26,7 +24,6 @@ export interface CreateAccountParams {
   balanceRaw: bigint;
   maxAutoAssociations?: number;
   publicKey: string;
-  keyType?: KeyAlgorithm;
 }
 
 // Import Hedera SDK types

src/core/services/account/account-transaction-service.ts

@@ -18,7 +18,6 @@ import {
 } from '@hashgraph/sdk';
 
 import { ValidationError } from '@/core/errors';
-import { KeyAlgorithm } from '@/core/shared/constants';
 
 export class AccountServiceImpl implements AccountService {
   private logger: Logger;
@@ -42,12 +41,7 @@ export class AccountServiceImpl implements AccountService {
         balance || 0,
       );
 
-      const keyType = params.keyType || KeyAlgorithm.ECDSA;
-      if (keyType === KeyAlgorithm.ECDSA) {
-        transaction.setECDSAKeyWithAlias(publicKey);
-      } else {
-        transaction.setKeyWithoutAlias(publicKey);
-      }
+      transaction.setKeyWithoutAlias(publicKey);
 
       if (params.maxAutoAssociations && params.maxAutoAssociations > 0) {
         transaction.setMaxAutomaticTokenAssociations(

src/plugins/account/__tests__/unit/create.test.ts

@@ -1,11 +1,14 @@
 import type { CoreApi } from '@/core/core-api/core-api.interface';
+import type { KeyResolverService } from '@/core/services/key-resolver/key-resolver-service.interface';
 import type { HederaMirrornodeService } from '@/core/services/mirrornode/hedera-mirrornode-service.interface';
 import type { TransactionResult } from '@/core/services/tx-execution/tx-execution-service.interface';
 
 import '@/core/utils/json-serialize';
 
 import {
-  ECDSA_EVM_ADDRESS,
+  ACCOUNT_ID_EVM_ADDRESS_8888,
+  ACCOUNT_ID_EVM_ADDRESS_9999,
+  ECDSA_HEX_PRIVATE_KEY,
   ECDSA_HEX_PUBLIC_KEY,
   ED25519_HEX_PUBLIC_KEY,
 } from '@/__tests__/mocks/fixtures';
@@ -77,7 +80,6 @@ describe('account plugin - create command (ADR-003)', () => {
       balanceRaw: 500000000000n,
       maxAutoAssociations: 3,
       publicKey: 'pub-key-test',
-      keyType: KeyAlgorithm.ECDSA,
     });
     expect(signing.signAndExecute).toHaveBeenCalled();
     expect(alias.register).toHaveBeenCalledWith(
@@ -98,7 +100,7 @@ describe('account plugin - create command (ADR-003)', () => {
         type: KeyAlgorithm.ECDSA,
         network: 'testnet',
         keyRefId: 'kr_test123',
-        evmAddress: ECDSA_EVM_ADDRESS,
+        evmAddress: ACCOUNT_ID_EVM_ADDRESS_9999,
       }),
     );
 
@@ -109,7 +111,7 @@ describe('account plugin - create command (ADR-003)', () => {
     expect(output.type).toBe(KeyAlgorithm.ECDSA);
     expect(output.network).toBe('testnet');
     expect(output.transactionId).toBe('0.0.1234@1234567890.000000000');
-    expect(output.evmAddress).toBe(ECDSA_EVM_ADDRESS);
+    expect(output.evmAddress).toBe(ACCOUNT_ID_EVM_ADDRESS_9999);
     expect(output.publicKey).toBe(ECDSA_HEX_PUBLIC_KEY);
   });
 
@@ -218,16 +220,171 @@ describe('account plugin - create command (ADR-003)', () => {
     );
     expect(account.createAccount).toHaveBeenCalledWith(
       expect.objectContaining({
-        keyType: KeyAlgorithm.ECDSA,
+        publicKey: 'pub-key-test',
       }),
     );
 
     const output = assertOutput(result.result, CreateAccountOutputSchema);
     expect(output.type).toBe(KeyAlgorithm.ECDSA);
-    expect(output.evmAddress).toBe(ECDSA_EVM_ADDRESS);
+    expect(output.evmAddress).toBe(ACCOUNT_ID_EVM_ADDRESS_8888);
     expect(output.publicKey).toBe(ECDSA_HEX_PUBLIC_KEY);
   });
 
+  test('creates account with provided private key (--key ecdsa:private:xxx)', async () => {
+    const logger = makeLogger();
+    const saveAccountMock = jest.fn();
+    MockedHelper.mockImplementation(() => ({ saveAccount: saveAccountMock }));
+
+    const { account, signing, networkMock, kms, alias, mirror, keyResolver } =
+      makeApiMocksForAccountCreate({
+        createAccountImpl: jest.fn().mockReturnValue({
+          transaction: {},
+          publicKey: ECDSA_HEX_PUBLIC_KEY,
+        }),
+        signAndExecuteImpl: jest.fn().mockResolvedValue({
+          transactionId: '0.0.1234@1234567890.000000004',
+          success: true,
+          accountId: '0.0.6666',
+          receipt: { status: { status: 'success' } },
+        }),
+        keyResolverGetPublicKeyImpl: jest.fn().mockResolvedValue({
+          keyRefId: 'kr_provided123',
+          publicKey: ECDSA_HEX_PUBLIC_KEY,
+        }),
+      });
+
+    kms.get = jest.fn().mockReturnValue({
+      keyRefId: 'kr_provided123',
+      publicKey: ECDSA_HEX_PUBLIC_KEY,
+      keyAlgorithm: KeyAlgorithm.ECDSA,
+      keyManager: 'local',
+      labels: [],
+      createdAt: '',
+      updatedAt: '',
+    });
+
+    const api: Partial<CoreApi> = {
+      account,
+      txExecution: signing,
+      network: networkMock,
+      kms,
+      alias,
+      mirror: mirror as HederaMirrornodeService,
+      keyResolver: keyResolver as KeyResolverService,
+      logger,
+    };
+
+    const args = makeArgs(api, logger, {
+      balance: '1000',
+      key: `ecdsa:private:${ECDSA_HEX_PRIVATE_KEY}`,
+    });
+
+    const result = await createAccount(args);
+
+    expect(kms.createLocalPrivateKey).not.toHaveBeenCalled();
+    expect(keyResolver.getPublicKey).toHaveBeenCalled();
+    expect(account.createAccount).toHaveBeenCalledWith(
+      expect.objectContaining({
+        publicKey: ECDSA_HEX_PUBLIC_KEY,
+      }),
+    );
+
+    const output = assertOutput(result.result, CreateAccountOutputSchema);
+    expect(output.accountId).toBe('0.0.6666');
+    expect(output.type).toBe(KeyAlgorithm.ECDSA);
+    expect(output.publicKey).toBe(ECDSA_HEX_PUBLIC_KEY);
+  });
+
+  test('creates account with key reference (--key kr_xxx)', async () => {
+    const logger = makeLogger();
+    const saveAccountMock = jest.fn();
+    MockedHelper.mockImplementation(() => ({ saveAccount: saveAccountMock }));
+
+    const { account, signing, networkMock, kms, alias, mirror, keyResolver } =
+      makeApiMocksForAccountCreate({
+        createAccountImpl: jest.fn().mockReturnValue({
+          transaction: {},
+          publicKey: ECDSA_HEX_PUBLIC_KEY,
+        }),
+        signAndExecuteImpl: jest.fn().mockResolvedValue({
+          transactionId: '0.0.1234@1234567890.000000005',
+          success: true,
+          accountId: '0.0.5555',
+          receipt: { status: { status: 'success' } },
+        }),
+        keyResolverGetPublicKeyImpl: jest.fn().mockResolvedValue({
+          keyRefId: 'kr_test123',
+          publicKey: ECDSA_HEX_PUBLIC_KEY,
+        }),
+      });
+
+    kms.get = jest.fn().mockReturnValue({
+      keyRefId: 'kr_test123',
+      publicKey: ECDSA_HEX_PUBLIC_KEY,
+      keyAlgorithm: KeyAlgorithm.ECDSA,
+      keyManager: 'local',
+      labels: [],
+      createdAt: '',
+      updatedAt: '',
+    });
+
+    const api: Partial<CoreApi> = {
+      account,
+      txExecution: signing,
+      network: networkMock,
+      kms,
+      alias,
+      mirror: mirror as HederaMirrornodeService,
+      keyResolver: keyResolver as KeyResolverService,
+      logger,
+    };
+
+    const args = makeArgs(api, logger, {
+      balance: '1000',
+      key: 'kr_test123',
+    });
+
+    const result = await createAccount(args);
+
+    expect(kms.createLocalPrivateKey).not.toHaveBeenCalled();
+    expect(keyResolver.getPublicKey).toHaveBeenCalled();
+    expect(account.createAccount).toHaveBeenCalledWith(
+      expect.objectContaining({
+        publicKey: ECDSA_HEX_PUBLIC_KEY,
+      }),
+    );
+
+    const output = assertOutput(result.result, CreateAccountOutputSchema);
+    expect(output.accountId).toBe('0.0.5555');
+  });
+
+  test('throws ValidationError when both --key and --key-type are provided', async () => {
+    const logger = makeLogger();
+    MockedHelper.mockImplementation(() => ({ saveAccount: jest.fn() }));
+
+    const { account, signing, networkMock, kms, alias, mirror, keyResolver } =
+      makeApiMocksForAccountCreate({});
+
+    const api: Partial<CoreApi> = {
+      account,
+      txExecution: signing,
+      network: networkMock,
+      kms,
+      alias,
+      mirror: mirror as HederaMirrornodeService,
+      keyResolver: keyResolver as KeyResolverService,
+      logger,
+    };
+
+    const args = makeArgs(api, logger, {
+      balance: '1000',
+      key: `ecdsa:private:${ECDSA_HEX_PRIVATE_KEY}`,
+      keyType: KeyAlgorithm.ECDSA,
+    });
+
+    await expect(createAccount(args)).rejects.toThrow();
+  });
+
   test('creates account with ED25519 key type', async () => {
     const logger = makeLogger();
     const saveAccountMock = jest.fn();
@@ -272,7 +429,7 @@ describe('account plugin - create command (ADR-003)', () => {
     );
     expect(account.createAccount).toHaveBeenCalledWith(
       expect.objectContaining({
-        keyType: KeyAlgorithm.ED25519,
+        publicKey: 'pub-key-test',
       }),
     );
 

src/plugins/account/__tests__/unit/helpers/mocks.ts

@@ -239,6 +239,7 @@ export interface ApiMocksConfig {
   signAndExecuteImpl?: jest.Mock;
   network?: 'testnet' | 'mainnet' | 'previewnet';
   operatorBalance?: bigint;
+  keyResolverGetPublicKeyImpl?: jest.Mock;
 }
 
 /**
@@ -254,6 +255,7 @@ export const makeApiMocksForAccountCreate = ({
   signAndExecuteImpl,
   network = 'testnet',
   operatorBalance = OPERATOR_SUFFICIENT_BALANCE,
+  keyResolverGetPublicKeyImpl,
 }: ApiMocksConfig) => {
   const account: jest.Mocked<AccountService> = {
     createAccount: createAccountImpl || jest.fn(),
@@ -284,5 +286,18 @@ export const makeApiMocksForAccountCreate = ({
 
   const alias = makeGlobalAliasMock();
 
-  return { account, signing, networkMock, kms, alias, mirror };
+  const keyResolver = {
+    getPublicKey:
+      keyResolverGetPublicKeyImpl ??
+      jest.fn().mockResolvedValue({
+        keyRefId: 'kr_provided123',
+        publicKey: 'provided-pub-key',
+      }),
+    resolveAccountCredentials: jest.fn(),
+    resolveAccountCredentialsWithFallback: jest.fn(),
+    resolveDestination: jest.fn(),
+    resolveSigningKey: jest.fn(),
+  };
+
+  return { account, signing, networkMock, kms, alias, mirror, keyResolver };
 };