Class Seed

Static ReadonlyMIN_SEED_LENGTH

Staticnew

• new(): Seed

  Create a new random seed with default length (16 bytes).

  Rust equivalent: Seed::new()

  Returns Seed

StaticnewWithLen

• newWithLen(count: number): Seed

  Create a new random seed with a specified length.

  Rust equivalent: Seed::new_with_len(count)

  Parameters

  • count: number

    Number of bytes (must be >= 16)

  Returns Seed

  Throws

  CryptoError if count < 16

StaticnewWithLenUsing

• newWithLenUsing(
      count: number,
      rng: { randomData: (size: number) => Uint8Array },
  ): Seed

  Create a new random seed with a specified length using provided RNG.

  Rust equivalent: Seed::new_with_len_using(count, rng)

  Parameters

  • count: number

    Number of bytes (must be >= 16)

  • rng: { randomData: (size: number) => Uint8Array }

    Random number generator

  Returns Seed

  Throws

  CryptoError if count < 16

StaticnewOpt

• newOpt(
      data: Uint8Array,
      name: string | undefined,
      note: string | undefined,
      creationDate: Date | undefined,
  ): Seed

  Create a new seed from data and optional metadata.

  Rust equivalent: Seed::new_opt(data, name, note, creation_date)

  Parameters

  • data: Uint8Array

    Seed bytes (must be >= 16 bytes)

  • name: string | undefined

    Optional name for the seed

  • note: string | undefined

    Optional note for the seed

  • creationDate: Date | undefined

    Optional creation date

  Returns Seed

  Throws

  CryptoError if data < 16 bytes

Staticfrom

• from(data: Uint8Array, metadata?: SeedMetadata): Seed

  Create a Seed from raw bytes with optional metadata.

  Note: The input data is copied to prevent external mutation of the seed's internal state.

  Parameters

  • data: Uint8Array

    Seed bytes (must be >= 16 bytes)

  • Optionalmetadata: SeedMetadata

    Optional metadata object

  Returns Seed

StaticfromHex

• fromHex(hex: string, metadata?: SeedMetadata): Seed

  Create a Seed from hex string with optional metadata.

  Parameters

  • hex: string

    Hex string representing seed bytes

  • Optionalmetadata: SeedMetadata

    Optional metadata object

  Returns Seed

Staticrandom

• random(size?: number, metadata?: SeedMetadata): Seed

  Generate a random seed with specified size (default 32 bytes).

  Convenience method that wraps newWithLen().

  Parameters

  • size: number = 32

    Number of bytes (must be >= 16, default 32)

  • Optionalmetadata: SeedMetadata

    Optional metadata object

  Returns Seed

StaticrandomUsing

• randomUsing(
      rng: { randomData: (size: number) => Uint8Array },
      size?: number,
      metadata?: SeedMetadata,
  ): Seed

  Generate a random seed using provided RNG.

  Convenience method that wraps newWithLenUsing().

  Parameters

  • rng: { randomData: (size: number) => Uint8Array }

    Random number generator

  • size: number = 32

    Number of bytes (must be >= 16, default 32)

  • Optionalmetadata: SeedMetadata

    Optional metadata object

  Returns Seed

asBytes

• asBytes(): Uint8Array

  Return the data of the seed as a reference to the internal bytes.

  Rust equivalent: seed.as_bytes()

  Note: Returns a reference to internal data. For a copy, use toData().

  Returns Uint8Array

toData

• toData(): Uint8Array

  Get the raw seed bytes (copy).

  Note: Returns a copy to prevent external mutation of the seed's internal state.

  Returns Uint8Array

toHex

• toHex(): string

  Get hex string representation.

  Returns string

toBase64

• toBase64(): string

  Get base64 representation.

  Returns string

size

• size(): number

  Get seed size in bytes.

  Returns number

name

• name(): string

  Return the name of the seed.

  Rust equivalent: seed.name() - returns empty string if not set.

  Returns string

setName

• setName(name: string): void

  Set the name of the seed.

  Rust equivalent: seed.set_name(name)

  Parameters

  • name: string

  Returns void

