Merge branch 'release/v1.0.31'

Author: andreashuber69

README.md

@@ -130,9 +130,9 @@ COLDCARD copy correctly derives the seed but then generates addresses from a dif
 ``` shell_session cSpell:disable
 $ npx verify-coldcard-dice-seed@latest
 Need to install the following packages:
-  verify-coldcard-dice-seed@1.0.30
+  verify-coldcard-dice-seed@1.0.31
 Ok to proceed? (y) y
-*** Verify COLDCARD Dice Seed v1.0.30 ***
+*** Verify COLDCARD Dice Seed v1.0.31 ***
 (tested with COLDCARD Mk4 firmware v5.2.2)
 
 This application guides you through verifying that your COLDCARD

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "verify-coldcard-dice-seed",
-  "version": "1.0.30",
+  "version": "1.0.31",
   "description": "Verify whether your COLDCARD correctly generates seeds and addresses from dice rolls.",
   "keywords": [
     "bitcoin",
@@ -65,8 +65,8 @@
     "@andreashuber69/eslint-config": "^1.2.6",
     "@picocss/pico": "^1.5.13",
     "@preact/preset-vite": "^2.8.2",
-    "@tsconfig/node20": "^20.1.2",
-    "@tsconfig/strictest": "^2.0.3",
+    "@tsconfig/node20": "^20.1.3",
+    "@tsconfig/strictest": "^2.0.4",
     "@types/node": "^20.11.30",
     "c8": "^9.1.0",
     "coveralls": "^3.1.1",
@@ -76,7 +76,7 @@
     "preact": "^10.20.1",
     "tsx": "^4.7.1",
     "typescript": "^5.4.3",
-    "vite": "^5.2.4",
+    "vite": "^5.2.6",
     "vite-plugin-node-polyfills": "^0.21.0",
     "vite-plugin-wasm": "^3.3.0"
   }

package.json

@@ -2,7 +2,6 @@
 import assert from "node:assert";
 import { describe, it } from "node:test";
 import { wordlists } from "bip39";
-import fetch from "node-fetch";
 
 import { calculateBip39Mnemonic } from "./calculateBip39Mnemonic.js";
 
@@ -12,16 +11,6 @@ if (!wordlist) {
     throw new Error("Missing english wordlist.");
 }
 
-const expectWords = async (entropy: string, words: string) => {
-    const wordCount = words.length === 0 ? 0 : words.split(" ").length;
-
-    await it(
-        entropy,
-        async () => assert((await calculateBip39Mnemonic(entropy, wordCount, wordlist)).join(" ") === words),
-    );
-};
-
-
 const expectError = async (entropy: string, newWordlist: readonly string[], errorMessage: string) => await it(
     entropy,
     async () => {
@@ -34,58 +23,8 @@ const expectError = async (entropy: string, newWordlist: readonly string[], erro
     },
 );
 
-
-const response = await fetch("https://raw.githubusercontent.com/trezor/python-mnemonic/master/vectors.json");
-
-if (!response.ok) {
-    throw new Error("Unexpected response");
-}
-
-const vectors = JSON.parse(await response.text()) as Record<string, unknown>;
-
 await describe(calculateBip39Mnemonic.name, async () => {
-    await describe("should calculate the expected words", async () => {
-        if (!("english" in vectors) || !Array.isArray(vectors["english"])) {
-            throw new Error("Unexpected response");
-        }
-
-        for (const vector of vectors["english"]) {
-            if (!Array.isArray(vector) || (vector.length < 2) ||
-                (typeof vector[0] !== "string") || (typeof vector[1] !== "string")) {
-                throw new Error("Unexpected response");
-            }
-
-            // https://github.com/typescript-eslint/typescript-eslint/issues/7464
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            const [entropy, words] = vector;
-            // eslint-disable-next-line no-await-in-loop
-            await expectWords(entropy, words);
-        }
-
-        await expectWords("", "");
-        await expectWords("00000000", "abandon abandon ability");
-        await expectWords("ffffffff", "zoo zoo zoo");
-    });
-
     await describe("should throw the expected exception", async () => {
-        await it("ffffffff", async () => {
-            try {
-                await calculateBip39Mnemonic("ffffffff", 2, wordlist);
-                assert(false, "Expected error to be thrown!");
-            } catch (error: unknown) {
-                assert(error instanceof RangeError && error.message === "wordCount must be a multiple of 3");
-            }
-        });
-
-        await it("fffffff", async () => {
-            try {
-                await calculateBip39Mnemonic("fffffff", 3, wordlist);
-                assert(false, "Expected error to be thrown!");
-            } catch (error: unknown) {
-                assert(error instanceof RangeError && error.message === "hexEntropy length must be >= 8");
-            }
-        });
-
         await expectError("ffffffff", wordlist.slice(1), "wordlist.length is invalid: 2047");
         await expectError("ffffffff", wordlist.slice(1024), "wordlist.length is invalid: 1024");
         const invalidWordlist = wordlist.slice(-1);

src/common/calculateBip39Mnemonic.spec.ts

@@ -0,0 +1,68 @@
+// https://github.com/andreashuber69/verify-coldcard-dice-seed/blob/develop/README.md#----verify-coldcard-dice-seed
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import fetch from "node-fetch";
+
+import { calculateEnglishBip39Mnemonic } from "./calculateEnglishBip39Mnemonic.js";
+
+const expectWords = async (entropy: string, words: string) => {
+    const wordCount = words.length === 0 ? 0 : words.split(" ").length;
+
+    await it(
+        entropy,
+        async () => assert((await calculateEnglishBip39Mnemonic(entropy, wordCount)).join(" ") === words),
+    );
+};
+
+const response = await fetch("https://raw.githubusercontent.com/trezor/python-mnemonic/master/vectors.json");
+
+if (!response.ok) {
+    throw new Error("Unexpected response");
+}
+
+const vectors = JSON.parse(await response.text()) as Record<string, unknown>;
+
+await describe(calculateEnglishBip39Mnemonic.name, async () => {
+    await describe("should calculate the expected words", async () => {
+        if (!("english" in vectors) || !Array.isArray(vectors["english"])) {
+            throw new Error("Unexpected response");
+        }
+
+        for (const vector of vectors["english"]) {
+            if (!Array.isArray(vector) || (vector.length < 2) ||
+                (typeof vector[0] !== "string") || (typeof vector[1] !== "string")) {
+                throw new Error("Unexpected response");
+            }
+
+            // https://github.com/typescript-eslint/typescript-eslint/issues/7464
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            const [entropy, words] = vector;
+            // eslint-disable-next-line no-await-in-loop
+            await expectWords(entropy, words);
+        }
+
+        await expectWords("", "");
+        await expectWords("00000000", "abandon abandon ability");
+        await expectWords("ffffffff", "zoo zoo zoo");
+    });
+
+    await describe("should throw the expected exception", async () => {
+        await it("ffffffff", async () => {
+            try {
+                await calculateEnglishBip39Mnemonic("ffffffff", 2);
+                assert(false, "Expected error to be thrown!");
+            } catch (error: unknown) {
+                assert(error instanceof RangeError && error.message === "wordCount must be a multiple of 3");
+            }
+        });
+
+        await it("fffffff", async () => {
+            try {
+                await calculateEnglishBip39Mnemonic("fffffff", 3);
+                assert(false, "Expected error to be thrown!");
+            } catch (error: unknown) {
+                assert(error instanceof RangeError && error.message === "hexEntropy length must be >= 8");
+            }
+        });
+    });
+});

src/common/calculateEnglishBip39Mnemonic.spec.ts

@@ -0,0 +1,12 @@
+// https://github.com/andreashuber69/verify-coldcard-dice-seed/blob/develop/README.md#----verify-coldcard-dice-seed
+import { wordlists } from "bip39";
+import { calculateBip39Mnemonic } from "./calculateBip39Mnemonic.js";
+
+const wordlist = wordlists["english"];
+
+if (!wordlist) {
+    throw new Error("Missing english wordlist.");
+}
+
+export const calculateEnglishBip39Mnemonic = async (hexEntropy: string, wordCount: number) =>
+    await calculateBip39Mnemonic(hexEntropy, wordCount, wordlist);

src/common/calculateEnglishBip39Mnemonic.ts

@@ -1,16 +1,11 @@
 // https://github.com/andreashuber69/verify-coldcard-dice-seed/blob/develop/README.md#----verify-coldcard-dice-seed
 import assert from "node:assert";
 import { describe, it } from "node:test";
-import { BIP32Factory } from "bip32";
-import { mnemonicToSeed } from "bip39";
-// eslint-disable-next-line import/no-namespace
-import * as ecc from "tiny-secp256k1";
 import { getAddresses } from "./getAddresses.js";
-
-const bip32 = BIP32Factory(ecc);
+import { getRoot } from "./getRoot.js";
 
 const getBatch = async (mnemonic: string, passphrase: string, accountRootPath: string, startIndex: number) =>
-    getAddresses(bip32.fromSeed(await mnemonicToSeed(mnemonic, passphrase)), accountRootPath, startIndex);
+    getAddresses(await getRoot(mnemonic, passphrase), accountRootPath, startIndex, 10);
 
 const rootPath = "m/84'/0'/0'/0";
 const getPath = (index: number) => `${rootPath}/${index}`;

src/common/getAddresses.spec.ts

@@ -2,16 +2,22 @@
 import type { BIP32Interface } from "bip32";
 import { toBech32Address } from "./toBech32Address.js";
 
-type Batch = [readonly [string, string], ...Array<readonly [string, string]>];
+type GrowToSize<T, N extends number, A extends T[]> = A["length"] extends N ? A : GrowToSize<T, N, [...A, T]>;
 
-export const getAddresses = (root: BIP32Interface, accountRootPath: string, startIndex: number): Readonly<Batch> => {
+type Batch<N extends number> = GrowToSize<[string, string], N, []>;
+
+export const getAddresses = <N extends number>(
+    root: BIP32Interface,
+    accountRootPath: string,
+    startIndex: number,
+    length: N,
+) => {
     const accountRoot = root.derivePath(accountRootPath);
-    const length = 10;
-    const result: Batch = [["", ""], ...new Array<[string, string]>(length - 1)];
+    const result = new Array<[string, string]>(length);
 
     for (let index = startIndex; index < startIndex + length; ++index) {
         result[index - startIndex] = [`${accountRootPath}/${index}`, toBech32Address(accountRoot.derive(index))];
     }
 
-    return result;
+    return result as Batch<N>;
 };

src/common/getAddresses.ts

@@ -0,0 +1,9 @@
+import { BIP32Factory } from "bip32";
+import { mnemonicToSeed } from "bip39";
+// eslint-disable-next-line import/no-namespace
+import * as ecc from "tiny-secp256k1";
+
+const bip32 = BIP32Factory(ecc);
+
+export const getRoot = async (mnemonic: string, passphrase: string) =>
+    bip32.fromSeed(await mnemonicToSeed(mnemonic, passphrase));

src/common/getRoot.ts

@@ -1,19 +1,14 @@
 // https://github.com/andreashuber69/verify-coldcard-dice-seed/blob/develop/README.md#----verify-coldcard-dice-seed
-import { BIP32Factory } from "bip32";
-import { mnemonicToSeed } from "bip39";
-// eslint-disable-next-line import/no-namespace
-import * as ecc from "tiny-secp256k1";
 import { getAddresses } from "../common/getAddresses.js";
+import { getRoot } from "../common/getRoot.js";
 import type { InOut } from "./InOut.js";
 import { waitForUser } from "./waitForUser.js";
 
-const bip32 = BIP32Factory(ecc);
-
 export const showAddresses = async ({ stdin, stdout }: InOut, words: readonly string[], passphrase: string) => {
     stdout.write("Select 'Address Explorer' and press the 4 button on your COLDCARD.\r\n");
     await waitForUser({ stdin, stdout });
-    const root = bip32.fromSeed(await mnemonicToSeed(words.join(" "), passphrase));
-    const getBatch = (startIndex: number) => getAddresses(root, "m/84'/0'/0'/0", startIndex);
+    const root = await getRoot(words.join(" "), passphrase);
+    const getBatch = (startIndex: number) => getAddresses(root, "m/84'/0'/0'/0", startIndex, 10);
 
     let batchStart = 0;
     let batch = getBatch(batchStart);