@bcts/seedtool-cli 1.0.0-alpha.14 → 1.0.0-alpha.16

package/LICENSE

@@ -1,5 +1,5 @@
 Copyright © 2025 Blockchain Commons, LLC
-Copyright © 2025 Leonardo Amoroso Custodio
+Copyright © 2025-2026 Leonardo Amoroso Custodio
 
 Redistribution and use in source and binary forms, with or without modification,
 are permitted provided that the following conditions are met:

package/README.md

@@ -1,11 +1,80 @@
-# Blockchain Commons Known Values for TypeScript
+# Blockchain Commons Seedtool CLI (TypeScript)
 
 > Disclaimer: This package is under active development and APIs may change.
 
 ## Introduction
 
-This package defines the [known values](https://github.com/BlockchainCommons/Research/blob/master/papers/bcr-2023-002-known-value.md) used in Blockchain Commons projects.
+`@bcts/seedtool-cli` is a command line tool for generating and transforming cryptographic seeds. It supports multiple input and output formats including BIP39 mnemonic phrases, hex, SSKR shares, and more.
+
+Features:
+- Generate random cryptographic seeds
+- Convert between seed formats (hex, BIP39, SSKR, etc.)
+- Split seeds using SSKR (Sharded Secret Key Reconstruction)
+- Recover seeds from SSKR shares
+- Support for deterministic seed generation
 
 ## Rust Reference Implementation
 
-This TypeScript implementation is based on [known-values-rust](https://github.com/BlockchainCommons/known-values-rust) **v0.13.0** ([commit](https://github.com/BlockchainCommons/known-values-rust/tree/75c0b893be3eebe0432749ef24b804569f6e1378)).
+This TypeScript implementation is based on [seedtool-cli-rust](https://github.com/BlockchainCommons/seedtool-cli-rust).
+
+## Installation
+
+```bash
+# Install globally
+bun add -g @bcts/seedtool-cli
+
+# Or run directly with bunx
+bunx @bcts/seedtool-cli --help
+```
+
+## Usage
+
+### Generate a Random Seed
+
+```bash
+# Generate a 16-byte (128-bit) seed (default)
+seedtool
+
+# Generate a 32-byte (256-bit) seed
+seedtool --count 32
+```
+
+### Input/Output Formats
+
+```bash
+# Output as BIP39 mnemonic
+seedtool --out bip39
+
+# Output as hex
+seedtool --out hex
+
+# Input from hex, output as BIP39
+seedtool --in hex --out bip39 7e31b2b14b895e75cdb82c22b013527c
+```
+
+### SSKR Shares
+
+```bash
+# Split a seed into SSKR shares (2-of-3)
+seedtool --out sskr --groups 2-of-3
+
+# Recover from SSKR shares
+seedtool --in sskr <share1> <share2>
+```
+
+## Command Line Reference
+
+```
+Usage: seedtool [options] [input...]
+
+Arguments:
+  input                Input data (format specified by --in)
+
+Options:
+  -c, --count <n>      Number of bytes to generate (default: 16)
+  -i, --in <format>    Input format: hex, bip39, sskr, random (default: random)
+  -o, --out <format>   Output format: hex, bip39, sskr, ur (default: hex)
+  -g, --groups <spec>  SSKR group specification (e.g., "2-of-3")
+  -h, --help           Display help
+  -V, --version        Display version
+```

package/dist/index.cjs

@@ -25,16 +25,16 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-let readline = require("readline");
-readline = __toESM(readline);
+let node_readline = require("node:readline");
+node_readline = __toESM(node_readline);
 let _bcts_components = require("@bcts/components");
 let _bcts_envelope = require("@bcts/envelope");
 let _bcts_known_values = require("@bcts/known-values");
 let _bcts_dcbor = require("@bcts/dcbor");
-let _noble_hashes_sha256 = require("@noble/hashes/sha256");
-let _noble_hashes_hkdf = require("@noble/hashes/hkdf");
+let _noble_hashes_sha2_js = require("@noble/hashes/sha2.js");
+let _noble_hashes_hkdf_js = require("@noble/hashes/hkdf.js");
 let _scure_bip39 = require("@scure/bip39");
-let _scure_bip39_wordlists_english = require("@scure/bip39/wordlists/english");
+let _scure_bip39_wordlists_english_js = require("@scure/bip39/wordlists/english.js");
 let _bcts_uniform_resources = require("@bcts/uniform-resources");
 let _bcts_tags = require("@bcts/tags");
 
@@ -143,8 +143,8 @@ function parseDate(s) {
 * Returns SSKRGroupSpec instance.
 */
 function parseGroupSpec(s) {
-	const match = s.match(/^(\d+)-of-(\d+)$/i);
-	if (!match) throw new Error(`Invalid group specification: ${s}. Use format 'M-of-N' (e.g., '2-of-3').`);
+	const match = /^(\d+)-of-(\d+)$/i.exec(s);
+	if (match === null) throw new Error(`Invalid group specification: ${s}. Use format 'M-of-N' (e.g., '2-of-3').`);
 	const threshold = parseInt(match[1], 10);
 	const count = parseInt(match[2], 10);
 	return _bcts_components.SSKRGroupSpec.new(threshold, count);
@@ -204,13 +204,13 @@ var Cli = class Cli {
 		if (this.input !== void 0) return this.input;
 		return new Promise((resolve, reject) => {
 			let data = "";
-			const rl = readline.createInterface({
+			const rl = node_readline.createInterface({
 				input: process.stdin,
 				output: process.stdout,
 				terminal: false
 			});
 			rl.on("line", (line) => {
-				data += line + "\n";
+				data += `${line}\n`;
 			});
 			rl.on("close", () => {
 				resolve(data.trim());
@@ -267,23 +267,23 @@ var Cli = class Cli {
 	*/
 	clone() {
 		const cli = new Cli();
-		cli.input = this.input;
+		if (this.input !== void 0) cli.input = this.input;
 		cli.count = this.count;
 		cli.in = this.in;
 		cli.out = this.out;
 		cli.low = this.low;
 		cli.high = this.high;
-		cli.name = this.name;
-		cli.note = this.note;
-		cli.date = this.date;
+		if (this.name !== void 0) cli.name = this.name;
+		if (this.note !== void 0) cli.note = this.note;
+		if (this.date !== void 0) cli.date = this.date;
 		cli.maxFragmentLen = this.maxFragmentLen;
 		cli.additionalParts = this.additionalParts;
 		cli.groups = [...this.groups];
 		cli.groupThreshold = this.groupThreshold;
 		cli.sskrFormat = this.sskrFormat;
-		cli.deterministic = this.deterministic;
-		cli.seed = this.seed?.clone();
-		cli.rng = this.rng;
+		if (this.deterministic !== void 0) cli.deterministic = this.deterministic;
+		if (this.seed !== void 0) cli.seed = this.seed.clone();
+		if (this.rng !== void 0) cli.rng = this.rng;
 		return cli;
 	}
 };
@@ -405,7 +405,7 @@ var Seed = class Seed {
 	* - Optional note assertion (if not empty)
 	*/
 	toEnvelope() {
-		let envelope = _bcts_envelope.Envelope.new((0, _bcts_dcbor.toByteString)(this._data));
+		let envelope = _bcts_envelope.Envelope.new(this._data);
 		envelope = envelope.addType(_bcts_known_values.SEED_TYPE);
 		if (this._creationDate !== void 0) {
 			const cborDate = _bcts_dcbor.CborDate.fromDatetime(this._creationDate);
@@ -524,7 +524,7 @@ var DeterministicRandomNumberGenerator = class DeterministicRandomNumberGenerato
 	* Matches Rust new_with_seed function.
 	*/
 	static newWithSeed(seedString) {
-		return new DeterministicRandomNumberGenerator((0, _noble_hashes_sha256.sha256)(new TextEncoder().encode(seedString)));
+		return new DeterministicRandomNumberGenerator((0, _noble_hashes_sha2_js.sha256)(new TextEncoder().encode(seedString)));
 	}
 	/**
 	* Generate deterministic random data.
@@ -557,7 +557,7 @@ var DeterministicRandomNumberGenerator = class DeterministicRandomNumberGenerato
 * Matches Rust hkdf_hmac_sha256 function from bc-crypto.
 */
 function hkdfHmacSha256(ikm, salt, length) {
-	return (0, _noble_hashes_hkdf.hkdf)(_noble_hashes_sha256.sha256, ikm, salt, new Uint8Array(0), length);
+	return (0, _noble_hashes_hkdf_js.hkdf)(_noble_hashes_sha2_js.sha256, ikm, salt, new Uint8Array(0), length);
 }
 /**
 * Generate deterministic random data from entropy using SHA256.
@@ -569,7 +569,7 @@ function hkdfHmacSha256(ikm, salt, length) {
 * @throws Error if n > 32
 */
 function sha256DeterministicRandom(entropy, n) {
-	const seed = (0, _noble_hashes_sha256.sha256)(entropy);
+	const seed = (0, _noble_hashes_sha2_js.sha256)(entropy);
 	if (n <= seed.length) return seed.slice(0, n);
 	else throw new Error("Random number generator limits reached.");
 }
@@ -593,7 +593,7 @@ function sha256DeterministicRandomString(str, n) {
 * @param n - Number of bytes to return
 */
 function deterministicRandom(entropy, n) {
-	return hkdfHmacSha256((0, _noble_hashes_sha256.sha256)(entropy), new Uint8Array(0), n);
+	return hkdfHmacSha256((0, _noble_hashes_sha2_js.sha256)(entropy), new Uint8Array(0), n);
 }
 
 //#endregion
@@ -744,19 +744,23 @@ var Bip39Format = class {
 	}
 	processInput(state) {
 		const normalized = state.expectInput().toLowerCase().trim().replace(/\s+/g, " ");
-		if (!(0, _scure_bip39.validateMnemonic)(normalized, _scure_bip39_wordlists_english.wordlist)) throw new Error("Invalid BIP39 mnemonic");
-		const entropy = (0, _scure_bip39.mnemonicToEntropy)(normalized, _scure_bip39_wordlists_english.wordlist);
+		if (!(0, _scure_bip39.validateMnemonic)(normalized, _scure_bip39_wordlists_english_js.wordlist)) throw new Error("Invalid BIP39 mnemonic");
+		const entropy = (0, _scure_bip39.mnemonicToEntropy)(normalized, _scure_bip39_wordlists_english_js.wordlist);
 		state.seed = Seed.new(entropy);
 		return state;
 	}
 	processOutput(state) {
-		return (0, _scure_bip39.entropyToMnemonic)(state.expectSeed().data(), _scure_bip39_wordlists_english.wordlist);
+		return (0, _scure_bip39.entropyToMnemonic)(state.expectSeed().data(), _scure_bip39_wordlists_english_js.wordlist);
 	}
 };
 
 //#endregion
 //#region src/formats/sskr.ts
 /**
+* SSKR format
+* Ported from seedtool-cli-rust/src/formats/sskr.rs
+*/
+/**
 * SSKR format handler.
 * Round-trippable: sskr shares → seed → sskr shares.
 * Supports multiple sub-formats: envelope, btw, btwm, btwu, ur.
@@ -781,16 +785,16 @@ var SSKRFormat = class {
 };
 function outputSskrSeed(seed, spec, format) {
 	switch (format) {
-		case "envelope": {
-			const envelope = seed.toEnvelope();
+		case SSKRFormatKey.Envelope: {
+			const seedEnvelope = seed.toEnvelope();
 			const contentKey = _bcts_envelope.SymmetricKey.new();
-			return envelope.wrap().encryptSubject(contentKey).sskrSplitFlattened(spec, contentKey).map((envelope$1) => envelope$1.urString()).join("\n");
+			return seedEnvelope.wrap().encryptSubject(contentKey).sskrSplitFlattened(spec, contentKey).map((env) => env.urString()).join("\n");
 		}
-		case "btw": return makeBytewordsShares(spec, seed, _bcts_uniform_resources.BytewordsStyle.Standard);
-		case "btwm": return makeBytewordsShares(spec, seed, _bcts_uniform_resources.BytewordsStyle.Minimal);
-		case "btwu": return makeBytewordsShares(spec, seed, _bcts_uniform_resources.BytewordsStyle.Uri);
-		case "ur": return makeShares(spec, seed).map((share) => {
-			return _bcts_uniform_resources.UR.fromCbor("sskr", (0, _bcts_dcbor.toByteString)(share.asBytes())).toString();
+		case SSKRFormatKey.Btw: return makeBytewordsShares(spec, seed, _bcts_uniform_resources.BytewordsStyle.Standard);
+		case SSKRFormatKey.Btwm: return makeBytewordsShares(spec, seed, _bcts_uniform_resources.BytewordsStyle.Minimal);
+		case SSKRFormatKey.Btwu: return makeBytewordsShares(spec, seed, _bcts_uniform_resources.BytewordsStyle.Uri);
+		case SSKRFormatKey.Ur: return makeShares(spec, seed).map((share) => {
+			return _bcts_uniform_resources.UR.new("sskr", (0, _bcts_dcbor.toByteString)(share.asBytes())).toString();
 		}).join("\n");
 	}
 }
@@ -812,7 +816,8 @@ function parseEnvelopes(input) {
 			shareEnvelopes.push(envelope);
 		} catch {}
 		if (shareEnvelopes.length === 0) return null;
-		const recoveredEnvelope = _bcts_envelope.Envelope.sskrJoin(shareEnvelopes).unwrap();
+		const sskrJoin = _bcts_envelope.Envelope.sskrJoin;
+		const recoveredEnvelope = sskrJoin(shareEnvelopes).unwrap();
 		return Seed.fromEnvelope(recoveredEnvelope);
 	} catch {
 		return null;
@@ -833,7 +838,7 @@ function fromTaggedCborShares(taggedCborDataShares) {
 			const cbor = (0, _bcts_dcbor.decodeCbor)(data);
 			const tagged = cbor;
 			if (tagged.tag !== _bcts_tags.SSKR_SHARE.value && tagged.tag !== _bcts_tags.SSKR_SHARE_V1.value) return null;
-			const bytes = (0, _bcts_dcbor.expectBytes)(tagged.value || cbor);
+			const bytes = (0, _bcts_dcbor.expectBytes)(tagged.value !== void 0 ? tagged.value : cbor);
 			untaggedShares.push(bytes);
 		}
 		return fromUntaggedCborShares(untaggedShares);
@@ -867,7 +872,7 @@ function parseUr(input, expectedTagValue, allowTaggedCbor) {
 			urs.push(ur);
 		} catch {}
 		if (urs.length === 0) return null;
-		for (const ur of urs) if (ur.type() !== expectedType) return null;
+		for (const ur of urs) if (ur.urTypeStr() !== expectedType) return null;
 		const untaggedCborShares = [];
 		for (const ur of urs) {
 			let cbor = ur.cbor();
@@ -892,9 +897,9 @@ function parseSskrSeed(input) {
 	if (btwmResult !== null) return btwmResult;
 	const btwuResult = parseBytewords(input, _bcts_uniform_resources.BytewordsStyle.Uri);
 	if (btwuResult !== null) return btwuResult;
-	const urResult = parseUr(input, _bcts_tags.SSKR_SHARE.value, false);
+	const urResult = parseUr(input, Number(_bcts_tags.SSKR_SHARE.value), false);
 	if (urResult !== null) return urResult;
-	const urLegacyResult = parseUr(input, _bcts_tags.SSKR_SHARE_V1.value, true);
+	const urLegacyResult = parseUr(input, Number(_bcts_tags.SSKR_SHARE_V1.value), true);
 	if (urLegacyResult !== null) return urLegacyResult;
 	throw new Error("Insufficient or invalid SSKR shares.");
 }
@@ -971,7 +976,7 @@ var MultipartFormat = class {
 		}
 		if (!decoder.isComplete()) throw new Error("Insufficient multipart shares");
 		const ur = decoder.message();
-		if (ur === void 0) throw new Error("Failed to decode multipart message");
+		if (ur === void 0 || ur === null) throw new Error("Failed to decode multipart message");
 		const envelope = _bcts_envelope.Envelope.fromUR(ur);
 		state.seed = Seed.fromEnvelope(envelope);
 		return state;
@@ -1278,28 +1283,31 @@ var BytewordsUriFormat = class {
 //#endregion
 //#region src/formats/format.ts
 /**
+* Format traits and factory functions
+* Ported from seedtool-cli-rust/src/formats/format.rs
+*/
+/**
 * Select input format by key.
 * Matches Rust select_input_format function.
 */
 function selectInputFormat(key) {
 	switch (key) {
-		case "random": return new RandomFormat();
-		case "hex": return new HexFormat();
-		case "btw": return new BytewordsStandardFormat();
-		case "btwu": return new BytewordsUriFormat();
-		case "btwm": return new BytewordsMinimalFormat();
-		case "bits": return new BitsFormat();
-		case "cards": return new CardsFormat();
-		case "dice": return new DiceFormat();
-		case "base6": return new Base6Format();
-		case "base10": return new Base10Format();
-		case "ints": return new IntsFormat();
-		case "bip39": return new Bip39Format();
-		case "sskr": return new SSKRFormat();
-		case "envelope": return new EnvelopeFormat();
-		case "multipart": return new MultipartFormat();
-		case "seed": return new SeedFormat();
-		default: throw new Error(`Unknown input format: ${key}`);
+		case InputFormatKey.Random: return new RandomFormat();
+		case InputFormatKey.Hex: return new HexFormat();
+		case InputFormatKey.Btw: return new BytewordsStandardFormat();
+		case InputFormatKey.Btwu: return new BytewordsUriFormat();
+		case InputFormatKey.Btwm: return new BytewordsMinimalFormat();
+		case InputFormatKey.Bits: return new BitsFormat();
+		case InputFormatKey.Cards: return new CardsFormat();
+		case InputFormatKey.Dice: return new DiceFormat();
+		case InputFormatKey.Base6: return new Base6Format();
+		case InputFormatKey.Base10: return new Base10Format();
+		case InputFormatKey.Ints: return new IntsFormat();
+		case InputFormatKey.Bip39: return new Bip39Format();
+		case InputFormatKey.Sskr: return new SSKRFormat();
+		case InputFormatKey.Envelope: return new EnvelopeFormat();
+		case InputFormatKey.Multipart: return new MultipartFormat();
+		case InputFormatKey.Seed: return new SeedFormat();
 	}
 }
 /**
@@ -1308,22 +1316,21 @@ function selectInputFormat(key) {
 */
 function selectOutputFormat(key) {
 	switch (key) {
-		case "hex": return new HexFormat();
-		case "btw": return new BytewordsStandardFormat();
-		case "btwu": return new BytewordsUriFormat();
-		case "btwm": return new BytewordsMinimalFormat();
-		case "bits": return new BitsFormat();
-		case "cards": return new CardsFormat();
-		case "dice": return new DiceFormat();
-		case "base6": return new Base6Format();
-		case "base10": return new Base10Format();
-		case "ints": return new IntsFormat();
-		case "bip39": return new Bip39Format();
-		case "sskr": return new SSKRFormat();
-		case "envelope": return new EnvelopeFormat();
-		case "multipart": return new MultipartFormat();
-		case "seed": return new SeedFormat();
-		default: throw new Error(`Unknown output format: ${key}`);
+		case OutputFormatKey.Hex: return new HexFormat();
+		case OutputFormatKey.Btw: return new BytewordsStandardFormat();
+		case OutputFormatKey.Btwu: return new BytewordsUriFormat();
+		case OutputFormatKey.Btwm: return new BytewordsMinimalFormat();
+		case OutputFormatKey.Bits: return new BitsFormat();
+		case OutputFormatKey.Cards: return new CardsFormat();
+		case OutputFormatKey.Dice: return new DiceFormat();
+		case OutputFormatKey.Base6: return new Base6Format();
+		case OutputFormatKey.Base10: return new Base10Format();
+		case OutputFormatKey.Ints: return new IntsFormat();
+		case OutputFormatKey.Bip39: return new Bip39Format();
+		case OutputFormatKey.Sskr: return new SSKRFormat();
+		case OutputFormatKey.Envelope: return new EnvelopeFormat();
+		case OutputFormatKey.Multipart: return new MultipartFormat();
+		case OutputFormatKey.Seed: return new SeedFormat();
 	}
 }