Open Admission & Stake

A subject joins the namespace after five checks, in a fixed order

The subject names a policy and the admission class it wants. The trust service runs its checks and stops at the first one that fails.

An accepted subject is visible in the namespace and holds nothing at any kernel. The receiving operator's own activation, on the right of the boundary, is what turns visibility into runtime trust, and the policy cannot waive it.

A signed policy names the classes a namespace accepts and the stake each needs

A FederatedOpenAdmissionPolicyArtifact lists the namespace's allowed classes from four: public_untrusted, reviewable, bond_backed, and role_gated. Each class may carry one stake requirement. A bond_backed class must have one with a slashable bond, and a role_gated entry must require a governance case before admission.

The validator refuses three weakenings: a bond-backed class whose bond cannot be slashed, a policy that drops explicit local review, and a policy that drops visibility-only participation. The open_admission program shows the first two.

Validate an open-admission policy and publish it

Validate the reference policy, refuse a bond-backed class without a slashable bond, then sign two registry records: one open, one guarded by proof of work.

Complete the project setup, then run the program from federation-guide/. The download includes every constructor and input.

cargo run --locked --bin open_admission

reference policy foap-1: valid; admission classes [PublicUntrusted, Reviewable, BondBacked]
bond_backed class without a slashable bond: refused (invalid admission: bond_backed admission requires slashable collateral)
policy that drops explicit local review: refused (invalid admission: open admission must still require explicit local review)
wrote two signed registry records and two evaluation requests to open-admission-run/

The records are signed with a deterministic example key and published to a local file registry. Evaluating a peer needs the trust service; the transcript on the page runs that half. No bond is posted and no reputation history exists for the example subject.

//! Validate an open-admission policy, refuse the unslashable variant, and
//! publish two signed registry records for the trust service.
use chio_core_types::crypto::Keypair;
use chio_federation::error::FederationContractError;
use chio_federation::open_admission::{
    validate_federated_open_admission_policy, FederatedOpenAdmissionPolicyArtifact,
    SignedFederatedOpenAdmissionPolicy,
};
use serde_json::{json, Value};

fn receive(value: Value) -> Result<FederatedOpenAdmissionPolicyArtifact, FederationContractError> {
    let policy: FederatedOpenAdmissionPolicyArtifact = serde_json::from_value(value)
        .map_err(|e| FederationContractError::InvalidAdmission(e.to_string()))?;
    validate_federated_open_admission_policy(&policy)?;
    Ok(policy)
}

fn record(
    policy: &FederatedOpenAdmissionPolicyArtifact,
    signer: &Keypair,
    anti_sybil: Value,
) -> Result<Value, Box<dyn std::error::Error>> {
    let signed = SignedFederatedOpenAdmissionPolicy::sign(policy.clone(), signer)
        .map_err(|e| format!("sign policy: {e:?}"))?;
    Ok(json!({
        "schema": "chio.permissionless-federation-policy.v1",
        "publishedAt": 1_743_552_200u64,
        "policy": serde_json::to_value(&signed)?,
        "antiSybil": anti_sybil,
        "note": "published by the federation guide open_admission program"
    }))
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    std::fs::create_dir("open-admission-run")?;
    let reference: Value = serde_json::from_slice(&std::fs::read("open-admission-policy.json")?)?;
    let policy = receive(reference.clone())?;
    println!(
        "reference policy {}: valid; admission classes {:?}",
        policy.policy_id, policy.allowed_admission_classes
    );
    let mut unslashable = reference.clone();
    unslashable["stakeRequirements"][0]["slashable"] = false.into();
    let err = receive(unslashable).unwrap_err();
    assert!(matches!(err, FederationContractError::InvalidAdmission(_)));
    println!("bond_backed class without a slashable bond: refused ({err})");
    let mut no_review = reference;
    no_review["explicitLocalReviewRequired"] = false.into();
    let err = receive(no_review).unwrap_err();
    println!("policy that drops explicit local review: refused ({err})");
    // Deterministic signer so the captured records are byte-stable across runs.
    let signer = Keypair::from_seed(&[7; 32]);
    let mut guarded = policy.clone();
    guarded.policy_id = "foap-1-guarded".into();
    for (name, artifact, anti_sybil) in [
        ("policy-open", &policy, json!({})),
        ("policy-guarded", &guarded, json!({ "proofOfWorkBits": 8 })),
    ] {
        std::fs::write(
            format!("open-admission-run/{name}.json"),
            serde_json::to_vec_pretty(&record(artifact, &signer, anti_sybil)?)?,
        )?;
    }
    std::fs::write(
        "open-admission-run/evaluate-open.json",
        serde_json::to_vec_pretty(&json!({
            "policyId": "foap-1",
            "subjectKey": "subject-guide-1",
            "requestedAdmissionClass": "reviewable"
        }))?,
    )?;
    std::fs::write(
        "open-admission-run/evaluate-guarded.json",
        serde_json::to_vec_pretty(&json!({
            "policyId": "foap-1-guarded",
            "subjectKey": "subject-guide-1",
            "requestedAdmissionClass": "public_untrusted"
        }))?,
    )?;
    println!("wrote two signed registry records and two evaluation requests to open-admission-run/");
    Ok(())
}

