1#![allow(unknown_lints)]
7#![allow(clippy::all)]
8
9#![allow(unused_attributes)]
10#![cfg_attr(rustfmt, rustfmt::skip)]
11
12#![allow(dead_code)]
13#![allow(missing_docs)]
14#![allow(non_camel_case_types)]
15#![allow(non_snake_case)]
16#![allow(non_upper_case_globals)]
17#![allow(trivial_casts)]
18#![allow(unused_results)]
19#![allow(unused_mut)]
20
21const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_7_2;
26
27#[derive(PartialEq,Clone,Default,Debug)]
29pub struct SmartContract {
30 pub origin_address: ::std::vec::Vec<u8>,
33 pub contract_address: ::std::vec::Vec<u8>,
35 pub abi: ::protobuf::MessageField<smart_contract::ABI>,
37 pub bytecode: ::std::vec::Vec<u8>,
39 pub call_value: i64,
41 pub consume_user_resource_percent: i64,
43 pub name: ::std::string::String,
45 pub origin_energy_limit: i64,
47 pub code_hash: ::std::vec::Vec<u8>,
49 pub trx_hash: ::std::vec::Vec<u8>,
51 pub version: i32,
53 pub special_fields: ::protobuf::SpecialFields,
56}
57
58impl<'a> ::std::default::Default for &'a SmartContract {
59 fn default() -> &'a SmartContract {
60 <SmartContract as ::protobuf::Message>::default_instance()
61 }
62}
63
64impl SmartContract {
65 pub fn new() -> SmartContract {
66 ::std::default::Default::default()
67 }
68
69 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
70 let mut fields = ::std::vec::Vec::with_capacity(11);
71 let mut oneofs = ::std::vec::Vec::with_capacity(0);
72 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
73 "origin_address",
74 |m: &SmartContract| { &m.origin_address },
75 |m: &mut SmartContract| { &mut m.origin_address },
76 ));
77 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
78 "contract_address",
79 |m: &SmartContract| { &m.contract_address },
80 |m: &mut SmartContract| { &mut m.contract_address },
81 ));
82 fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, smart_contract::ABI>(
83 "abi",
84 |m: &SmartContract| { &m.abi },
85 |m: &mut SmartContract| { &mut m.abi },
86 ));
87 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
88 "bytecode",
89 |m: &SmartContract| { &m.bytecode },
90 |m: &mut SmartContract| { &mut m.bytecode },
91 ));
92 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
93 "call_value",
94 |m: &SmartContract| { &m.call_value },
95 |m: &mut SmartContract| { &mut m.call_value },
96 ));
97 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
98 "consume_user_resource_percent",
99 |m: &SmartContract| { &m.consume_user_resource_percent },
100 |m: &mut SmartContract| { &mut m.consume_user_resource_percent },
101 ));
102 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
103 "name",
104 |m: &SmartContract| { &m.name },
105 |m: &mut SmartContract| { &mut m.name },
106 ));
107 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
108 "origin_energy_limit",
109 |m: &SmartContract| { &m.origin_energy_limit },
110 |m: &mut SmartContract| { &mut m.origin_energy_limit },
111 ));
112 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
113 "code_hash",
114 |m: &SmartContract| { &m.code_hash },
115 |m: &mut SmartContract| { &mut m.code_hash },
116 ));
117 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
118 "trx_hash",
119 |m: &SmartContract| { &m.trx_hash },
120 |m: &mut SmartContract| { &mut m.trx_hash },
121 ));
122 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
123 "version",
124 |m: &SmartContract| { &m.version },
125 |m: &mut SmartContract| { &mut m.version },
126 ));
127 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SmartContract>(
128 "SmartContract",
129 fields,
130 oneofs,
131 )
132 }
133}
134
135impl ::protobuf::Message for SmartContract {
136 const NAME: &'static str = "SmartContract";
137
138 fn is_initialized(&self) -> bool {
139 true
140 }
141
142 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
143 while let Some(tag) = is.read_raw_tag_or_eof()? {
144 match tag {
145 10 => {
146 self.origin_address = is.read_bytes()?;
147 },
148 18 => {
149 self.contract_address = is.read_bytes()?;
150 },
151 26 => {
152 ::protobuf::rt::read_singular_message_into_field(is, &mut self.abi)?;
153 },
154 34 => {
155 self.bytecode = is.read_bytes()?;
156 },
157 40 => {
158 self.call_value = is.read_int64()?;
159 },
160 48 => {
161 self.consume_user_resource_percent = is.read_int64()?;
162 },
163 58 => {
164 self.name = is.read_string()?;
165 },
166 64 => {
167 self.origin_energy_limit = is.read_int64()?;
168 },
169 74 => {
170 self.code_hash = is.read_bytes()?;
171 },
172 82 => {
173 self.trx_hash = is.read_bytes()?;
174 },
175 88 => {
176 self.version = is.read_int32()?;
177 },
178 tag => {
179 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
180 },
181 };
182 }
183 ::std::result::Result::Ok(())
184 }
185
186 #[allow(unused_variables)]
188 fn compute_size(&self) -> u64 {
189 let mut my_size = 0;
190 if !self.origin_address.is_empty() {
191 my_size += ::protobuf::rt::bytes_size(1, &self.origin_address);
192 }
193 if !self.contract_address.is_empty() {
194 my_size += ::protobuf::rt::bytes_size(2, &self.contract_address);
195 }
196 if let Some(v) = self.abi.as_ref() {
197 let len = v.compute_size();
198 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
199 }
200 if !self.bytecode.is_empty() {
201 my_size += ::protobuf::rt::bytes_size(4, &self.bytecode);
202 }
203 if self.call_value != 0 {
204 my_size += ::protobuf::rt::int64_size(5, self.call_value);
205 }
206 if self.consume_user_resource_percent != 0 {
207 my_size += ::protobuf::rt::int64_size(6, self.consume_user_resource_percent);
208 }
209 if !self.name.is_empty() {
210 my_size += ::protobuf::rt::string_size(7, &self.name);
211 }
212 if self.origin_energy_limit != 0 {
213 my_size += ::protobuf::rt::int64_size(8, self.origin_energy_limit);
214 }
215 if !self.code_hash.is_empty() {
216 my_size += ::protobuf::rt::bytes_size(9, &self.code_hash);
217 }
218 if !self.trx_hash.is_empty() {
219 my_size += ::protobuf::rt::bytes_size(10, &self.trx_hash);
220 }
221 if self.version != 0 {
222 my_size += ::protobuf::rt::int32_size(11, self.version);
223 }
224 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
225 self.special_fields.cached_size().set(my_size as u32);
226 my_size
227 }
228
229 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
230 if !self.origin_address.is_empty() {
231 os.write_bytes(1, &self.origin_address)?;
232 }
233 if !self.contract_address.is_empty() {
234 os.write_bytes(2, &self.contract_address)?;
235 }
236 if let Some(v) = self.abi.as_ref() {
237 ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
238 }
239 if !self.bytecode.is_empty() {
240 os.write_bytes(4, &self.bytecode)?;
241 }
242 if self.call_value != 0 {
243 os.write_int64(5, self.call_value)?;
244 }
245 if self.consume_user_resource_percent != 0 {
246 os.write_int64(6, self.consume_user_resource_percent)?;
247 }
248 if !self.name.is_empty() {
249 os.write_string(7, &self.name)?;
250 }
251 if self.origin_energy_limit != 0 {
252 os.write_int64(8, self.origin_energy_limit)?;
253 }
254 if !self.code_hash.is_empty() {
255 os.write_bytes(9, &self.code_hash)?;
256 }
257 if !self.trx_hash.is_empty() {
258 os.write_bytes(10, &self.trx_hash)?;
259 }
260 if self.version != 0 {
261 os.write_int32(11, self.version)?;
262 }
263 os.write_unknown_fields(self.special_fields.unknown_fields())?;
264 ::std::result::Result::Ok(())
265 }
266
267 fn special_fields(&self) -> &::protobuf::SpecialFields {
268 &self.special_fields
269 }
270
271 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
272 &mut self.special_fields
273 }
274
275 fn new() -> SmartContract {
276 SmartContract::new()
277 }
278
279 fn clear(&mut self) {
280 self.origin_address.clear();
281 self.contract_address.clear();
282 self.abi.clear();
283 self.bytecode.clear();
284 self.call_value = 0;
285 self.consume_user_resource_percent = 0;
286 self.name.clear();
287 self.origin_energy_limit = 0;
288 self.code_hash.clear();
289 self.trx_hash.clear();
290 self.version = 0;
291 self.special_fields.clear();
292 }
293
294 fn default_instance() -> &'static SmartContract {
295 static instance: SmartContract = SmartContract {
296 origin_address: ::std::vec::Vec::new(),
297 contract_address: ::std::vec::Vec::new(),
298 abi: ::protobuf::MessageField::none(),
299 bytecode: ::std::vec::Vec::new(),
300 call_value: 0,
301 consume_user_resource_percent: 0,
302 name: ::std::string::String::new(),
303 origin_energy_limit: 0,
304 code_hash: ::std::vec::Vec::new(),
305 trx_hash: ::std::vec::Vec::new(),
306 version: 0,
307 special_fields: ::protobuf::SpecialFields::new(),
308 };
309 &instance
310 }
311}
312
313impl ::protobuf::MessageFull for SmartContract {
314 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
315 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
316 descriptor.get(|| file_descriptor().message_by_package_relative_name("SmartContract").unwrap()).clone()
317 }
318}
319
320impl ::std::fmt::Display for SmartContract {
321 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
322 ::protobuf::text_format::fmt(self, f)
323 }
324}
325
326impl ::protobuf::reflect::ProtobufValue for SmartContract {
327 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
328}
329
330pub mod smart_contract {
332 #[derive(PartialEq,Clone,Default,Debug)]
334 pub struct ABI {
335 pub entrys: ::std::vec::Vec<abi::Entry>,
338 pub special_fields: ::protobuf::SpecialFields,
341 }
342
343 impl<'a> ::std::default::Default for &'a ABI {
344 fn default() -> &'a ABI {
345 <ABI as ::protobuf::Message>::default_instance()
346 }
347 }
348
349 impl ABI {
350 pub fn new() -> ABI {
351 ::std::default::Default::default()
352 }
353
354 pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
355 let mut fields = ::std::vec::Vec::with_capacity(1);
356 let mut oneofs = ::std::vec::Vec::with_capacity(0);
357 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
358 "entrys",
359 |m: &ABI| { &m.entrys },
360 |m: &mut ABI| { &mut m.entrys },
361 ));
362 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ABI>(
363 "SmartContract.ABI",
364 fields,
365 oneofs,
366 )
367 }
368 }
369
370 impl ::protobuf::Message for ABI {
371 const NAME: &'static str = "ABI";
372
373 fn is_initialized(&self) -> bool {
374 true
375 }
376
377 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
378 while let Some(tag) = is.read_raw_tag_or_eof()? {
379 match tag {
380 10 => {
381 self.entrys.push(is.read_message()?);
382 },
383 tag => {
384 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
385 },
386 };
387 }
388 ::std::result::Result::Ok(())
389 }
390
391 #[allow(unused_variables)]
393 fn compute_size(&self) -> u64 {
394 let mut my_size = 0;
395 for value in &self.entrys {
396 let len = value.compute_size();
397 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
398 };
399 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
400 self.special_fields.cached_size().set(my_size as u32);
401 my_size
402 }
403
404 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
405 for v in &self.entrys {
406 ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
407 };
408 os.write_unknown_fields(self.special_fields.unknown_fields())?;
409 ::std::result::Result::Ok(())
410 }
411
412 fn special_fields(&self) -> &::protobuf::SpecialFields {
413 &self.special_fields
414 }
415
416 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
417 &mut self.special_fields
418 }
419
420 fn new() -> ABI {
421 ABI::new()
422 }
423
424 fn clear(&mut self) {
425 self.entrys.clear();
426 self.special_fields.clear();
427 }
428
429 fn default_instance() -> &'static ABI {
430 static instance: ABI = ABI {
431 entrys: ::std::vec::Vec::new(),
432 special_fields: ::protobuf::SpecialFields::new(),
433 };
434 &instance
435 }
436 }
437
438 impl ::protobuf::MessageFull for ABI {
439 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
440 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
441 descriptor.get(|| super::file_descriptor().message_by_package_relative_name("SmartContract.ABI").unwrap()).clone()
442 }
443 }
444
445 impl ::std::fmt::Display for ABI {
446 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
447 ::protobuf::text_format::fmt(self, f)
448 }
449 }
450
451 impl ::protobuf::reflect::ProtobufValue for ABI {
452 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
453 }
454
455 pub mod abi {
457 #[derive(PartialEq,Clone,Default,Debug)]
459 pub struct Entry {
460 pub anonymous: bool,
463 pub constant: bool,
465 pub name: ::std::string::String,
467 pub inputs: ::std::vec::Vec<entry::Param>,
469 pub outputs: ::std::vec::Vec<entry::Param>,
471 pub type_: ::protobuf::EnumOrUnknown<entry::EntryType>,
473 pub payable: bool,
475 pub stateMutability: ::protobuf::EnumOrUnknown<entry::StateMutabilityType>,
477 pub special_fields: ::protobuf::SpecialFields,
480 }
481
482 impl<'a> ::std::default::Default for &'a Entry {
483 fn default() -> &'a Entry {
484 <Entry as ::protobuf::Message>::default_instance()
485 }
486 }
487
488 impl Entry {
489 pub fn new() -> Entry {
490 ::std::default::Default::default()
491 }
492
493 pub(in super::super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
494 let mut fields = ::std::vec::Vec::with_capacity(8);
495 let mut oneofs = ::std::vec::Vec::with_capacity(0);
496 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
497 "anonymous",
498 |m: &Entry| { &m.anonymous },
499 |m: &mut Entry| { &mut m.anonymous },
500 ));
501 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
502 "constant",
503 |m: &Entry| { &m.constant },
504 |m: &mut Entry| { &mut m.constant },
505 ));
506 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
507 "name",
508 |m: &Entry| { &m.name },
509 |m: &mut Entry| { &mut m.name },
510 ));
511 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
512 "inputs",
513 |m: &Entry| { &m.inputs },
514 |m: &mut Entry| { &mut m.inputs },
515 ));
516 fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
517 "outputs",
518 |m: &Entry| { &m.outputs },
519 |m: &mut Entry| { &mut m.outputs },
520 ));
521 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
522 "type",
523 |m: &Entry| { &m.type_ },
524 |m: &mut Entry| { &mut m.type_ },
525 ));
526 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
527 "payable",
528 |m: &Entry| { &m.payable },
529 |m: &mut Entry| { &mut m.payable },
530 ));
531 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
532 "stateMutability",
533 |m: &Entry| { &m.stateMutability },
534 |m: &mut Entry| { &mut m.stateMutability },
535 ));
536 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Entry>(
537 "SmartContract.ABI.Entry",
538 fields,
539 oneofs,
540 )
541 }
542 }
543
544 impl ::protobuf::Message for Entry {
545 const NAME: &'static str = "Entry";
546
547 fn is_initialized(&self) -> bool {
548 true
549 }
550
551 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
552 while let Some(tag) = is.read_raw_tag_or_eof()? {
553 match tag {
554 8 => {
555 self.anonymous = is.read_bool()?;
556 },
557 16 => {
558 self.constant = is.read_bool()?;
559 },
560 26 => {
561 self.name = is.read_string()?;
562 },
563 34 => {
564 self.inputs.push(is.read_message()?);
565 },
566 42 => {
567 self.outputs.push(is.read_message()?);
568 },
569 48 => {
570 self.type_ = is.read_enum_or_unknown()?;
571 },
572 56 => {
573 self.payable = is.read_bool()?;
574 },
575 64 => {
576 self.stateMutability = is.read_enum_or_unknown()?;
577 },
578 tag => {
579 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
580 },
581 };
582 }
583 ::std::result::Result::Ok(())
584 }
585
586 #[allow(unused_variables)]
588 fn compute_size(&self) -> u64 {
589 let mut my_size = 0;
590 if self.anonymous != false {
591 my_size += 1 + 1;
592 }
593 if self.constant != false {
594 my_size += 1 + 1;
595 }
596 if !self.name.is_empty() {
597 my_size += ::protobuf::rt::string_size(3, &self.name);
598 }
599 for value in &self.inputs {
600 let len = value.compute_size();
601 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
602 };
603 for value in &self.outputs {
604 let len = value.compute_size();
605 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
606 };
607 if self.type_ != ::protobuf::EnumOrUnknown::new(entry::EntryType::UnknownEntryType) {
608 my_size += ::protobuf::rt::int32_size(6, self.type_.value());
609 }
610 if self.payable != false {
611 my_size += 1 + 1;
612 }
613 if self.stateMutability != ::protobuf::EnumOrUnknown::new(entry::StateMutabilityType::UnknownMutabilityType) {
614 my_size += ::protobuf::rt::int32_size(8, self.stateMutability.value());
615 }
616 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
617 self.special_fields.cached_size().set(my_size as u32);
618 my_size
619 }
620
621 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
622 if self.anonymous != false {
623 os.write_bool(1, self.anonymous)?;
624 }
625 if self.constant != false {
626 os.write_bool(2, self.constant)?;
627 }
628 if !self.name.is_empty() {
629 os.write_string(3, &self.name)?;
630 }
631 for v in &self.inputs {
632 ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
633 };
634 for v in &self.outputs {
635 ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
636 };
637 if self.type_ != ::protobuf::EnumOrUnknown::new(entry::EntryType::UnknownEntryType) {
638 os.write_enum(6, ::protobuf::EnumOrUnknown::value(&self.type_))?;
639 }
640 if self.payable != false {
641 os.write_bool(7, self.payable)?;
642 }
643 if self.stateMutability != ::protobuf::EnumOrUnknown::new(entry::StateMutabilityType::UnknownMutabilityType) {
644 os.write_enum(8, ::protobuf::EnumOrUnknown::value(&self.stateMutability))?;
645 }
646 os.write_unknown_fields(self.special_fields.unknown_fields())?;
647 ::std::result::Result::Ok(())
648 }
649
650 fn special_fields(&self) -> &::protobuf::SpecialFields {
651 &self.special_fields
652 }
653
654 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
655 &mut self.special_fields
656 }
657
658 fn new() -> Entry {
659 Entry::new()
660 }
661
662 fn clear(&mut self) {
663 self.anonymous = false;
664 self.constant = false;
665 self.name.clear();
666 self.inputs.clear();
667 self.outputs.clear();
668 self.type_ = ::protobuf::EnumOrUnknown::new(entry::EntryType::UnknownEntryType);
669 self.payable = false;
670 self.stateMutability = ::protobuf::EnumOrUnknown::new(entry::StateMutabilityType::UnknownMutabilityType);
671 self.special_fields.clear();
672 }
673
674 fn default_instance() -> &'static Entry {
675 static instance: Entry = Entry {
676 anonymous: false,
677 constant: false,
678 name: ::std::string::String::new(),
679 inputs: ::std::vec::Vec::new(),
680 outputs: ::std::vec::Vec::new(),
681 type_: ::protobuf::EnumOrUnknown::from_i32(0),
682 payable: false,
683 stateMutability: ::protobuf::EnumOrUnknown::from_i32(0),
684 special_fields: ::protobuf::SpecialFields::new(),
685 };
686 &instance
687 }
688 }
689
690 impl ::protobuf::MessageFull for Entry {
691 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
692 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
693 descriptor.get(|| super::super::file_descriptor().message_by_package_relative_name("SmartContract.ABI.Entry").unwrap()).clone()
694 }
695 }
696
697 impl ::std::fmt::Display for Entry {
698 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
699 ::protobuf::text_format::fmt(self, f)
700 }
701 }
702
703 impl ::protobuf::reflect::ProtobufValue for Entry {
704 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
705 }
706
707 pub mod entry {
709 #[derive(PartialEq,Clone,Default,Debug)]
711 pub struct Param {
712 pub indexed: bool,
715 pub name: ::std::string::String,
717 pub type_: ::std::string::String,
719 pub special_fields: ::protobuf::SpecialFields,
722 }
723
724 impl<'a> ::std::default::Default for &'a Param {
725 fn default() -> &'a Param {
726 <Param as ::protobuf::Message>::default_instance()
727 }
728 }
729
730 impl Param {
731 pub fn new() -> Param {
732 ::std::default::Default::default()
733 }
734
735 pub(in super::super::super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
736 let mut fields = ::std::vec::Vec::with_capacity(3);
737 let mut oneofs = ::std::vec::Vec::with_capacity(0);
738 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
739 "indexed",
740 |m: &Param| { &m.indexed },
741 |m: &mut Param| { &mut m.indexed },
742 ));
743 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
744 "name",
745 |m: &Param| { &m.name },
746 |m: &mut Param| { &mut m.name },
747 ));
748 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
749 "type",
750 |m: &Param| { &m.type_ },
751 |m: &mut Param| { &mut m.type_ },
752 ));
753 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Param>(
754 "SmartContract.ABI.Entry.Param",
755 fields,
756 oneofs,
757 )
758 }
759 }
760
761 impl ::protobuf::Message for Param {
762 const NAME: &'static str = "Param";
763
764 fn is_initialized(&self) -> bool {
765 true
766 }
767
768 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
769 while let Some(tag) = is.read_raw_tag_or_eof()? {
770 match tag {
771 8 => {
772 self.indexed = is.read_bool()?;
773 },
774 18 => {
775 self.name = is.read_string()?;
776 },
777 26 => {
778 self.type_ = is.read_string()?;
779 },
780 tag => {
781 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
782 },
783 };
784 }
785 ::std::result::Result::Ok(())
786 }
787
788 #[allow(unused_variables)]
790 fn compute_size(&self) -> u64 {
791 let mut my_size = 0;
792 if self.indexed != false {
793 my_size += 1 + 1;
794 }
795 if !self.name.is_empty() {
796 my_size += ::protobuf::rt::string_size(2, &self.name);
797 }
798 if !self.type_.is_empty() {
799 my_size += ::protobuf::rt::string_size(3, &self.type_);
800 }
801 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
802 self.special_fields.cached_size().set(my_size as u32);
803 my_size
804 }
805
806 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
807 if self.indexed != false {
808 os.write_bool(1, self.indexed)?;
809 }
810 if !self.name.is_empty() {
811 os.write_string(2, &self.name)?;
812 }
813 if !self.type_.is_empty() {
814 os.write_string(3, &self.type_)?;
815 }
816 os.write_unknown_fields(self.special_fields.unknown_fields())?;
817 ::std::result::Result::Ok(())
818 }
819
820 fn special_fields(&self) -> &::protobuf::SpecialFields {
821 &self.special_fields
822 }
823
824 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
825 &mut self.special_fields
826 }
827
828 fn new() -> Param {
829 Param::new()
830 }
831
832 fn clear(&mut self) {
833 self.indexed = false;
834 self.name.clear();
835 self.type_.clear();
836 self.special_fields.clear();
837 }
838
839 fn default_instance() -> &'static Param {
840 static instance: Param = Param {
841 indexed: false,
842 name: ::std::string::String::new(),
843 type_: ::std::string::String::new(),
844 special_fields: ::protobuf::SpecialFields::new(),
845 };
846 &instance
847 }
848 }
849
850 impl ::protobuf::MessageFull for Param {
851 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
852 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
853 descriptor.get(|| super::super::super::file_descriptor().message_by_package_relative_name("SmartContract.ABI.Entry.Param").unwrap()).clone()
854 }
855 }
856
857 impl ::std::fmt::Display for Param {
858 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
859 ::protobuf::text_format::fmt(self, f)
860 }
861 }
862
863 impl ::protobuf::reflect::ProtobufValue for Param {
864 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
865 }
866
867 #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
868 pub enum EntryType {
870 UnknownEntryType = 0,
872 Constructor = 1,
874 Function = 2,
876 Event = 3,
878 Fallback = 4,
880 Receive = 5,
882 Error = 6,
884 }
885
886 impl ::protobuf::Enum for EntryType {
887 const NAME: &'static str = "EntryType";
888
889 fn value(&self) -> i32 {
890 *self as i32
891 }
892
893 fn from_i32(value: i32) -> ::std::option::Option<EntryType> {
894 match value {
895 0 => ::std::option::Option::Some(EntryType::UnknownEntryType),
896 1 => ::std::option::Option::Some(EntryType::Constructor),
897 2 => ::std::option::Option::Some(EntryType::Function),
898 3 => ::std::option::Option::Some(EntryType::Event),
899 4 => ::std::option::Option::Some(EntryType::Fallback),
900 5 => ::std::option::Option::Some(EntryType::Receive),
901 6 => ::std::option::Option::Some(EntryType::Error),
902 _ => ::std::option::Option::None
903 }
904 }
905
906 fn from_str(str: &str) -> ::std::option::Option<EntryType> {
907 match str {
908 "UnknownEntryType" => ::std::option::Option::Some(EntryType::UnknownEntryType),
909 "Constructor" => ::std::option::Option::Some(EntryType::Constructor),
910 "Function" => ::std::option::Option::Some(EntryType::Function),
911 "Event" => ::std::option::Option::Some(EntryType::Event),
912 "Fallback" => ::std::option::Option::Some(EntryType::Fallback),
913 "Receive" => ::std::option::Option::Some(EntryType::Receive),
914 "Error" => ::std::option::Option::Some(EntryType::Error),
915 _ => ::std::option::Option::None
916 }
917 }
918
919 const VALUES: &'static [EntryType] = &[
920 EntryType::UnknownEntryType,
921 EntryType::Constructor,
922 EntryType::Function,
923 EntryType::Event,
924 EntryType::Fallback,
925 EntryType::Receive,
926 EntryType::Error,
927 ];
928 }
929
930 impl ::protobuf::EnumFull for EntryType {
931 fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
932 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
933 descriptor.get(|| super::super::super::file_descriptor().enum_by_package_relative_name("SmartContract.ABI.Entry.EntryType").unwrap()).clone()
934 }
935
936 fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
937 let index = *self as usize;
938 Self::enum_descriptor().value_by_index(index)
939 }
940 }
941
942 impl ::std::default::Default for EntryType {
943 fn default() -> Self {
944 EntryType::UnknownEntryType
945 }
946 }
947
948 impl EntryType {
949 pub(in super::super::super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
950 ::protobuf::reflect::GeneratedEnumDescriptorData::new::<EntryType>("SmartContract.ABI.Entry.EntryType")
951 }
952 }
953
954 #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
955 pub enum StateMutabilityType {
957 UnknownMutabilityType = 0,
959 Pure = 1,
961 View = 2,
963 Nonpayable = 3,
965 Payable = 4,
967 }
968
969 impl ::protobuf::Enum for StateMutabilityType {
970 const NAME: &'static str = "StateMutabilityType";
971
972 fn value(&self) -> i32 {
973 *self as i32
974 }
975
976 fn from_i32(value: i32) -> ::std::option::Option<StateMutabilityType> {
977 match value {
978 0 => ::std::option::Option::Some(StateMutabilityType::UnknownMutabilityType),
979 1 => ::std::option::Option::Some(StateMutabilityType::Pure),
980 2 => ::std::option::Option::Some(StateMutabilityType::View),
981 3 => ::std::option::Option::Some(StateMutabilityType::Nonpayable),
982 4 => ::std::option::Option::Some(StateMutabilityType::Payable),
983 _ => ::std::option::Option::None
984 }
985 }
986
987 fn from_str(str: &str) -> ::std::option::Option<StateMutabilityType> {
988 match str {
989 "UnknownMutabilityType" => ::std::option::Option::Some(StateMutabilityType::UnknownMutabilityType),
990 "Pure" => ::std::option::Option::Some(StateMutabilityType::Pure),
991 "View" => ::std::option::Option::Some(StateMutabilityType::View),
992 "Nonpayable" => ::std::option::Option::Some(StateMutabilityType::Nonpayable),
993 "Payable" => ::std::option::Option::Some(StateMutabilityType::Payable),
994 _ => ::std::option::Option::None
995 }
996 }
997
998 const VALUES: &'static [StateMutabilityType] = &[
999 StateMutabilityType::UnknownMutabilityType,
1000 StateMutabilityType::Pure,
1001 StateMutabilityType::View,
1002 StateMutabilityType::Nonpayable,
1003 StateMutabilityType::Payable,
1004 ];
1005 }
1006
1007 impl ::protobuf::EnumFull for StateMutabilityType {
1008 fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
1009 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
1010 descriptor.get(|| super::super::super::file_descriptor().enum_by_package_relative_name("SmartContract.ABI.Entry.StateMutabilityType").unwrap()).clone()
1011 }
1012
1013 fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
1014 let index = *self as usize;
1015 Self::enum_descriptor().value_by_index(index)
1016 }
1017 }
1018
1019 impl ::std::default::Default for StateMutabilityType {
1020 fn default() -> Self {
1021 StateMutabilityType::UnknownMutabilityType
1022 }
1023 }
1024
1025 impl StateMutabilityType {
1026 pub(in super::super::super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
1027 ::protobuf::reflect::GeneratedEnumDescriptorData::new::<StateMutabilityType>("SmartContract.ABI.Entry.StateMutabilityType")
1028 }
1029 }
1030 }
1031 }
1032}
1033
1034#[derive(PartialEq,Clone,Default,Debug)]
1036pub struct ContractState {
1037 pub energy_usage: i64,
1040 pub energy_factor: i64,
1042 pub update_cycle: i64,
1044 pub special_fields: ::protobuf::SpecialFields,
1047}
1048
1049impl<'a> ::std::default::Default for &'a ContractState {
1050 fn default() -> &'a ContractState {
1051 <ContractState as ::protobuf::Message>::default_instance()
1052 }
1053}
1054
1055impl ContractState {
1056 pub fn new() -> ContractState {
1057 ::std::default::Default::default()
1058 }
1059
1060 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1061 let mut fields = ::std::vec::Vec::with_capacity(3);
1062 let mut oneofs = ::std::vec::Vec::with_capacity(0);
1063 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1064 "energy_usage",
1065 |m: &ContractState| { &m.energy_usage },
1066 |m: &mut ContractState| { &mut m.energy_usage },
1067 ));
1068 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1069 "energy_factor",
1070 |m: &ContractState| { &m.energy_factor },
1071 |m: &mut ContractState| { &mut m.energy_factor },
1072 ));
1073 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1074 "update_cycle",
1075 |m: &ContractState| { &m.update_cycle },
1076 |m: &mut ContractState| { &mut m.update_cycle },
1077 ));
1078 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ContractState>(
1079 "ContractState",
1080 fields,
1081 oneofs,
1082 )
1083 }
1084}
1085
1086impl ::protobuf::Message for ContractState {
1087 const NAME: &'static str = "ContractState";
1088
1089 fn is_initialized(&self) -> bool {
1090 true
1091 }
1092
1093 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1094 while let Some(tag) = is.read_raw_tag_or_eof()? {
1095 match tag {
1096 8 => {
1097 self.energy_usage = is.read_int64()?;
1098 },
1099 16 => {
1100 self.energy_factor = is.read_int64()?;
1101 },
1102 24 => {
1103 self.update_cycle = is.read_int64()?;
1104 },
1105 tag => {
1106 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1107 },
1108 };
1109 }
1110 ::std::result::Result::Ok(())
1111 }
1112
1113 #[allow(unused_variables)]
1115 fn compute_size(&self) -> u64 {
1116 let mut my_size = 0;
1117 if self.energy_usage != 0 {
1118 my_size += ::protobuf::rt::int64_size(1, self.energy_usage);
1119 }
1120 if self.energy_factor != 0 {
1121 my_size += ::protobuf::rt::int64_size(2, self.energy_factor);
1122 }
1123 if self.update_cycle != 0 {
1124 my_size += ::protobuf::rt::int64_size(3, self.update_cycle);
1125 }
1126 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1127 self.special_fields.cached_size().set(my_size as u32);
1128 my_size
1129 }
1130
1131 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1132 if self.energy_usage != 0 {
1133 os.write_int64(1, self.energy_usage)?;
1134 }
1135 if self.energy_factor != 0 {
1136 os.write_int64(2, self.energy_factor)?;
1137 }
1138 if self.update_cycle != 0 {
1139 os.write_int64(3, self.update_cycle)?;
1140 }
1141 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1142 ::std::result::Result::Ok(())
1143 }
1144
1145 fn special_fields(&self) -> &::protobuf::SpecialFields {
1146 &self.special_fields
1147 }
1148
1149 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1150 &mut self.special_fields
1151 }
1152
1153 fn new() -> ContractState {
1154 ContractState::new()
1155 }
1156
1157 fn clear(&mut self) {
1158 self.energy_usage = 0;
1159 self.energy_factor = 0;
1160 self.update_cycle = 0;
1161 self.special_fields.clear();
1162 }
1163
1164 fn default_instance() -> &'static ContractState {
1165 static instance: ContractState = ContractState {
1166 energy_usage: 0,
1167 energy_factor: 0,
1168 update_cycle: 0,
1169 special_fields: ::protobuf::SpecialFields::new(),
1170 };
1171 &instance
1172 }
1173}
1174
1175impl ::protobuf::MessageFull for ContractState {
1176 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1177 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1178 descriptor.get(|| file_descriptor().message_by_package_relative_name("ContractState").unwrap()).clone()
1179 }
1180}
1181
1182impl ::std::fmt::Display for ContractState {
1183 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1184 ::protobuf::text_format::fmt(self, f)
1185 }
1186}
1187
1188impl ::protobuf::reflect::ProtobufValue for ContractState {
1189 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1190}
1191
1192#[derive(PartialEq,Clone,Default,Debug)]
1194pub struct CreateSmartContract {
1195 pub owner_address: ::std::vec::Vec<u8>,
1198 pub new_contract: ::protobuf::MessageField<SmartContract>,
1200 pub call_token_value: i64,
1202 pub token_id: i64,
1204 pub special_fields: ::protobuf::SpecialFields,
1207}
1208
1209impl<'a> ::std::default::Default for &'a CreateSmartContract {
1210 fn default() -> &'a CreateSmartContract {
1211 <CreateSmartContract as ::protobuf::Message>::default_instance()
1212 }
1213}
1214
1215impl CreateSmartContract {
1216 pub fn new() -> CreateSmartContract {
1217 ::std::default::Default::default()
1218 }
1219
1220 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1221 let mut fields = ::std::vec::Vec::with_capacity(4);
1222 let mut oneofs = ::std::vec::Vec::with_capacity(0);
1223 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1224 "owner_address",
1225 |m: &CreateSmartContract| { &m.owner_address },
1226 |m: &mut CreateSmartContract| { &mut m.owner_address },
1227 ));
1228 fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, SmartContract>(
1229 "new_contract",
1230 |m: &CreateSmartContract| { &m.new_contract },
1231 |m: &mut CreateSmartContract| { &mut m.new_contract },
1232 ));
1233 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1234 "call_token_value",
1235 |m: &CreateSmartContract| { &m.call_token_value },
1236 |m: &mut CreateSmartContract| { &mut m.call_token_value },
1237 ));
1238 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1239 "token_id",
1240 |m: &CreateSmartContract| { &m.token_id },
1241 |m: &mut CreateSmartContract| { &mut m.token_id },
1242 ));
1243 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<CreateSmartContract>(
1244 "CreateSmartContract",
1245 fields,
1246 oneofs,
1247 )
1248 }
1249}
1250
1251impl ::protobuf::Message for CreateSmartContract {
1252 const NAME: &'static str = "CreateSmartContract";
1253
1254 fn is_initialized(&self) -> bool {
1255 true
1256 }
1257
1258 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1259 while let Some(tag) = is.read_raw_tag_or_eof()? {
1260 match tag {
1261 10 => {
1262 self.owner_address = is.read_bytes()?;
1263 },
1264 18 => {
1265 ::protobuf::rt::read_singular_message_into_field(is, &mut self.new_contract)?;
1266 },
1267 24 => {
1268 self.call_token_value = is.read_int64()?;
1269 },
1270 32 => {
1271 self.token_id = is.read_int64()?;
1272 },
1273 tag => {
1274 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1275 },
1276 };
1277 }
1278 ::std::result::Result::Ok(())
1279 }
1280
1281 #[allow(unused_variables)]
1283 fn compute_size(&self) -> u64 {
1284 let mut my_size = 0;
1285 if !self.owner_address.is_empty() {
1286 my_size += ::protobuf::rt::bytes_size(1, &self.owner_address);
1287 }
1288 if let Some(v) = self.new_contract.as_ref() {
1289 let len = v.compute_size();
1290 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
1291 }
1292 if self.call_token_value != 0 {
1293 my_size += ::protobuf::rt::int64_size(3, self.call_token_value);
1294 }
1295 if self.token_id != 0 {
1296 my_size += ::protobuf::rt::int64_size(4, self.token_id);
1297 }
1298 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1299 self.special_fields.cached_size().set(my_size as u32);
1300 my_size
1301 }
1302
1303 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1304 if !self.owner_address.is_empty() {
1305 os.write_bytes(1, &self.owner_address)?;
1306 }
1307 if let Some(v) = self.new_contract.as_ref() {
1308 ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
1309 }
1310 if self.call_token_value != 0 {
1311 os.write_int64(3, self.call_token_value)?;
1312 }
1313 if self.token_id != 0 {
1314 os.write_int64(4, self.token_id)?;
1315 }
1316 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1317 ::std::result::Result::Ok(())
1318 }
1319
1320 fn special_fields(&self) -> &::protobuf::SpecialFields {
1321 &self.special_fields
1322 }
1323
1324 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1325 &mut self.special_fields
1326 }
1327
1328 fn new() -> CreateSmartContract {
1329 CreateSmartContract::new()
1330 }
1331
1332 fn clear(&mut self) {
1333 self.owner_address.clear();
1334 self.new_contract.clear();
1335 self.call_token_value = 0;
1336 self.token_id = 0;
1337 self.special_fields.clear();
1338 }
1339
1340 fn default_instance() -> &'static CreateSmartContract {
1341 static instance: CreateSmartContract = CreateSmartContract {
1342 owner_address: ::std::vec::Vec::new(),
1343 new_contract: ::protobuf::MessageField::none(),
1344 call_token_value: 0,
1345 token_id: 0,
1346 special_fields: ::protobuf::SpecialFields::new(),
1347 };
1348 &instance
1349 }
1350}
1351
1352impl ::protobuf::MessageFull for CreateSmartContract {
1353 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1354 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1355 descriptor.get(|| file_descriptor().message_by_package_relative_name("CreateSmartContract").unwrap()).clone()
1356 }
1357}
1358
1359impl ::std::fmt::Display for CreateSmartContract {
1360 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1361 ::protobuf::text_format::fmt(self, f)
1362 }
1363}
1364
1365impl ::protobuf::reflect::ProtobufValue for CreateSmartContract {
1366 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1367}
1368
1369#[derive(PartialEq,Clone,Default,Debug)]
1371pub struct TriggerSmartContract {
1372 pub owner_address: ::std::vec::Vec<u8>,
1375 pub contract_address: ::std::vec::Vec<u8>,
1377 pub call_value: i64,
1379 pub data: ::std::vec::Vec<u8>,
1381 pub call_token_value: i64,
1383 pub token_id: i64,
1385 pub special_fields: ::protobuf::SpecialFields,
1388}
1389
1390impl<'a> ::std::default::Default for &'a TriggerSmartContract {
1391 fn default() -> &'a TriggerSmartContract {
1392 <TriggerSmartContract as ::protobuf::Message>::default_instance()
1393 }
1394}
1395
1396impl TriggerSmartContract {
1397 pub fn new() -> TriggerSmartContract {
1398 ::std::default::Default::default()
1399 }
1400
1401 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1402 let mut fields = ::std::vec::Vec::with_capacity(6);
1403 let mut oneofs = ::std::vec::Vec::with_capacity(0);
1404 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1405 "owner_address",
1406 |m: &TriggerSmartContract| { &m.owner_address },
1407 |m: &mut TriggerSmartContract| { &mut m.owner_address },
1408 ));
1409 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1410 "contract_address",
1411 |m: &TriggerSmartContract| { &m.contract_address },
1412 |m: &mut TriggerSmartContract| { &mut m.contract_address },
1413 ));
1414 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1415 "call_value",
1416 |m: &TriggerSmartContract| { &m.call_value },
1417 |m: &mut TriggerSmartContract| { &mut m.call_value },
1418 ));
1419 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1420 "data",
1421 |m: &TriggerSmartContract| { &m.data },
1422 |m: &mut TriggerSmartContract| { &mut m.data },
1423 ));
1424 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1425 "call_token_value",
1426 |m: &TriggerSmartContract| { &m.call_token_value },
1427 |m: &mut TriggerSmartContract| { &mut m.call_token_value },
1428 ));
1429 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1430 "token_id",
1431 |m: &TriggerSmartContract| { &m.token_id },
1432 |m: &mut TriggerSmartContract| { &mut m.token_id },
1433 ));
1434 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<TriggerSmartContract>(
1435 "TriggerSmartContract",
1436 fields,
1437 oneofs,
1438 )
1439 }
1440}
1441
1442impl ::protobuf::Message for TriggerSmartContract {
1443 const NAME: &'static str = "TriggerSmartContract";
1444
1445 fn is_initialized(&self) -> bool {
1446 true
1447 }
1448
1449 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1450 while let Some(tag) = is.read_raw_tag_or_eof()? {
1451 match tag {
1452 10 => {
1453 self.owner_address = is.read_bytes()?;
1454 },
1455 18 => {
1456 self.contract_address = is.read_bytes()?;
1457 },
1458 24 => {
1459 self.call_value = is.read_int64()?;
1460 },
1461 34 => {
1462 self.data = is.read_bytes()?;
1463 },
1464 40 => {
1465 self.call_token_value = is.read_int64()?;
1466 },
1467 48 => {
1468 self.token_id = is.read_int64()?;
1469 },
1470 tag => {
1471 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1472 },
1473 };
1474 }
1475 ::std::result::Result::Ok(())
1476 }
1477
1478 #[allow(unused_variables)]
1480 fn compute_size(&self) -> u64 {
1481 let mut my_size = 0;
1482 if !self.owner_address.is_empty() {
1483 my_size += ::protobuf::rt::bytes_size(1, &self.owner_address);
1484 }
1485 if !self.contract_address.is_empty() {
1486 my_size += ::protobuf::rt::bytes_size(2, &self.contract_address);
1487 }
1488 if self.call_value != 0 {
1489 my_size += ::protobuf::rt::int64_size(3, self.call_value);
1490 }
1491 if !self.data.is_empty() {
1492 my_size += ::protobuf::rt::bytes_size(4, &self.data);
1493 }
1494 if self.call_token_value != 0 {
1495 my_size += ::protobuf::rt::int64_size(5, self.call_token_value);
1496 }
1497 if self.token_id != 0 {
1498 my_size += ::protobuf::rt::int64_size(6, self.token_id);
1499 }
1500 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1501 self.special_fields.cached_size().set(my_size as u32);
1502 my_size
1503 }
1504
1505 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1506 if !self.owner_address.is_empty() {
1507 os.write_bytes(1, &self.owner_address)?;
1508 }
1509 if !self.contract_address.is_empty() {
1510 os.write_bytes(2, &self.contract_address)?;
1511 }
1512 if self.call_value != 0 {
1513 os.write_int64(3, self.call_value)?;
1514 }
1515 if !self.data.is_empty() {
1516 os.write_bytes(4, &self.data)?;
1517 }
1518 if self.call_token_value != 0 {
1519 os.write_int64(5, self.call_token_value)?;
1520 }
1521 if self.token_id != 0 {
1522 os.write_int64(6, self.token_id)?;
1523 }
1524 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1525 ::std::result::Result::Ok(())
1526 }
1527
1528 fn special_fields(&self) -> &::protobuf::SpecialFields {
1529 &self.special_fields
1530 }
1531
1532 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1533 &mut self.special_fields
1534 }
1535
1536 fn new() -> TriggerSmartContract {
1537 TriggerSmartContract::new()
1538 }
1539
1540 fn clear(&mut self) {
1541 self.owner_address.clear();
1542 self.contract_address.clear();
1543 self.call_value = 0;
1544 self.data.clear();
1545 self.call_token_value = 0;
1546 self.token_id = 0;
1547 self.special_fields.clear();
1548 }
1549
1550 fn default_instance() -> &'static TriggerSmartContract {
1551 static instance: TriggerSmartContract = TriggerSmartContract {
1552 owner_address: ::std::vec::Vec::new(),
1553 contract_address: ::std::vec::Vec::new(),
1554 call_value: 0,
1555 data: ::std::vec::Vec::new(),
1556 call_token_value: 0,
1557 token_id: 0,
1558 special_fields: ::protobuf::SpecialFields::new(),
1559 };
1560 &instance
1561 }
1562}
1563
1564impl ::protobuf::MessageFull for TriggerSmartContract {
1565 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1566 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1567 descriptor.get(|| file_descriptor().message_by_package_relative_name("TriggerSmartContract").unwrap()).clone()
1568 }
1569}
1570
1571impl ::std::fmt::Display for TriggerSmartContract {
1572 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1573 ::protobuf::text_format::fmt(self, f)
1574 }
1575}
1576
1577impl ::protobuf::reflect::ProtobufValue for TriggerSmartContract {
1578 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1579}
1580
1581#[derive(PartialEq,Clone,Default,Debug)]
1583pub struct ClearABIContract {
1584 pub owner_address: ::std::vec::Vec<u8>,
1587 pub contract_address: ::std::vec::Vec<u8>,
1589 pub special_fields: ::protobuf::SpecialFields,
1592}
1593
1594impl<'a> ::std::default::Default for &'a ClearABIContract {
1595 fn default() -> &'a ClearABIContract {
1596 <ClearABIContract as ::protobuf::Message>::default_instance()
1597 }
1598}
1599
1600impl ClearABIContract {
1601 pub fn new() -> ClearABIContract {
1602 ::std::default::Default::default()
1603 }
1604
1605 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1606 let mut fields = ::std::vec::Vec::with_capacity(2);
1607 let mut oneofs = ::std::vec::Vec::with_capacity(0);
1608 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1609 "owner_address",
1610 |m: &ClearABIContract| { &m.owner_address },
1611 |m: &mut ClearABIContract| { &mut m.owner_address },
1612 ));
1613 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1614 "contract_address",
1615 |m: &ClearABIContract| { &m.contract_address },
1616 |m: &mut ClearABIContract| { &mut m.contract_address },
1617 ));
1618 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ClearABIContract>(
1619 "ClearABIContract",
1620 fields,
1621 oneofs,
1622 )
1623 }
1624}
1625
1626impl ::protobuf::Message for ClearABIContract {
1627 const NAME: &'static str = "ClearABIContract";
1628
1629 fn is_initialized(&self) -> bool {
1630 true
1631 }
1632
1633 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1634 while let Some(tag) = is.read_raw_tag_or_eof()? {
1635 match tag {
1636 10 => {
1637 self.owner_address = is.read_bytes()?;
1638 },
1639 18 => {
1640 self.contract_address = is.read_bytes()?;
1641 },
1642 tag => {
1643 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1644 },
1645 };
1646 }
1647 ::std::result::Result::Ok(())
1648 }
1649
1650 #[allow(unused_variables)]
1652 fn compute_size(&self) -> u64 {
1653 let mut my_size = 0;
1654 if !self.owner_address.is_empty() {
1655 my_size += ::protobuf::rt::bytes_size(1, &self.owner_address);
1656 }
1657 if !self.contract_address.is_empty() {
1658 my_size += ::protobuf::rt::bytes_size(2, &self.contract_address);
1659 }
1660 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1661 self.special_fields.cached_size().set(my_size as u32);
1662 my_size
1663 }
1664
1665 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1666 if !self.owner_address.is_empty() {
1667 os.write_bytes(1, &self.owner_address)?;
1668 }
1669 if !self.contract_address.is_empty() {
1670 os.write_bytes(2, &self.contract_address)?;
1671 }
1672 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1673 ::std::result::Result::Ok(())
1674 }
1675
1676 fn special_fields(&self) -> &::protobuf::SpecialFields {
1677 &self.special_fields
1678 }
1679
1680 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1681 &mut self.special_fields
1682 }
1683
1684 fn new() -> ClearABIContract {
1685 ClearABIContract::new()
1686 }
1687
1688 fn clear(&mut self) {
1689 self.owner_address.clear();
1690 self.contract_address.clear();
1691 self.special_fields.clear();
1692 }
1693
1694 fn default_instance() -> &'static ClearABIContract {
1695 static instance: ClearABIContract = ClearABIContract {
1696 owner_address: ::std::vec::Vec::new(),
1697 contract_address: ::std::vec::Vec::new(),
1698 special_fields: ::protobuf::SpecialFields::new(),
1699 };
1700 &instance
1701 }
1702}
1703
1704impl ::protobuf::MessageFull for ClearABIContract {
1705 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1706 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1707 descriptor.get(|| file_descriptor().message_by_package_relative_name("ClearABIContract").unwrap()).clone()
1708 }
1709}
1710
1711impl ::std::fmt::Display for ClearABIContract {
1712 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1713 ::protobuf::text_format::fmt(self, f)
1714 }
1715}
1716
1717impl ::protobuf::reflect::ProtobufValue for ClearABIContract {
1718 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1719}
1720
1721#[derive(PartialEq,Clone,Default,Debug)]
1723pub struct UpdateSettingContract {
1724 pub owner_address: ::std::vec::Vec<u8>,
1727 pub contract_address: ::std::vec::Vec<u8>,
1729 pub consume_user_resource_percent: i64,
1731 pub special_fields: ::protobuf::SpecialFields,
1734}
1735
1736impl<'a> ::std::default::Default for &'a UpdateSettingContract {
1737 fn default() -> &'a UpdateSettingContract {
1738 <UpdateSettingContract as ::protobuf::Message>::default_instance()
1739 }
1740}
1741
1742impl UpdateSettingContract {
1743 pub fn new() -> UpdateSettingContract {
1744 ::std::default::Default::default()
1745 }
1746
1747 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1748 let mut fields = ::std::vec::Vec::with_capacity(3);
1749 let mut oneofs = ::std::vec::Vec::with_capacity(0);
1750 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1751 "owner_address",
1752 |m: &UpdateSettingContract| { &m.owner_address },
1753 |m: &mut UpdateSettingContract| { &mut m.owner_address },
1754 ));
1755 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1756 "contract_address",
1757 |m: &UpdateSettingContract| { &m.contract_address },
1758 |m: &mut UpdateSettingContract| { &mut m.contract_address },
1759 ));
1760 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1761 "consume_user_resource_percent",
1762 |m: &UpdateSettingContract| { &m.consume_user_resource_percent },
1763 |m: &mut UpdateSettingContract| { &mut m.consume_user_resource_percent },
1764 ));
1765 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<UpdateSettingContract>(
1766 "UpdateSettingContract",
1767 fields,
1768 oneofs,
1769 )
1770 }
1771}
1772
1773impl ::protobuf::Message for UpdateSettingContract {
1774 const NAME: &'static str = "UpdateSettingContract";
1775
1776 fn is_initialized(&self) -> bool {
1777 true
1778 }
1779
1780 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1781 while let Some(tag) = is.read_raw_tag_or_eof()? {
1782 match tag {
1783 10 => {
1784 self.owner_address = is.read_bytes()?;
1785 },
1786 18 => {
1787 self.contract_address = is.read_bytes()?;
1788 },
1789 24 => {
1790 self.consume_user_resource_percent = is.read_int64()?;
1791 },
1792 tag => {
1793 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1794 },
1795 };
1796 }
1797 ::std::result::Result::Ok(())
1798 }
1799
1800 #[allow(unused_variables)]
1802 fn compute_size(&self) -> u64 {
1803 let mut my_size = 0;
1804 if !self.owner_address.is_empty() {
1805 my_size += ::protobuf::rt::bytes_size(1, &self.owner_address);
1806 }
1807 if !self.contract_address.is_empty() {
1808 my_size += ::protobuf::rt::bytes_size(2, &self.contract_address);
1809 }
1810 if self.consume_user_resource_percent != 0 {
1811 my_size += ::protobuf::rt::int64_size(3, self.consume_user_resource_percent);
1812 }
1813 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1814 self.special_fields.cached_size().set(my_size as u32);
1815 my_size
1816 }
1817
1818 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1819 if !self.owner_address.is_empty() {
1820 os.write_bytes(1, &self.owner_address)?;
1821 }
1822 if !self.contract_address.is_empty() {
1823 os.write_bytes(2, &self.contract_address)?;
1824 }
1825 if self.consume_user_resource_percent != 0 {
1826 os.write_int64(3, self.consume_user_resource_percent)?;
1827 }
1828 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1829 ::std::result::Result::Ok(())
1830 }
1831
1832 fn special_fields(&self) -> &::protobuf::SpecialFields {
1833 &self.special_fields
1834 }
1835
1836 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1837 &mut self.special_fields
1838 }
1839
1840 fn new() -> UpdateSettingContract {
1841 UpdateSettingContract::new()
1842 }
1843
1844 fn clear(&mut self) {
1845 self.owner_address.clear();
1846 self.contract_address.clear();
1847 self.consume_user_resource_percent = 0;
1848 self.special_fields.clear();
1849 }
1850
1851 fn default_instance() -> &'static UpdateSettingContract {
1852 static instance: UpdateSettingContract = UpdateSettingContract {
1853 owner_address: ::std::vec::Vec::new(),
1854 contract_address: ::std::vec::Vec::new(),
1855 consume_user_resource_percent: 0,
1856 special_fields: ::protobuf::SpecialFields::new(),
1857 };
1858 &instance
1859 }
1860}
1861
1862impl ::protobuf::MessageFull for UpdateSettingContract {
1863 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1864 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1865 descriptor.get(|| file_descriptor().message_by_package_relative_name("UpdateSettingContract").unwrap()).clone()
1866 }
1867}
1868
1869impl ::std::fmt::Display for UpdateSettingContract {
1870 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1871 ::protobuf::text_format::fmt(self, f)
1872 }
1873}
1874
1875impl ::protobuf::reflect::ProtobufValue for UpdateSettingContract {
1876 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1877}
1878
1879#[derive(PartialEq,Clone,Default,Debug)]
1881pub struct UpdateEnergyLimitContract {
1882 pub owner_address: ::std::vec::Vec<u8>,
1885 pub contract_address: ::std::vec::Vec<u8>,
1887 pub origin_energy_limit: i64,
1889 pub special_fields: ::protobuf::SpecialFields,
1892}
1893
1894impl<'a> ::std::default::Default for &'a UpdateEnergyLimitContract {
1895 fn default() -> &'a UpdateEnergyLimitContract {
1896 <UpdateEnergyLimitContract as ::protobuf::Message>::default_instance()
1897 }
1898}
1899
1900impl UpdateEnergyLimitContract {
1901 pub fn new() -> UpdateEnergyLimitContract {
1902 ::std::default::Default::default()
1903 }
1904
1905 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1906 let mut fields = ::std::vec::Vec::with_capacity(3);
1907 let mut oneofs = ::std::vec::Vec::with_capacity(0);
1908 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1909 "owner_address",
1910 |m: &UpdateEnergyLimitContract| { &m.owner_address },
1911 |m: &mut UpdateEnergyLimitContract| { &mut m.owner_address },
1912 ));
1913 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1914 "contract_address",
1915 |m: &UpdateEnergyLimitContract| { &m.contract_address },
1916 |m: &mut UpdateEnergyLimitContract| { &mut m.contract_address },
1917 ));
1918 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
1919 "origin_energy_limit",
1920 |m: &UpdateEnergyLimitContract| { &m.origin_energy_limit },
1921 |m: &mut UpdateEnergyLimitContract| { &mut m.origin_energy_limit },
1922 ));
1923 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<UpdateEnergyLimitContract>(
1924 "UpdateEnergyLimitContract",
1925 fields,
1926 oneofs,
1927 )
1928 }
1929}
1930
1931impl ::protobuf::Message for UpdateEnergyLimitContract {
1932 const NAME: &'static str = "UpdateEnergyLimitContract";
1933
1934 fn is_initialized(&self) -> bool {
1935 true
1936 }
1937
1938 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1939 while let Some(tag) = is.read_raw_tag_or_eof()? {
1940 match tag {
1941 10 => {
1942 self.owner_address = is.read_bytes()?;
1943 },
1944 18 => {
1945 self.contract_address = is.read_bytes()?;
1946 },
1947 24 => {
1948 self.origin_energy_limit = is.read_int64()?;
1949 },
1950 tag => {
1951 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1952 },
1953 };
1954 }
1955 ::std::result::Result::Ok(())
1956 }
1957
1958 #[allow(unused_variables)]
1960 fn compute_size(&self) -> u64 {
1961 let mut my_size = 0;
1962 if !self.owner_address.is_empty() {
1963 my_size += ::protobuf::rt::bytes_size(1, &self.owner_address);
1964 }
1965 if !self.contract_address.is_empty() {
1966 my_size += ::protobuf::rt::bytes_size(2, &self.contract_address);
1967 }
1968 if self.origin_energy_limit != 0 {
1969 my_size += ::protobuf::rt::int64_size(3, self.origin_energy_limit);
1970 }
1971 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1972 self.special_fields.cached_size().set(my_size as u32);
1973 my_size
1974 }
1975
1976 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1977 if !self.owner_address.is_empty() {
1978 os.write_bytes(1, &self.owner_address)?;
1979 }
1980 if !self.contract_address.is_empty() {
1981 os.write_bytes(2, &self.contract_address)?;
1982 }
1983 if self.origin_energy_limit != 0 {
1984 os.write_int64(3, self.origin_energy_limit)?;
1985 }
1986 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1987 ::std::result::Result::Ok(())
1988 }
1989
1990 fn special_fields(&self) -> &::protobuf::SpecialFields {
1991 &self.special_fields
1992 }
1993
1994 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1995 &mut self.special_fields
1996 }
1997
1998 fn new() -> UpdateEnergyLimitContract {
1999 UpdateEnergyLimitContract::new()
2000 }
2001
2002 fn clear(&mut self) {
2003 self.owner_address.clear();
2004 self.contract_address.clear();
2005 self.origin_energy_limit = 0;
2006 self.special_fields.clear();
2007 }
2008
2009 fn default_instance() -> &'static UpdateEnergyLimitContract {
2010 static instance: UpdateEnergyLimitContract = UpdateEnergyLimitContract {
2011 owner_address: ::std::vec::Vec::new(),
2012 contract_address: ::std::vec::Vec::new(),
2013 origin_energy_limit: 0,
2014 special_fields: ::protobuf::SpecialFields::new(),
2015 };
2016 &instance
2017 }
2018}
2019
2020impl ::protobuf::MessageFull for UpdateEnergyLimitContract {
2021 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
2022 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
2023 descriptor.get(|| file_descriptor().message_by_package_relative_name("UpdateEnergyLimitContract").unwrap()).clone()
2024 }
2025}
2026
2027impl ::std::fmt::Display for UpdateEnergyLimitContract {
2028 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2029 ::protobuf::text_format::fmt(self, f)
2030 }
2031}
2032
2033impl ::protobuf::reflect::ProtobufValue for UpdateEnergyLimitContract {
2034 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
2035}
2036
2037#[derive(PartialEq,Clone,Default,Debug)]
2039pub struct SmartContractDataWrapper {
2040 pub smart_contract: ::protobuf::MessageField<SmartContract>,
2043 pub runtimecode: ::std::vec::Vec<u8>,
2045 pub contract_state: ::protobuf::MessageField<ContractState>,
2047 pub special_fields: ::protobuf::SpecialFields,
2050}
2051
2052impl<'a> ::std::default::Default for &'a SmartContractDataWrapper {
2053 fn default() -> &'a SmartContractDataWrapper {
2054 <SmartContractDataWrapper as ::protobuf::Message>::default_instance()
2055 }
2056}
2057
2058impl SmartContractDataWrapper {
2059 pub fn new() -> SmartContractDataWrapper {
2060 ::std::default::Default::default()
2061 }
2062
2063 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
2064 let mut fields = ::std::vec::Vec::with_capacity(3);
2065 let mut oneofs = ::std::vec::Vec::with_capacity(0);
2066 fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, SmartContract>(
2067 "smart_contract",
2068 |m: &SmartContractDataWrapper| { &m.smart_contract },
2069 |m: &mut SmartContractDataWrapper| { &mut m.smart_contract },
2070 ));
2071 fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
2072 "runtimecode",
2073 |m: &SmartContractDataWrapper| { &m.runtimecode },
2074 |m: &mut SmartContractDataWrapper| { &mut m.runtimecode },
2075 ));
2076 fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, ContractState>(
2077 "contract_state",
2078 |m: &SmartContractDataWrapper| { &m.contract_state },
2079 |m: &mut SmartContractDataWrapper| { &mut m.contract_state },
2080 ));
2081 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SmartContractDataWrapper>(
2082 "SmartContractDataWrapper",
2083 fields,
2084 oneofs,
2085 )
2086 }
2087}
2088
2089impl ::protobuf::Message for SmartContractDataWrapper {
2090 const NAME: &'static str = "SmartContractDataWrapper";
2091
2092 fn is_initialized(&self) -> bool {
2093 true
2094 }
2095
2096 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
2097 while let Some(tag) = is.read_raw_tag_or_eof()? {
2098 match tag {
2099 10 => {
2100 ::protobuf::rt::read_singular_message_into_field(is, &mut self.smart_contract)?;
2101 },
2102 18 => {
2103 self.runtimecode = is.read_bytes()?;
2104 },
2105 26 => {
2106 ::protobuf::rt::read_singular_message_into_field(is, &mut self.contract_state)?;
2107 },
2108 tag => {
2109 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2110 },
2111 };
2112 }
2113 ::std::result::Result::Ok(())
2114 }
2115
2116 #[allow(unused_variables)]
2118 fn compute_size(&self) -> u64 {
2119 let mut my_size = 0;
2120 if let Some(v) = self.smart_contract.as_ref() {
2121 let len = v.compute_size();
2122 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
2123 }
2124 if !self.runtimecode.is_empty() {
2125 my_size += ::protobuf::rt::bytes_size(2, &self.runtimecode);
2126 }
2127 if let Some(v) = self.contract_state.as_ref() {
2128 let len = v.compute_size();
2129 my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
2130 }
2131 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2132 self.special_fields.cached_size().set(my_size as u32);
2133 my_size
2134 }
2135
2136 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
2137 if let Some(v) = self.smart_contract.as_ref() {
2138 ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
2139 }
2140 if !self.runtimecode.is_empty() {
2141 os.write_bytes(2, &self.runtimecode)?;
2142 }
2143 if let Some(v) = self.contract_state.as_ref() {
2144 ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
2145 }
2146 os.write_unknown_fields(self.special_fields.unknown_fields())?;
2147 ::std::result::Result::Ok(())
2148 }
2149
2150 fn special_fields(&self) -> &::protobuf::SpecialFields {
2151 &self.special_fields
2152 }
2153
2154 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
2155 &mut self.special_fields
2156 }
2157
2158 fn new() -> SmartContractDataWrapper {
2159 SmartContractDataWrapper::new()
2160 }
2161
2162 fn clear(&mut self) {
2163 self.smart_contract.clear();
2164 self.runtimecode.clear();
2165 self.contract_state.clear();
2166 self.special_fields.clear();
2167 }
2168
2169 fn default_instance() -> &'static SmartContractDataWrapper {
2170 static instance: SmartContractDataWrapper = SmartContractDataWrapper {
2171 smart_contract: ::protobuf::MessageField::none(),
2172 runtimecode: ::std::vec::Vec::new(),
2173 contract_state: ::protobuf::MessageField::none(),
2174 special_fields: ::protobuf::SpecialFields::new(),
2175 };
2176 &instance
2177 }
2178}
2179
2180impl ::protobuf::MessageFull for SmartContractDataWrapper {
2181 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
2182 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
2183 descriptor.get(|| file_descriptor().message_by_package_relative_name("SmartContractDataWrapper").unwrap()).clone()
2184 }
2185}
2186
2187impl ::std::fmt::Display for SmartContractDataWrapper {
2188 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2189 ::protobuf::text_format::fmt(self, f)
2190 }
2191}
2192
2193impl ::protobuf::reflect::ProtobufValue for SmartContractDataWrapper {
2194 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
2195}
2196
2197static file_descriptor_proto_data: &'static [u8] = b"\
2198 \n\"core/contract/smart_contract.proto\x12\x08protocol\x1a\x0fcore/Tron.\
2199 proto\"\xa0\t\n\rSmartContract\x12%\n\x0eorigin_address\x18\x01\x20\x01(\
2200 \x0cR\roriginAddress\x12)\n\x10contract_address\x18\x02\x20\x01(\x0cR\
2201 \x0fcontractAddress\x12-\n\x03abi\x18\x03\x20\x01(\x0b2\x1b.protocol.Sma\
2202 rtContract.ABIR\x03abi\x12\x1a\n\x08bytecode\x18\x04\x20\x01(\x0cR\x08by\
2203 tecode\x12\x1d\n\ncall_value\x18\x05\x20\x01(\x03R\tcallValue\x12A\n\x1d\
2204 consume_user_resource_percent\x18\x06\x20\x01(\x03R\x1aconsumeUserResour\
2205 cePercent\x12\x12\n\x04name\x18\x07\x20\x01(\tR\x04name\x12.\n\x13origin\
2206 _energy_limit\x18\x08\x20\x01(\x03R\x11originEnergyLimit\x12\x1b\n\tcode\
2207 _hash\x18\t\x20\x01(\x0cR\x08codeHash\x12\x19\n\x08trx_hash\x18\n\x20\
2208 \x01(\x0cR\x07trxHash\x12\x18\n\x07version\x18\x0b\x20\x01(\x05R\x07vers\
2209 ion\x1a\xf9\x05\n\x03ABI\x129\n\x06entrys\x18\x01\x20\x03(\x0b2!.protoco\
2210 l.SmartContract.ABI.EntryR\x06entrys\x1a\xb6\x05\n\x05Entry\x12\x1c\n\ta\
2211 nonymous\x18\x01\x20\x01(\x08R\tanonymous\x12\x1a\n\x08constant\x18\x02\
2212 \x20\x01(\x08R\x08constant\x12\x12\n\x04name\x18\x03\x20\x01(\tR\x04name\
2213 \x12?\n\x06inputs\x18\x04\x20\x03(\x0b2'.protocol.SmartContract.ABI.Entr\
2214 y.ParamR\x06inputs\x12A\n\x07outputs\x18\x05\x20\x03(\x0b2'.protocol.Sma\
2215 rtContract.ABI.Entry.ParamR\x07outputs\x12?\n\x04type\x18\x06\x20\x01(\
2216 \x0e2+.protocol.SmartContract.ABI.Entry.EntryTypeR\x04type\x12\x18\n\x07\
2217 payable\x18\x07\x20\x01(\x08R\x07payable\x12_\n\x0fstateMutability\x18\
2218 \x08\x20\x01(\x0e25.protocol.SmartContract.ABI.Entry.StateMutabilityType\
2219 R\x0fstateMutability\x1aI\n\x05Param\x12\x18\n\x07indexed\x18\x01\x20\
2220 \x01(\x08R\x07indexed\x12\x12\n\x04name\x18\x02\x20\x01(\tR\x04name\x12\
2221 \x12\n\x04type\x18\x03\x20\x01(\tR\x04type\"q\n\tEntryType\x12\x14\n\x10\
2222 UnknownEntryType\x10\0\x12\x0f\n\x0bConstructor\x10\x01\x12\x0c\n\x08Fun\
2223 ction\x10\x02\x12\t\n\x05Event\x10\x03\x12\x0c\n\x08Fallback\x10\x04\x12\
2224 \x0b\n\x07Receive\x10\x05\x12\t\n\x05Error\x10\x06\"a\n\x13StateMutabili\
2225 tyType\x12\x19\n\x15UnknownMutabilityType\x10\0\x12\x08\n\x04Pure\x10\
2226 \x01\x12\x08\n\x04View\x10\x02\x12\x0e\n\nNonpayable\x10\x03\x12\x0b\n\
2227 \x07Payable\x10\x04\"z\n\rContractState\x12!\n\x0cenergy_usage\x18\x01\
2228 \x20\x01(\x03R\x0benergyUsage\x12#\n\renergy_factor\x18\x02\x20\x01(\x03\
2229 R\x0cenergyFactor\x12!\n\x0cupdate_cycle\x18\x03\x20\x01(\x03R\x0bupdate\
2230 Cycle\"\xbb\x01\n\x13CreateSmartContract\x12#\n\rowner_address\x18\x01\
2231 \x20\x01(\x0cR\x0cownerAddress\x12:\n\x0cnew_contract\x18\x02\x20\x01(\
2232 \x0b2\x17.protocol.SmartContractR\x0bnewContract\x12(\n\x10call_token_va\
2233 lue\x18\x03\x20\x01(\x03R\x0ecallTokenValue\x12\x19\n\x08token_id\x18\
2234 \x04\x20\x01(\x03R\x07tokenId\"\xde\x01\n\x14TriggerSmartContract\x12#\n\
2235 \rowner_address\x18\x01\x20\x01(\x0cR\x0cownerAddress\x12)\n\x10contract\
2236 _address\x18\x02\x20\x01(\x0cR\x0fcontractAddress\x12\x1d\n\ncall_value\
2237 \x18\x03\x20\x01(\x03R\tcallValue\x12\x12\n\x04data\x18\x04\x20\x01(\x0c\
2238 R\x04data\x12(\n\x10call_token_value\x18\x05\x20\x01(\x03R\x0ecallTokenV\
2239 alue\x12\x19\n\x08token_id\x18\x06\x20\x01(\x03R\x07tokenId\"b\n\x10Clea\
2240 rABIContract\x12#\n\rowner_address\x18\x01\x20\x01(\x0cR\x0cownerAddress\
2241 \x12)\n\x10contract_address\x18\x02\x20\x01(\x0cR\x0fcontractAddress\"\
2242 \xaa\x01\n\x15UpdateSettingContract\x12#\n\rowner_address\x18\x01\x20\
2243 \x01(\x0cR\x0cownerAddress\x12)\n\x10contract_address\x18\x02\x20\x01(\
2244 \x0cR\x0fcontractAddress\x12A\n\x1dconsume_user_resource_percent\x18\x03\
2245 \x20\x01(\x03R\x1aconsumeUserResourcePercent\"\x9b\x01\n\x19UpdateEnergy\
2246 LimitContract\x12#\n\rowner_address\x18\x01\x20\x01(\x0cR\x0cownerAddres\
2247 s\x12)\n\x10contract_address\x18\x02\x20\x01(\x0cR\x0fcontractAddress\
2248 \x12.\n\x13origin_energy_limit\x18\x03\x20\x01(\x03R\x11originEnergyLimi\
2249 t\"\xbc\x01\n\x18SmartContractDataWrapper\x12>\n\x0esmart_contract\x18\
2250 \x01\x20\x01(\x0b2\x17.protocol.SmartContractR\rsmartContract\x12\x20\n\
2251 \x0bruntimecode\x18\x02\x20\x01(\x0cR\x0bruntimecode\x12>\n\x0econtract_\
2252 state\x18\x03\x20\x01(\x0b2\x17.protocol.ContractStateR\rcontractStateBE\
2253 \n\x18org.tron.protos.contractZ)github.com/tronprotocol/grpc-gateway/cor\
2254 eJ\xde\x20\n\x06\x12\x04\0\0g\x01\n\x08\n\x01\x0c\x12\x03\0\0\x12\n\x08\
2255 \n\x01\x02\x12\x03\x02\0\x11\n\x08\n\x01\x08\x12\x03\x04\01\nH\n\x02\x08\
2256 \x01\x12\x03\x04\01\"=Specify\x20the\x20name\x20of\x20the\x20package\x20\
2257 that\x20generated\x20the\x20Java\x20file\n\n\x08\n\x01\x08\x12\x03\x06\0\
2258 @\nt\n\x02\x08\x0b\x12\x03\x06\0@\x1aioption\x20java_outer_classname\x20\
2259 =\x20\"CreateSmartContract\";\x20//Specify\x20the\x20class\x20name\x20of\
2260 \x20the\x20generated\x20Java\x20file\n\n\t\n\x02\x03\0\x12\x03\x08\0\x19\
2261 \n\n\n\x02\x04\0\x12\x04\n\0:\x01\n\n\n\x03\x04\0\x01\x12\x03\n\x08\x15\
2262 \n\x0c\n\x04\x04\0\x03\0\x12\x04\x0b\x02.\x03\n\x0c\n\x05\x04\0\x03\0\
2263 \x01\x12\x03\x0b\n\r\n\x0e\n\x06\x04\0\x03\0\x03\0\x12\x04\x0c\x04,\x05\
2264 \n\x0e\n\x07\x04\0\x03\0\x03\0\x01\x12\x03\x0c\x0c\x11\n\x10\n\x08\x04\0\
2265 \x03\0\x03\0\x04\0\x12\x04\r\x06\x15\x07\n\x10\n\t\x04\0\x03\0\x03\0\x04\
2266 \0\x01\x12\x03\r\x0b\x14\n\x11\n\n\x04\0\x03\0\x03\0\x04\0\x02\0\x12\x03\
2267 \x0e\x08\x1d\n\x12\n\x0b\x04\0\x03\0\x03\0\x04\0\x02\0\x01\x12\x03\x0e\
2268 \x08\x18\n\x12\n\x0b\x04\0\x03\0\x03\0\x04\0\x02\0\x02\x12\x03\x0e\x1b\
2269 \x1c\n\x11\n\n\x04\0\x03\0\x03\0\x04\0\x02\x01\x12\x03\x0f\x08\x18\n\x12\
2270 \n\x0b\x04\0\x03\0\x03\0\x04\0\x02\x01\x01\x12\x03\x0f\x08\x13\n\x12\n\
2271 \x0b\x04\0\x03\0\x03\0\x04\0\x02\x01\x02\x12\x03\x0f\x16\x17\n\x11\n\n\
2272 \x04\0\x03\0\x03\0\x04\0\x02\x02\x12\x03\x10\x08\x15\n\x12\n\x0b\x04\0\
2273 \x03\0\x03\0\x04\0\x02\x02\x01\x12\x03\x10\x08\x10\n\x12\n\x0b\x04\0\x03\
2274 \0\x03\0\x04\0\x02\x02\x02\x12\x03\x10\x13\x14\n\x11\n\n\x04\0\x03\0\x03\
2275 \0\x04\0\x02\x03\x12\x03\x11\x08\x12\n\x12\n\x0b\x04\0\x03\0\x03\0\x04\0\
2276 \x02\x03\x01\x12\x03\x11\x08\r\n\x12\n\x0b\x04\0\x03\0\x03\0\x04\0\x02\
2277 \x03\x02\x12\x03\x11\x10\x11\n\x11\n\n\x04\0\x03\0\x03\0\x04\0\x02\x04\
2278 \x12\x03\x12\x08\x15\n\x12\n\x0b\x04\0\x03\0\x03\0\x04\0\x02\x04\x01\x12\
2279 \x03\x12\x08\x10\n\x12\n\x0b\x04\0\x03\0\x03\0\x04\0\x02\x04\x02\x12\x03\
2280 \x12\x13\x14\n\x11\n\n\x04\0\x03\0\x03\0\x04\0\x02\x05\x12\x03\x13\x08\
2281 \x14\n\x12\n\x0b\x04\0\x03\0\x03\0\x04\0\x02\x05\x01\x12\x03\x13\x08\x0f\
2282 \n\x12\n\x0b\x04\0\x03\0\x03\0\x04\0\x02\x05\x02\x12\x03\x13\x12\x13\n\
2283 \x11\n\n\x04\0\x03\0\x03\0\x04\0\x02\x06\x12\x03\x14\x08\x12\n\x12\n\x0b\
2284 \x04\0\x03\0\x03\0\x04\0\x02\x06\x01\x12\x03\x14\x08\r\n\x12\n\x0b\x04\0\
2285 \x03\0\x03\0\x04\0\x02\x06\x02\x12\x03\x14\x10\x11\n\x10\n\x08\x04\0\x03\
2286 \0\x03\0\x03\0\x12\x04\x16\x06\x1b\x07\n\x10\n\t\x04\0\x03\0\x03\0\x03\0\
2287 \x01\x12\x03\x16\x0e\x13\n\x11\n\n\x04\0\x03\0\x03\0\x03\0\x02\0\x12\x03\
2288 \x17\x08\x19\n\x12\n\x0b\x04\0\x03\0\x03\0\x03\0\x02\0\x05\x12\x03\x17\
2289 \x08\x0c\n\x12\n\x0b\x04\0\x03\0\x03\0\x03\0\x02\0\x01\x12\x03\x17\r\x14\
2290 \n\x12\n\x0b\x04\0\x03\0\x03\0\x03\0\x02\0\x03\x12\x03\x17\x17\x18\n\x11\
2291 \n\n\x04\0\x03\0\x03\0\x03\0\x02\x01\x12\x03\x18\x08\x18\n\x12\n\x0b\x04\
2292 \0\x03\0\x03\0\x03\0\x02\x01\x05\x12\x03\x18\x08\x0e\n\x12\n\x0b\x04\0\
2293 \x03\0\x03\0\x03\0\x02\x01\x01\x12\x03\x18\x0f\x13\n\x12\n\x0b\x04\0\x03\
2294 \0\x03\0\x03\0\x02\x01\x03\x12\x03\x18\x16\x17\n+\n\n\x04\0\x03\0\x03\0\
2295 \x03\0\x02\x02\x12\x03\x19\x08\x18\"\x18\x20SolidityType\x20type\x20=\
2296 \x203;\n\n\x12\n\x0b\x04\0\x03\0\x03\0\x03\0\x02\x02\x05\x12\x03\x19\x08\
2297 \x0e\n\x12\n\x0b\x04\0\x03\0\x03\0\x03\0\x02\x02\x01\x12\x03\x19\x0f\x13\
2298 \n\x12\n\x0b\x04\0\x03\0\x03\0\x03\0\x02\x02\x03\x12\x03\x19\x16\x17\n\
2299 \x10\n\x08\x04\0\x03\0\x03\0\x04\x01\x12\x04\x1c\x06\"\x07\n\x10\n\t\x04\
2300 \0\x03\0\x03\0\x04\x01\x01\x12\x03\x1c\x0b\x1e\n\x11\n\n\x04\0\x03\0\x03\
2301 \0\x04\x01\x02\0\x12\x03\x1d\x08\"\n\x12\n\x0b\x04\0\x03\0\x03\0\x04\x01\
2302 \x02\0\x01\x12\x03\x1d\x08\x1d\n\x12\n\x0b\x04\0\x03\0\x03\0\x04\x01\x02\
2303 \0\x02\x12\x03\x1d\x20!\n\x11\n\n\x04\0\x03\0\x03\0\x04\x01\x02\x01\x12\
2304 \x03\x1e\x08\x11\n\x12\n\x0b\x04\0\x03\0\x03\0\x04\x01\x02\x01\x01\x12\
2305 \x03\x1e\x08\x0c\n\x12\n\x0b\x04\0\x03\0\x03\0\x04\x01\x02\x01\x02\x12\
2306 \x03\x1e\x0f\x10\n\x11\n\n\x04\0\x03\0\x03\0\x04\x01\x02\x02\x12\x03\x1f\
2307 \x08\x11\n\x12\n\x0b\x04\0\x03\0\x03\0\x04\x01\x02\x02\x01\x12\x03\x1f\
2308 \x08\x0c\n\x12\n\x0b\x04\0\x03\0\x03\0\x04\x01\x02\x02\x02\x12\x03\x1f\
2309 \x0f\x10\n\x11\n\n\x04\0\x03\0\x03\0\x04\x01\x02\x03\x12\x03\x20\x08\x17\
2310 \n\x12\n\x0b\x04\0\x03\0\x03\0\x04\x01\x02\x03\x01\x12\x03\x20\x08\x12\n\
2311 \x12\n\x0b\x04\0\x03\0\x03\0\x04\x01\x02\x03\x02\x12\x03\x20\x15\x16\n\
2312 \x11\n\n\x04\0\x03\0\x03\0\x04\x01\x02\x04\x12\x03!\x08\x14\n\x12\n\x0b\
2313 \x04\0\x03\0\x03\0\x04\x01\x02\x04\x01\x12\x03!\x08\x0f\n\x12\n\x0b\x04\
2314 \0\x03\0\x03\0\x04\x01\x02\x04\x02\x12\x03!\x12\x13\n\x0f\n\x08\x04\0\
2315 \x03\0\x03\0\x02\0\x12\x03$\x06\x19\n\x10\n\t\x04\0\x03\0\x03\0\x02\0\
2316 \x05\x12\x03$\x06\n\n\x10\n\t\x04\0\x03\0\x03\0\x02\0\x01\x12\x03$\x0b\
2317 \x14\n\x10\n\t\x04\0\x03\0\x03\0\x02\0\x03\x12\x03$\x17\x18\n\x0f\n\x08\
2318 \x04\0\x03\0\x03\0\x02\x01\x12\x03%\x06\x18\n\x10\n\t\x04\0\x03\0\x03\0\
2319 \x02\x01\x05\x12\x03%\x06\n\n\x10\n\t\x04\0\x03\0\x03\0\x02\x01\x01\x12\
2320 \x03%\x0b\x13\n\x10\n\t\x04\0\x03\0\x03\0\x02\x01\x03\x12\x03%\x16\x17\n\
2321 \x0f\n\x08\x04\0\x03\0\x03\0\x02\x02\x12\x03&\x06\x16\n\x10\n\t\x04\0\
2322 \x03\0\x03\0\x02\x02\x05\x12\x03&\x06\x0c\n\x10\n\t\x04\0\x03\0\x03\0\
2323 \x02\x02\x01\x12\x03&\r\x11\n\x10\n\t\x04\0\x03\0\x03\0\x02\x02\x03\x12\
2324 \x03&\x14\x15\n\x0f\n\x08\x04\0\x03\0\x03\0\x02\x03\x12\x03'\x06\x20\n\
2325 \x10\n\t\x04\0\x03\0\x03\0\x02\x03\x04\x12\x03'\x06\x0e\n\x10\n\t\x04\0\
2326 \x03\0\x03\0\x02\x03\x06\x12\x03'\x0f\x14\n\x10\n\t\x04\0\x03\0\x03\0\
2327 \x02\x03\x01\x12\x03'\x15\x1b\n\x10\n\t\x04\0\x03\0\x03\0\x02\x03\x03\
2328 \x12\x03'\x1e\x1f\n\x0f\n\x08\x04\0\x03\0\x03\0\x02\x04\x12\x03(\x06!\n\
2329 \x10\n\t\x04\0\x03\0\x03\0\x02\x04\x04\x12\x03(\x06\x0e\n\x10\n\t\x04\0\
2330 \x03\0\x03\0\x02\x04\x06\x12\x03(\x0f\x14\n\x10\n\t\x04\0\x03\0\x03\0\
2331 \x02\x04\x01\x12\x03(\x15\x1c\n\x10\n\t\x04\0\x03\0\x03\0\x02\x04\x03\
2332 \x12\x03(\x1f\x20\n\x0f\n\x08\x04\0\x03\0\x03\0\x02\x05\x12\x03)\x06\x19\
2333 \n\x10\n\t\x04\0\x03\0\x03\0\x02\x05\x06\x12\x03)\x06\x0f\n\x10\n\t\x04\
2334 \0\x03\0\x03\0\x02\x05\x01\x12\x03)\x10\x14\n\x10\n\t\x04\0\x03\0\x03\0\
2335 \x02\x05\x03\x12\x03)\x17\x18\n\x0f\n\x08\x04\0\x03\0\x03\0\x02\x06\x12\
2336 \x03*\x06\x17\n\x10\n\t\x04\0\x03\0\x03\0\x02\x06\x05\x12\x03*\x06\n\n\
2337 \x10\n\t\x04\0\x03\0\x03\0\x02\x06\x01\x12\x03*\x0b\x12\n\x10\n\t\x04\0\
2338 \x03\0\x03\0\x02\x06\x03\x12\x03*\x15\x16\n\x0f\n\x08\x04\0\x03\0\x03\0\
2339 \x02\x07\x12\x03+\x06.\n\x10\n\t\x04\0\x03\0\x03\0\x02\x07\x06\x12\x03+\
2340 \x06\x19\n\x10\n\t\x04\0\x03\0\x03\0\x02\x07\x01\x12\x03+\x1a)\n\x10\n\t\
2341 \x04\0\x03\0\x03\0\x02\x07\x03\x12\x03+,-\n\r\n\x06\x04\0\x03\0\x02\0\
2342 \x12\x03-\x04\x1e\n\x0e\n\x07\x04\0\x03\0\x02\0\x04\x12\x03-\x04\x0c\n\
2343 \x0e\n\x07\x04\0\x03\0\x02\0\x06\x12\x03-\r\x12\n\x0e\n\x07\x04\0\x03\0\
2344 \x02\0\x01\x12\x03-\x13\x19\n\x0e\n\x07\x04\0\x03\0\x02\0\x03\x12\x03-\
2345 \x1c\x1d\n\x0b\n\x04\x04\0\x02\0\x12\x03/\x02\x1b\n\x0c\n\x05\x04\0\x02\
2346 \0\x05\x12\x03/\x02\x07\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03/\x08\x16\n\
2347 \x0c\n\x05\x04\0\x02\0\x03\x12\x03/\x19\x1a\n\x0b\n\x04\x04\0\x02\x01\
2348 \x12\x030\x02\x1d\n\x0c\n\x05\x04\0\x02\x01\x05\x12\x030\x02\x07\n\x0c\n\
2349 \x05\x04\0\x02\x01\x01\x12\x030\x08\x18\n\x0c\n\x05\x04\0\x02\x01\x03\
2350 \x12\x030\x1b\x1c\n\x0b\n\x04\x04\0\x02\x02\x12\x031\x02\x0e\n\x0c\n\x05\
2351 \x04\0\x02\x02\x06\x12\x031\x02\x05\n\x0c\n\x05\x04\0\x02\x02\x01\x12\
2352 \x031\x06\t\n\x0c\n\x05\x04\0\x02\x02\x03\x12\x031\x0c\r\n\x0b\n\x04\x04\
2353 \0\x02\x03\x12\x032\x02\x15\n\x0c\n\x05\x04\0\x02\x03\x05\x12\x032\x02\
2354 \x07\n\x0c\n\x05\x04\0\x02\x03\x01\x12\x032\x08\x10\n\x0c\n\x05\x04\0\
2355 \x02\x03\x03\x12\x032\x13\x14\n\x0b\n\x04\x04\0\x02\x04\x12\x033\x02\x17\
2356 \n\x0c\n\x05\x04\0\x02\x04\x05\x12\x033\x02\x07\n\x0c\n\x05\x04\0\x02\
2357 \x04\x01\x12\x033\x08\x12\n\x0c\n\x05\x04\0\x02\x04\x03\x12\x033\x15\x16\
2358 \n\x0b\n\x04\x04\0\x02\x05\x12\x034\x02*\n\x0c\n\x05\x04\0\x02\x05\x05\
2359 \x12\x034\x02\x07\n\x0c\n\x05\x04\0\x02\x05\x01\x12\x034\x08%\n\x0c\n\
2360 \x05\x04\0\x02\x05\x03\x12\x034()\n\x0b\n\x04\x04\0\x02\x06\x12\x035\x02\
2361 \x12\n\x0c\n\x05\x04\0\x02\x06\x05\x12\x035\x02\x08\n\x0c\n\x05\x04\0\
2362 \x02\x06\x01\x12\x035\t\r\n\x0c\n\x05\x04\0\x02\x06\x03\x12\x035\x10\x11\
2363 \n\x0b\n\x04\x04\0\x02\x07\x12\x036\x02\x20\n\x0c\n\x05\x04\0\x02\x07\
2364 \x05\x12\x036\x02\x07\n\x0c\n\x05\x04\0\x02\x07\x01\x12\x036\x08\x1b\n\
2365 \x0c\n\x05\x04\0\x02\x07\x03\x12\x036\x1e\x1f\n\x0b\n\x04\x04\0\x02\x08\
2366 \x12\x037\x02\x16\n\x0c\n\x05\x04\0\x02\x08\x05\x12\x037\x02\x07\n\x0c\n\
2367 \x05\x04\0\x02\x08\x01\x12\x037\x08\x11\n\x0c\n\x05\x04\0\x02\x08\x03\
2368 \x12\x037\x14\x15\n\x0b\n\x04\x04\0\x02\t\x12\x038\x02\x16\n\x0c\n\x05\
2369 \x04\0\x02\t\x05\x12\x038\x02\x07\n\x0c\n\x05\x04\0\x02\t\x01\x12\x038\
2370 \x08\x10\n\x0c\n\x05\x04\0\x02\t\x03\x12\x038\x13\x15\n\x0b\n\x04\x04\0\
2371 \x02\n\x12\x039\x02\x15\n\x0c\n\x05\x04\0\x02\n\x05\x12\x039\x02\x07\n\
2372 \x0c\n\x05\x04\0\x02\n\x01\x12\x039\x08\x0f\n\x0c\n\x05\x04\0\x02\n\x03\
2373 \x12\x039\x12\x14\n\n\n\x02\x04\x01\x12\x04<\0@\x01\n\n\n\x03\x04\x01\
2374 \x01\x12\x03<\x08\x15\n\x0b\n\x04\x04\x01\x02\0\x12\x03=\x02\x19\n\x0c\n\
2375 \x05\x04\x01\x02\0\x05\x12\x03=\x02\x07\n\x0c\n\x05\x04\x01\x02\0\x01\
2376 \x12\x03=\x08\x14\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03=\x17\x18\n\x0b\n\
2377 \x04\x04\x01\x02\x01\x12\x03>\x02\x1a\n\x0c\n\x05\x04\x01\x02\x01\x05\
2378 \x12\x03>\x02\x07\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\x03>\x08\x15\n\x0c\
2379 \n\x05\x04\x01\x02\x01\x03\x12\x03>\x18\x19\n\x0b\n\x04\x04\x01\x02\x02\
2380 \x12\x03?\x02\x19\n\x0c\n\x05\x04\x01\x02\x02\x05\x12\x03?\x02\x07\n\x0c\
2381 \n\x05\x04\x01\x02\x02\x01\x12\x03?\x08\x14\n\x0c\n\x05\x04\x01\x02\x02\
2382 \x03\x12\x03?\x17\x18\n\n\n\x02\x04\x02\x12\x04B\0G\x01\n\n\n\x03\x04\
2383 \x02\x01\x12\x03B\x08\x1b\n\x0b\n\x04\x04\x02\x02\0\x12\x03C\x02\x1a\n\
2384 \x0c\n\x05\x04\x02\x02\0\x05\x12\x03C\x02\x07\n\x0c\n\x05\x04\x02\x02\0\
2385 \x01\x12\x03C\x08\x15\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03C\x18\x19\n\
2386 \x0b\n\x04\x04\x02\x02\x01\x12\x03D\x02!\n\x0c\n\x05\x04\x02\x02\x01\x06\
2387 \x12\x03D\x02\x0f\n\x0c\n\x05\x04\x02\x02\x01\x01\x12\x03D\x10\x1c\n\x0c\
2388 \n\x05\x04\x02\x02\x01\x03\x12\x03D\x1f\x20\n\x0b\n\x04\x04\x02\x02\x02\
2389 \x12\x03E\x02\x1d\n\x0c\n\x05\x04\x02\x02\x02\x05\x12\x03E\x02\x07\n\x0c\
2390 \n\x05\x04\x02\x02\x02\x01\x12\x03E\x08\x18\n\x0c\n\x05\x04\x02\x02\x02\
2391 \x03\x12\x03E\x1b\x1c\n\x0b\n\x04\x04\x02\x02\x03\x12\x03F\x02\x15\n\x0c\
2392 \n\x05\x04\x02\x02\x03\x05\x12\x03F\x02\x07\n\x0c\n\x05\x04\x02\x02\x03\
2393 \x01\x12\x03F\x08\x10\n\x0c\n\x05\x04\x02\x02\x03\x03\x12\x03F\x13\x14\n\
2394 \n\n\x02\x04\x03\x12\x04I\0P\x01\n\n\n\x03\x04\x03\x01\x12\x03I\x08\x1c\
2395 \n\x0b\n\x04\x04\x03\x02\0\x12\x03J\x02\x1a\n\x0c\n\x05\x04\x03\x02\0\
2396 \x05\x12\x03J\x02\x07\n\x0c\n\x05\x04\x03\x02\0\x01\x12\x03J\x08\x15\n\
2397 \x0c\n\x05\x04\x03\x02\0\x03\x12\x03J\x18\x19\n\x0b\n\x04\x04\x03\x02\
2398 \x01\x12\x03K\x02\x1d\n\x0c\n\x05\x04\x03\x02\x01\x05\x12\x03K\x02\x07\n\
2399 \x0c\n\x05\x04\x03\x02\x01\x01\x12\x03K\x08\x18\n\x0c\n\x05\x04\x03\x02\
2400 \x01\x03\x12\x03K\x1b\x1c\n\x0b\n\x04\x04\x03\x02\x02\x12\x03L\x02\x17\n\
2401 \x0c\n\x05\x04\x03\x02\x02\x05\x12\x03L\x02\x07\n\x0c\n\x05\x04\x03\x02\
2402 \x02\x01\x12\x03L\x08\x12\n\x0c\n\x05\x04\x03\x02\x02\x03\x12\x03L\x15\
2403 \x16\n\x0b\n\x04\x04\x03\x02\x03\x12\x03M\x02\x11\n\x0c\n\x05\x04\x03\
2404 \x02\x03\x05\x12\x03M\x02\x07\n\x0c\n\x05\x04\x03\x02\x03\x01\x12\x03M\
2405 \x08\x0c\n\x0c\n\x05\x04\x03\x02\x03\x03\x12\x03M\x0f\x10\n\x0b\n\x04\
2406 \x04\x03\x02\x04\x12\x03N\x02\x1d\n\x0c\n\x05\x04\x03\x02\x04\x05\x12\
2407 \x03N\x02\x07\n\x0c\n\x05\x04\x03\x02\x04\x01\x12\x03N\x08\x18\n\x0c\n\
2408 \x05\x04\x03\x02\x04\x03\x12\x03N\x1b\x1c\n\x0b\n\x04\x04\x03\x02\x05\
2409 \x12\x03O\x02\x15\n\x0c\n\x05\x04\x03\x02\x05\x05\x12\x03O\x02\x07\n\x0c\
2410 \n\x05\x04\x03\x02\x05\x01\x12\x03O\x08\x10\n\x0c\n\x05\x04\x03\x02\x05\
2411 \x03\x12\x03O\x13\x14\n\n\n\x02\x04\x04\x12\x04R\0U\x01\n\n\n\x03\x04\
2412 \x04\x01\x12\x03R\x08\x18\n\x0b\n\x04\x04\x04\x02\0\x12\x03S\x02\x1a\n\
2413 \x0c\n\x05\x04\x04\x02\0\x05\x12\x03S\x02\x07\n\x0c\n\x05\x04\x04\x02\0\
2414 \x01\x12\x03S\x08\x15\n\x0c\n\x05\x04\x04\x02\0\x03\x12\x03S\x18\x19\n\
2415 \x0b\n\x04\x04\x04\x02\x01\x12\x03T\x02\x1d\n\x0c\n\x05\x04\x04\x02\x01\
2416 \x05\x12\x03T\x02\x07\n\x0c\n\x05\x04\x04\x02\x01\x01\x12\x03T\x08\x18\n\
2417 \x0c\n\x05\x04\x04\x02\x01\x03\x12\x03T\x1b\x1c\n\n\n\x02\x04\x05\x12\
2418 \x04W\0[\x01\n\n\n\x03\x04\x05\x01\x12\x03W\x08\x1d\n\x0b\n\x04\x04\x05\
2419 \x02\0\x12\x03X\x02\x1a\n\x0c\n\x05\x04\x05\x02\0\x05\x12\x03X\x02\x07\n\
2420 \x0c\n\x05\x04\x05\x02\0\x01\x12\x03X\x08\x15\n\x0c\n\x05\x04\x05\x02\0\
2421 \x03\x12\x03X\x18\x19\n\x0b\n\x04\x04\x05\x02\x01\x12\x03Y\x02\x1d\n\x0c\
2422 \n\x05\x04\x05\x02\x01\x05\x12\x03Y\x02\x07\n\x0c\n\x05\x04\x05\x02\x01\
2423 \x01\x12\x03Y\x08\x18\n\x0c\n\x05\x04\x05\x02\x01\x03\x12\x03Y\x1b\x1c\n\
2424 \x0b\n\x04\x04\x05\x02\x02\x12\x03Z\x02*\n\x0c\n\x05\x04\x05\x02\x02\x05\
2425 \x12\x03Z\x02\x07\n\x0c\n\x05\x04\x05\x02\x02\x01\x12\x03Z\x08%\n\x0c\n\
2426 \x05\x04\x05\x02\x02\x03\x12\x03Z()\n\n\n\x02\x04\x06\x12\x04]\0a\x01\n\
2427 \n\n\x03\x04\x06\x01\x12\x03]\x08!\n\x0b\n\x04\x04\x06\x02\0\x12\x03^\
2428 \x02\x1a\n\x0c\n\x05\x04\x06\x02\0\x05\x12\x03^\x02\x07\n\x0c\n\x05\x04\
2429 \x06\x02\0\x01\x12\x03^\x08\x15\n\x0c\n\x05\x04\x06\x02\0\x03\x12\x03^\
2430 \x18\x19\n\x0b\n\x04\x04\x06\x02\x01\x12\x03_\x02\x1d\n\x0c\n\x05\x04\
2431 \x06\x02\x01\x05\x12\x03_\x02\x07\n\x0c\n\x05\x04\x06\x02\x01\x01\x12\
2432 \x03_\x08\x18\n\x0c\n\x05\x04\x06\x02\x01\x03\x12\x03_\x1b\x1c\n\x0b\n\
2433 \x04\x04\x06\x02\x02\x12\x03`\x02\x20\n\x0c\n\x05\x04\x06\x02\x02\x05\
2434 \x12\x03`\x02\x07\n\x0c\n\x05\x04\x06\x02\x02\x01\x12\x03`\x08\x1b\n\x0c\
2435 \n\x05\x04\x06\x02\x02\x03\x12\x03`\x1e\x1f\n\n\n\x02\x04\x07\x12\x04c\0\
2436 g\x01\n\n\n\x03\x04\x07\x01\x12\x03c\x08\x20\n\x0b\n\x04\x04\x07\x02\0\
2437 \x12\x03d\x02#\n\x0c\n\x05\x04\x07\x02\0\x06\x12\x03d\x02\x0f\n\x0c\n\
2438 \x05\x04\x07\x02\0\x01\x12\x03d\x10\x1e\n\x0c\n\x05\x04\x07\x02\0\x03\
2439 \x12\x03d!\"\n\x0b\n\x04\x04\x07\x02\x01\x12\x03e\x02\x18\n\x0c\n\x05\
2440 \x04\x07\x02\x01\x05\x12\x03e\x02\x07\n\x0c\n\x05\x04\x07\x02\x01\x01\
2441 \x12\x03e\x08\x13\n\x0c\n\x05\x04\x07\x02\x01\x03\x12\x03e\x16\x17\n\x0b\
2442 \n\x04\x04\x07\x02\x02\x12\x03f\x02#\n\x0c\n\x05\x04\x07\x02\x02\x06\x12\
2443 \x03f\x02\x0f\n\x0c\n\x05\x04\x07\x02\x02\x01\x12\x03f\x10\x1e\n\x0c\n\
2444 \x05\x04\x07\x02\x02\x03\x12\x03f!\"b\x06proto3\
2445";
2446
2447fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
2449 static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new();
2450 file_descriptor_proto_lazy.get(|| {
2451 ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
2452 })
2453}
2454
2455pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
2457 static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new();
2458 static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new();
2459 file_descriptor.get(|| {
2460 let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
2461 let mut deps = ::std::vec::Vec::with_capacity(1);
2462 deps.push(super::Tron::file_descriptor().clone());
2463 let mut messages = ::std::vec::Vec::with_capacity(11);
2464 messages.push(SmartContract::generated_message_descriptor_data());
2465 messages.push(ContractState::generated_message_descriptor_data());
2466 messages.push(CreateSmartContract::generated_message_descriptor_data());
2467 messages.push(TriggerSmartContract::generated_message_descriptor_data());
2468 messages.push(ClearABIContract::generated_message_descriptor_data());
2469 messages.push(UpdateSettingContract::generated_message_descriptor_data());
2470 messages.push(UpdateEnergyLimitContract::generated_message_descriptor_data());
2471 messages.push(SmartContractDataWrapper::generated_message_descriptor_data());
2472 messages.push(smart_contract::ABI::generated_message_descriptor_data());
2473 messages.push(smart_contract::abi::Entry::generated_message_descriptor_data());
2474 messages.push(smart_contract::abi::entry::Param::generated_message_descriptor_data());
2475 let mut enums = ::std::vec::Vec::with_capacity(2);
2476 enums.push(smart_contract::abi::entry::EntryType::generated_enum_descriptor_data());
2477 enums.push(smart_contract::abi::entry::StateMutabilityType::generated_enum_descriptor_data());
2478 ::protobuf::reflect::GeneratedFileDescriptor::new_generated(
2479 file_descriptor_proto(),
2480 deps,
2481 messages,
2482 enums,
2483 )
2484 });
2485 ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
2486 })
2487}