Enum DlcKey 

pub enum DlcKey {
    Private {
        privkey: PrivateKey,
        pubkey: PublicKey,
    },
    Public {
        pubkey: PublicKey,
    },
}

Client-side wrapper for Ed25519 key operations: verify tokens and (when private) create compact signed tokens.

Variants

Private

Private key (protected seed + public bytes + public key tag)

Fields

privkey: PrivateKey

Protected signing seed (secure wrapper)

pubkey: PublicKey

Public key bytes (wrapped)

Public

Public-only key (public bytes)

Fields

pubkey: PublicKey

Public key bytes (wrapped)

Implementations

impl DlcKey

pub fn new(pubkey: &str, privkey: &str) -> Result<Self, DlcError>

pub fn public(pubkey: &str) -> Result<Self, DlcError>

Construct a DlcKey::Public from a base64url-encoded public key string.

pub fn generate_random() -> Self

Generate a new DlcKey::Private with a random seed and derived public key.

The public key is derived from the generated seed so the keypair is valid.

pub fn get_public_key(&self) -> &PublicKey

pub fn sign(&self, data: &[u8]) -> Result<[u8; 64], DlcError>

Sign data using the private key. Returns a 64-byte signature.

pub fn verify(&self, data: &[u8], signature: &[u8; 64]) -> Result<(), DlcError>

Verify a 64-byte Ed25519 signature against provided data.

pub fn create_signed_license<D>( &self, dlcs: impl IntoIterator<Item = D>, product: Product, ) -> Result<SignedLicense, DlcError>

where D: Display,

Create a compact offline-signed token that can be verified by this key’s public key.

Returns a SignedLicense (zeroized on drop). The license payload includes the provided DLC ids and product binding. Create a compact offline-signed token (SignedLicense).

pub fn extend_signed_license<D>( &self, existing: &SignedLicense, new_dlcs: impl IntoIterator<Item = D>, product: Product, ) -> Result<SignedLicense, DlcError>

where D: Display,

Extend an existing signed license by merging additional DLC ids while preserving backwards compatibility.

Extracts the DLC ids from an existing (unsigned or unverified) license payload, merges them with the provided new DLC ids (with deduplication), and creates a fresh signed license with the combined list. The product must match this key’s current product.

Important: This creates a NEW signed token with a potentially different signature, but the payload contains all previous DLC ids plus the new ones. Existing DLC packs remain unlocked by the new license.

Example

use bevy_dlc::{DlcKey, SignedLicense, Product};

// in a real program you would obtain a key and product from your build
// process or configuration.  we use simple constructors here so the
// example compiles without panicking.
let dlc_key: DlcKey = DlcKey::generate_random();
let product: Product = Product::from("my_game");

let old_license = SignedLicense::from("...existing token...");
let _new_license = dlc_key
    .extend_signed_license(&old_license, &["new_expansion"], product)
    .unwrap();

pub fn verify_signed_license(&self, license: &SignedLicense) -> bool

Verify a compact signed-license (signature + payload) using this key’s public key Verify a compact signed-license using this key’s public key.

Returns true if the signature is valid and the token is well-formed, false otherwise. No further payload validation is performed.

Trait Implementations

impl Clone for DlcKey

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Display for DlcKey

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

Formats the value using the given formatter.

impl From<&DlcKey> for String

fn from(k: &DlcKey) -> Self

Converts to this type from the input type.

impl Resource for DlcKey

where Self: Send + Sync + 'static,