Struct Seed 

pub struct Seed { /* private fields */ }

A cryptographic seed for deterministic key generation.

A Seed is a source of entropy used to generate cryptographic keys in a deterministic manner. Unlike randomly generated keys, seed-derived keys can be recreated if you have the original seed, making them useful for backup and recovery scenarios.

This implementation of Seed includes the random seed data as well as optional metadata:

• A name (for identifying the seed)
• A note (for storing additional information)
• A creation date

The minimum seed length is 16 bytes to ensure sufficient security and entropy.

CBOR Serialization

Seed implements the CBORTaggedCodable trait, which means it can be serialized to and deserialized from CBOR with specific tags. The tags used are TAG_SEED and the older TAG_SEED_V1 for backward compatibility.

When serialized to CBOR, a Seed is represented as a map with the following keys:

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

UR Serialization

When serialized as a Uniform Resource (UR), a Seed is represented with the type “seed”.

Key Derivation

A Seed implements the PrivateKeyDataProvider trait, which means it can be used as a source of entropy for deriving private keys in various cryptographic schemes.

Examples

Creating a new random seed:

use bc_components::Seed;

// Create a new random seed with default length (16 bytes)
let seed = Seed::new();

Creating a seed with a specific length:

use bc_components::Seed;

// Create a seed with 32 bytes of entropy
let seed = Seed::new_with_len(32).unwrap();

Creating a seed with metadata:

use bc_components::Seed;
use dcbor::prelude::*;

// Create seed data
let data = vec![0u8; 16];

// Create a seed with name, note, and creation date
let mut seed = Seed::new_opt(
    data,
    Some("Wallet Backup".to_string()),
    Some("Cold storage backup for main wallet".to_string()),
    Some(Date::now()),
)
.unwrap();

// Modify metadata
seed.set_name("Updated Wallet Backup");

Implementations

impl Seed

pub const MIN_SEED_LENGTH: usize = 16usize

pub fn new() -> Self

Create a new random seed.

The length of the seed will be 16 bytes.

pub fn new_with_len(count: usize) -> Result<Self>

Create a new random seed with a specified length.

If the number of bytes is less than 16, this will return None.

pub fn new_with_len_using( count: usize, rng: &mut impl RandomNumberGenerator, ) -> Result<Self>

Create a new random seed with a specified length.

If the number of bytes is less than 16, this will return None.

pub fn new_opt( data: impl AsRef<[u8]>, name: Option<String>, note: Option<String>, creation_date: Option<Date>, ) -> Result<Self>

Create a new seed from the data and options.

If the data is less than 16 bytes, this will return None.

pub fn as_bytes(&self) -> &[u8]

Return the data of the seed.

pub fn name(&self) -> &str

Return the name of the seed.

pub fn set_name(&mut self, name: &str)

Set the name of the seed.

pub fn note(&self) -> &str

Return the note of the seed.

pub fn set_note(&mut self, note: &str)

Set the note of the seed.

pub fn creation_date(&self) -> &Option<Date>

Return the creation date of the seed.

pub fn set_creation_date(&mut self, creation_date: Option<Date>)

Set the creation date of the seed.

Trait Implementations

impl AsRef<[u8]> for Seed

Allows using a Seed as a reference to a byte slice.

fn as_ref(&self) -> &[u8]

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<Seed> for Seed

Provides a self-reference, enabling API consistency with other types.

fn as_ref(&self) -> &Seed

Converts this type into a shared reference of the (usually inferred) input type.

impl CBORTagged for Seed

Identifies the CBOR tags used for Seed serialization, including the legacy tag.

fn cbor_tags() -> Vec<Tag>

Returns the CBOR tags associated with this type.

impl CBORTaggedDecodable for Seed

Defines how a Seed is decoded from CBOR.

fn from_untagged_cbor(cbor: CBOR) -> Result<Self>

Creates an instance of this type by decoding it from untagged CBOR.

fn from_tagged_cbor(cbor: CBOR) -> Result<Self, Error>

where Self: Sized,

Creates an instance of this type by decoding it from tagged CBOR.

fn from_tagged_cbor_data(data: impl AsRef<[u8]>) -> Result<Self, Error>

where Self: Sized,

Creates an instance of this type by decoding it from binary encoded tagged CBOR.

fn from_untagged_cbor_data(data: impl AsRef<[u8]>) -> Result<Self, Error>

where Self: Sized,

Creates an instance of this type by decoding it from binary encoded untagged CBOR.

impl CBORTaggedEncodable for Seed

Defines how a Seed is encoded as CBOR (as a map with data and metadata).

fn untagged_cbor(&self) -> CBOR

Returns the untagged CBOR encoding of this instance.

fn tagged_cbor(&self) -> CBOR

Returns the tagged CBOR encoding of this instance.

fn tagged_cbor_data(&self) -> Vec<u8>

Returns the tagged value in CBOR binary representation.

impl Clone for Seed

fn clone(&self) -> Seed

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Seed

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Seed

Provides a default implementation that creates a new random seed with the minimum length.

fn default() -> Self

Returns the “default value” for a type.

impl From<Seed> for CBOR

Enables conversion of a Seed into a tagged CBOR value.

fn from(value: Seed) -> Self

Converts to this type from the input type.

impl Hash for Seed

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Seed

fn eq(&self, other: &Seed) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PrivateKeyDataProvider for Seed

Implements PrivateKeyDataProvider to use seed data for key derivation.

fn private_key_data(&self) -> Vec<u8>

Returns unique data from which cryptographic keys can be derived.

impl TryFrom<CBOR> for Seed

Enables conversion from CBOR to Seed, with proper error handling.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(cbor: CBOR) -> Result<Self>

Performs the conversion.

impl Eq for Seed

impl StructuralPartialEq for Seed