sigil-core · genesis

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GenesisConfig {
/// Chain identifier.

pub chain_id: ChainId,
/// Unix timestamp for genesis block.

pub genesis_time: u64,
/// Protocol version at genesis.

pub protocol_version: String,
/// Initial validator set with their stakes.

pub validators: Vec<GenesisValidator>,
/// Initial account balances (DID -> balance in micro-MINT).

#[serde(default)]
pub balances: HashMap<String, u64>,
/// Initial identity documents for launch/custody DIDs.

///

/// A DID with a genesis balance but no identity document is spend-locked

/// until a key-derived self-registration is possible. Mainnet launch

/// custody accounts should seed explicit identity documents here.

#[serde(default, skip_serializing_if = "HashMap::is_empty")]
pub identities: HashMap<String, serde_json::Value>,
/// Protocol parameters.

pub params: ProtocolParams,
/// Economic parameters.

pub economics: EconomicParams,
/// Tower consensus parameters (slot duration, epoch length, committee sizes).

/// Absent in old genesis files — defaults applied automatically.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub tower_params: Option<TowerParams>,
/// On-chain governance parameters (deposits, voting period, quorum, timelock).

/// Absent in old genesis files — defaults applied automatically.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub governance_params: Option<GovernanceParams>,
/// Smart-contract platform parameters.

/// Absent in old genesis files — defaults applied automatically.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub contract_params: Option<ContractParams>,
/// CZAC protocol parameters.

/// Absent in old genesis files — defaults applied automatically.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub czac_params: Option<CzacParams>,
/// Vigils event-driven autonomous contract parameters.

/// Absent in old genesis files — defaults applied automatically.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub vigils_params: Option<VigilsParams>,
/// Nova metaverse launch configuration.

/// Absent in old genesis files — defaults to disabled/no genesis worlds.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub nova_params: Option<crate::nova::NovaParams>,
/// Reference contracts deployed as part of genesis.

#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub reference_contracts: Vec<GenesisReferenceContract>,
/// Compute marketplace parameters.

#[cfg(feature = "compute")]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub compute_params: Option<ComputeParams>,
/// On-chain `@username` registry parameters (length-tier prices, multiplier,

/// reserved list, dispute multisig DIDs). Absent in old genesis files —

/// defaults applied via `effective_username_params`.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub username_params: Option<crate::username::UsernameParams>
}

pub fn compute_state_root(&self) -> Result<SigilHash, crate::error::CoreError>;

pub fn validate(&self) -> Result<(), GenesisValidationError>;

pub fn testnet_default() -> Self;

pub fn effective_tower_params(&self) -> TowerParams;

pub fn effective_governance_params(&self) -> GovernanceParams;

pub fn effective_contract_params(&self) -> ContractParams;

pub fn effective_czac_params(&self) -> CzacParams;

pub fn effective_vigils_params(&self) -> VigilsParams;

pub fn effective_nova_params(&self) -> crate::nova::NovaParams;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GenesisReferenceContract {
pub name: String,
pub version: String,
pub contract_did: String,
pub controller_did: String,
pub runtime: ContractRuntime,
pub code_hash: String,
/// Hex-encoded WASM bytecode. Embedded in genesis so validators deploy

/// identical content-addressed code without filesystem dependencies.

pub code_hex: String,
#[serde(default)]
pub init_args: serde_json::Value,
pub upgrade_policy: ControlPolicy,
pub call_policy: ControlPolicy,
#[serde(default)]
pub allowed_host_functions: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub zone_id: Option<String>,
pub contract_kind: ContractKind,
#[serde(default)]
pub accepts_vigil_callbacks: bool,
pub license_metadata: ContractLicenseMetadata
}

pub fn code_bytes(&self) -> Result<Vec<u8>, String>;

pub fn parsed_code_hash(&self) -> Result<SigilHash, String>;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GenesisValidator {
/// OAS DID of the validator entity.

pub did: String,
/// Human root DID in the lineage chain.

pub human_root_did: String,
/// Generation distance from human root.

pub generation: u32,
/// Initial stake in micro-MINT.

pub stake: u64,
/// Validator mode.

pub mode: ValidatorGenesisMode,
/// Ed25519 consensus public key (hex-encoded).

pub consensus_pubkey: String,
/// P2P networking public key (hex-encoded).

pub network_pubkey: String
}

