test: coin-support-utils createAccount

packages/coin-support-utils/package.json

@@ -9,13 +9,14 @@
   "scripts": {
     "lint": "eslint --ext .ts,tsx,js,jsx src/ --fix",
     "lint:check": "eslint --ext .ts,tsx,js,jsx src/",
-    "pretty": "prettier --write \"src/**/*.ts?(x)\"",
-    "pretty:check": "prettier --check \"src/**/*.ts?(x)\"",
+    "pretty": "prettier --write \"src/**/*.ts?(x)\" \"tests/**/*.ts?(x)\"",
+    "pretty:check": "prettier --check \"src/**/*.ts?(x)\" \"tests/**/*.ts?(x)\"",
     "build": "rimraf dist && pnpm build:esm && pnpm build:cjs",
     "build:cjs": "tsc -p tsconfig_cjs.json",
     "build:esm": "tsc -p tsconfig.json",
     "build:dirty": "pnpm build:esm",
-    "pre-commit": "lint-staged"
+    "pre-commit": "lint-staged",
+    "test": "jest"
   },
   "devDependencies": {
     "@cypherock/eslint-config": "workspace:^",

packages/coin-support-utils/src/createAccount/createAccount.ts

@@ -77,16 +77,15 @@ export function makeCreateAccountsObservable<
           assetId: params.coinId,
         });
 
-        const derivationPathsPerScheme = await generateDerivationPathsPerScheme(
-          {
-            ...params,
-            limit: params.derivationPathLimit,
-            existingAccounts,
-          },
-        );
-        if (finished) return;
+        const derivationPathsPerScheme = generateDerivationPathsPerScheme({
+          ...params,
+          limit: params.derivationPathLimit,
+          existingAccounts,
+        });
 
         app = await params.createApp(params.connection);
