@bcts/seedtool-cli 1.0.0-alpha.14

package/src/random.ts

@@ -0,0 +1,130 @@
+/**
+ * Random number generation utilities
+ * Ported from seedtool-cli-rust/src/random.rs
+ */
+
+import { sha256 } from "@noble/hashes/sha256";
+import { hkdf } from "@noble/hashes/hkdf";
+
+/** SHA256 output size in bytes */
+const SHA256_SIZE = 32;
+
+/**
+ * Deterministic random number generator.
+ * Matches Rust DeterministicRandomNumberGenerator struct.
+ *
+ * Uses HKDF-HMAC-SHA256 to generate deterministic random data
+ * from a seed, with an incrementing salt for each call.
+ */
+export class DeterministicRandomNumberGenerator {
+  private seed: Uint8Array;
+  private salt: bigint;
+
+  /**
+   * Create a new deterministic RNG from a 32-byte seed.
+   */
+  constructor(seed: Uint8Array) {
+    if (seed.length !== SHA256_SIZE) {
+      throw new Error(`Seed must be ${SHA256_SIZE} bytes, got ${seed.length}`);
+    }
+    this.seed = new Uint8Array(seed);
+    this.salt = 0n;
+  }
+
+  /**
+   * Create a new deterministic RNG from a seed string.
+   * The string is hashed with SHA256 to produce the seed.
+   * Matches Rust new_with_seed function.
+   */
+  static newWithSeed(seedString: string): DeterministicRandomNumberGenerator {
+    const encoder = new TextEncoder();
+    const seed = sha256(encoder.encode(seedString));
+    return new DeterministicRandomNumberGenerator(seed);
+  }
+
+  /**
+   * Generate deterministic random data.
+   * Matches Rust deterministic_random_data method.
+   *
+   * Each call increments the salt and uses HKDF to derive
+   * the requested number of bytes.
+   */
+  deterministicRandomData(size: number): Uint8Array {
+    this.salt += 1n;
+
+    // Convert salt to little-endian bytes
+    const saltBytes = new Uint8Array(8);
+    const view = new DataView(saltBytes.buffer);
+    // Split into low and high 32-bit parts for BigInt handling
+    const low = Number(this.salt & 0xffffffffn);
+    const high = Number((this.salt >> 32n) & 0xffffffffn);
+    view.setUint32(0, low, true); // little-endian
+    view.setUint32(4, high, true);
+
+    return hkdfHmacSha256(this.seed, saltBytes, size);
+  }
+
+  /**
+   * Clone the RNG state.
+   */
+  clone(): DeterministicRandomNumberGenerator {
+    const rng = new DeterministicRandomNumberGenerator(this.seed);
+    rng.salt = this.salt;
+    return rng;
+  }
+}
+
+/**
+ * HKDF-HMAC-SHA256 key derivation.
+ * Matches Rust hkdf_hmac_sha256 function from bc-crypto.
+ */
+export function hkdfHmacSha256(ikm: Uint8Array, salt: Uint8Array, length: number): Uint8Array {
+  // @noble/hashes hkdf takes (hash, ikm, salt, info, length)
+  // Use empty info for our use case
+  return hkdf(sha256, ikm, salt, new Uint8Array(0), length);
+}
+
+/**
+ * Generate deterministic random data from entropy using SHA256.
+ * If n <= 32, returns the first n bytes of SHA256(entropy).
+ * Matches Rust sha256_deterministic_random function.
+ *
+ * @param entropy - The entropy bytes to hash
+ * @param n - Number of bytes to return (must be <= 32)
+ * @throws Error if n > 32
+ */
+export function sha256DeterministicRandom(entropy: Uint8Array, n: number): Uint8Array {
+  const seed = sha256(entropy);
+  if (n <= seed.length) {
+    return seed.slice(0, n);
+  } else {
+    throw new Error("Random number generator limits reached.");
+  }
+}
+
+/**
+ * Generate deterministic random data from a string using SHA256.
+ * Matches Rust sha256_deterministic_random_string function.
+ *
+ * @param str - The string to hash
+ * @param n - Number of bytes to return (must be <= 32)
+ * @throws Error if n > 32
+ */
+export function sha256DeterministicRandomString(str: string, n: number): Uint8Array {
+  const encoder = new TextEncoder();
+  const entropy = encoder.encode(str);
+  return sha256DeterministicRandom(entropy, n);
+}
+
+/**
+ * Generate deterministic random data from entropy using HKDF.
+ * This can generate any length output.
+ * Matches Rust deterministic_random function.
+ *
+ * @param entropy - The entropy bytes
+ * @param n - Number of bytes to return
+ */
+export function deterministicRandom(entropy: Uint8Array, n: number): Uint8Array {
+  const seed = sha256(entropy);
+  return hkdfHmacSha256(seed, new Uint8Array(0), n);
+}