pub fn validate_validator_did(did: &str) -> Result<(), GenesisValidationError>;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ValidatorGenesisMode {
    /// Block Producer: executes transactions and generates ZK proofs.
    BlockProducer,
    /// Block Validator: verifies ZK proofs without re-executing.
    BlockValidator,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProtocolParams {
/// Backward-compatible target block time in whole seconds.

pub target_block_time_secs: u64,
/// Precise target block time in milliseconds. When present, this is the

/// canonical value; `target_block_time_secs` is retained for older config

/// files and coarse operator displays.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub target_block_time_ms: Option<u64>,
/// Blocks per epoch.

pub blocks_per_epoch: u64,
/// Maximum transactions per block.

pub max_txs_per_block: u32,
/// Maximum block gas limit.

pub max_block_gas: u64,
/// Ed25519 transaction signature batch size for validator admission.

///

/// This is a node-performance knob, not consensus entropy: different

/// values still verify the same ordered transaction list deterministically.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub signature_batch_size: Option<usize>,
/// Minimum stake for Block Producers (micro-MINT).

pub min_bp_stake: u64,
/// Minimum stake for Block Validators (micro-MINT).

pub min_bv_stake: u64,
/// Unbonding period in epochs.

pub unbonding_epochs: u32,
/// Maximum validators in the active set.

pub max_validators: u32
}

pub fn target_block_time_millis(&self) -> u64;

pub fn target_block_time_seconds(&self) -> f64;

pub fn signature_batch_size(&self) -> usize;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EconomicParams {
/// Base block reward in micro-MINT.

pub base_block_reward: u64,
/// Lineage generation decay factor (beta).

pub generation_decay_beta: f64,
/// Minimum human root share of rewards (as fraction, e.g., 0.51).

pub min_human_share: f64,
/// Treasury allocation fraction (e.g., 0.15).

pub treasury_fraction: f64,
/// Slashing lineage propagation factor (delta).

pub slashing_delta: f64,
/// Publisher bond slash distribution: reporter share.

pub bond_slash_reporter: f64,
/// Publisher bond slash distribution: harmed party share.

pub bond_slash_harmed: f64,
/// Publisher bond slash distribution: treasury share.

pub bond_slash_treasury: f64
}

#[cfg(feature = "compute")]
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ComputeParams {
/// Minimum stake for compute providers by tier (micro-MINT).

pub provider_stake_tiers: ProviderStakeTiers,
/// Challenge window in epochs.

pub challenge_window_epochs: u32,
/// Number of arbitrators for challenge resolution.

pub arbitration_committee_size: u32,
/// Challenge success split: challenger share.

pub challenge_success_challenger: f64,
/// Challenge success split: arbitrators share.

pub challenge_success_arbitrators: f64,
/// Challenge success split: treasury share.

pub challenge_success_treasury: f64,
/// Sentinel probe interval in seconds.

pub sentinel_probe_interval_secs: u64,
/// Allowlist of DIDs authorised to resolve compute challenges. The

/// executor MUST fail closed when the sender is not in this list. An

/// empty list disables challenge resolution entirely (intentional —

/// safer default than implicit prefix-matching authority).

#[serde(default)]
pub challenge_resolver_dids: Vec<String>,
/// When `true`, T3 (TEE) receipts may settle. When `false`, the

/// executor refuses T3 settlement (vendor-specific TEE crypto is not

/// yet wired). Default is `false`.

#[serde(default)]
pub tee_verifier_enabled: bool,
/// Provider exit cooldown in epochs.

#[serde(default = "default_unbonding_epochs")]
pub unbonding_epochs: u64,
/// Default challenger deposit (micro-MINT) when the tx omits one.

#[serde(default = "default_challenge_deposit")]
pub default_challenge_deposit: u64,
/// Phase 12 — DIDs authorised to submit `MacaProposeEpoch` /

/// `MacaFinalizeEpoch`. Empty disables MACA epoch proposal.

#[serde(default)]
pub proposer_dids: Vec<String>,
/// Phase 12 — DIDs authorised to submit `MacaPublishBeacon`.

#[serde(default)]
pub beacon_dids: Vec<String>,
/// Phase 12 — minimum agreeing validators for `MacaQuorumProof`

/// to be `Confirmed`.

#[serde(default = "default_validator_quorum_threshold")]
pub validator_quorum_threshold: u32,
/// Permit settlement of receipts with no stored compute job. This is a

/// named compatibility mode only; mainnet and canary default it off.

#[serde(default)]
pub allow_ad_hoc_receipts: bool,
/// Phase 14a — AMD SEV-SNP trust anchors. SEC1-uncompressed VCEK

/// pubkeys + SHA-384 measurement allowlist. `None` keeps the

/// SEV-SNP verifier in Phase 13 fail-closed mode.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub sev_snp_trust_anchors: Option<SevSnpTrustAnchorsGenesis>,
/// Phase 14b — Intel SGX DCAP trust anchors. Pinned Intel SGX Root

/// CA fingerprint + MRENCLAVE / MRSIGNER allowlists + freshness +

/// minimum SVN. `None` keeps the SGX verifier in fail-closed mode.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub sgx_dcap_trust_anchors: Option<SgxDcapTrustAnchorsGenesis>,
/// Phase 14c — Intel TDX trust anchors. Pinned Intel SGX Root CA

/// fingerprint + MRTD / MRSIGNER_SEAM / RTMR allowlists +

/// collateral. `None` keeps the TDX verifier in fail-closed mode.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub tdx_trust_anchors: Option<TdxTrustAnchorsGenesis>,
/// Phase 14d — Arm CCA trust anchors. Pinned IAK pubkey(s) + RIM

/// allowlist + receipt-binding/freshness toggles. `None` keeps

/// the Arm CCA verifier in fail-closed mode.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub arm_cca_trust_anchors: Option<ArmCcaTrustAnchorsGenesis>
}

#[cfg(feature = "compute")]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct SevSnpTrustAnchorsGenesis {
#[serde(default)]
pub acceptable_vcek_pubkeys: Vec<Vec<u8>>,
#[serde(
        default,
        serialize_with = "bytes_hex_vec_serde::serialize",
        deserialize_with = "bytes_hex_vec_serde::deserialize"
    )]