Open the source file. Each program asserts its expected refusals; keys, timestamps, and digests change between runs.

Read the complete reference policy and its fields.

The trust service publishes each policy with its anti-sybil controls

Each operator runs its own trust service, and its federation-policy registry is part of the trust control plane. A FederationAdmissionPolicyRecord wraps the signed policy with a rate limit, a proof-of-work difficulty, a bond-backed-only switch, and an optional local reputation floor.

$ chio --control-url http://127.0.0.1:8940 --control-token demo-token \
  trust federation-policy upsert --input ./policy-open.json

federation policy upserted: foap-1

$ chio --control-url http://127.0.0.1:8940 --control-token demo-token \
  trust federation-policy list

federation_policies: 2
- foap-1 operator=origin-operator min_score=none
- foap-1-guarded operator=origin-operator min_score=none

You should see both records under origin-operator, neither with a reputation floor. The record commands take a local registry file or a running service through the global --control-url; evaluate needs the service.

chio trust federation-policy upsert --input open-admission-run/policy-open.json --federation-policies-file open-admission-run/registry.json
chio trust federation-policy upsert --input open-admission-run/policy-guarded.json --federation-policies-file open-admission-run/registry.json

federation policy upserted: foap-1
federation policy upserted: foap-1-guarded

chio trust federation-policy list --federation-policies-file open-admission-run/registry.json

federation_policies: 2
- foap-1 operator=origin-operator min_score=none
- foap-1-guarded operator=origin-operator min_score=none

An evaluation returns acceptance or the first check that failed

The request names the policy, the subject key, the requested class, and an optional proof-of-work nonce. The service checks, in order:

1. Class. The signed policy allows the requested class.
2. Proof of work. When the record sets a difficulty, the SHA-256 of policy_id:subject_key:nonce starts with that many zero bits.
3. Bond-backed only. When the switch is on, the requested class is bond_backed.
4. Reputation. When the record sets a floor, the subject's effective local score meets it.
5. Rate limit. The evaluation fits the record's window for this subject, and counts against it.

$ chio --control-url http://127.0.0.1:8940 --control-token demo-token \
  trust federation-policy evaluate --input ./evaluate-open.json

policy_id:               foap-1
subject_key:             subject-guide-1
accepted:                true
decision_reason:         subject satisfied the configured federation reputation and anti-sybil controls
minimum_reputation_score: none
observed_reputation_score: none

You should see accepted: true and the reason the service returns when every check passes. The same subject against foap-1-guarded, sent without a nonce, is refused at the second check:

$ chio --control-url http://127.0.0.1:8940 --control-token demo-token \
  trust federation-policy evaluate --input ./evaluate-guarded.json

policy_id:               foap-1-guarded
subject_key:             subject-guide-1
accepted:                false
decision_reason:         proof-of-work nonce did not satisfy the configured federation policy difficulty
minimum_reputation_score: none
observed_reputation_score: none

Admission makes a subject visible, and the receiver decides trust

Every valid policy keeps explicitLocalReviewRequired and visibilityOnlyWithoutActivation set. A remote activation still crosses as its own exchange, which the receiving operator imports under its own controls. Reputation the subject earned elsewhere arrives weighted by the receiver.

Read more in Trust Activation Exchange and Reputation Clearing.

Next: activate an admitted participant