package/src/seed.ts

@@ -0,0 +1,300 @@
+/**
+ * Seed type for seedtool-cli
+ * Ported from seedtool-cli-rust/src/seed.rs
+ *
+ * This is a local Seed type that wraps the seed data with metadata
+ * and provides Envelope conversion. It differs from @bcts/components Seed
+ * in that it doesn't enforce minimum length (for CLI flexibility) and
+ * has direct Envelope conversion methods.
+ */
+
+import { Envelope } from "@bcts/envelope";
+import { Seed as ComponentsSeed } from "@bcts/components";
+import { NAME, NOTE, DATE, SEED_TYPE } from "@bcts/known-values";
+import { toByteString, CborDate } from "@bcts/dcbor";
+
+/**
+ * Seed with optional metadata.
+ * Matches Rust Seed struct in seed.rs.
+ */
+export class Seed {
+  private _data: Uint8Array;
+  private _name: string;
+  private _note: string;
+  private _creationDate?: Date;
+
+  /**
+   * Create a new Seed with the given data.
+   * Matches Rust Seed::new function.
+   */
+  constructor(data: Uint8Array) {
+    this._data = new Uint8Array(data);
+    this._name = "";
+    this._note = "";
+    this._creationDate = undefined;
+  }
+
+  /**
+   * Create a new Seed with data and optional metadata.
+   * Matches Rust Seed::new_opt function.
+   */
+  static newOpt(data: Uint8Array, name: string, note: string, creationDate?: Date): Seed {
+    const seed = new Seed(data);
+    seed._name = name;
+    seed._note = note;
+    seed._creationDate = creationDate;
+    return seed;
+  }
+
+  /**
+   * Create a new Seed from raw data.
+   * Convenience factory method.
+   */
+  static new(data: Uint8Array): Seed {
+    return new Seed(data);
+  }
+
+  // ============================================================================
+  // Accessors
+  // ============================================================================
+
+  /**
+   * Get the seed data.
+   * Matches Rust seed.data() method.
+   */
+  data(): Uint8Array {
+    return this._data;
+  }
+
+  /**
+   * Get the seed name.
+   * Matches Rust seed.name() method.
+   * Returns empty string if not set.
+   */
+  name(): string {
+    return this._name;
+  }
+
+  /**
+   * Set the seed name.
+   * Matches Rust seed.set_name() method.
+   */
+  setName(name: string): void {
+    this._name = name;
+  }
+
+  /**
+   * Get the seed note.
+   * Matches Rust seed.note() method.
+   * Returns empty string if not set.
+   */
+  note(): string {
+    return this._note;
+  }
+
+  /**
+   * Set the seed note.
+   * Matches Rust seed.set_note() method.
+   */
+  setNote(note: string): void {
+    this._note = note;
+  }
+
+  /**
+   * Get the creation date.
+   * Matches Rust seed.creation_date() method.
+   */
+  creationDate(): Date | undefined {
+    return this._creationDate;
+  }
+
+  /**
+   * Set the creation date.
+   * Matches Rust seed.set_creation_date() method.
+   */
+  setCreationDate(date: Date | undefined): void {
+    this._creationDate = date;
+  }
+
+  // ============================================================================
+  // Cloning
+  // ============================================================================
+
+  /**
+   * Clone the seed.
+   */
+  clone(): Seed {
+    return Seed.newOpt(new Uint8Array(this._data), this._name, this._note, this._creationDate);
+  }
+
+  // ============================================================================
+  // Envelope Conversion
+  // ============================================================================
+
+  /**
+   * Convert to Envelope.
+   * Matches Rust impl From<Seed> for Envelope.
+   *
+   * Creates an envelope with:
+   * - Subject: byte string of seed data
+   * - Type assertion: 'Seed'
+   * - Optional date assertion
+   * - Optional name assertion (if not empty)
+   * - Optional note assertion (if not empty)
+   */
+  toEnvelope(): Envelope {
+    // Create envelope with seed data as byte string subject
+    let envelope = Envelope.new(toByteString(this._data));
+
+    // Add type assertion
+    envelope = envelope.addType(SEED_TYPE);
+
+    // Add optional date assertion (using CBOR Date tag 1)
+    if (this._creationDate !== undefined) {
+      const cborDate = CborDate.fromDatetime(this._creationDate);
+      envelope = envelope.addAssertion(DATE, cborDate);
+    }
+
+    // Add optional name assertion (only if not empty)
+    if (this._name.length > 0) {
+      envelope = envelope.addAssertion(NAME, this._name);
+    }
+
+    // Add optional note assertion (only if not empty)
+    if (this._note.length > 0) {
+      envelope = envelope.addAssertion(NOTE, this._note);
+    }
+
+    return envelope;
+  }
+
+  /**
+   * Create a Seed from an Envelope.
+   * Matches Rust impl TryFrom<Envelope> for Seed.
+   */
+  static fromEnvelope(envelope: Envelope): Seed {
+    // Check type
+    envelope.checkTypeValue(SEED_TYPE);
+
+    // Extract data from subject (byte string)
+    const subject = envelope.subject();
+    const leaf = subject.asLeaf();
+    if (leaf === undefined) {
+      throw new Error("Seed envelope must have a leaf subject");
+    }
+    const data = leaf.asByteString();
+    if (data === undefined) {
+      throw new Error("Seed envelope subject must be a byte string");
+    }
+
+    // Extract optional name
+    let name = "";
+    try {
+      const nameObj = envelope.objectForPredicate(NAME);
+      if (nameObj !== undefined) {
+        const nameStr = nameObj.asText();
+        if (nameStr !== undefined) {
+          name = nameStr;
+        }
+      }
+    } catch {
+      // Name is optional
+    }
+
+    // Extract optional note
+    let note = "";
+    try {
+      const noteObj = envelope.objectForPredicate(NOTE);
+      if (noteObj !== undefined) {
+        const noteStr = noteObj.asText();
+        if (noteStr !== undefined) {
+          note = noteStr;
+        }
+      }
+    } catch {
+      // Note is optional
+    }
+
+    // Extract optional creation date (CBOR Date tag 1)
+    let creationDate: Date | undefined;
+    try {
+      const dateObj = envelope.objectForPredicate(DATE);
+      if (dateObj !== undefined) {
+        // Try to extract as CborDate first (tag 1)
+        const leaf = dateObj.asLeaf();
+        if (leaf !== undefined) {
+          const cborDate = CborDate.fromTaggedCbor(leaf);
+          creationDate = cborDate.datetime();
+        }
+      }
+    } catch {
+      // Date is optional, or might be a different format - try ISO string fallback
+      try {
+        const dateObj = envelope.objectForPredicate(DATE);
+        if (dateObj !== undefined) {
+          const dateStr = dateObj.asText();
+          if (dateStr !== undefined) {
+            creationDate = new Date(dateStr);
+          }
+        }
+      } catch {
+        // Date is optional
+      }
+    }
+
+    return Seed.newOpt(data, name, note, creationDate);
+  }
+
+  // ============================================================================
+  // ComponentsSeed Conversion
+  // ============================================================================
+
+  /**
+   * Convert to @bcts/components Seed.
+   * Matches Rust impl TryFrom<&Seed> for ComponentsSeed.
+   */
+  toComponentsSeed(): ComponentsSeed {
+    return ComponentsSeed.newOpt(
+      this._data,
+      this._name.length > 0 ? this._name : undefined,
+      this._note.length > 0 ? this._note : undefined,
+      this._creationDate,
+    );
+  }
+
+  /**
+   * Create from @bcts/components Seed.
+   * Matches Rust impl From<ComponentsSeed> for Seed.
+   */
+  static fromComponentsSeed(seed: ComponentsSeed): Seed {
+    return Seed.newOpt(seed.asBytes(), seed.name(), seed.note(), seed.creationDate());
+  }
+
+  // ============================================================================
+  // String Representation
+  // ============================================================================
+
+  /**
+   * Get string representation.
+   */
+  toString(): string {
+    const hex = Array.from(this._data.slice(0, 8))
+      .map((b) => b.toString(16).padStart(2, "0"))
+      .join("");
+    return `Seed(${hex}..., ${this._data.length} bytes)`;
+  }
+
+  /**
+   * Check equality with another Seed.
+   */
+  equals(other: Seed): boolean {
+    if (this._data.length !== other._data.length) return false;
+    for (let i = 0; i < this._data.length; i++) {
+      if (this._data[i] !== other._data[i]) return false;
+    }
+    if (this._name !== other._name) return false;
+    if (this._note !== other._note) return false;
+    if (this._creationDate?.getTime() !== other._creationDate?.getTime()) return false;
+    return true;
+  }
+}