pub measurement_allowlist: Vec<Vec<u8>>,
/// SHA-256 of the AMD ARK certificate (DER form). When set, the

/// verifier validates the cert chain VCEK→ASK→ARK and extracts the

/// VCEK pubkey from it.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub pinned_ark_fingerprint_sha256: Option<[u8; 32]>,
/// SHA-256 of the AMD ASK / product signing certificate (DER form).

/// When set, the chain accepts only SEV-SNP attestations carrying the

/// product ASK pinned here.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub pinned_ask_fingerprint_sha256: Option<[u8; 32]>,
/// Optional exact VCEK allowlist by chip ID and reported TCB.

#[serde(default)]
pub vcek_allowlist: Vec<SevSnpVcekAllowlistEntryGenesis>,
/// Maximum attestation age in chain epochs.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub max_attestation_age_epochs: Option<u64>,
/// Minimum SEV-SNP TCB version components.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub min_tcb: Option<SevSnpTcbGenesis>,
/// Require REPORT_DATA receipt-binding on every report.

#[serde(default)]
pub require_receipt_binding: bool
}

#[cfg(feature = "compute")]
pub fn serialize<S>(values: &[Vec<u8>], serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,;

#[cfg(feature = "compute")]
pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<Vec<u8>>, D::Error>
    where
        D: Deserializer<'de>,;

#[cfg(feature = "compute")]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct SevSnpVcekAllowlistEntryGenesis {
pub product: String,
pub chip_id: Vec<u8>,
pub tcb: SevSnpTcbGenesis,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub vcek_fingerprint_sha256: Option<[u8; 32]>
}

#[cfg(feature = "compute")]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
pub struct SevSnpTcbGenesis {
pub bootloader: u8,
pub tee: u8,
pub snp: u8,
pub microcode: u8
}

#[cfg(feature = "compute")]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
pub struct SgxDcapTrustAnchorsGenesis {
/// SHA-256 of Intel SGX Root CA DER.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub pinned_intel_root_fingerprint_sha256: Option<[u8; 32]>,
/// 32-byte MRENCLAVE values the chain accepts.

#[serde(default)]
pub mrenclave_allowlist: Vec<Vec<u8>>,
/// 32-byte MRSIGNER values the chain accepts.

#[serde(default)]
pub mrsigner_allowlist: Vec<Vec<u8>>,
/// Freshness window in chain epochs.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub max_attestation_age_epochs: Option<u64>,
/// Minimum ISV enclave SVN.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub min_isv_svn: Option<u16>,
/// Minimum PCE SVN.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub min_pce_svn: Option<u16>,
/// Require REPORT_DATA receipt-binding on every quote.

#[serde(default)]
pub require_receipt_binding: bool,
// ----- Phase 14b-2 collateral hardening -----
#[serde(default, skip_serializing_if = "Option::is_none")]
pub intel_tcb_signing_cert_der: Option<Vec<u8>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tcb_info_json: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub qe_identity_json: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub pck_crl_der: Option<Vec<u8>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub root_ca_crl_der: Option<Vec<u8>>,
#[serde(default)]
pub allowed_tcb_statuses: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub collateral_max_age_epochs: Option<u64>
}

