// GENERATED FILE - DO NOT EDIT
// Source: protocol/enums.yml | Generated: 2025-10-03 19:49:45
use serde::{Serialize, Deserialize};
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum AccountAuthOperationType {
#[serde(rename = "unknown")]
Unknown,
#[serde(rename = "enable")]
Enable,
#[serde(rename = "disable")]
Disable,
#[serde(rename = "addauthority")]
AddAuthority,
#[serde(rename = "removeauthority")]
RemoveAuthority,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum AccountType {
#[serde(rename = "unknown")]
Unknown,
#[serde(rename = "anchorLedger", alias = "anchorledger")]
AnchorLedger,
#[serde(rename = "identity")]
Identity,
#[serde(rename = "tokenIssuer")]
TokenIssuer,
#[serde(rename = "tokenAccount", alias = "tokenaccount")]
TokenAccount,
#[serde(rename = "liteTokenAccount", alias = "litetokenaccount")]
LiteTokenAccount,
#[serde(rename = "blockLedger")]
BlockLedger,
#[serde(rename = "keyPage")]
KeyPage,
#[serde(rename = "keyBook")]
KeyBook,
#[serde(rename = "dataAccount", alias = "dataaccount")]
DataAccount,
#[serde(rename = "liteDataAccount")]
LiteDataAccount,
#[serde(rename = "unknownSigner")]
UnknownSigner,
#[serde(rename = "systemLedger")]
SystemLedger,
#[serde(rename = "liteIdentity")]
LiteIdentity,
#[serde(rename = "syntheticLedger")]
SyntheticLedger,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum AllowedTransactionBit {
#[serde(rename = "updatekeypage")]
UpdateKeyPage,
#[serde(rename = "updateaccountauth")]
UpdateAccountAuth,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum BookType {
#[serde(rename = "normal")]
Normal,
#[serde(rename = "validator")]
Validator,
#[serde(rename = "operator")]
Operator,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum DataEntryType {
#[serde(rename = "unknown")]
Unknown,
#[serde(rename = "factom")]
Factom,
#[serde(rename = "accumulate")]
Accumulate,
#[serde(rename = "doublehash")]
DoubleHash,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ExecutorVersion {
#[serde(rename = "v1")]
V1,
#[serde(rename = "v1SignatureAnchoring", alias = "v1-signatureAnchoring")]
V1SignatureAnchoring,
#[serde(rename = "v1DoubleHashEntries", alias = "v1-doubleHashEntries")]
V1DoubleHashEntries,
#[serde(rename = "v1Halt", alias = "v1-halt")]
V1Halt,
#[serde(rename = "v2")]
V2,
#[serde(rename = "v2Baikonur", alias = "v2-baikonur")]
V2Baikonur,
#[serde(rename = "v2Vandenberg", alias = "v2-vandenberg")]
V2Vandenberg,
#[serde(rename = "v2Jiuquan", alias = "v2-jiuquan")]
V2Jiuquan,
#[serde(rename = "vNext", alias = "vnext")]
VNext,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum KeyPageOperationType {
#[serde(rename = "unknown")]
Unknown,
#[serde(rename = "update")]
Update,
#[serde(rename = "remove")]
Remove,
#[serde(rename = "add")]
Add,
#[serde(rename = "setthreshold")]
SetThreshold,
#[serde(rename = "updateallowed")]
UpdateAllowed,
#[serde(rename = "setrejectthreshold")]
SetRejectThreshold,
#[serde(rename = "setresponsethreshold")]
SetResponseThreshold,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum NetworkMaintenanceOperationType {
#[serde(rename = "unknown")]
Unknown,
#[serde(rename = "pendingtransactiongc")]
PendingTransactionGC,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ObjectType {
#[serde(rename = "unknown")]
Unknown,
#[serde(rename = "account")]
Account,
#[serde(rename = "transaction")]
Transaction,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum PartitionType {
#[serde(rename = "directory")]
Directory,
#[serde(rename = "blockValidator", alias = "block-validator")]
BlockValidator,
#[serde(rename = "blockSummary", alias = "block-summary")]
BlockSummary,
#[serde(rename = "bootstrap")]
Bootstrap,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum SignatureType {
#[serde(rename = "unknown")]
Unknown,
#[serde(rename = "legacyED25519")]
LegacyED25519,
#[serde(rename = "ed25519")]
ED25519,
#[serde(rename = "rcd1")]
RCD1,
#[serde(rename = "receipt")]
Receipt,
#[serde(rename = "synthetic")]
Partition,
#[serde(rename = "set")]
Set,
#[serde(rename = "remote")]
Remote,
#[serde(rename = "btc")]
BTC,
#[serde(rename = "btclegacy")]
BTCLegacy,
#[serde(rename = "eth")]
ETH,
#[serde(rename = "delegated")]
Delegated,
#[serde(rename = "internal")]
Internal,
#[serde(rename = "authority")]
Authority,
#[serde(rename = "rsasha256")]
RsaSha256,
#[serde(rename = "ecdsasha256")]
EcdsaSha256,
#[serde(rename = "typeddata")]
TypedData,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum TransactionMax {
#[serde(rename = "user")]
User,
#[serde(rename = "synthetic")]
Synthetic,
#[serde(rename = "system")]
System,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum TransactionType {
#[serde(rename = "unknown")]
Unknown,
#[serde(rename = "createIdentity")]
CreateIdentity,
#[serde(rename = "createTokenAccount")]
CreateTokenAccount,
#[serde(rename = "sendTokens")]
SendTokens,
#[serde(rename = "createDataAccount")]
CreateDataAccount,
#[serde(rename = "writeData")]
WriteData,
#[serde(rename = "writeDataTo")]
WriteDataTo,
#[serde(rename = "acmeFaucet")]
AcmeFaucet,
#[serde(rename = "createToken")]
CreateToken,
#[serde(rename = "issueTokens")]
IssueTokens,
#[serde(rename = "burnTokens")]
BurnTokens,
#[serde(rename = "createLiteTokenAccount")]
CreateLiteTokenAccount,
#[serde(rename = "createKeyPage")]
CreateKeyPage,
#[serde(rename = "createKeyBook")]
CreateKeyBook,
#[serde(rename = "addCredits")]
AddCredits,
#[serde(rename = "updateKeyPage")]
UpdateKeyPage,
#[serde(rename = "lockAccount")]
LockAccount,
#[serde(rename = "burnCredits")]
BurnCredits,
#[serde(rename = "transferCredits")]
TransferCredits,
#[serde(rename = "updateAccountAuth")]
UpdateAccountAuth,
#[serde(rename = "updateKey")]
UpdateKey,
#[serde(rename = "networkMaintenance")]
NetworkMaintenance,
#[serde(rename = "activateProtocolVersion")]
ActivateProtocolVersion,
#[serde(rename = "signPending")]
Remote,
#[serde(rename = "syntheticCreateIdentity")]
SyntheticCreateIdentity,
#[serde(rename = "syntheticWriteData")]
SyntheticWriteData,
#[serde(rename = "syntheticDepositTokens")]
SyntheticDepositTokens,
#[serde(rename = "syntheticDepositCredits")]
SyntheticDepositCredits,
#[serde(rename = "syntheticBurnTokens")]
SyntheticBurnTokens,
#[serde(rename = "syntheticForwardTransaction")]
SyntheticForwardTransaction,
#[serde(rename = "systemGenesis")]
SystemGenesis,
#[serde(rename = "directoryAnchor")]
DirectoryAnchor,
#[serde(rename = "blockValidatorAnchor")]
BlockValidatorAnchor,
#[serde(rename = "systemWriteData")]
SystemWriteData,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum VoteType {
#[serde(rename = "accept")]
Accept,
#[serde(rename = "reject")]
Reject,
#[serde(rename = "abstain")]
Abstain,
#[serde(rename = "suggest")]
Suggest,
}
impl VoteType {
/// Get the numeric value of the vote type (matches Go protocol)
pub fn value(&self) -> u64 {
match self {
VoteType::Accept => 0,
VoteType::Reject => 1,
VoteType::Abstain => 2,
VoteType::Suggest => 3,
}
}
/// Create a VoteType from its numeric value
pub fn from_u64(value: u64) -> Option<Self> {
match value {
0 => Some(VoteType::Accept),
1 => Some(VoteType::Reject),
2 => Some(VoteType::Abstain),
3 => Some(VoteType::Suggest),
_ => None,
}
}
/// Get all possible vote types
pub fn all() -> &'static [VoteType] {
&[VoteType::Accept, VoteType::Reject, VoteType::Abstain, VoteType::Suggest]
}
/// Check if this vote type approves (accepts) the proposal
pub fn is_approval(&self) -> bool {
matches!(self, VoteType::Accept)
}
/// Check if this vote type rejects the proposal
pub fn is_rejection(&self) -> bool {
matches!(self, VoteType::Reject)
}
/// Check if this vote type is an abstention
pub fn is_abstention(&self) -> bool {
matches!(self, VoteType::Abstain)
}
/// Check if this vote type is a suggestion (proposal)
pub fn is_suggestion(&self) -> bool {
matches!(self, VoteType::Suggest)
}
/// Get string representation matching Go protocol
pub fn as_str(&self) -> &'static str {
match self {
VoteType::Accept => "accept",
VoteType::Reject => "reject",
VoteType::Abstain => "abstain",
VoteType::Suggest => "suggest",
}
}
/// Parse from string (case-insensitive)
pub fn from_str_case_insensitive(s: &str) -> Option<Self> {
match s.to_lowercase().as_str() {
"accept" => Some(VoteType::Accept),
"reject" => Some(VoteType::Reject),
"abstain" => Some(VoteType::Abstain),
"suggest" => Some(VoteType::Suggest),
_ => None,
}
}
}
impl Default for VoteType {
/// Default vote type is Accept (matches Go protocol)
fn default() -> Self {
VoteType::Accept
}
}
impl std::fmt::Display for VoteType {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.as_str())
}
}
/// Vote tallying result for counting signature votes
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct VoteTally {
/// Number of accept votes
pub accept: u64,
/// Number of reject votes
pub reject: u64,
/// Number of abstain votes
pub abstain: u64,
/// Number of suggest votes
pub suggest: u64,
}
impl VoteTally {
/// Create an empty tally
pub fn new() -> Self {
Self::default()
}
/// Add a vote to the tally
pub fn add_vote(&mut self, vote: VoteType) {
match vote {
VoteType::Accept => self.accept += 1,
VoteType::Reject => self.reject += 1,
VoteType::Abstain => self.abstain += 1,
VoteType::Suggest => self.suggest += 1,
}
}
/// Add multiple votes of the same type
pub fn add_votes(&mut self, vote: VoteType, count: u64) {
match vote {
VoteType::Accept => self.accept += count,
VoteType::Reject => self.reject += count,
VoteType::Abstain => self.abstain += count,
VoteType::Suggest => self.suggest += count,
}
}
/// Get the total number of votes (excluding abstentions)
pub fn total_active(&self) -> u64 {
self.accept + self.reject + self.suggest
}
/// Get the total number of all votes (including abstentions)
pub fn total(&self) -> u64 {
self.accept + self.reject + self.abstain + self.suggest
}
/// Check if the vote passes with simple majority (more accepts than rejects)
pub fn passes_simple_majority(&self) -> bool {
self.accept > self.reject
}
/// Check if the vote passes with strict majority (>50% accepts of active votes)
pub fn passes_strict_majority(&self) -> bool {
let total_active = self.total_active();
if total_active == 0 {
return false;
}
self.accept > total_active / 2
}
/// Check if the vote passes with supermajority (>=2/3 accepts of active votes)
pub fn passes_supermajority(&self) -> bool {
let total_active = self.total_active();
if total_active == 0 {
return false;
}
// Using >= 2/3 threshold: accept * 3 >= total * 2
self.accept * 3 >= total_active * 2
}
/// Check if the vote passes with given threshold (accepts as percentage of active votes)
pub fn passes_threshold(&self, threshold_percent: u64) -> bool {
if threshold_percent > 100 {
return false;
}
let total_active = self.total_active();
if total_active == 0 {
return threshold_percent == 0;
}
// accept * 100 >= total * threshold
self.accept * 100 >= total_active * threshold_percent
}
/// Get the acceptance percentage (of active votes)
pub fn acceptance_percentage(&self) -> f64 {
let total_active = self.total_active();
if total_active == 0 {
return 0.0;
}
(self.accept as f64 / total_active as f64) * 100.0
}
/// Merge another tally into this one
pub fn merge(&mut self, other: &VoteTally) {
self.accept += other.accept;
self.reject += other.reject;
self.abstain += other.abstain;
self.suggest += other.suggest;
}
}
pub fn __roundtrip_one(enum_name: &str, tag: &str) -> Result<(), Box<dyn std::error::Error>> {
match enum_name {
"AccountAuthOperationType" => {
let v = serde_json::Value::String(tag.to_string());
let val: AccountAuthOperationType = serde_json::from_value(v.clone())?;
let back = serde_json::to_value(&val)?;
if back != v {
return Err(format!("Roundtrip failed for {}::{}: expected {}, got {}",
enum_name, tag, v, back).into());
}
}
"AccountType" => {
let v = serde_json::Value::String(tag.to_string());
let val: AccountType = serde_json::from_value(v.clone())?;
let back = serde_json::to_value(&val)?;
if back != v {
return Err(format!("Roundtrip failed for {}::{}: expected {}, got {}",
enum_name, tag, v, back).into());
}
}
"AllowedTransactionBit" => {
let v = serde_json::Value::String(tag.to_string());
let val: AllowedTransactionBit = serde_json::from_value(v.clone())?;
let back = serde_json::to_value(&val)?;
if back != v {
return Err(format!("Roundtrip failed for {}::{}: expected {}, got {}",
enum_name, tag, v, back).into());
}
}
"BookType" => {
let v = serde_json::Value::String(tag.to_string());
let val: BookType = serde_json::from_value(v.clone())?;
let back = serde_json::to_value(&val)?;
if back != v {
return Err(format!("Roundtrip failed for {}::{}: expected {}, got {}",
enum_name, tag, v, back).into());
}
}
"DataEntryType" => {
let v = serde_json::Value::String(tag.to_string());
let val: DataEntryType = serde_json::from_value(v.clone())?;
let back = serde_json::to_value(&val)?;
if back != v {
return Err(format!("Roundtrip failed for {}::{}: expected {}, got {}",
enum_name, tag, v, back).into());
}
}
"ExecutorVersion" => {
let v = serde_json::Value::String(tag.to_string());
let val: ExecutorVersion = serde_json::from_value(v.clone())?;
let back = serde_json::to_value(&val)?;
if back != v {
return Err(format!("Roundtrip failed for {}::{}: expected {}, got {}",
enum_name, tag, v, back).into());
}
}
"KeyPageOperationType" => {
let v = serde_json::Value::String(tag.to_string());
let val: KeyPageOperationType = serde_json::from_value(v.clone())?;
let back = serde_json::to_value(&val)?;
if back != v {
return Err(format!("Roundtrip failed for {}::{}: expected {}, got {}",
enum_name, tag, v, back).into());
}
}
"NetworkMaintenanceOperationType" => {
let v = serde_json::Value::String(tag.to_string());
let val: NetworkMaintenanceOperationType = serde_json::from_value(v.clone())?;
let back = serde_json::to_value(&val)?;
if back != v {
return Err(format!("Roundtrip failed for {}::{}: expected {}, got {}",
enum_name, tag, v, back).into());
}
}
"ObjectType" => {
let v = serde_json::Value::String(tag.to_string());
let val: ObjectType = serde_json::from_value(v.clone())?;
let back = serde_json::to_value(&val)?;
if back != v {
return Err(format!("Roundtrip failed for {}::{}: expected {}, got {}",
enum_name, tag, v, back).into());
}
}
"PartitionType" => {
let v = serde_json::Value::String(tag.to_string());
let val: PartitionType = serde_json::from_value(v.clone())?;
let back = serde_json::to_value(&val)?;
if back != v {
return Err(format!("Roundtrip failed for {}::{}: expected {}, got {}",
enum_name, tag, v, back).into());
}
}
"SignatureType" => {
let v = serde_json::Value::String(tag.to_string());
let val: SignatureType = serde_json::from_value(v.clone())?;
let back = serde_json::to_value(&val)?;
if back != v {
return Err(format!("Roundtrip failed for {}::{}: expected {}, got {}",
enum_name, tag, v, back).into());
}
}
"TransactionMax" => {
let v = serde_json::Value::String(tag.to_string());
let val: TransactionMax = serde_json::from_value(v.clone())?;
let back = serde_json::to_value(&val)?;
if back != v {
return Err(format!("Roundtrip failed for {}::{}: expected {}, got {}",
enum_name, tag, v, back).into());
}
}
"TransactionType" => {
let v = serde_json::Value::String(tag.to_string());
let val: TransactionType = serde_json::from_value(v.clone())?;
let back = serde_json::to_value(&val)?;
if back != v {
return Err(format!("Roundtrip failed for {}::{}: expected {}, got {}",
enum_name, tag, v, back).into());
}
}
"VoteType" => {
let v = serde_json::Value::String(tag.to_string());
let val: VoteType = serde_json::from_value(v.clone())?;
let back = serde_json::to_value(&val)?;
if back != v {
return Err(format!("Roundtrip failed for {}::{}: expected {}, got {}",
enum_name, tag, v, back).into());
}
}
_ => return Err(format!("Unknown enum: {}", enum_name).into()),
}
Ok(())
}
pub fn __get_all_enum_variants() -> std::collections::HashMap<String, Vec<String>> {
let mut map = std::collections::HashMap::new();
map.insert("AccountAuthOperationType".to_string(), vec!["unknown".to_string(), "enable".to_string(), "disable".to_string(), "addauthority".to_string(), "removeauthority".to_string()]);
map.insert("AccountType".to_string(), vec!["unknown".to_string(), "anchorledger".to_string(), "identity".to_string(), "token".to_string(), "tokenaccount".to_string(), "litetokenaccount".to_string(), "blockledger".to_string(), "keypage".to_string(), "keybook".to_string(), "dataaccount".to_string(), "litedataaccount".to_string(), "unknownsigner".to_string(), "systemledger".to_string(), "liteidentity".to_string(), "syntheticledger".to_string()]);
map.insert("AllowedTransactionBit".to_string(), vec!["updatekeypage".to_string(), "updateaccountauth".to_string()]);
map.insert("BookType".to_string(), vec!["normal".to_string(), "validator".to_string(), "operator".to_string()]);
map.insert("DataEntryType".to_string(), vec!["unknown".to_string(), "factom".to_string(), "accumulate".to_string(), "doublehash".to_string()]);
map.insert("ExecutorVersion".to_string(), vec!["v1".to_string(), "v1-signatureAnchoring".to_string(), "v1-doubleHashEntries".to_string(), "v1-halt".to_string(), "v2".to_string(), "v2-baikonur".to_string(), "v2-vandenberg".to_string(), "v2-jiuquan".to_string(), "vnext".to_string()]);
map.insert("KeyPageOperationType".to_string(), vec!["unknown".to_string(), "update".to_string(), "remove".to_string(), "add".to_string(), "setthreshold".to_string(), "updateallowed".to_string(), "setrejectthreshold".to_string(), "setresponsethreshold".to_string()]);
map.insert("NetworkMaintenanceOperationType".to_string(), vec!["unknown".to_string(), "pendingtransactiongc".to_string()]);
map.insert("ObjectType".to_string(), vec!["unknown".to_string(), "account".to_string(), "transaction".to_string()]);
map.insert("PartitionType".to_string(), vec!["directory".to_string(), "block-validator".to_string(), "block-summary".to_string(), "bootstrap".to_string()]);
map.insert("SignatureType".to_string(), vec!["unknown".to_string(), "legacyed25519".to_string(), "ed25519".to_string(), "rcd1".to_string(), "receipt".to_string(), "synthetic".to_string(), "set".to_string(), "remote".to_string(), "btc".to_string(), "btclegacy".to_string(), "eth".to_string(), "delegated".to_string(), "internal".to_string(), "authority".to_string(), "rsasha256".to_string(), "ecdsasha256".to_string(), "typeddata".to_string()]);
map.insert("TransactionMax".to_string(), vec!["user".to_string(), "synthetic".to_string(), "system".to_string()]);
map.insert("TransactionType".to_string(), vec!["unknown".to_string(), "createIdentity".to_string(), "createTokenAccount".to_string(), "sendTokens".to_string(), "createDataAccount".to_string(), "writeData".to_string(), "writeDataTo".to_string(), "acmeFaucet".to_string(), "createToken".to_string(), "issueTokens".to_string(), "burnTokens".to_string(), "createLiteTokenAccount".to_string(), "createKeyPage".to_string(), "createKeyBook".to_string(), "addCredits".to_string(), "updateKeyPage".to_string(), "lockAccount".to_string(), "burnCredits".to_string(), "transferCredits".to_string(), "updateAccountAuth".to_string(), "updateKey".to_string(), "networkMaintenance".to_string(), "activateProtocolVersion".to_string(), "signPending".to_string(), "syntheticCreateIdentity".to_string(), "syntheticWriteData".to_string(), "syntheticDepositTokens".to_string(), "syntheticDepositCredits".to_string(), "syntheticBurnTokens".to_string(), "syntheticForwardTransaction".to_string(), "systemGenesis".to_string(), "directoryAnchor".to_string(), "blockValidatorAnchor".to_string(), "systemWriteData".to_string()]);
map.insert("VoteType".to_string(), vec!["accept".to_string(), "reject".to_string(), "abstain".to_string(), "suggest".to_string()]);
map
}