Struct Keys 

pub struct Keys {
    pub own: Vec<Cert>,
    pub others: Vec<Cert>,
    pub cards: Vec<KnownCard>,
    pub shared: Vec<KnownCard>,
    pub addresses: Vec<String>,
}

The keys Sioul knows: yours (their secret parts here, or on a security key), others’, and your security keys.

Fields

own: Vec<Cert>

others: Vec<Cert>

cards: Vec<KnownCard>

Your security keys read on this device, as pgp/cards.toml lists them: they alone sign here (review of 19 October 2026, F18).

shared: Vec<KnownCard>

Your security keys your other devices made known and this one did not read (pgp/cards/), those stopped here aside (pgp/stopped.toml): they serve encryption to you, Autocrypt and the reader’s words, never signing here.

addresses: Vec<String>

Your addresses: your accounts’ (config.toml). With the addresses your security keys serve, they are yours whatever certificate claims them; never taken from a certificate’s user IDs (review of 19 October 2026, F1).

Implementations

impl Keys

pub fn load() -> Keys

pub fn load_at(root: &Path) -> Keys

The keys of the folder root (pgp/): yours, others’, your security keys (cards.toml), and those your other devices made known (cards/, securitykey::shared_cards): a security key read on your computer, its certificate with it, so that a phone encrypts to you, hands your key by Autocrypt and says what waits for the key. A key this device read itself says what it is; its certificate is merged with the shared one (a renewal made on another computer).

pub fn own_for(&self, address: &str) -> Option<Own<'_>>

Your key for an address, able to sign now. A security key read on this device that serves the address comes first, and alone: a key kept here for the same address only opens older mail. When that security key’s certificate expired, nothing signs for the address until it is renewed. A security key another computer read signs nowhere but there (review of 19 October 2026, F18): to sign here, it is read here.

pub fn card_for(&self, address: &str) -> Option<(&KnownCard, &Cert)>

The security key read here that signs for address, and its certificate, even when it expired: to say so.

pub fn serving_card(&self, address: &str) -> Option<(&KnownCard, &Cert)>

The security key of yours that serves address, read here or on another device of yours, and its certificate: encryption to you, Autocrypt, and what the reader says wait for it.

pub fn all_cards(&self) -> impl Iterator<Item = &KnownCard>

Every security key of yours known here: read here first, then those your other devices made known.

pub fn cert(&self, fingerprint: &str) -> Option<&Cert>

Your certificate of this fingerprint.

pub fn for_address(&self, address: &str) -> Option<&Cert>

A key to encrypt to address: someone’s, or yours. For one of your own addresses, your own key alone: never a certificate someone sent claiming it (an Autocrypt header, a lookup), which would read what you send yourself; none when yours cannot take encryption now.

Someone’s keys are kept for the address each came for alone (for_its_address). Two of them for one address (a key made anew, the old one kept): the one whose newest live encryption key is the most recent, then the one whose primary key is, then by fingerprint; never the order the folder lists them in (review of 19 October 2026, F2). Others’ before a key of yours that names the address.

pub fn self_cert_for(&self, address: &str) -> Option<&Cert>

Your own certificate to encrypt to, for address: your security key’s when one serves the address (its certificate as your computer read it), else a key of yours naming it; none when it cannot take encryption now (expired, revoked).

pub fn own_certs(&self) -> Vec<&Cert>

Your own certificates that can take what is sealed for you alone (your security keys’, as your computer read them, and your keys here): an encryption key not revoked, expired or not, since you open such a seal with it (F19); never a certificate revoked as a whole (N3). Encrypted to each, any of them opens it.

pub fn is_own_address(&self, address: &str) -> bool

Whether address is yours: one of your accounts’ addresses, or one a security key of yours serves. Never from a certificate’s user IDs, which anyone can write (review of 19 October 2026, F1).

pub fn usable(&self, cert: &Cert) -> bool

Whether cert may serve: valid, not revoked as a whole (usable), and not revoked by its designated revoker (a Revocation Key, GnuPG’s addrevoker) whose own certificate is kept here, yours or someone’s, the revocation checked against it (review of 19 October 2026, R2). Sequoia says such a revocation “could be”, leaving that check to whoever holds the revoker’s certificate; one that does not check is passed over, since anyone can attach one.

fn serves(&self, cert: &Cert, address: &str) -> bool

Whether cert serves address: bound to it and usable here (names, Keys::usable).

pub fn is_yours(&self, fingerprint: &Fingerprint) -> bool

Whether fingerprint is one of your certificates: kept with yours, or your security keys’ (cards.toml).

fn all(&self) -> impl Iterator<Item = &Cert>

fn by_handle(&self, handle: &KeyHandle) -> Option<&Cert>

Trait Implementations

impl Clone for Keys

fn clone(&self) -> Keys

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for Keys

fn default() -> Keys

Returns the “default value” for a type.