#[cfg(feature = "compute")]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
pub struct ArmCcaTrustAnchorsGenesis {
#[serde(default)]
pub pinned_iak_pubkeys_sec1: Vec<Vec<u8>>,
#[serde(default)]
pub rim_allowlist: Vec<Vec<u8>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub max_attestation_age_epochs: Option<u64>,
#[serde(default)]
pub require_receipt_binding: bool
}

#[cfg(feature = "compute")]
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
pub struct TdxTrustAnchorsGenesis {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub pinned_intel_root_fingerprint_sha256: Option<[u8; 32]>,
#[serde(default)]
pub mrtd_allowlist: Vec<Vec<u8>>,
#[serde(default)]
pub mrsigner_seam_allowlist: Vec<Vec<u8>>,
#[serde(default)]
pub rtmr0_allowlist: Vec<Vec<u8>>,
#[serde(default)]
pub rtmr1_allowlist: Vec<Vec<u8>>,
#[serde(default)]
pub rtmr2_allowlist: Vec<Vec<u8>>,
#[serde(default)]
pub rtmr3_allowlist: Vec<Vec<u8>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub max_attestation_age_epochs: Option<u64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub min_pce_svn: Option<u16>,
#[serde(default)]
pub require_receipt_binding: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub intel_tcb_signing_cert_der: Option<Vec<u8>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tcb_info_json: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub qe_identity_json: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub pck_crl_der: Option<Vec<u8>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub root_ca_crl_der: Option<Vec<u8>>,
#[serde(default)]
pub allowed_tcb_statuses: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub collateral_max_age_epochs: Option<u64>
}

