#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(non_camel_case_types)]
#![allow(unused_imports)]
#![allow(unknown_lints)]
#![allow(clippy::all)]
#![cfg_attr(rustfmt, rustfmt_skip)]
use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, WriterBackend, Result};
use quick_protobuf::sizeofs::*;
use super::*;
#[derive(Debug, Default, PartialEq, Clone)]
pub struct SwitchboardInstruction {
pub instruction: mod_SwitchboardInstruction::OneOfinstruction,
}
impl<'a> MessageRead<'a> for SwitchboardInstruction {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.instruction = mod_SwitchboardInstruction::OneOfinstruction::init_instruction(r.read_message::<mod_SwitchboardInstruction::InitInstruction>(bytes)?),
Ok(18) => msg.instruction = mod_SwitchboardInstruction::OneOfinstruction::register_job_instruction(r.read_message::<mod_SwitchboardInstruction::RegisterJobInstruction>(bytes)?),
Ok(26) => msg.instruction = mod_SwitchboardInstruction::OneOfinstruction::unregister_job_instruction(r.read_message::<mod_SwitchboardInstruction::UnregisterJobInstruction>(bytes)?),
Ok(34) => msg.instruction = mod_SwitchboardInstruction::OneOfinstruction::update_aggregate_instruction(r.read_message::<mod_SwitchboardInstruction::UpdateAggregateInstruction>(bytes)?),
Ok(42) => msg.instruction = mod_SwitchboardInstruction::OneOfinstruction::get_aggregate_instruction(r.read_message::<mod_SwitchboardInstruction::GetAggregateInstruction>(bytes)?),
Ok(50) => msg.instruction = mod_SwitchboardInstruction::OneOfinstruction::save_result_instruction(r.read_message::<mod_SwitchboardInstruction::SaveResultInstruction>(bytes)?),
Ok(58) => msg.instruction = mod_SwitchboardInstruction::OneOfinstruction::set_aggregator_configs_instruction(r.read_message::<mod_SwitchboardInstruction::SetAggregatorConfigsInstruction>(bytes)?),
Ok(66) => msg.instruction = mod_SwitchboardInstruction::OneOfinstruction::set_fulfillment_manager_configs_instruction(r.read_message::<mod_SwitchboardInstruction::SetFulfillmentManagerConfigsInstruction>(bytes)?),
Ok(74) => msg.instruction = mod_SwitchboardInstruction::OneOfinstruction::heartbeat_instruction(r.read_message::<mod_SwitchboardInstruction::HeartbeatInstruction>(bytes)?),
Ok(82) => msg.instruction = mod_SwitchboardInstruction::OneOfinstruction::register_auth_instruction(r.read_message::<mod_SwitchboardInstruction::RegisterAuthInstruction>(bytes)?),
Ok(90) => msg.instruction = mod_SwitchboardInstruction::OneOfinstruction::reach_fulfiller_agreement_instruction(r.read_message::<mod_SwitchboardInstruction::ReachFulfillerAgreementInstruction>(bytes)?),
Ok(98) => msg.instruction = mod_SwitchboardInstruction::OneOfinstruction::remove_fulfiller_instruction(r.read_message::<mod_SwitchboardInstruction::RemoveFulfillerInstruction>(bytes)?),
Ok(106) => msg.instruction = mod_SwitchboardInstruction::OneOfinstruction::link_parse_optimized_account_instruction(r.read_message::<mod_SwitchboardInstruction::LinkedParseOptimizedResultAccountInstruction>(bytes)?),
Ok(114) => msg.instruction = mod_SwitchboardInstruction::OneOfinstruction::set_bundle_auth_configs_instruction(r.read_message::<mod_SwitchboardInstruction::SetBundleAuthConfigsInstruction>(bytes)?),
Ok(122) => msg.instruction = mod_SwitchboardInstruction::OneOfinstruction::add_bundle_auth_instruction(r.read_message::<mod_SwitchboardInstruction::AddBundleAuthInstruction>(bytes)?),
Ok(130) => msg.instruction = mod_SwitchboardInstruction::OneOfinstruction::remove_bundle_auth_instruction(r.read_message::<mod_SwitchboardInstruction::RemoveBundleAuthInstruction>(bytes)?),
Ok(138) => msg.instruction = mod_SwitchboardInstruction::OneOfinstruction::save_bundle_result_instruction(r.read_message::<mod_SwitchboardInstruction::SaveBundleResultInstruction>(bytes)?),
Ok(146) => msg.instruction = mod_SwitchboardInstruction::OneOfinstruction::set_vrf_configs_instruction(r.read_message::<mod_SwitchboardInstruction::SetVrfConfigsInstruction>(bytes)?),
Ok(154) => msg.instruction = mod_SwitchboardInstruction::OneOfinstruction::request_randomness_instruction(r.read_message::<mod_SwitchboardInstruction::RequestRandomnessInstruction>(bytes)?),
Ok(162) => msg.instruction = mod_SwitchboardInstruction::OneOfinstruction::respond_randomness_instruction(r.read_message::<mod_SwitchboardInstruction::RespondRandomnessInstruction>(bytes)?),
Ok(170) => msg.instruction = mod_SwitchboardInstruction::OneOfinstruction::confirm_randomness_proof_instruction(r.read_message::<mod_SwitchboardInstruction::ConfirmRandomnessProofInstruction>(bytes)?),
Ok(178) => msg.instruction = mod_SwitchboardInstruction::OneOfinstruction::set_vrf_permit_instruction(r.read_message::<mod_SwitchboardInstruction::SetVrfPermitInstruction>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl MessageWrite for SwitchboardInstruction {
fn get_size(&self) -> usize {
0
+ match self.instruction {
mod_SwitchboardInstruction::OneOfinstruction::init_instruction(ref m) => 1 + sizeof_len((m).get_size()),
mod_SwitchboardInstruction::OneOfinstruction::register_job_instruction(ref m) => 1 + sizeof_len((m).get_size()),
mod_SwitchboardInstruction::OneOfinstruction::unregister_job_instruction(ref m) => 1 + sizeof_len((m).get_size()),
mod_SwitchboardInstruction::OneOfinstruction::update_aggregate_instruction(ref m) => 1 + sizeof_len((m).get_size()),
mod_SwitchboardInstruction::OneOfinstruction::get_aggregate_instruction(ref m) => 1 + sizeof_len((m).get_size()),
mod_SwitchboardInstruction::OneOfinstruction::save_result_instruction(ref m) => 1 + sizeof_len((m).get_size()),
mod_SwitchboardInstruction::OneOfinstruction::set_aggregator_configs_instruction(ref m) => 1 + sizeof_len((m).get_size()),
mod_SwitchboardInstruction::OneOfinstruction::set_fulfillment_manager_configs_instruction(ref m) => 1 + sizeof_len((m).get_size()),
mod_SwitchboardInstruction::OneOfinstruction::heartbeat_instruction(ref m) => 1 + sizeof_len((m).get_size()),
mod_SwitchboardInstruction::OneOfinstruction::register_auth_instruction(ref m) => 1 + sizeof_len((m).get_size()),
mod_SwitchboardInstruction::OneOfinstruction::reach_fulfiller_agreement_instruction(ref m) => 1 + sizeof_len((m).get_size()),
mod_SwitchboardInstruction::OneOfinstruction::remove_fulfiller_instruction(ref m) => 1 + sizeof_len((m).get_size()),
mod_SwitchboardInstruction::OneOfinstruction::link_parse_optimized_account_instruction(ref m) => 1 + sizeof_len((m).get_size()),
mod_SwitchboardInstruction::OneOfinstruction::set_bundle_auth_configs_instruction(ref m) => 1 + sizeof_len((m).get_size()),
mod_SwitchboardInstruction::OneOfinstruction::add_bundle_auth_instruction(ref m) => 1 + sizeof_len((m).get_size()),
mod_SwitchboardInstruction::OneOfinstruction::remove_bundle_auth_instruction(ref m) => 2 + sizeof_len((m).get_size()),
mod_SwitchboardInstruction::OneOfinstruction::save_bundle_result_instruction(ref m) => 2 + sizeof_len((m).get_size()),
mod_SwitchboardInstruction::OneOfinstruction::set_vrf_configs_instruction(ref m) => 2 + sizeof_len((m).get_size()),
mod_SwitchboardInstruction::OneOfinstruction::request_randomness_instruction(ref m) => 2 + sizeof_len((m).get_size()),
mod_SwitchboardInstruction::OneOfinstruction::respond_randomness_instruction(ref m) => 2 + sizeof_len((m).get_size()),
mod_SwitchboardInstruction::OneOfinstruction::confirm_randomness_proof_instruction(ref m) => 2 + sizeof_len((m).get_size()),
mod_SwitchboardInstruction::OneOfinstruction::set_vrf_permit_instruction(ref m) => 2 + sizeof_len((m).get_size()),
mod_SwitchboardInstruction::OneOfinstruction::None => 0,
} }
fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
match self.instruction { mod_SwitchboardInstruction::OneOfinstruction::init_instruction(ref m) => { w.write_with_tag(10, |w| w.write_message(m))? },
mod_SwitchboardInstruction::OneOfinstruction::register_job_instruction(ref m) => { w.write_with_tag(18, |w| w.write_message(m))? },
mod_SwitchboardInstruction::OneOfinstruction::unregister_job_instruction(ref m) => { w.write_with_tag(26, |w| w.write_message(m))? },
mod_SwitchboardInstruction::OneOfinstruction::update_aggregate_instruction(ref m) => { w.write_with_tag(34, |w| w.write_message(m))? },
mod_SwitchboardInstruction::OneOfinstruction::get_aggregate_instruction(ref m) => { w.write_with_tag(42, |w| w.write_message(m))? },
mod_SwitchboardInstruction::OneOfinstruction::save_result_instruction(ref m) => { w.write_with_tag(50, |w| w.write_message(m))? },
mod_SwitchboardInstruction::OneOfinstruction::set_aggregator_configs_instruction(ref m) => { w.write_with_tag(58, |w| w.write_message(m))? },
mod_SwitchboardInstruction::OneOfinstruction::set_fulfillment_manager_configs_instruction(ref m) => { w.write_with_tag(66, |w| w.write_message(m))? },
mod_SwitchboardInstruction::OneOfinstruction::heartbeat_instruction(ref m) => { w.write_with_tag(74, |w| w.write_message(m))? },
mod_SwitchboardInstruction::OneOfinstruction::register_auth_instruction(ref m) => { w.write_with_tag(82, |w| w.write_message(m))? },
mod_SwitchboardInstruction::OneOfinstruction::reach_fulfiller_agreement_instruction(ref m) => { w.write_with_tag(90, |w| w.write_message(m))? },
mod_SwitchboardInstruction::OneOfinstruction::remove_fulfiller_instruction(ref m) => { w.write_with_tag(98, |w| w.write_message(m))? },
mod_SwitchboardInstruction::OneOfinstruction::link_parse_optimized_account_instruction(ref m) => { w.write_with_tag(106, |w| w.write_message(m))? },
mod_SwitchboardInstruction::OneOfinstruction::set_bundle_auth_configs_instruction(ref m) => { w.write_with_tag(114, |w| w.write_message(m))? },
mod_SwitchboardInstruction::OneOfinstruction::add_bundle_auth_instruction(ref m) => { w.write_with_tag(122, |w| w.write_message(m))? },
mod_SwitchboardInstruction::OneOfinstruction::remove_bundle_auth_instruction(ref m) => { w.write_with_tag(130, |w| w.write_message(m))? },
mod_SwitchboardInstruction::OneOfinstruction::save_bundle_result_instruction(ref m) => { w.write_with_tag(138, |w| w.write_message(m))? },
mod_SwitchboardInstruction::OneOfinstruction::set_vrf_configs_instruction(ref m) => { w.write_with_tag(146, |w| w.write_message(m))? },
mod_SwitchboardInstruction::OneOfinstruction::request_randomness_instruction(ref m) => { w.write_with_tag(154, |w| w.write_message(m))? },
mod_SwitchboardInstruction::OneOfinstruction::respond_randomness_instruction(ref m) => { w.write_with_tag(162, |w| w.write_message(m))? },
mod_SwitchboardInstruction::OneOfinstruction::confirm_randomness_proof_instruction(ref m) => { w.write_with_tag(170, |w| w.write_message(m))? },
mod_SwitchboardInstruction::OneOfinstruction::set_vrf_permit_instruction(ref m) => { w.write_with_tag(178, |w| w.write_message(m))? },
mod_SwitchboardInstruction::OneOfinstruction::None => {},
} Ok(())
}
}
pub mod mod_SwitchboardInstruction {
use super::*;
#[derive(Debug, Default, PartialEq, Clone)]
pub struct InitInstruction {
pub type_pb: Option<switchboard_account_types::SwitchboardAccountType>,
}
impl<'a> MessageRead<'a> for InitInstruction {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(8) => msg.type_pb = Some(r.read_enum(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl MessageWrite for InitInstruction {
fn get_size(&self) -> usize {
0
+ self.type_pb.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
}
fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
if let Some(ref s) = self.type_pb { w.write_with_tag(8, |w| w.write_enum(*s as i32))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct RegisterJobInstruction {
pub job: Option<job_schemas::OracleJob>,
}
impl<'a> MessageRead<'a> for RegisterJobInstruction {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.job = Some(r.read_message::<job_schemas::OracleJob>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl MessageWrite for RegisterJobInstruction {
fn get_size(&self) -> usize {
0
+ self.job.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
}
fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
if let Some(ref s) = self.job { w.write_with_tag(10, |w| w.write_message(s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct UnregisterJobInstruction {
pub job_pubkey: Option<Vec<u8>>,
}
impl<'a> MessageRead<'a> for UnregisterJobInstruction {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.job_pubkey = Some(r.read_bytes(bytes)?.to_owned()),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl MessageWrite for UnregisterJobInstruction {
fn get_size(&self) -> usize {
0
+ self.job_pubkey.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
}
fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
if let Some(ref s) = self.job_pubkey { w.write_with_tag(10, |w| w.write_bytes(&**s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct UpdateAggregateInstruction { }
impl<'a> MessageRead<'a> for UpdateAggregateInstruction {
fn from_reader(r: &mut BytesReader, _: &[u8]) -> Result<Self> {
r.read_to_end();
Ok(Self::default())
}
}
impl MessageWrite for UpdateAggregateInstruction { }
#[derive(Debug, Default, PartialEq, Clone)]
pub struct GetAggregateInstruction { }
impl<'a> MessageRead<'a> for GetAggregateInstruction {
fn from_reader(r: &mut BytesReader, _: &[u8]) -> Result<Self> {
r.read_to_end();
Ok(Self::default())
}
}
impl MessageWrite for GetAggregateInstruction { }
#[derive(Debug, Default, PartialEq, Clone)]
pub struct SetAggregatorConfigsInstruction {
pub min_confirmations: Option<i32>,
pub min_update_delay_seconds: Option<i64>,
pub fulfillment_manager_pubkey: Option<Vec<u8>>,
pub lock: Option<bool>,
}
impl<'a> MessageRead<'a> for SetAggregatorConfigsInstruction {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(8) => msg.min_confirmations = Some(r.read_int32(bytes)?),
Ok(16) => msg.min_update_delay_seconds = Some(r.read_int64(bytes)?),
Ok(26) => msg.fulfillment_manager_pubkey = Some(r.read_bytes(bytes)?.to_owned()),
Ok(40) => msg.lock = Some(r.read_bool(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl MessageWrite for SetAggregatorConfigsInstruction {
fn get_size(&self) -> usize {
0
+ self.min_confirmations.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
+ self.min_update_delay_seconds.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
+ self.fulfillment_manager_pubkey.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
+ self.lock.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
}
fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
if let Some(ref s) = self.min_confirmations { w.write_with_tag(8, |w| w.write_int32(*s))?; }
if let Some(ref s) = self.min_update_delay_seconds { w.write_with_tag(16, |w| w.write_int64(*s))?; }
if let Some(ref s) = self.fulfillment_manager_pubkey { w.write_with_tag(26, |w| w.write_bytes(&**s))?; }
if let Some(ref s) = self.lock { w.write_with_tag(40, |w| w.write_bool(*s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct SetFulfillmentManagerConfigsInstruction {
pub heartbeat_auth_required: Option<bool>,
pub usage_auth_required: Option<bool>,
pub lock: Option<bool>,
}
impl<'a> MessageRead<'a> for SetFulfillmentManagerConfigsInstruction {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(8) => msg.heartbeat_auth_required = Some(r.read_bool(bytes)?),
Ok(16) => msg.usage_auth_required = Some(r.read_bool(bytes)?),
Ok(24) => msg.lock = Some(r.read_bool(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl MessageWrite for SetFulfillmentManagerConfigsInstruction {
fn get_size(&self) -> usize {
0
+ self.heartbeat_auth_required.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
+ self.usage_auth_required.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
+ self.lock.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
}
fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
if let Some(ref s) = self.heartbeat_auth_required { w.write_with_tag(8, |w| w.write_bool(*s))?; }
if let Some(ref s) = self.usage_auth_required { w.write_with_tag(16, |w| w.write_bool(*s))?; }
if let Some(ref s) = self.lock { w.write_with_tag(24, |w| w.write_bool(*s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct SaveResultInstruction {
pub node_idx: Option<u32>,
pub result: Option<f64>,
pub error: Option<bool>,
pub round_slot: Option<u64>,
pub min_response: Option<f64>,
pub max_response: Option<f64>,
}
impl<'a> MessageRead<'a> for SaveResultInstruction {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(16) => msg.node_idx = Some(r.read_uint32(bytes)?),
Ok(33) => msg.result = Some(r.read_double(bytes)?),
Ok(40) => msg.error = Some(r.read_bool(bytes)?),
Ok(48) => msg.round_slot = Some(r.read_uint64(bytes)?),
Ok(57) => msg.min_response = Some(r.read_double(bytes)?),
Ok(65) => msg.max_response = Some(r.read_double(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl MessageWrite for SaveResultInstruction {
fn get_size(&self) -> usize {
0
+ self.node_idx.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
+ self.result.as_ref().map_or(0, |_| 1 + 8)
+ self.error.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
+ self.round_slot.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
+ self.min_response.as_ref().map_or(0, |_| 1 + 8)
+ self.max_response.as_ref().map_or(0, |_| 1 + 8)
}
fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
if let Some(ref s) = self.node_idx { w.write_with_tag(16, |w| w.write_uint32(*s))?; }
if let Some(ref s) = self.result { w.write_with_tag(33, |w| w.write_double(*s))?; }
if let Some(ref s) = self.error { w.write_with_tag(40, |w| w.write_bool(*s))?; }
if let Some(ref s) = self.round_slot { w.write_with_tag(48, |w| w.write_uint64(*s))?; }
if let Some(ref s) = self.min_response { w.write_with_tag(57, |w| w.write_double(*s))?; }
if let Some(ref s) = self.max_response { w.write_with_tag(65, |w| w.write_double(*s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct HeartbeatInstruction {
pub lease_count: Option<i64>,
pub slot_expiration: Option<i64>,
}
impl<'a> MessageRead<'a> for HeartbeatInstruction {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(8) => msg.lease_count = Some(r.read_int64(bytes)?),
Ok(16) => msg.slot_expiration = Some(r.read_int64(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl MessageWrite for HeartbeatInstruction {
fn get_size(&self) -> usize {
0
+ self.lease_count.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
+ self.slot_expiration.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
}
fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
if let Some(ref s) = self.lease_count { w.write_with_tag(8, |w| w.write_int64(*s))?; }
if let Some(ref s) = self.slot_expiration { w.write_with_tag(16, |w| w.write_int64(*s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct RegisterAuthInstruction {
pub authorize_heartbeat: Option<bool>,
pub authorize_usage: Option<bool>,
}
impl<'a> MessageRead<'a> for RegisterAuthInstruction {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(8) => msg.authorize_heartbeat = Some(r.read_bool(bytes)?),
Ok(16) => msg.authorize_usage = Some(r.read_bool(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl MessageWrite for RegisterAuthInstruction {
fn get_size(&self) -> usize {
0
+ self.authorize_heartbeat.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
+ self.authorize_usage.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
}
fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
if let Some(ref s) = self.authorize_heartbeat { w.write_with_tag(8, |w| w.write_bool(*s))?; }
if let Some(ref s) = self.authorize_usage { w.write_with_tag(16, |w| w.write_bool(*s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct ReachFulfillerAgreementInstruction { }
impl<'a> MessageRead<'a> for ReachFulfillerAgreementInstruction {
fn from_reader(r: &mut BytesReader, _: &[u8]) -> Result<Self> {
r.read_to_end();
Ok(Self::default())
}
}
impl MessageWrite for ReachFulfillerAgreementInstruction { }
#[derive(Debug, Default, PartialEq, Clone)]
pub struct RemoveFulfillerInstruction { }
impl<'a> MessageRead<'a> for RemoveFulfillerInstruction {
fn from_reader(r: &mut BytesReader, _: &[u8]) -> Result<Self> {
r.read_to_end();
Ok(Self::default())
}
}
impl MessageWrite for RemoveFulfillerInstruction { }
#[derive(Debug, Default, PartialEq, Clone)]
pub struct LinkedParseOptimizedResultAccountInstruction { }
impl<'a> MessageRead<'a> for LinkedParseOptimizedResultAccountInstruction {
fn from_reader(r: &mut BytesReader, _: &[u8]) -> Result<Self> {
r.read_to_end();
Ok(Self::default())
}
}
impl MessageWrite for LinkedParseOptimizedResultAccountInstruction { }
#[derive(Debug, Default, PartialEq, Clone)]
pub struct SetBundleAuthConfigsInstruction {
pub idx: Option<i32>,
}
impl<'a> MessageRead<'a> for SetBundleAuthConfigsInstruction {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(8) => msg.idx = Some(r.read_int32(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl MessageWrite for SetBundleAuthConfigsInstruction {
fn get_size(&self) -> usize {
0
+ self.idx.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
}
fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
if let Some(ref s) = self.idx { w.write_with_tag(8, |w| w.write_int32(*s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct AddBundleAuthInstruction { }
impl<'a> MessageRead<'a> for AddBundleAuthInstruction {
fn from_reader(r: &mut BytesReader, _: &[u8]) -> Result<Self> {
r.read_to_end();
Ok(Self::default())
}
}
impl MessageWrite for AddBundleAuthInstruction { }
#[derive(Debug, Default, PartialEq, Clone)]
pub struct RemoveBundleAuthInstruction { }
impl<'a> MessageRead<'a> for RemoveBundleAuthInstruction {
fn from_reader(r: &mut BytesReader, _: &[u8]) -> Result<Self> {
r.read_to_end();
Ok(Self::default())
}
}
impl MessageWrite for RemoveBundleAuthInstruction { }
#[derive(Debug, Default, PartialEq, Clone)]
pub struct SaveBundleResultInstruction { }
impl<'a> MessageRead<'a> for SaveBundleResultInstruction {
fn from_reader(r: &mut BytesReader, _: &[u8]) -> Result<Self> {
r.read_to_end();
Ok(Self::default())
}
}
impl MessageWrite for SaveBundleResultInstruction { }
#[derive(Debug, Default, PartialEq, Clone)]
pub struct SetVrfConfigsInstruction {
pub min_proof_confirmations: Option<i32>,
pub lock_configs: Option<bool>,
}
impl<'a> MessageRead<'a> for SetVrfConfigsInstruction {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(24) => msg.min_proof_confirmations = Some(r.read_int32(bytes)?),
Ok(32) => msg.lock_configs = Some(r.read_bool(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl MessageWrite for SetVrfConfigsInstruction {
fn get_size(&self) -> usize {
0
+ self.min_proof_confirmations.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
+ self.lock_configs.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
}
fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
if let Some(ref s) = self.min_proof_confirmations { w.write_with_tag(24, |w| w.write_int32(*s))?; }
if let Some(ref s) = self.lock_configs { w.write_with_tag(32, |w| w.write_bool(*s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct RequestRandomnessInstruction { }
impl<'a> MessageRead<'a> for RequestRandomnessInstruction {
fn from_reader(r: &mut BytesReader, _: &[u8]) -> Result<Self> {
r.read_to_end();
Ok(Self::default())
}
}
impl MessageWrite for RequestRandomnessInstruction { }
#[derive(Debug, Default, PartialEq, Clone)]
pub struct RespondRandomnessInstruction {
pub value: Option<Vec<u8>>,
pub proof: Option<Vec<u8>>,
}
impl<'a> MessageRead<'a> for RespondRandomnessInstruction {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.value = Some(r.read_bytes(bytes)?.to_owned()),
Ok(18) => msg.proof = Some(r.read_bytes(bytes)?.to_owned()),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl MessageWrite for RespondRandomnessInstruction {
fn get_size(&self) -> usize {
0
+ self.value.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
+ self.proof.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
}
fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
if let Some(ref s) = self.value { w.write_with_tag(10, |w| w.write_bytes(&**s))?; }
if let Some(ref s) = self.proof { w.write_with_tag(18, |w| w.write_bytes(&**s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct ConfirmRandomnessProofInstruction {
pub proof: Option<Vec<u8>>,
}
impl<'a> MessageRead<'a> for ConfirmRandomnessProofInstruction {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.proof = Some(r.read_bytes(bytes)?.to_owned()),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl MessageWrite for ConfirmRandomnessProofInstruction {
fn get_size(&self) -> usize {
0
+ self.proof.as_ref().map_or(0, |m| 1 + sizeof_len((m).len()))
}
fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
if let Some(ref s) = self.proof { w.write_with_tag(10, |w| w.write_bytes(&**s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct SetVrfPermitInstruction {
pub enabled: Option<bool>,
}
impl<'a> MessageRead<'a> for SetVrfPermitInstruction {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(8) => msg.enabled = Some(r.read_bool(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl MessageWrite for SetVrfPermitInstruction {
fn get_size(&self) -> usize {
0
+ self.enabled.as_ref().map_or(0, |m| 1 + sizeof_varint(*(m) as u64))
}
fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
if let Some(ref s) = self.enabled { w.write_with_tag(8, |w| w.write_bool(*s))?; }
Ok(())
}
}
#[derive(Debug, PartialEq, Clone)]
pub enum OneOfinstruction {
init_instruction(mod_SwitchboardInstruction::InitInstruction),
register_job_instruction(mod_SwitchboardInstruction::RegisterJobInstruction),
unregister_job_instruction(mod_SwitchboardInstruction::UnregisterJobInstruction),
update_aggregate_instruction(mod_SwitchboardInstruction::UpdateAggregateInstruction),
get_aggregate_instruction(mod_SwitchboardInstruction::GetAggregateInstruction),
save_result_instruction(mod_SwitchboardInstruction::SaveResultInstruction),
set_aggregator_configs_instruction(mod_SwitchboardInstruction::SetAggregatorConfigsInstruction),
set_fulfillment_manager_configs_instruction(mod_SwitchboardInstruction::SetFulfillmentManagerConfigsInstruction),
heartbeat_instruction(mod_SwitchboardInstruction::HeartbeatInstruction),
register_auth_instruction(mod_SwitchboardInstruction::RegisterAuthInstruction),
reach_fulfiller_agreement_instruction(mod_SwitchboardInstruction::ReachFulfillerAgreementInstruction),
remove_fulfiller_instruction(mod_SwitchboardInstruction::RemoveFulfillerInstruction),
link_parse_optimized_account_instruction(mod_SwitchboardInstruction::LinkedParseOptimizedResultAccountInstruction),
set_bundle_auth_configs_instruction(mod_SwitchboardInstruction::SetBundleAuthConfigsInstruction),
add_bundle_auth_instruction(mod_SwitchboardInstruction::AddBundleAuthInstruction),
remove_bundle_auth_instruction(mod_SwitchboardInstruction::RemoveBundleAuthInstruction),
save_bundle_result_instruction(mod_SwitchboardInstruction::SaveBundleResultInstruction),
set_vrf_configs_instruction(mod_SwitchboardInstruction::SetVrfConfigsInstruction),
request_randomness_instruction(mod_SwitchboardInstruction::RequestRandomnessInstruction),
respond_randomness_instruction(mod_SwitchboardInstruction::RespondRandomnessInstruction),
confirm_randomness_proof_instruction(mod_SwitchboardInstruction::ConfirmRandomnessProofInstruction),
set_vrf_permit_instruction(mod_SwitchboardInstruction::SetVrfPermitInstruction),
None,
}
impl Default for OneOfinstruction {
fn default() -> Self {
OneOfinstruction::None
}
}
}