sigil-core · vigil

pub const VIGIL_EVENT_ID_DOMAIN: &[u8];

pub const VIGIL_SUBSCRIPTION_ID_DOMAIN: &[u8];

pub const VIGIL_FILTER_HASH_DOMAIN: &[u8];

pub const MIN_VIGIL_BOND: u128;

pub const MIN_INGESTOR_BOND: u128;

pub const MAX_FILTER_DEPTH: usize;

pub const MAX_FILTER_ARRAY_LEN: usize;

pub const MAX_FIELD_PATH_LEN: usize;

pub const MAX_EVENT_PAYLOAD_BYTES: usize;

pub const MAX_EVENT_PROOF_BYTES: usize;

pub const DEFAULT_MAX_CALLBACK_GAS: u64;

pub type OasDid = String;

pub type ContractAddress = String;

pub type AccountAddress = String;

pub type MethodSelector = String;

pub type ZoneId = String;

pub type TopicId = String;

pub type ExternalChainId = String;

pub type ExternalAddress = String;

pub type ExternalTopicId = String;

pub type OracleFeedId = String;

pub type AriseRequestId = String;

pub type ContentHash = SigilHash;

#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
pub enum VigilError {
    #[error("vigil filter depth {depth} exceeds max {max}")]
    FilterTooDeep { depth: usize, max: usize },
    #[error("vigil filter array length {len} exceeds max {max}")]
    FilterTooWide { len: usize, max: usize },
    #[error("vigil filter field path length {len} exceeds max {max}")]
    FieldPathTooLong { len: usize, max: usize },
    #[error("vigil field path segment must not be empty")]
    EmptyFieldPathSegment,
    #[error("vigil callback contract must not be empty")]
    EmptyCallbackContract,
    #[error("vigil callback method must not be empty")]
    EmptyCallbackMethod,
    #[error("vigil gas tank account must not be empty")]
    EmptyGasTank,
    #[error("vigil subscriber DID must not be empty")]
    EmptySubscriberDid,
    #[error("vigil ingestor DID must not be empty")]
    EmptyIngestorDid,
    #[error("vigil bond {amount} below minimum {minimum}")]
    BondBelowMinimum { amount: u128, minimum: u128 },
    #[error("vigil max_callback_gas must be greater than zero")]
    ZeroCallbackGas,
    #[error("vigil max_deliveries_per_epoch must be greater than zero")]
    ZeroDeliveryLimit,
    #[error("vigil source does not match subscription")]
    SourceMismatch,
    #[error("vigil source kind {kind:?} requires a proof")]
    ProofRequired { kind: EventSourceKind },
    #[error("vigil proof kind does not match source kind {kind:?}")]
    ProofSourceMismatch { kind: EventSourceKind },
    #[error("vigil event payload is {len} bytes; max is {max}")]
    PayloadTooLarge { len: usize, max: usize },
    #[error("vigil proof is {len} bytes; max is {max}")]
    ProofTooLarge { len: usize, max: usize },
    #[error("vigil canonical encoding failed: {0}")]
    Encoding(String),
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum EventSourceKind {
    InZone,
    CrossZone,
    ExternalChain,
    Oracle,
    ComputeCompletion,
    TimeTrigger,
    TeeAttested,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum TimeKind {
    BlockHeight,
    AttestedWallClock,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum RecurrenceSpec {
    EveryBlocks { interval: u64 },
    EveryAttestedSeconds { interval: u64 },
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct OracleThreshold {
pub committee_id: String,
pub min_signatures: u16
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ProviderClass {
    Any,
    TeeBacked,
    Redundant,
    Deterministic,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum TeeClass {
    SgxDcap,
    SevSnp,
    Tdx,
    ArmCca,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(tag = "source_kind", rename_all = "snake_case")]
pub enum EventSource {
    InZone {
        zone_id: ZoneId,
        emitter: ContractAddress,
        topic: TopicId,
    },
    CrossZone {
        source_zone: ZoneId,
        emitter: ContractAddress,
        topic: TopicId,
    },
    ExternalChain {
        chain_id: ExternalChainId,
        emitter: ExternalAddress,
        topic: ExternalTopicId,
    },
    Oracle {
        feed_id: OracleFeedId,
        threshold: OracleThreshold,
    },
    ComputeCompletion {
        arise_request_id: AriseRequestId,
        provider_class: ProviderClass,
    },
    TimeTrigger {
        kind: TimeKind,
        target: u64,
        recurrence: Option<RecurrenceSpec>,
    },
    TeeAttested {
        model_or_payload_id: ContentHash,
        attestation_class: TeeClass,
    },
}

pub fn kind(&self) -> EventSourceKind;

pub fn matches_kind(&self, kind: EventSourceKind) -> bool;

pub fn matches_subscription(&self, subscription_source: &Self) -> bool;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "type", content = "value", rename_all = "snake_case")]
pub enum CanonicalValue {
    String(String),
    Bytes(Vec<u8>),
    U64(u64),
    I64(i64),
    Bool(bool),
    Hash(SigilHash),
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "op", content = "args", rename_all = "snake_case")]
pub enum EventFilter {
    Any,
    TopicEquals(TopicId),
    PayloadFieldEquals {
        path: Vec<String>,
        value: CanonicalValue,
    },
    PayloadFieldRange {
        path: Vec<String>,
        min: CanonicalValue,
        max: CanonicalValue,
    },
    All(Vec<EventFilter>),
    #[serde(alias = "Any2")]
    AnyOf(Vec<EventFilter>),
}

pub fn validate_bounds(&self) -> Result<(), VigilError>;

pub fn evaluate(&self, payload: &serde_json::Value) -> Result<bool, VigilError>;

pub fn filter_hash(&self) -> Result<SigilHash, VigilError>;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Event {
pub source: EventSource,
pub payload: serde_json::Value,
pub source_finality_anchor: SigilHash
}

pub fn validate_size(&self) -> Result<(), VigilError>;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum EventProof {
    None,
    CrossZone {
        proof_hash: SigilHash,
        encoded_proof: Vec<u8>,
    },
    ExternalChain {
        client_id: String,
        proof_hash: SigilHash,
        encoded_proof: Vec<u8>,
    },
    Oracle {
        committee_id: String,
        signature_bundle: Vec<u8>,
    },
    ComputeReceipt {
        receipt_id: String,
        receipt_hash: SigilHash,
        provider_signature: Vec<u8>,
    },
    TeeQuote {
        quote_hash: SigilHash,
        quote: Vec<u8>,
        material_hash: SigilHash,
    },
}

pub fn encoded_len(&self) -> usize;

pub fn validate_size(&self) -> Result<(), VigilError>;

pub fn matches_source(&self, source: &EventSource) -> Result<bool, VigilError>;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SubscriptionStatus {
    Active,
    Paused,
    Slashed,
    Expired,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum IngestorStatus {
    Active,
    Paused,
    Slashed,
    Deregistered,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct VigilSubscription {
pub subscription_id: SigilHash,
pub subscriber_did: OasDid,
pub callback_contract: ContractAddress,
pub callback_method: MethodSelector,
pub event_source: EventSource,
pub event_filter: EventFilter,
pub gas_tank: AccountAddress,
pub bond_amount: u128,
pub max_callback_gas: u64,
pub max_deliveries_per_epoch: u32,
pub created_at_height: u64,
pub expires_at_height: Option<u64>,
pub status: SubscriptionStatus,
pub deliveries_this_epoch: u32,
pub epoch_window_start: u64
}

pub fn is_active_at(&self, height: u64) -> bool;

pub fn source_filter_key(&self) -> Result<(EventSourceKind, SigilHash), VigilError>;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Ingestor {
pub ingestor_did: OasDid,
pub bond: u128,
pub supported_sources: Vec<EventSourceKind>,
pub fee_per_delivery: u64,
pub reputation: u32,
pub registered_at_height: u64,
pub status: IngestorStatus
}

pub fn supports(&self, source: EventSourceKind) -> bool;

pub fn validate_registration(&self) -> Result<(), VigilError>;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RegisterVigilSubscriptionData {
pub callback_contract: ContractAddress,
pub callback_method: MethodSelector,
pub event_source: EventSource,
pub event_filter: EventFilter,
pub gas_tank: AccountAddress,
pub bond_amount: u128,
pub max_callback_gas: u64,
pub max_deliveries_per_epoch: u32,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub expires_at_height: Option<u64>
}

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

pub fn subscription_id_for(&self, subscriber_did: &str) -> Result<SigilHash, VigilError>;

pub fn into_record(
        &self,
        subscriber_did: impl Into<String>,
        created_at_height: u64,
        epoch_window_start: u64,
    ) -> Result<VigilSubscription, VigilError>;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UpdateVigilSubscriptionData {
pub subscription_id: SigilHash,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub event_filter: Option<EventFilter>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub callback_method: Option<MethodSelector>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub max_callback_gas: Option<u64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub max_deliveries_per_epoch: Option<u32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub expires_at_height: Option<Option<u64>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<SubscriptionStatus>
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct CancelVigilSubscriptionData {
pub subscription_id: SigilHash
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct DepositVigilGasData {
pub subscription_id: SigilHash,
pub amount: u64
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct WithdrawVigilGasData {
pub subscription_id: SigilHash,
pub amount: u64,
pub recipient_did: OasDid
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventDeliveryData {
pub subscription_id: SigilHash,
pub event: Event,
pub proof: EventProof,
pub ingestor_did: OasDid
}

pub fn event_id(&self) -> Result<SigilHash, VigilError>;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SlashIngestorData {
pub ingestor_did: OasDid,
pub evidence_hash: SigilHash,
pub slash_amount: u128
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RegisterIngestorData {
pub ingestor_did: OasDid,
pub bond: u128,
pub supported_sources: Vec<EventSourceKind>,
pub fee_per_delivery: u64
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UpdateIngestorStakeData {
pub ingestor_did: OasDid,
pub bond_delta: i128,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub supported_sources: Option<Vec<EventSourceKind>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fee_per_delivery: Option<u64>
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct DeregisterIngestorData {
pub ingestor_did: OasDid
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum VigilDeliveryStatus {
    Scheduled,
    Delivered,
    Reverted,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct VigilDeliveryRecord {
pub subscription_id: SigilHash,
pub event_id: SigilHash,
pub ingestor_did: OasDid,
pub delivered_at_height: u64,
pub status: VigilDeliveryStatus,
pub proof_hash: SigilHash
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ScheduledVigilCallback {
pub subscription_id: SigilHash,
pub event_id: SigilHash,
pub subscriber_did: OasDid,
pub callback_contract: ContractAddress,
pub callback_method: MethodSelector,
pub payload: serde_json::Value,
pub gas_tank: AccountAddress,
pub gas_limit: u64,
pub scheduled_at_height: u64
}

pub fn canonical_event_id(event: &Event) -> Result<SigilHash, VigilError>;

pub fn canonical_proof_hash(proof: &EventProof) -> Result<SigilHash, VigilError>;