Struct iroh_p2p::Keychain

pub struct Keychain<S: Storage> { /* private fields */ }

A keychain to manage your keys.

Implementations

impl<S: Storage> Keychain<S>

pub fn from_storage(storage: S) -> Self

Create a keychain based on the provided storage.

Examples found in repository

src/keys.rs (line 104)

    fn default() -> Self {
        let storage = MemoryStorage::default();
        Self::from_storage(storage)
    }
}

impl Keychain<MemoryStorage> {
    pub fn new() -> Self {
        Default::default()
    }
}

impl Keychain<DiskStorage> {
    /// Creates a new on disk keychain, with the root defaulting to `.iroh`.
    pub async fn new(root: PathBuf) -> Result<Self> {
        Self::with_root(root).await
    }

    /// Creates a new on disk keychain, located at the given path.
    ///
    /// If the path does not exist it is created.
    pub async fn with_root(root: PathBuf) -> Result<Self> {
        let storage = DiskStorage::new(&root).await?;
        Ok(Self::from_storage(storage))
    }

pub async fn create_ed25519_key(&mut self) -> Result<()>

Creates a new Ed25519 based key and stores it.

Examples found in repository

src/node.rs (line 1061)

async fn load_identity<S: Storage>(kc: &mut Keychain<S>) -> Result<Keypair> {
    if kc.is_empty().await? {
        info!("no identity found, creating",);
        kc.create_ed25519_key().await?;
    }

    // for now we just use the first key
    let first_key = kc.keys().next().await;
    if let Some(keypair) = first_key {
        let keypair: Keypair = keypair?.into();
        info!("identity loaded: {}", PeerId::from(keypair.public()));
        return Ok(keypair);
    }

    Err(anyhow!("inconsistent keystate"))
}

pub fn keys(&self) -> impl Stream<Item = Result<Keypair>> + '_

Returns a stream of all keys stored.

Examples found in repository

src/node.rs (line 1065)

async fn load_identity<S: Storage>(kc: &mut Keychain<S>) -> Result<Keypair> {
    if kc.is_empty().await? {
        info!("no identity found, creating",);
        kc.create_ed25519_key().await?;
    }

    // for now we just use the first key
    let first_key = kc.keys().next().await;
    if let Some(keypair) = first_key {
        let keypair: Keypair = keypair?.into();
        info!("identity loaded: {}", PeerId::from(keypair.public()));
        return Ok(keypair);
    }

    Err(anyhow!("inconsistent keystate"))
}

pub async fn len(&self) -> Result<usize>

Returns how many keys are stored in this keychain.

pub async fn is_empty(&self) -> Result<bool>

Returns true if there are no keys stored.

Examples found in repository

src/node.rs (line 1059)

async fn load_identity<S: Storage>(kc: &mut Keychain<S>) -> Result<Keypair> {
    if kc.is_empty().await? {
        info!("no identity found, creating",);
        kc.create_ed25519_key().await?;
    }

    // for now we just use the first key
    let first_key = kc.keys().next().await;
    if let Some(keypair) = first_key {
        let keypair: Keypair = keypair?.into();
        info!("identity loaded: {}", PeerId::from(keypair.public()));
        return Ok(keypair);
    }

    Err(anyhow!("inconsistent keystate"))
}

impl Keychain<MemoryStorage>

pub fn new() -> Self

impl Keychain<DiskStorage>

pub async fn new(root: PathBuf) -> Result<Self>

Creates a new on disk keychain, with the root defaulting to .iroh.

pub async fn with_root(root: PathBuf) -> Result<Self>

Creates a new on disk keychain, located at the given path.

If the path does not exist it is created.

Examples found in repository

src/keys.rs (line 117)

    pub async fn new(root: PathBuf) -> Result<Self> {
        Self::with_root(root).await
    }

Trait Implementations

impl<S: Debug + Storage> Debug for Keychain<S>

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

Formats the value using the given formatter.

impl Default for Keychain<MemoryStorage>

fn default() -> Self

Returns the “default value” for a type.