Struct AirGappedOrgBundle 

pub struct AirGappedOrgBundle {
    pub schema_version: u32,
    pub org_did: IdentityDID,
    pub org_prefix: Prefix,
    pub built_at_org_seq: u128,
    pub built_at: String,
    pub org_kel: BundledKel,
    pub member_kels: Vec<BundledKel>,
    pub offboarding_records: Vec<SignedOffboardingRecord>,
    pub pinned_roots: Vec<IdentityDID>,
}

A self-contained, URL-free bundle for offline first-party org/member provenance.

Fields

schema_version: u32

Wire-format schema version (AIR_GAPPED_ORG_BUNDLE_SCHEMA_VERSION).

org_did: IdentityDID

The org’s did:keri: (validated on deserialize).

org_prefix: Prefix

The org’s KEL prefix.

built_at_org_seq: u128

The org KEL sequence at build time — the offline verifier reports “verified as-of KEL position X”.

built_at: String

Build timestamp (RFC 3339). Provenance only — authority ordering is by KEL position, never this wall-clock value.

org_kel: BundledKel

The org’s KEL (delegation, scope, and revocation seals all ride here).

member_kels: Vec<BundledKel>

Each delegated member’s own KEL (live and revoked members both included so the verifier can classify any artifact).

offboarding_records: Vec<SignedOffboardingRecord>

Durable, signed off-boarding records.

pinned_roots: Vec<IdentityDID>

Pinned trust roots — for a first-party org bundle, the org itself. The verifier trusts these DIDs and reads their keys from the bundled KEL.

Implementations

impl AirGappedOrgBundle

pub fn to_canonical_json(&self) -> Result<String, OrgBundleError>

Serialize the bundle to deterministic, canonical JSON (RFC 8785 via json-canon) — the on-disk/wire form.

Usage:

std::fs::write(out, bundle.to_canonical_json()?)?;

pub fn from_json(json: &str) -> Result<AirGappedOrgBundle, OrgBundleError>

Parse a bundle from its JSON form. Typed identifiers fail closed on malformed input.

Usage:

let bundle = AirGappedOrgBundle::from_json(&std::fs::read_to_string(path)?)?;

pub fn authenticated_org_state(&self) -> Result<KeyState, OrgBundleError>

The org’s authenticated key state, derived from the bundled org KEL alone.

Authenticates the embedded org KEL (RT-002 — every event SAID-correct AND signed by the controlling key-state, not merely structurally valid) and returns the resolved auths_keri::KeyState. The org KEL is the root of trust, so it authenticates with no delegator lookup.

This is the one public call for “give me the org’s authenticated key state from evidence alone” — the only trust-rooted source of the org’s current verkey available offline (e.g. to verify a DSSE envelope the org signed). Every downstream verifier (CI gate, browser widget, third-party audit tool) shares it instead of re-implementing the authenticate-then-resolve path.

Fails closed (OrgBundleError::Integrity) on a tampered event, a length mismatch between events and attachments, an unparseable attachment, or a signature that does not verify.

Usage:

let state = bundle.authenticated_org_state()?;
let org_verkey = state.current_key();

Trait Implementations

impl Clone for AirGappedOrgBundle

fn clone(&self) -> AirGappedOrgBundle

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AirGappedOrgBundle

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AirGappedOrgBundle

fn deserialize<__D>( __deserializer: __D, ) -> Result<AirGappedOrgBundle, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for AirGappedOrgBundle

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.