#[cfg(feature = "compute")]
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProviderStakeTiers {
/// Consumer tier (micro-MINT).

pub consumer: u64,
/// Professional tier (micro-MINT).

pub professional: u64,
/// Enterprise tier (micro-MINT).

pub enterprise: u64,
/// Cluster tier (micro-MINT).

pub cluster: u64
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TowerParams {
/// Slot duration in seconds.

pub slot_duration_secs: u64,
/// Number of slots per epoch.

pub slots_per_epoch: u64,
/// Minimum stake to become a Tower validator (micro-MINT).

pub min_tower_stake: u64,
/// Tower committee size (Block Producers per slot).

pub bp_committee_size: u32,
/// Tower committee size (Block Validators per slot).

pub bv_committee_size: u32
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GovernanceParams {
/// Minimum deposit for a parameter change proposal (micro-MINT).

pub proposal_deposit_parameter: u64,
/// Minimum deposit for a WASI module upgrade proposal (micro-MINT).

pub proposal_deposit_wasi: u64,
/// Minimum deposit for a treasury spend proposal (micro-MINT).

pub proposal_deposit_treasury: u64,
/// Minimum deposit for a validator slashing proposal (micro-MINT).

pub proposal_deposit_slashing: u64,
/// Minimum deposit for an emergency action proposal (micro-MINT).

pub proposal_deposit_emergency: u64,
/// Voting period in epochs (standard proposals).

pub voting_period_epochs: u64,
/// Voting period in epochs (emergency proposals).

pub emergency_voting_period_epochs: u64,
/// Timelock period in epochs (standard proposals).

pub timelock_epochs: u64,
/// Minimum quorum fraction (e.g. 0.40 = 40% of staked SIGIL must vote).

pub quorum_fraction: f64
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ContractParams {
/// Maximum bytecode size for `RegisterContractCode`, in bytes.

pub max_code_size: u64,
/// Required base fee for code registration, in micro-MINT.

pub register_code_base_fee: u64,
/// Additional fee per started KiB of bytecode, in micro-MINT.

pub register_code_fee_per_kib: u64,
/// Height where privileged system contracts become the policy gate for

/// core chain features. Before this height, legacy native execution stays

/// active so a hard fork can be scheduled without changing old genesis

/// files. `u64::MAX` means not scheduled.

#[serde(default = "default_system_contracts_activation_height")]
pub system_contracts_activation_height: u64
}

#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct CzacParams {
/// Enables CZAC payment-channel transactions that take custody of user

/// funds. Must remain false on `sigil-mainnet-1` for v1.

pub payment_channels_enabled: bool
}

pub fn canary_enabled() -> Self;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct VigilsParams {
/// Master switch for all Vigils transactions.

pub active: bool,
/// Height before which Vigils transactions fail validation.

pub activation_height: u64,
/// Event source kinds currently accepted by semantic validation.

pub enabled_sources: Vec<crate::vigil::EventSourceKind>,
/// Maximum accepted EventDelivery transactions per block.

pub max_event_deliveries_per_block: u32,
/// Separate callback gas budget for the Vigils execution pass.

pub max_callback_gas_per_block: u64,
/// Maximum gas for one callback.

pub max_single_callback_gas: u64,
/// Maximum canonical event payload size.

pub max_event_payload_bytes: u64,
/// Maximum canonical proof size.

pub max_event_proof_bytes: u64
}

pub fn to_json(&self) -> Result<String, crate::error::CoreError>;

pub fn from_json(json: &str) -> Result<Self, crate::error::CoreError>;

pub fn write_to_file(&self, path: &std::path::Path) -> Result<(), crate::error::CoreError>;

pub fn read_from_file(path: &std::path::Path) -> Result<Self, crate::error::CoreError>;

#[derive(Debug)]
pub struct GenesisBuilder {

}

pub fn new_testnet() -> Self;

pub fn username_params(mut self, params: crate::username::UsernameParams) -> Self;

pub fn chain_id(mut self, id: ChainId) -> Self;

pub fn genesis_time(mut self, time: u64) -> Self;

pub fn add_validator(mut self, validator: GenesisValidator) -> Self;

pub fn add_balance(mut self, did: String, balance: u64) -> Self;

pub fn add_identity(mut self, did: String, document: serde_json::Value) -> Self;

pub fn protocol_params(mut self, params: ProtocolParams) -> Self;

pub fn economics(mut self, economics: EconomicParams) -> Self;

pub fn tower_params(mut self, tower: TowerParams) -> Self;

pub fn governance_params(mut self, governance: GovernanceParams) -> Self;

pub fn contract_params(mut self, contracts: ContractParams) -> Self;

pub fn czac_params(mut self, czac: CzacParams) -> Self;

pub fn vigils_params(mut self, vigils: VigilsParams) -> Self;

pub fn nova_params(mut self, nova: crate::nova::NovaParams) -> Self;

pub fn reference_contract(mut self, contract: GenesisReferenceContract) -> Self;

pub fn build(self) -> Result<GenesisConfig, GenesisValidationError>;

pub fn testnet_default() -> Self;

pub fn testnet_default() -> Self;

pub fn generate_testnet_genesis(
    num_validators: usize,
    genesis_time: u64,
) -> Result<GenesisConfig, GenesisValidationError>;

#[derive(Debug, Clone, thiserror::Error)]
pub enum GenesisValidationError {
    #[error("genesis must have at least one validator")]
    NoValidators,

    #[error("invalid OAS DID for {did}: {reason}")]
    InvalidDid { did: String, reason: String },

    #[error("invalid {field} for {did}: {reason}")]
    InvalidPublicKey {
        did: String,
        field: &'static str,
        reason: String,
    },

    #[error("invalid genesis identity document for {did}: {reason}")]
    InvalidIdentityDocument { did: String, reason: String },

    #[error("validator {did} has insufficient stake: {stake} < {minimum}")]
    InsufficientStake {
        did: String,
        stake: u64,
        minimum: u64,
    },

    #[error("duplicate validator DID: {0}")]
    DuplicateValidator(String),

    #[error("duplicate validator {field}: {value}")]
    DuplicateValidatorPublicKey { field: &'static str, value: String },

    #[error("validator {0} missing human root DID")]
    MissingHumanRoot(String),

    #[error("invalid compute genesis params: {reason}")]
    InvalidComputeParams { reason: String },

    #[error("invalid CZAC genesis params: {reason}")]
    InvalidCzacParams { reason: String },

    #[error("invalid Nova genesis params: {reason}")]
    InvalidNovaParams { reason: String },

    #[error("invalid reference contract {contract_did}: {reason}")]
    InvalidReferenceContract {
        contract_did: String,
        reason: String,
    },
}