package/src/styles.ts

@@ -0,0 +1,50 @@
+/**
+ * CLI styling utilities
+ * Ported from seedtool-cli-rust/src/styles.rs
+ */
+
+import chalk from "chalk";
+
+/**
+ * Get CLI styles matching the Rust clap styling.
+ * Matches Rust get_styles function.
+ *
+ * These styles are used for CLI help text formatting:
+ * - usage: Bold, underlined, yellow - for usage section headers
+ * - header: Bold, underlined, yellow - for section headers
+ * - literal: Green - for command/argument literals
+ * - invalid: Bold, red - for invalid input indicators
+ * - error: Bold, red - for error messages
+ * - valid: Bold, underlined, green - for valid input indicators
+ * - placeholder: Bright cyan - for placeholder values
+ */
+export const styles = {
+  /** Style for usage section headers */
+  usage: chalk.bold.underline.yellow,
+
+  /** Style for section headers */
+  header: chalk.bold.underline.yellow,
+
+  /** Style for command/argument literals */
+  literal: chalk.green,
+
+  /** Style for invalid input indicators */
+  invalid: chalk.bold.red,
+
+  /** Style for error messages */
+  error: chalk.bold.red,
+
+  /** Style for valid input indicators */
+  valid: chalk.bold.underline.green,
+
+  /** Style for placeholder values */
+  placeholder: chalk.cyanBright,
+};
+
+/**
+ * Get styles object for use with commander.js
+ * Note: Commander uses different styling API than clap
+ */
+export function getStyles() {
+  return styles;
+}

