sigil-core · velocity

Source: sigil/node/sigil-core/src/velocity.rs. SHA-256: 13489dea1fc8c80ffaa3d5049a0af91d7d3cd6c8303cefc9fecd46e9edc56856.

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.

velocity::LaneId

pub type LaneId = u32;

Source line: 15.

velocity::SlotId

pub type SlotId = u64;

Source line: 16.

velocity::VelocityAccessMode

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum VelocityAccessMode {
    Read,
    Write,
}

Source line: 20.

velocity::VelocityAccess

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct VelocityAccess {
pub partition: String,
pub key: String,
pub mode: VelocityAccessMode
}

Source line: 26.

velocity::VelocityAccess::write

pub fn write(partition: impl Into<String>, key: impl Into<String>) -> Self;

Source line: 33.

velocity::VelocityTxKind

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "type", content = "data")]
pub enum VelocityTxKind {
    Transfer {
        recipient_did: String,
        amount: u128,
    },
    Event {
        topic: String,
        payload_hash: SigilHash,
        sequence: u64,
    },
}

Source line: 44.

velocity::VelocityTransaction

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct VelocityTransaction {
pub chain_id: String,
pub lane_id: LaneId,
pub slot_id: SlotId,
pub sender_did: String,
pub nonce: u64,
pub timestamp_ns: u64,
pub kind: VelocityTxKind,
pub access: Vec<VelocityAccess>,
pub signer_public_key: Vec<u8>,
pub signature: Vec<u8>
}

Source line: 57.

velocity::VelocityTransaction::signed_transfer

#[allow(clippy::too_many_arguments)]
pub fn signed_transfer(
        chain_id: impl Into<String>,
        lane_id: LaneId,
        slot_id: SlotId,
        sender_did: impl Into<String>,
        recipient_did: impl Into<String>,
        amount: u128,
        nonce: u64,
        timestamp_ns: u64,
        signing_key: &SigningKey,
    ) -> Result<Self, CoreError>;

Source line: 72.

velocity::VelocityTransaction::verify_signature

pub fn verify_signature(&self) -> Result<(), CoreError>;

Source line: 109.

velocity::VelocityTransaction::tx_hash

pub fn tx_hash(&self) -> SigilHash;

Source line: 141.

velocity::VelocityLaneConfig

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct VelocityLaneConfig {
pub chain_id: String,
pub lane_id: LaneId,
pub slot_id: SlotId,
pub parent_lane_hash: SigilHash,
pub slot_start_ns: u64,
pub slot_end_ns: u64
}

Source line: 168.

velocity::VelocityLaneHeader

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct VelocityLaneHeader {
pub chain_id: String,
pub lane_id: LaneId,
pub slot_id: SlotId,
pub parent_lane_hash: SigilHash,
pub tx_root: SigilHash,
pub receipt_root: SigilHash,
pub state_delta_root: SigilHash,
pub post_state_root: SigilHash,
pub slot_start_ns: u64,
pub slot_end_ns: u64,
pub raw_tx_count: u64,
pub accepted_tx_count: u64,
pub invalid_tx_count: u64,
pub dropped_tx_count: u64
}

Source line: 178.

velocity::VelocityLaneHeader::block_hash

pub fn block_hash(&self) -> SigilHash;

Source line: 196.

velocity::VelocityReceiptStatus

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum VelocityReceiptStatus {
    Committed,
}

Source line: 219.

velocity::VelocityStateDelta

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct VelocityStateDelta {
pub partition: String,
pub key: String,
pub old_value: Vec<u8>,
pub new_value: Vec<u8>
}

Source line: 224.

velocity::VelocityReceipt

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct VelocityReceipt {
pub tx_hash: SigilHash,
pub status: VelocityReceiptStatus,
pub lane_id: LaneId,
pub slot_id: SlotId,
pub state_deltas: Vec<VelocityStateDelta>
}

Source line: 232.

velocity::VelocityDroppedTx

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct VelocityDroppedTx {
pub tx_hash: SigilHash,
pub reason: String
}

Source line: 241.

velocity::VelocityLaneBlock

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct VelocityLaneBlock {
pub header: VelocityLaneHeader,
pub transactions: Vec<VelocityTransaction>,
pub receipts: Vec<VelocityReceipt>,
pub dropped: Vec<VelocityDroppedTx>
}

Source line: 247.

velocity::VelocityLaneBlock::verify_roots

pub fn verify_roots(&self) -> Result<bool, CoreError>;

Source line: 255.

velocity::VelocityExecutionOutcome

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct VelocityExecutionOutcome {
pub block: VelocityLaneBlock,
pub post_state: VelocityAccountState,
pub raw_tx_count: u64,
pub accepted_tx_count: u64,
pub invalid_tx_count: u64,
pub dropped_tx_count: u64
}

Source line: 268.

velocity::VelocityExecutionOutcome::committed_tx_count

pub fn committed_tx_count(&self) -> u64;

Source line: 278.

velocity::VelocityAccount

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub struct VelocityAccount {
pub balance: u128,
pub nonce: u64
}