note

• note(): string

  Return the note of the seed.

  Rust equivalent: seed.note() - returns empty string if not set.

  Returns string

setNote

• setNote(note: string): void

  Set the note of the seed.

  Rust equivalent: seed.set_note(note)

  Parameters

  • note: string

  Returns void

creationDate

• creationDate(): Date | undefined

  Return the creation date of the seed.

  Rust equivalent: seed.creation_date()

  Returns Date | undefined

setCreationDate

• setCreationDate(creationDate: Date | undefined): void

  Set the creation date of the seed.

  Rust equivalent: seed.set_creation_date(date)

  Parameters

  • creationDate: Date | undefined

  Returns void

createdAt

• createdAt(): Date | undefined

  Return the creation date of the seed (alias for creationDate).

  Returns Date | undefined

  Deprecated

  Use creationDate() for Rust API parity.

setCreatedAt

• setCreatedAt(date: Date): void

  Set the creation date of the seed (alias for setCreationDate).

  Parameters

  • date: Date

  Returns void

  Deprecated

  Use setCreationDate() for Rust API parity.

getMetadata

• getMetadata(): SeedMetadata

  Get metadata as an object.

  TypeScript convenience method - returns a snapshot of current metadata.

  Returns SeedMetadata

equals

• equals(other: Seed): boolean

  Compare with another Seed.

  Parameters

  • other: Seed

  Returns boolean

toString

• toString(): string

  Get string representation.

  Returns string

privateKeyData

• privateKeyData(): Uint8Array

  Returns unique data from which cryptographic keys can be derived.

  This implementation returns a copy of the seed data, which can be used as entropy for deriving private keys in various cryptographic schemes.

  Returns Uint8Array

  A Uint8Array containing the seed data

cborTags

• cborTags(): Tag[]

  Returns the CBOR tags associated with Seed. Includes TAG_SEED (40300) and TAG_SEED_V1 (300) for backward compatibility.

  Returns Tag[]

untaggedCbor

• untaggedCbor(): Cbor

  Returns the untagged CBOR encoding (as a map). Map keys:

  • 1: seed data (required)
  • 2: creation date (optional)
  • 3: name (optional, omitted if empty)
  • 4: note (optional, omitted if empty)

  Returns Cbor

taggedCbor

• taggedCbor(): Cbor

  Returns the tagged CBOR encoding.

  Returns Cbor

taggedCborData

• taggedCborData(): Uint8Array

  Returns the tagged value in CBOR binary representation.

  Returns Uint8Array

fromUntaggedCbor

• fromUntaggedCbor(cborValue: Cbor): Seed

  Creates a Seed by decoding it from untagged CBOR.

  Parameters

  • cborValue: Cbor

  Returns Seed

fromTaggedCbor

• fromTaggedCbor(cbor: Cbor): Seed

  Creates a Seed by decoding it from tagged CBOR.

  Parameters

  • cbor: Cbor

  Returns Seed

StaticfromTaggedCbor

• fromTaggedCbor(cborValue: Cbor): Seed

  Static method to decode from tagged CBOR.

  Parameters

  • cborValue: Cbor

  Returns Seed

StaticfromTaggedCborData

• fromTaggedCborData(data: Uint8Array): Seed

  Static method to decode from tagged CBOR binary data.

  Parameters

  • data: Uint8Array

  Returns Seed

StaticfromUntaggedCborData

• fromUntaggedCborData(data: Uint8Array): Seed

  Static method to decode from untagged CBOR binary data.

  Parameters

  • data: Uint8Array

  Returns Seed

ur

• ur(): UR

  Returns the UR representation of the Seed. Note: URs use untagged CBOR since the type is conveyed by the UR type itself.

  Returns UR

urString

• urString(): string

  Returns the UR string representation.

  Returns string

StaticfromUR

• fromUR(ur: UR): Seed

  Creates a Seed from a UR.

  Parameters

  • ur: UR

  Returns Seed

StaticfromURString

• fromURString(urString: string): Seed

  Creates a Seed from a UR string.

  Parameters

  • urString: string

  Returns Seed