+        if (finished) return;
+
         const addressesPerScheme = await generateAddressesPerScheme({
           ...params,
           app,

packages/coin-support-utils/src/createAccount/generateAddresses.ts

@@ -30,7 +30,7 @@ export interface IGenerateAddressesPerSchemeParams<T>
 export async function generateAddressesPerScheme<T>(
   params: IGenerateAddressesPerSchemeParams<T>,
 ) {
-  const { derivationPathsPerScheme } = params;
+  const { derivationPathsPerScheme, getAddressesFromDevice } = params;
   const allDerivationPaths = Object.values(derivationPathsPerScheme).reduce(
     (a, b) => [...a, ...b],
     [],
@@ -40,7 +40,7 @@ export async function generateAddressesPerScheme<T>(
     index: startIndex,
   }));
 
-  const addresses = await params.getAddressesFromDevice({
+  const addresses = await getAddressesFromDevice({
     ...params,
     derivationPaths: mappedDerivationPaths,
   });

packages/coin-support-utils/src/createAccount/schemes.ts

@@ -1,5 +1,4 @@
 import {
-  ICreateAccountParams,
   IDerivationPathGenerator,
   IDerivationScheme,
 } from '@cypherock/coin-support-interfaces';
@@ -31,25 +30,25 @@ export const createDerivationPathGenerator =
     return derivationPaths;
   };
 
-export interface IGenerateDerivationPathsPerSchemeParams
-  extends ICreateAccountParams {
+export interface IGenerateDerivationPathsPerSchemeParams {
   derivationPathSchemes: Record<string, IDerivationScheme | undefined>;
   limit: number;
   existingAccounts: IAccount[];
 }
 
-export const generateDerivationPathsPerScheme = async (
+export const generateDerivationPathsPerScheme = (
   params: IGenerateDerivationPathsPerSchemeParams,
 ) => {
   const { derivationPathSchemes, limit, existingAccounts } = params;
 
   const existingDerivationPaths = existingAccounts.map(e => e.derivationPath);
 
-  const derivationSchemeNames = Object.keys(derivationPathSchemes).filter(
-    n => !!derivationPathSchemes[n],
-  );
+  const derivationSchemes = Object.entries(derivationPathSchemes).filter(
+    ([, value]) => value !== undefined,
+  ) as [string, IDerivationScheme][];
+
   const pathLimitPerDerivationScheme = Math.floor(
-    limit / derivationSchemeNames.length,
+    limit / derivationSchemes.length,
   );
 
   const derivedPathsPerScheme: Record<
@@ -58,10 +57,7 @@ export const generateDerivationPathsPerScheme = async (
   > = {};
   const derivedPaths: string[] = [];
 
-  for (const schemeName of derivationSchemeNames) {
-    const derivationPathSchemeDetails = derivationPathSchemes[schemeName];
-    if (!derivationPathSchemeDetails) continue;
-
+  for (const [schemeName, derivationPathSchemeDetails] of derivationSchemes) {
     const paths = derivationPathSchemeDetails.generator(
       // This is done because there can be overlapping derivation paths
       // between different schemes

packages/coin-support-utils/tests/01.common/01.mapDerivationPath/__fixtures__/index.ts

@@ -0,0 +1,6 @@
+import { IFixtures } from './types';
+import { valid } from './valid';
+
+export const fixtures: IFixtures = {
+  valid,
+};

packages/coin-support-utils/tests/01.common/01.mapDerivationPath/__fixtures__/types.ts

@@ -0,0 +1,9 @@
+export interface MapDerivationPathTestCases {
+  name: string;
+  input: string;
+  output: number[];
+}
+
+export interface IFixtures {
+  valid: MapDerivationPathTestCases[];
+}

packages/coin-support-utils/tests/01.common/01.mapDerivationPath/__fixtures__/valid.ts

@@ -0,0 +1,19 @@
+import { MapDerivationPathTestCases } from './types';
+
+export const valid: MapDerivationPathTestCases[] = [
+  {
+    name: 'should map derivation path with single index',
+    input: "m/44'",
+    output: [0x80000000 + 44],
+  },
+  {
+    name: 'should map derivation path with multiple index',
+    input: "m/44'/0'/0'/0/0",
+    output: [2147483692, 2147483648, 2147483648, 0, 0],
+  },
+  {
+    name: 'should map derivation path with multiple index without m prefix',
+    input: "44'/0'/0'/0/0",
+    output: [2147483692, 2147483648, 2147483648, 0, 0],
+  },
+];

packages/coin-support-utils/tests/01.common/01.mapDerivationPath/index.ts

@@ -0,0 +1,12 @@
+import { describe, test } from '@jest/globals';
+import { fixtures } from './__fixtures__';
+import { mapDerivationPath } from '../../../src';
+
+describe('01. mapDerivationPath', () => {
+  fixtures.valid.forEach(({ name, input, output }) => {
+    test(name, () => {
+      const result = mapDerivationPath(input);
+      expect(result).toStrictEqual(output);
+    });
+  });
+});

packages/coin-support-utils/tests/02.createAccount/01.createDerivationPathGenerator/__fixtures__/index.ts

@@ -0,0 +1,6 @@
+import { IFixtures } from './types';
+import { valid } from './valid';
+
+export const fixtures: IFixtures = {
+  valid,
+};

packages/coin-support-utils/tests/02.createAccount/01.createDerivationPathGenerator/__fixtures__/types.ts

@@ -0,0 +1,15 @@
+import { createDerivationPathGenerator } from '../../../../src';
+
+export interface DerivationPathGeneratorTestCases {
+  name: string;
+  input: {
+    basePath: string;
+    existingDerivationPaths: string[];
+    limit: number;
+  };
+  output: ReturnType<ReturnType<typeof createDerivationPathGenerator>>;
+}
+
+export interface IFixtures {
+  valid: DerivationPathGeneratorTestCases[];
+}

packages/coin-support-utils/tests/02.createAccount/01.createDerivationPathGenerator/__fixtures__/valid.ts

@@ -0,0 +1,67 @@
+import { DerivationPathGeneratorTestCases } from './types';
+
+export const valid: DerivationPathGeneratorTestCases[] = [
+  {
+    name: 'should generate derivation path from zero index',
+    input: {
+      basePath: "m/44'/0'/0'/0/i",
+      existingDerivationPaths: [],
+      limit: 3,
+    },
+    output: [
+      {
+        derivationPath: "m/44'/0'/0'/0/0",
+        index: 0,
+      },
+      {
+        derivationPath: "m/44'/0'/0'/0/1",
+        index: 1,
+      },
+      {
+        derivationPath: "m/44'/0'/0'/0/2",
+        index: 2,
+      },
+    ],
+  },
+  {
+    name: 'should generate derivation path excluding existing derivation path',
+    input: {
+      basePath: "m/44'/0'/0'/0/i",
+      existingDerivationPaths: ["m/44'/0'/0'/0/1"],
+      limit: 2,
+    },
+    output: [
+      {
+        derivationPath: "m/44'/0'/0'/0/0",
+        index: 0,
+      },
+      {
+        derivationPath: "m/44'/0'/0'/0/2",
+        index: 2,
+      },
+    ],
+  },
+  {
+    name: 'should return basePath if it does not include i',
+    input: {
+      basePath: "m/44'/0'/0'/0/0",
+      existingDerivationPaths: [],
+      limit: 2,
+    },
+    output: [
+      {
+        derivationPath: "m/44'/0'/0'/0/0",
+        index: 0,
+      },
+    ],
+  },
+  {
+    name: 'should return return empty array if base path is already derived and it does not include i',
+    input: {
+      basePath: "m/44'/0'/0'/0/0",
+      existingDerivationPaths: ["m/44'/0'/0'/0/0"],
+      limit: 2,
+    },
+    output: [],
+  },
+];

packages/coin-support-utils/tests/02.createAccount/01.createDerivationPathGenerator/index.ts

@@ -0,0 +1,14 @@
+import { describe, test } from '@jest/globals';
+import { createDerivationPathGenerator } from '../../../src';
+import { fixtures } from './__fixtures__';
+
+describe('01. createDerivationPathGenerator', () => {
+  fixtures.valid.forEach(({ name, input, output }) => {
+    test(name, () => {
+      const generator = createDerivationPathGenerator(input.basePath);
+      expect(generator).toBeInstanceOf(Function);
+      const result = generator(input.existingDerivationPaths, input.limit);
+      expect(result).toStrictEqual(output);
+    });
+  });
+});

packages/coin-support-utils/tests/02.createAccount/02.generateDerivationPathPerScheme/__fixtures__/index.ts

@@ -0,0 +1,6 @@
+import { IFixtures } from './types';
+import { valid } from './valid';
+
+export const fixtures: IFixtures = {
+  valid,
+};

packages/coin-support-utils/tests/02.createAccount/02.generateDerivationPathPerScheme/__fixtures__/types.ts

@@ -0,0 +1,14 @@
+import {
+  IGenerateDerivationPathsPerSchemeParams,
+  generateDerivationPathsPerScheme,
+} from '../../../../src';
+
+export interface DerivationPathPerSchemeGeneratorTestCases {
+  name: string;
+  input: IGenerateDerivationPathsPerSchemeParams;
+  output: ReturnType<typeof generateDerivationPathsPerScheme>;
+}
+
+export interface IFixtures {
+  valid: DerivationPathPerSchemeGeneratorTestCases[];
+}