sigil-compute · bridge_arise

Source: sigil/node/sigil-compute/src/bridge_arise.rs. SHA-256: cf567abd0d3e5055d57f977b1d68d8c7afef65385f6e2fded7c37c1b81d01a6d.

This reference follows declared source modules, retains conditional attributes, and includes public declarations and implementation methods. Private-module re-exports and trait resolution require the compiler; this is a source reference, not a claim that every listed item is a root import. Function bodies and constant values are omitted.

bridge_arise::AriseProviderRegistration

Wire-compatible provider registration. Mirrors arise_sigil::provider::ProviderRegistration.

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct AriseProviderRegistration {
pub provider_did: String,
pub human_root_did: String,
pub tier: AriseProviderTier,
pub stake: u64,
pub capabilities: serde_json::Value,
pub pricing: AriseComputePricing,
pub registered_epoch: u64,
pub status: AriseProviderStatus
}

Source line: 32.

bridge_arise::AriseProviderTier

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum AriseProviderTier {
    Consumer,
    Professional,
    Enterprise,
    Cluster,
}

Source line: 44.

bridge_arise::AriseProviderStatus

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum AriseProviderStatus {
    Active,
    Suspended,
    Exiting,
    Exited,
}

Source line: 52.

bridge_arise::AriseComputePricing

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct AriseComputePricing {
pub price_per_input_token: u64,
pub price_per_output_token: u64,
pub price_per_gpu_second: u64,
pub min_job_cost: u64
}

Source line: 60.

bridge_arise::AriseComputeReceipt

Wire-compatible compute receipt. Mirrors arise_sigil::receipt::ComputeReceipt.

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct AriseComputeReceipt {
pub receipt_id: String,
pub job_id: String,
pub provider_did: String,
pub consumer_did: String,
pub model_id: String,
pub tokens_in: u64,
pub tokens_out: u64,
pub gpu_seconds: f64,
pub total_cost: u64,
pub started_at: String,
pub completed_at: String,
pub input_hash: SigilHash,
pub output_hash: SigilHash,
pub receipt_hash: SigilHash,
pub provider_signature: Vec<u8>
}

Source line: 70.

bridge_arise::AriseComputeReceipt::from_sigil

Convert from a Sigil on-chain receipt. Field-for-field mapping; the MACA-only fields (commitments, authority context, TEE) are dropped — arise-bridge's wire format does not carry them today.

pub fn from_sigil(r: &ComputeReceipt) -> Self;

Source line: 92.

bridge_arise::AriseSettlementAction

Wire-compatible settlement action — matches arise_sigil::settlement::SettlementAction.

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AriseSettlementAction {
pub receipt: AriseComputeReceipt,
pub provider_did: String,
pub consumer_did: String,
pub amount: u64
}

Source line: 120.

bridge_arise::AriseSettlementAction::from_sigil

pub fn from_sigil(r: &ComputeReceipt) -> Self;

Source line: 128.

bridge_arise::T1Outcome

Result of optimistic verification.

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum T1Outcome {
    Accept,
    Reject(String),
}

Source line: 144.

bridge_arise::verify_t1_optimistic

T1 optimistic verification of a Sigil compute receipt. Performs the structural checks that match arise_verify::optimistic semantics:

receipt hash matches recomputed canonical hash;
signature length is Ed25519 (64 bytes);
cost is non-zero.

pub fn verify_t1_optimistic(receipt: &ComputeReceipt) -> T1Outcome;

Source line: 155.

bridge_arise::T2ProviderResult

One provider's contribution to a T2 quorum.

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct T2ProviderResult {
pub provider_did: String,
pub human_root_did: Option<String>,
pub output_hash: SigilHash
}

Source line: 177.

bridge_arise::T2RedundantVerifier

T2 verifier with Sybil resistance and majority output selection.

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct T2RedundantVerifier {
pub job_id: String,
pub required_providers: usize,
pub required_majority: usize
}

Source line: 185.

bridge_arise::T2Error

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum T2Error {
    DuplicateProvider { provider_did: String },
    DuplicateHumanRoot { human_root_did: String },
    Capacity { required: usize, current: usize },
}

Source line: 194.

bridge_arise::T2Outcome

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "outcome", rename_all = "snake_case")]
pub enum T2Outcome {
    Majority {
        winning_hash: SigilHash,
        agreeing: Vec<String>,
        outliers: Vec<String>,
    },
    NoQuorum {
        votes: HashMap<String, u32>,
    },
}

Source line: 220.

bridge_arise::T2RedundantVerifier::new

pub fn new(job_id: String, n: usize) -> Self;

Source line: 232.

bridge_arise::T2RedundantVerifier::add

pub fn add(&mut self, r: T2ProviderResult) -> Result<(), T2Error>;

Source line: 242.

bridge_arise::T2RedundantVerifier::results

pub fn results(&self) -> &[T2ProviderResult];

Source line: 273.

bridge_arise::T2RedundantVerifier::tally

Tally output hashes; if any reaches required_majority, return its agreeing/outlier provider partition. Otherwise NoQuorum.

pub fn tally(&self) -> T2Outcome;

Source line: 279.

bridge_arise::T3Outcome

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum T3Outcome {
    Accept,
    Reject(String),
}

Source line: 327.

bridge_arise::verify_t3_attestation

Structural verification of a TEE attestation report.

This deliberately fails closed after shape validation. A structurally plausible TEE quote is not a verified attestation until a vendor-specific verifier has checked the report signature, certificate chain, measurement policy, nonce binding, and revocation material.

pub fn verify_t3_attestation(att: &SigilTeeAttestation) -> T3Outcome;

Source line: 338.

bridge_arise::verify_receipt_for_tier

Selects the appropriate verification path for a Sigil receipt and runs the structural checks for T1 / T3 (T2 quorum is multi-receipt and uses T2RedundantVerifier directly).

pub fn verify_receipt_for_tier(receipt: &ComputeReceipt) -> T1Outcome;

Source line: 373.

sigil-compute · bridge_arise

On this page