package/src/util.ts

@@ -0,0 +1,140 @@
+/**
+ * Utility functions for data conversion
+ * Ported from seedtool-cli-rust/src/util.rs
+ */
+
+/**
+ * Convert bytes to hex string.
+ * Matches Rust data_to_hex function.
+ */
+export function dataToHex(bytes: Uint8Array): string {
+  return Array.from(bytes)
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+}
+
+/**
+ * Convert hex string to bytes.
+ * Matches Rust hex_to_data function.
+ */
+export function hexToData(hex: string): Uint8Array {
+  if (hex.length % 2 !== 0) {
+    throw new Error("Hex string must have even length");
+  }
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    const byte = parseInt(hex.substring(i, i + 2), 16);
+    if (isNaN(byte)) {
+      throw new Error(`Invalid hex character at position ${i}`);
+    }
+    bytes[i / 2] = byte;
+  }
+  return bytes;
+}
+
+/**
+ * Convert byte values to a different base range [0, base-1].
+ * Each byte (0-255) is scaled proportionally to the target base.
+ * Matches Rust data_to_base function.
+ *
+ * @param buf - Input bytes
+ * @param base - Target base (e.g., 6 for base-6)
+ * @returns Array of values in range [0, base-1]
+ */
+export function dataToBase(buf: Uint8Array, base: number): Uint8Array {
+  const result = new Uint8Array(buf.length);
+  for (let i = 0; i < buf.length; i++) {
+    // Scale from [0,255] to [0,base-1] with rounding
+    result[i] = Math.round((buf[i] / 255) * (base - 1));
+  }
+  return result;
+}
+
+/**
+ * Convert bytes to an alphabet string using a base and alphabet function.
+ * Matches Rust data_to_alphabet function.
+ *
+ * @param buf - Input bytes
+ * @param base - Target base
+ * @param toAlphabet - Function to convert index to character
+ * @returns String of alphabet characters
+ */
+export function dataToAlphabet(
+  buf: Uint8Array,
+  base: number,
+  toAlphabet: (n: number) => string,
+): string {
+  const data = dataToBase(buf, base);
+  return Array.from(data)
+    .map((b) => toAlphabet(b))
+    .join("");
+}
+
+/**
+ * Parse whitespace-separated integers.
+ * Matches Rust parse_ints function.
+ *
+ * @param input - Space-separated integer string
+ * @returns Array of bytes
+ * @throws Error if any integer is out of range [0, 255]
+ */
+export function parseInts(input: string): Uint8Array {
+  const parts = input.trim().split(/\s+/);
+  const result: number[] = [];
+  for (const s of parts) {
+    if (s === "") continue;
+    const i = parseInt(s, 10);
+    if (isNaN(i)) {
+      throw new Error(`Invalid integer: ${s}`);
+    }
+    if (i < 0 || i > 255) {
+      throw new Error("Integer out of range. Allowed: [0-255]");
+    }
+    result.push(i);
+  }
+  return new Uint8Array(result);
+}
+
+/**
+ * Convert bytes to a string of integers in a given range.
+ * Matches Rust data_to_ints function.
+ *
+ * @param buf - Input bytes
+ * @param low - Lowest output value (0-254)
+ * @param high - Highest output value (1-255), low < high
+ * @param separator - String to separate values
+ * @returns String of integers
+ * @throws Error if range is invalid
+ */
+export function dataToInts(buf: Uint8Array, low: number, high: number, separator: string): string {
+  if (!(low < high && high <= 255)) {
+    throw new Error("Int conversion range must be in 0 <= low < high <= 255.");
+  }
+  const base = high - low + 1;
+  const data = dataToBase(buf, base);
+  return Array.from(data)
+    .map((b) => (b + low).toString())
+    .join(separator);
+}
+
+/**
+ * Parse a string of digits in a given range to bytes.
+ * Matches Rust digits_to_data function.
+ *
+ * @param inStr - String of digits
+ * @param low - Lowest valid digit
+ * @param high - Highest valid digit
+ * @returns Array of digit values
+ * @throws Error if any digit is out of range
+ */
+export function digitsToData(inStr: string, low: number, high: number): Uint8Array {
+  const result: number[] = [];
+  for (const c of inStr) {
+    const n = c.charCodeAt(0) - "0".charCodeAt(0);
+    if (n < low || n > high) {
+      throw new Error(`Invalid digit: ${c}. Expected range [${low}-${high}].`);
+    }
+    result.push(n);
+  }
+  return new Uint8Array(result);
+}