Source line: 284.

velocity::VelocityAccountState

#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct VelocityAccountState {

}

Source line: 290.

velocity::VelocityAccountState::with_account

pub fn with_account(mut self, did: impl Into<String>, balance: u128, nonce: u64) -> Self;

Source line: 295.

velocity::VelocityAccountState::set_account

pub fn set_account(&mut self, did: impl Into<String>, balance: u128, nonce: u64);

Source line: 300.

velocity::VelocityAccountState::balance

pub fn balance(&self, did: &str) -> u128;

Source line: 305.

velocity::VelocityAccountState::nonce

pub fn nonce(&self, did: &str) -> u64;

Source line: 312.

velocity::VelocityAccountState::state_root

pub fn state_root(&self) -> SigilHash;

Source line: 356.

velocity::VelocityLaneCommitment

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct VelocityLaneCommitment {
pub lane_id: LaneId,
pub slot_id: SlotId,
pub lane_block_hash: SigilHash,
pub tx_root: SigilHash,
pub receipt_root: SigilHash,
pub state_delta_root: SigilHash,
pub post_state_root: SigilHash,
pub committed_tx_count: u64
}

Source line: 371.

velocity::VelocityRootCommitment

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct VelocityRootCommitment {
pub chain_id: String,
pub root_height: u64,
pub committed_at_ns: u64,
pub lane_commitment_root: SigilHash,
pub committed_tx_count: u64,
pub lane_commitments: Vec<VelocityLaneCommitment>
}

Source line: 383.

velocity::VelocityRootCommitment::from_lane_blocks

pub fn from_lane_blocks(
        chain_id: impl Into<String>,
        root_height: u64,
        committed_at_ns: u64,
        lane_blocks: &[VelocityLaneBlock],
    ) -> Result<Self, CoreError>;

Source line: 393.

velocity::VelocityRootCommitment::verify_against_lane_blocks

pub fn verify_against_lane_blocks(
        &self,
        lane_blocks: &[VelocityLaneBlock],
    ) -> Result<bool, CoreError>;

Source line: 428.

velocity::VelocityLaneCommitteeMember

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct VelocityLaneCommitteeMember {
pub operator_id: String,
pub validator_did: String,
pub stake: u128,
pub provider: String,
pub asn: u32,
pub region: String
}

Source line: 443.

velocity::VelocityLaneCommitteeAssignment

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct VelocityLaneCommitteeAssignment {
pub lane_id: LaneId,
pub rotation_epoch: u64,
pub rotation_interval_slots: u64,
pub randomness_seed: SigilHash,
pub members: Vec<VelocityLaneCommitteeMember>
}

Source line: 453.

velocity::VelocityLaneDemotionPolicy

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct VelocityLaneDemotionPolicy {
pub max_p95_latency_ns: u64,
pub max_missed_slots: u64,
pub max_invalid_roots: u64,
pub max_missing_artifacts: u64,
pub slash_on_equivocation: bool,
pub slash_on_invalid_root: bool
}

Source line: 462.

velocity::VelocityLaneSloSample

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct VelocityLaneSloSample {
pub lane_id: LaneId,
pub slot_id: SlotId,
pub p95_latency_ns: u64,
pub missed_slots: u64,
pub invalid_roots: u64,
pub missing_artifacts: u64,
pub equivocations: u64
}

Source line: 472.

velocity::VelocityLaneDemotionDecision

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct VelocityLaneDemotionDecision {
pub lane_id: LaneId,
pub slot_id: SlotId,
pub demote: bool,
pub slash: bool,
pub reasons: Vec<String>
}

Source line: 483.

velocity::assign_velocity_lane_committee

pub fn assign_velocity_lane_committee(
    lane_id: LaneId,
    slot_id: SlotId,
    rotation_interval_slots: u64,
    committee_size: usize,
    candidates: &[VelocityLaneCommitteeMember],
    randomness_seed: SigilHash,
) -> Result<VelocityLaneCommitteeAssignment, CoreError>;

Source line: 491.

velocity::evaluate_velocity_lane_demotion

pub fn evaluate_velocity_lane_demotion(
    sample: &VelocityLaneSloSample,
    policy: &VelocityLaneDemotionPolicy,
) -> VelocityLaneDemotionDecision;

Source line: 552.

velocity::lane_for_account

pub fn lane_for_account(account_did: &str, lane_count: LaneId) -> Result<LaneId, CoreError>;

Source line: 598.

velocity::execute_velocity_lane_block

pub fn execute_velocity_lane_block(
    config: VelocityLaneConfig,
    initial_state: VelocityAccountState,
    raw_txs: Vec<VelocityTransaction>,
) -> Result<VelocityExecutionOutcome, CoreError>;

Source line: 627.

velocity::replay_velocity_lane_block

pub fn replay_velocity_lane_block(
    block: &VelocityLaneBlock,
    initial_state: VelocityAccountState,
) -> Result<VelocityExecutionOutcome, CoreError>;

Source line: 696.

sigil-core · velocity

On this page